El póker tiene etiqueta en la forma en que organizas tus fichas, a menudo aplicadas en torneos: es posible que tus fichas no se "oculten" a tus oponentes al estar detrás de otros, principalmente para no ocultar algunas fichas de gran denominación.

El reto

Vamos a jugar al póker en ASCII, por lo que necesitamos escribir una función o programa que dibuje nuestra disposición de pila de chips ASCII dado su valor total n.

Entrada
: un entero positivo n(hasta se 2**32-1debe manejar)

Salida
: una representación ASCII de la disposición de la pila como se define a continuación.
Esto puede contener espacios en blanco a la derecha de cada línea, de modo que ninguna línea sea más larga que un carácter más que la longitud utilizada por los caracteres imprimibles en la línea más larga (inferior);
Esto puede contener una nueva línea final; y
Los caracteres que representan chips pueden estar en minúsculas si lo prefiere.

La disposición de la pila:

• Contener la menor cantidad de fichas posibles, dadas las denominaciones (ver más abajo);
• Tendrá fichas de igual valor en "pilas" (columnas);
• Ser ordenado de tal manera que las pilas más cortas estén a la derecha de las pilas más altas; y
• Ordene de manera que las pilas con fichas de mayor denominación estén a la derecha de las pilas de igual tamaño de denominaciones más bajas (lo que representa que son visibles para nuestro oponente a la derecha)

Las fichas en sí deben representarse como caracteres individuales que identifiquen su color:

    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

Ejemplo

Para n = 276,352el menor número de chips sería:

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

El single Pdebe ir a la extrema derecha,
luego los tres montones de tamaño 2deben ir a continuación,
pero MMdeben ir más a la derecha seguidos por el GGy luego WWdesde 100K > 25 > 1 entonces los dos montones de tamaño 3van a la izquierda,
pero el CCCmust ir a la derecha del BBBdesde25K > 100

Ahora debemos colocar estos chips en pilas reales, para hacer nuestra salida:

BC
BCWGM
BCWGMP

Casos de prueba

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

Este es el código de golf , por lo que gana el código más corto en bytes. Sin escapatorias, yada yada, ya sabes el ejercicio.

Pyth, 56 55 52 bytes

El código contiene algunos no imprimibles, así que aquí hay un xxdhexdump reversible .

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/

Pruébalo en línea. Banco de pruebas.

Consejo profesional: para jugar golf 1al final de un programa que acepte un número distinto de cero Q, solo agregue /. /QQ, que en Python sería Q // Q, es 1 para no cero Q.

Sin compresión y no imprimibles (55 bytes):

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

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

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)

Formateado y comentado

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

Manifestación

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>

Rubí, 181 177 bytes

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

Pruebas de ideona .

Python 2.7, 282 248 238 bytes

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

Explicación:
Llene la lista Lcon elementos que [quanity, chip_order, chip_character]indiquen la cantidad de cada tipo de chip, donde se chip_ordergarantiza que los chips de igual cantidad se ordenen en orden inverso (los chips de mayor valor primero ). Tome las fichas Len reversa para construir cadenas para cada línea. Imprima líneas al revés para obtener las líneas más pequeñas en la parte superior.

Gracias a Blue por algunas de las mejoras.

Mathematica, 440 bytes

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 representación ASCI y el orden correcto se tragan la mayor parte del código.

* Solo funciona con la Versión 11 y superior (uso de Nothing) *

PHP, 274 bytes

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