O pôquer tem regras de como você organiza suas fichas, geralmente aplicadas em torneios - suas fichas podem não ser "escondidas" dos seus oponentes por ficarem atrás de outras pessoas, principalmente para não esconder algumas fichas de denominação.

O desafio

Vamos jogar pôquer em ASCII, por isso precisamos escrever uma função ou programa que desenhe nosso arranjo de fichas ASCII, considerando seu valor total n.

Entrada
- Um número inteiro positivo, n(até 2**32-1deve ser tratado)

Saída
- Uma representação ASCII da organização da pilha, conforme definido abaixo.
Isso pode conter espaços em branco à direita de cada linha, de modo que nenhuma linha tenha mais que um caractere a mais do que o comprimento usado pelos caracteres imprimíveis na linha mais longa (inferior);
Isso pode conter uma única nova linha à direita; e
Os caracteres que representam os chips podem estar em minúsculas, se você preferir.

A disposição da pilha irá:

• Conter o menor número possível de fichas, considerando as denominações (veja abaixo);
• Terá fichas com valor igual em "pilhas" (colunas);
• Seja ordenado de forma que as pilhas mais curtas fiquem à direita das pilhas mais altas; e
• Seja ordenado de forma que as pilhas com fichas de denominação maior estejam à direita das pilhas de igual tamanho das denominações mais baixas (representando que são visíveis ao (s) nosso (s) oponente (s) à direita)

As próprias fichas devem ser representadas como caracteres individuais, identificando sua cor:

    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

Exemplo

Para n = 276,352o menor número de fichas seria:

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

O single Pdeve ir na extrema direita,
depois as três pilhas de tamanho 2devem ir a seguir,
- mas a MMdeve ir mais longe para a direita, seguido pelo GGe então WWdesde 100K > 25 > 1 então as duas pilhas de tamanho 3vão para a esquerda,
- mas o CCCdeve vá para a direita do BBBdesde25K > 100

Agora devemos colocar esses chips em pilhas reais, para produzir nossa saída:

BC
BCWGM
BCWGMP

Casos de teste

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

Isso é código-golfe , então o código mais curto em bytes vence. Sem brechas, yada yada, você sabe o que fazer.

Pitão, 56 55 52 bytes

O código contém alguns imprimíveis, então aqui está um xxdhexdump reversível .

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/

Experimente online. Suíte de teste.

Dica profissional: para jogar golfe 1no final de um programa que aceite um número diferente de zero Q, basta adicionar /. /QQ, que seria em Python Q // Q, é 1 para diferente de zero Q.

Sem compactação e não imprimíveis (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)

Formatado e 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)

Demo

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>

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

Testes em Ideone .

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

Explicação:
Preencha a lista Lcom os elementos que [quanity, chip_order, chip_character]indicam a quantidade de cada tipo de chip, onde chip_ordergarante que os chips de quantidade igual sejam classificados na ordem inversa ( primeiro os chips de maior valor ). Pegue as fichas Lno sentido inverso para criar cordas para cada linha. Imprima linhas no sentido inverso para obter as menores linhas no topo.

Obrigado ao Blue por algumas das melhorias.

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)

A representação ASCI e a ordem correta engolem a maior parte do código.

* Funciona apenas com a versão 11 e 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";}