Le poker a une étiquette dans la façon dont vous organisez vos jetons, souvent appliquée dans les tournois - vos jetons peuvent ne pas être "cachés" à vos adversaires en étant derrière les autres, surtout pour ne pas cacher des jetons de grande dénomination.

Le défi

Nous allons jouer au poker en ASCII, donc nous avons besoin d'écrire une fonction ou d'un programme qui attirera notre arrangement de pile de jetons ASCII compte tenu de sa valeur totale, n.

Entrée
- Un entier positif, n(jusqu'à 2**32-1doit être traité)

Sortie
- Une représentation ASCII de l'arrangement de pile tel que défini ci-dessous.
Cela peut contenir un espace blanc à droite de chaque ligne de sorte qu'aucune ligne ne dépasse un caractère de plus que la longueur utilisée par les caractères imprimables dans la ligne la plus longue (en bas);
Il peut contenir une seule nouvelle ligne de fin; et
Les caractères représentant les puces peuvent être en minuscules si vous préférez.

L'arrangement de pile:

• Contenir le moins de jetons possible, compte tenu des dénominations (voir ci-dessous);
• Aura des puces de valeur égale en "piles" (colonnes);
• Être ordonné de telle sorte que les piles les plus courtes soient à droite des piles plus hautes; et
• Être ordonné de telle sorte que les piles avec des jetons de dénomination plus grande soient à droite des piles de dénominations inférieures de taille égale (ce qui signifie qu'elles sont visibles par nos adversaires à droite)

Les puces elles-mêmes doivent être représentées comme des caractères individuels identifiant leur couleur:

    White : 1    = W
      Red : 5    = R
    Green : 25   = G
    Black : 100  = B
   Yellow : 500  = Y
     Pink : 1K   = P
   Orange : 5K   = O
     Cyan : 25K  = C
  Magenta : 100K = M
Aqua-blue : 500K = A
 Lavender : 1M   = L
   Indigo : 5M   = I
Turquoise : 25M  = T
   Violet : 100M = V
   Silver : 500M = S

Exemple

Pour n = 276,352le plus petit nombre de puces serait:

2 * 100K + 3 * 25K + 1 * 1K + 3 * 100 + 2 * 25 + 2 * 1
    MM         CCC       P        BBB       GG       WW

Le single Pdoit aller à l'extrême droite,
puis les trois piles de taille 2doivent aller ensuite,
- mais le MMdoit aller le plus à droite, suivi du GGpuis, puis WWdepuis, 100K > 25 > 1 les deux piles de taille 3vont à gauche,
- mais le CCCmust aller à droite du BBBdepuis25K > 100

Maintenant, nous devons placer ces puces dans des piles réelles, pour faire notre sortie:

BC
BCWGM
BCWGMP

Cas de test

Input:
1

Output:
W


Input:
9378278

Output:
L
LWGPCM
LWGPCMB
LWGPCMBI


Input:
22222222

Output:
ROI
ROI
ROIWBPML
ROIWBPML


Input:
1342185143

Output:
WRCIV
WRCIVOLS
WRCIVOLSGBMT


Input:
2147483647

Output:
RMIS
RMISPC
RMISPCWL
RMISPCWLGBYOTV


Input:
4294967295

Output:
S
S
S
S
SRML
SRMLGOIT
SRMLGOITBPCV
SRMLGOITBPCVA

C'est le code-golf , donc le code le plus court en octets l'emporte. Pas d'échappatoires, yada yada, vous connaissez l'exercice.

Pyth, 56 55 52 octets

Le code contient des non imprimables, voici donc un xxdhexdump réversible .

00000000: 3d48 516a 5f2e 745f 2023 6c44 2a56 2e22  =HQj_.t_ #lD*V."
00000010: 4159 261c 0c24 2087 0c86 1e22 6d68 412e  AY&..$ ...."mhA.
00000020: 4448 645f 2e75 2a4e 5950 2a33 6a37 3733  DHd_.u*NYP*3j773
00000030: 3620 362f                                6 6/

Essayez-le en ligne. Suite de tests.

1Conseil de pro: pour jouer au golf à la fin d'un programme acceptant un numéro différent de zéro Q, ajoutez-le /. /QQ, qui serait en Python Q // Q, est 1 pour différent de zéro Q.

Sans compression et non imprimables (55 octets):

=HQj_.t_ #lD*V"SVTILAMCOPYBGRW"mhA.DHd_.u*NYP*3j7736 6/

JavaScript (ES6), 185 177 ... 171 octets

f=(a,s='')=>(a=(a[0]?a:[...(m='25455')+m+m].map((m,i)=>(a-=(k=a/(v/=m)|0)*v,k*16+i),v=1E9).sort((a,b)=>b-a)).map(n=>n>15&&(s+='SVTILAMCOPYBGRW'[n&15],n-16)),s&&f(a)+`
`+s)

Formaté et commenté

(a, s = '') => (                           // a = bankroll OR array of chip stacks
  a = (                                    // s = string of chip initials for this iteration
    a[0] ?                                 // if 'a' already is an array:
      a                                    // use it as-is
    :                                      // else, 'a' is the bankroll:
      [...(m = '25455') + m + m]           // for each 'm' in [ 2, 5, 4, 5, 5, ... ] (x3)
      .map((m, i) =>                       // v = current chip value = previous value / m
        (                                  // k = floor(a / v) = number of these chips
          a -= (k = a / (v /= m) | 0) * v, // update remaining bankroll: a = a - k * v
          k * 16 + i                       // saved in array: chip index in bits 0-3
        ),                                 // and number of chips in bits 4+
        v = 1E9                            // initial chip value = 1 billion
      )                                    // (1B / 2 -> 500M, 500M / 5 -> 100M, etc.)
      .sort((a, b) => b - a)               // sort the chip stacks
  )                                        //
  .map(n =>                                // for each chip stack:
    n > 15 &&                              // if there's at least one remaining chip of
    (                                      // this kind:
      s += 'SVTILAMCOPYBGRW'[n & 15],      // append its initial to the string
      n - 16                               // decrement the number of chips in this stack
    )                                      //
  ),                                       // process recursive call if there was at least
  s && f(a) + '\n' + s                     // one non-empty chip stack (the next lines are
)                                          // appended at the beginning of the final string)

Démo

let f=(a,s='')=>(a=(a[0]?a:[...(m='25455')+m+m].map((m,i)=>(a-=(k=a/(v/=m)|0)*v,k*16+i),v=1E9).sort((a,b)=>b-a)).map(n=>n>15&&(s+='SVTILAMCOPYBGRW'[n&15],n-16)),s&&f(a)+`
`+s)

function update() {
  document.getElementById('o').innerHTML = f(+document.getElementById('i').value);
}
update();

<input id="i" value="1342185143" oninput="update()"><pre id="o"></pre>

Rubis, 181 177 octets

->n{*a=5*10**8
14.times{|i|a<<a[-1]/[5,4,5,5,2][i%5]}
a=a.zip("SVTILAMCOPYBGRW".chars).map{|v,c|[-(n/v),v,c,n%=v]}.sort
l=-a[0][0]
(1..l).map{|i|a.map{|d|l-i<-d[0]?d[2]:""}*""}}

Tests sur Ideone .

Python 2.7, 282 248 238 octets

c=input();L=[]
for i in range(15):m=[5,1,25,5,1][i%5]*10**int("886665533322000"[i]);L+=[[c/m,i,"SVTILAMCOPYBGRW"[i]]];c%=m
L.sort();S=[]
while L[~1][0]:
 s=""
 for X in L[::-1]:
  if X[0]>0:X[0]-=1;s+=X[2]
 S+=[s]
for s in S[::-1]:print s

Explication:
Remplissez la liste Lavec des éléments [quanity, chip_order, chip_character]indiquant la quantité de chaque type de puce, ce qui chip_ordergarantit que les puces de quantité égale sont triées dans l'ordre inverse (les puces de valeur supérieure en premier ). Prenez des jetons Là l'envers pour créer des chaînes pour chaque ligne. Imprimez les lignes en sens inverse pour obtenir les plus petites lignes sur le dessus.

Merci à Blue pour certaines des améliorations.

Mathematica, 440 octets

n=Input[]
c=Characters["SVTILAMCOPYBGRW"]
l=Reap[Do[n=n-#[[-i]]*Sow[Floor[n/#[[-i]]]]&@FoldList[Times,1,{5,5,4,5,2,5,5,4,5,2,5,5,4,5}],{i,1,15}]][[2,1]]
StringJoin@@((StringJoin[#,"\n"])&/@StringJoin/@Reverse/@((PadRight[#,Max[l],""]&/@Sort[Table[If[l[[n]]>0,Table[c[[n]],l[[n]]],Nothing],{n,1,15}],If[Length[#1]==Length[#2],Position[c,#1[[1]]][[1,1]]<Position[c,#2[[1]]][[1,1]],Length[#1]<Length[#2]]&])[[All,#]]&/@Range[Max[l]])//Reverse)

La représentation ASCI et l'ordre correct avalent la majeure partie du code.

* Fonctionne uniquement avec la version 11 et supérieure (utilisation de Nothing) *

PHP, 274 octets

$t=$argv[1];$n=[500,100,25,5,1];$c=YBGRWAMCOPSVTIL;foreach($n as$k=>$v)for($i=0;$i<3;)$r[$v*10**($i*3)]=$c[$k+$i++*5];krsort($r);foreach($r as$v=>$k)$t-=($x[$v]=floor($t/$v))*$v;ksort($x);arsort($x);for($y=max($x);$y;$y--){foreach($x as$k=>$v)if($v>=$y)echo$r[$k];echo"\n";}