Il poker ha l'etichetta nel modo in cui disponi le tue fiches, spesso applicate nei tornei: le tue fiches potrebbero non essere "nascoste" dai tuoi avversari essendo dietro gli altri, principalmente per non nascondere alcune fiche di grande denominazione.

La sfida

Stiamo per giocare a poker in ASCII, quindi abbiamo bisogno di scrivere una funzione o un programma che attirerà il nostro accordo stack ASCII dato il suo valore complessivo, n.

Input
- Un numero intero positivo, n(fino a che 2**32-1deve essere gestito)

Output
: una rappresentazione ASCII della disposizione dello stack come definito di seguito.
Questo può contenere spazi bianchi a destra di ogni riga in modo tale che nessuna riga sia più lunga di un carattere in più rispetto alla lunghezza utilizzata dai caratteri stampabili nella riga più lunga (in basso);
Questo può contenere una nuova riga finale singola; e
I personaggi che rappresentano i chip possono essere in minuscolo se preferisci.

La disposizione dello stack dovrà:

• Contenere il minor numero possibile di chip, date le denominazioni (vedi sotto);
• Avrà chip di pari valore in "pile" (colonne);
• Ordinare in modo tale che le pile più corte siano a destra delle pile più alte; e
• Essere ordinati in modo tale che pile con gettoni di taglio maggiore siano a destra di pile di uguali dimensioni di taglio inferiore (che rappresentano che sono visibili ai nostri avversari sulla destra)

I chip stessi devono essere rappresentati come singoli personaggi che identificano il loro colore:

    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

Esempio

Per n = 276,352il minor numero di chip sarebbe:

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

Il singolo Pdeve andare all'estrema destra,
quindi le tre pile di dimensioni 2devono andare dopo,
ma il MMmust deve andare più a destra seguito da GGe poi WWda 100K > 25 > 1 allora le due pile di dimensioni 3vanno a sinistra,
ma il CCCmust vai a destra del BBBda25K > 100

Ora dobbiamo posizionare questi chip in stack effettivi, per rendere il nostro output:

BC
BCWGM
BCWGMP

Casi 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

Questo è code-golf , quindi vince il codice più breve in byte. Niente scappatoie, yada yada, conosci il trapano.

Pyth, 56 55 52 byte

Il codice contiene alcuni non stampabili, quindi ecco un xxdhexdump reversibile .

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/

Provalo online. Suite di test.

Suggerimento professionale: giocare a golf 1alla fine di un programma accettando un numero diverso da zero Q, basta aggiungere /. /QQ, che in Python sarebbe Q // Q, è 1 per diverso da zero Q.

Senza compressione e non stampabili (55 byte):

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

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

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)

Formattato e commentato

(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)

dimostrazione

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>

Rubino, 181 177 byte

->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]:""}*""}}

Test su Ideone .

Python 2.7, 282 248 238 byte

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

Spiegazione:
Riempire l'elenco Lcon elementi che [quanity, chip_order, chip_character]indicano la quantità di ciascun tipo di chip, in cui si chip_orderassicura che i chip di uguale quantità vengano ordinati in ordine inverso (i chip con valore più elevato prima ). Prendi i gettoni dal Lretro per costruire stringhe per ogni linea. Stampa le linee al contrario per ottenere le linee più piccole in cima.

Grazie a Blue per alcuni dei miglioramenti.

Mathematica, 440 byte

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 rappresentazione ASCI e il giusto ordine ingoiano gran parte del codice.

* Funziona solo con la versione 11 e successive (utilizzo di Nothing) *

PHP, 274 byte

$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";}