Poker ma etykietę w sposobie układania żetonów, często egzekwowaną w turniejach - twoje żetony nie mogą być „ukryte” przed przeciwnikami przez bycie za innymi, głównie po to, aby nie ukrywać dużych żetonów o dużych nominałach.

Wyzwanie

Będziemy grać w pokera w ASCII, więc musimy napisać funkcję lub program, który narysuje nasz układ żetonów ASCII, biorąc pod uwagę jego całkowitą wartość n.

Dane wejściowe
- dodatnia liczba całkowita n(maksymalnie 2**32-1należy obsłużyć)

Dane wyjściowe
- reprezentacja ASCII układu stosu, jak zdefiniowano poniżej.
Może zawierać białą spację po prawej stronie każdego wiersza, tak że żaden wiersz nie jest dłuższy niż jeden znak więcej niż długość używana przez znaki drukowalne w najdłuższej (dolnej) linii;
Może zawierać pojedynczą końcową nową linię; i
Znaki reprezentujące żetony mogą być pisane małymi literami, jeśli wolisz.

Układ stosu:

• Zawierają jak najmniejszą liczbę żetonów, biorąc pod uwagę nominały (patrz poniżej);
• Będzie miał żetony o równej wartości w „stosach” (kolumnach);
• Zamów tak, aby krótsze stosy znajdowały się po prawej stronie wyższych stosów; i
• Ułóż je tak, aby stosy z żetonami o większych nominałach były po prawej stronie stosów o mniejszych nominałach równej wielkości (co oznacza, że ​​są widoczne dla naszego przeciwnika (przeciwników) po prawej stronie)

Same żetony należy przedstawić jako pojedyncze znaki identyfikujące ich kolor:

    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

Przykład

Dla n = 276,352najmniejszej liczby żetonów byłoby:

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

Singiel Pmusi iść po prawej stronie,
następnie trzy stosy wielkości 2muszą przejść dalej,
- ale MMmusi iść najdalej w prawo, a GGnastępnie, a następnie, WWod 100K > 25 > 1 tego czasu dwa stosy wielkości 3idą po lewej,
- ale CCCmusi idź na prawo od tego BBBczasu25K > 100

Teraz musimy umieścić te żetony w rzeczywistych stosach, aby uzyskać nasz wynik:

BC
BCWGM
BCWGMP

Przypadki testowe

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

To jest golf golfowy , więc wygrywa najkrótszy kod w bajtach. Żadnych luk, Yada Yada, znasz wiertło.

Pyth, 56 55 52 bajtów

Kod zawiera niektóre niedrukowalne elementy, więc oto odwracalny xxdzrzut heksowy.

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/

Wypróbuj online. Zestaw testowy.

Pro wskazówka: aby zagrać 1w golfa na końcu programu akceptującego niezerową liczbę Q, wystarczy dodać /. /QQ, która w Pythonie byłaby równa Q // Q1 dla niezerowej Q.

Bez kompresji i niedrukowalnych (55 bajtów):

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

JavaScript (ES6), 185 177 ... 171 bajtów

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)

Sformatowane i skomentowane

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

Próbny

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>

Rubin, 181 177 bajtów

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

Testy na Ideone .

Python 2.7, 282 248 238 bajtów

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

Objaśnienie:
Wypełnij listę Lelementami [quanity, chip_order, chip_character]wskazującymi ilość każdego rodzaju żetonów, gdzie chip_orderzapewnia sortowanie żetonów o równej ilości w odwrotnej kolejności ( najpierw żetony o wyższej wartości ). Weź żetony z Lrewersu, aby budować ciągi dla każdej linii. Drukuj linie w odwrotnej kolejności, aby uzyskać najmniejsze linie na górze.

Dzięki Blue za niektóre ulepszenia.

Mathematica, 440 bajtów

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)

Reprezentacja ASCI i właściwa kolejność połykają większość kodu.

* Działa tylko z wersją 11 i wyższą (użycie Nothing) *

PHP, 274 bajtów

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