Poker memiliki etiket dalam cara Anda mengatur chip Anda, sering kali diberlakukan di turnamen - chip Anda mungkin tidak "disembunyikan" dari lawan Anda dengan berada di belakang yang lain, kebanyakan untuk tidak menyembunyikan beberapa chip denominasi besar.

Tantangan

Kami akan bermain poker di ASCII, jadi kami perlu menulis fungsi atau program yang akan menarik susunan chip ASCII kami dengan nilai totalnya n,.

Input
- Bilangan bulat positif, n(hingga 2**32-1harus ditangani)

Output
- Representasi ASCII dari pengaturan stack seperti yang didefinisikan di bawah ini.
Ini mungkin berisi spasi putih di sebelah kanan setiap baris sehingga tidak ada garis yang lebih panjang dari satu karakter lebih dari panjang yang digunakan oleh karakter yang dapat dicetak dalam garis terpanjang (bawah);
Ini mungkin mengandung satu baris baru yang tertinggal; dan
Karakter yang mewakili chip mungkin dalam huruf kecil jika Anda mau.

Pengaturan tumpukan akan:

• Mengandung keripik sesedikit mungkin, mengingat denominasi (lihat di bawah);
• Akan memiliki chip bernilai sama di "tumpukan" (kolom);
• Diperintahkan sedemikian rupa sehingga tumpukan yang lebih pendek berada di sebelah kanan tumpukan yang lebih tinggi; dan
• Diperintahkan sedemikian rupa sehingga tumpukan dengan chip denominasi yang lebih besar akan berada di sebelah kanan tumpukan yang berukuran sama dari denominasi yang lebih rendah (menyatakan bahwa mereka dapat dilihat oleh lawan kami di sebelah kanan)

Chip itu sendiri harus direpresentasikan sebagai karakter individu yang mengidentifikasi warna mereka:

    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

Contoh

Untuk n = 276,352jumlah chip terkecil adalah:

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

Satu Pharus pergi di paling kanan,
maka tiga tumpukan ukuran 2harus pergi berikutnya,
- tetapi MMharus pergi terjauh ke kanan diikuti oleh GGdan kemudian WWsejak 100K > 25 > 1 itu dua tumpukan ukuran 3pergi ke kiri,
- tetapi CCCharus pergi ke kanan BBBsejak saat itu25K > 100

Sekarang kita harus menempatkan chip ini ke tumpukan yang sebenarnya, untuk menghasilkan output:

BC
BCWGM
BCWGMP

Uji Kasus

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

Ini adalah kode-golf , jadi kode terpendek dalam byte menang. Tidak ada celah, yada yada, Anda tahu bornya.

Pyth, 56 55 52 byte

Kode ini mengandung beberapa unsintables, jadi inilah xxdhexdump yang dapat dibalik.

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/

Cobalah online. Suite uji.

Kiat pro: untuk bermain golf 1di akhir program yang menerima angka bukan nol Q, cukup tambahkan /. /QQ, yang dalam Python akan Q // Q, adalah 1 untuk nol Q.

Tanpa kompresi dan unsintables (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)

Diformat dan dikomentari

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

Tes pada 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

Penjelasan:
Isi daftar Ldengan elemen-elemen yang [quanity, chip_order, chip_character]menunjukkan jumlah masing-masing jenis chip, di mana chip_ordermemastikan chip dengan jumlah yang sama disortir dalam urutan terbalik (chip bernilai lebih tinggi terlebih dahulu ). Ambil chip dari Lterbalik untuk membangun string untuk setiap baris. Cetak garis secara terbalik untuk mendapatkan garis terkecil di atas.

Terima kasih kepada Blue untuk beberapa perbaikannya.

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)

Representasi ASCI dan urutan kanan menelan sebagian besar kode.

* Hanya berfungsi dengan Version11 dan lebih tinggi (penggunaan Tidak Ada) *

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