Poker hat eine Etikette, wie Sie Ihre Chips arrangieren, die oft bei Turnieren durchgesetzt wird - Ihre Chips können Ihren Gegnern nicht "verborgen" werden, indem Sie hinter anderen Chips stehen, meistens, um einige Chips mit großem Nennwert nicht zu verbergen.

Die Herausforderung

Wir werden Poker in ASCII spielen, also müssen wir eine Funktion oder ein Programm schreiben, die / das unsere ASCII - Chipstapelanordnung aufgrund ihres Gesamtwerts zeichnet n.

Eingabe
- Eine positive ganze Zahl n(bis zu 2**32-1sollte behandelt werden)

Ausgabe
- Eine ASCII-Darstellung der Stapelanordnung wie unten definiert.
Dies kann Leerzeichen rechts von jeder Zeile enthalten, sodass keine Zeile länger als ein Zeichen ist als die Länge, die druckbare Zeichen in der längsten (untersten) Zeile verwenden.
Dies kann eine einzelne nachgestellte neue Zeile enthalten. und
Die Zeichen, die Chips darstellen, können nach Belieben in Kleinbuchstaben geschrieben werden.

Die Stapelanordnung wird:

• Enthalten Sie die geringstmöglichen Chips, je nach Stückelung (siehe unten).
• Wird gleichwertige Chips in "Stapeln" (Spalten) haben;
• Sie müssen so angeordnet sein, dass die kürzeren Stapel rechts von den größeren Stapeln stehen. und
• Sie müssen so angeordnet sein, dass Stapel mit Chips mit höherem Nennwert rechts von gleich großen Stapeln mit niedrigerem Nennwert stehen (was bedeutet, dass sie für unsere Gegner auf der rechten Seite sichtbar sind).

Die Chips selbst sollen als einzelne Zeichen dargestellt werden, die ihre Farbe kennzeichnen:

    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

Beispiel

Für n = 276,352die kleinste Anzahl von Chips wäre:

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

Die einzelnen Pmuss weitergehen ganz rechts,
dann die drei Stapel von Größe als 2nächstes gehen muss,
- aber das MMmuss nach rechts durch die gefolgt gehen am weitesten GGund dann die WWda 100K > 25 > 1 dann die beiden Stapel von Größe 3gehen auf der linken Seite
- aber das CCCmuss gehe nach rechts von dem BBBda25K > 100

Jetzt müssen wir diese Chips in tatsächliche Stapel legen, um unsere Ausgabe zu machen:

BC
BCWGM
BCWGMP

Testfälle

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

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes. Keine Lücken, yada yada, du kennst die Übung.

Pyth, 56 55 52 Bytes

Der Code enthält einige nicht druckbare Dateien. Hier ist also ein umkehrbarer xxdHexdump.

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/

Probieren Sie es online aus. Testsuite.

Profi-Tipp: Zum Golfspielen 1am Ende eines Programms, in dem eine Zahl ungleich Null akzeptiert wird Q, einfach hinzufügen /. /QQ, was in Python wäre Q // Q, ist 1 für ungleich Null Q.

Ohne Komprimierung und nicht druckbare Dateien (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)

Formatiert und kommentiert

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

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

Tests auf 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

Erläuterung:
Füllen Sie die Liste Lmit Elementen [quanity, chip_order, chip_character], die die Menge der einzelnen Chipsarten angeben, wobei chip_ordersichergestellt wird, dass Chips gleicher Menge in umgekehrter Reihenfolge sortiert werden (Chips mit höherem Wert zuerst ). Nehmen Sie die Chips Lin umgekehrter Reihenfolge, um Zeichenfolgen für jede Zeile zu bilden. Drucken Sie die Zeilen in umgekehrter Reihenfolge, um die kleinsten Zeilen nach oben zu bringen.

Vielen Dank an Blue für einige Verbesserungen.

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)

Die ASCI-Darstellung und die richtige Reihenfolge verschlucken den größten Teil des Codes.

* Funktioniert nur mit Version 11 und höher (Verwendung von 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";}