Poker có phép xã giao trong cách bạn sắp xếp chip của mình, thường được thi hành trong các giải đấu - chip của bạn có thể không bị "ẩn" khỏi đối thủ bằng cách đứng sau những người khác, chủ yếu là không che giấu một số chip có mệnh giá lớn.

Các thách thức

Chúng tôi sẽ chơi bài xì phé trong ASCII, vì vậy chúng tôi cần viết một hàm hoặc chương trình sẽ vẽ sắp xếp ngăn xếp chip ASCII với tổng giá trị của nó , n.

Đầu vào
- Một số nguyên dương, n( 2**32-1cần xử lý tối đa)

Đầu ra
- Một đại diện ASCII của sắp xếp ngăn xếp như được định nghĩa dưới đây.
Điều này có thể chứa khoảng trắng ở bên phải của mỗi dòng sao cho không có dòng nào dài hơn một ký tự so với độ dài được sử dụng bởi các ký tự có thể in trong dòng dài nhất (dưới cùng);
Điều này có thể chứa một dòng mới duy nhất; và
Các ký tự đại diện cho chip có thể được viết thường nếu bạn thích.

Sắp xếp ngăn xếp sẽ:

• Chứa ít chip nhất có thể, với các mệnh giá (xem bên dưới);
• Sẽ có các chip có giá trị bằng nhau trong "ngăn xếp" (cột);
• Được ra lệnh sao cho các ngăn xếp ngắn hơn ở bên phải của các ngăn xếp cao hơn; và
• Được yêu cầu sao cho các ngăn xếp có chip có mệnh giá lớn hơn sẽ ở bên phải các ngăn có kích thước bằng nhau có mệnh giá thấp hơn (thể hiện rằng chúng có thể nhìn thấy đối thủ của chúng ta ở bên phải)

Các chip phải được thể hiện dưới dạng các ký tự riêng lẻ xác định màu của chúng:

    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

Thí dụ

Đối với n = 276,352số lượng chip nhỏ nhất sẽ là:

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

Các đơn Pphải đi vào góc xa bên phải,
sau đó ba ngăn xếp kích thước 2phải đi tới,
- nhưng MMphải đi xa nhất bên phải tiếp theo là GGvà sau đó là WWkể từ 100K > 25 > 1 sau đó hai ngăn xếp kích thước 3đi ở bên trái,
- nhưng CCCphải đi bên phải BBBtừ25K > 100

Bây giờ chúng ta phải đặt các chip này vào ngăn xếp thực tế, để tạo đầu ra:

BC
BCWGM
BCWGMP

Các trường hợp thử nghiệm

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

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte thắng. Không có sơ hở, yada yada, bạn biết khoan.

Pyth, 56 55 52 byte

Mã này chứa một số không thể in được, vì vậy đây là một xxdhexdump có thể đảo ngược .

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/

Hãy thử trực tuyến. Bộ thử nghiệm.

Mẹo chuyên nghiệp: để chơi golf 1vào cuối chương trình chấp nhận số khác không Q, chỉ cần thêm /. /QQ, trong Python sẽ Q // Qlà 1 cho số khác Q.

Không nén và không thể in (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)

Định dạng và nhận xét

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

Bản giới thiệu

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>

Hồng ngọc 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]:""}*""}}

Các thử nghiệm trên 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

Giải thích:
Điền vào danh sách Lvới các yếu tố [quanity, chip_order, chip_character]cho biết số lượng của từng loại chip, trong đó chip_orderđảm bảo các chip có số lượng bằng nhau được sắp xếp theo thứ tự ngược lại ( trước tiên là chip có giá trị cao hơn ). Lấy chip từ Lngược lại để xây dựng chuỗi cho mỗi dòng. In các dòng ngược lại để có được các dòng nhỏ nhất trên đầu trang.

Cảm ơn Blue cho một số cải tiến.

Toán học, 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)

Đại diện ASCI và thứ tự đúng nuốt hầu hết mã.

* Chỉ hoạt động với Phiên bản 11 trở lên (sử dụng Không có gì) *

PHP, 274 byte

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