Nhiệm vụ của bạn là lấp đầy các thùng với các số cho đến một đầu vào nhất định.

Quy tắc

Các số chiếm vị trí ngoài cùng bên trái rồi ngoài cùng bên phải, sau đó ngoài cùng bên trái và cứ thế.

Sau khi tràn, các con số bắt đầu tập hợp xung quanh xô theo cách tương tự. Họ chiếm vị trí theo đường chéo.

Các ví dụ sẽ làm rõ đầu ra dự kiến ​​là gì (Một số quy tắc được đề cập trong các ví dụ).

Để có nhiều hơn 10, sử dụng chữ số ngoài cùng bên phải

Ví dụ:

The bucket: 
|      |  or |      | 
|      |     |      | 
|      |     |      |
|      |     |      |
|------|     |______|

input:1  (You can start from either 0 or 1)
output:
|      |  (There can be whitespace to the left even if there is no overflow
|      |  but the bucket must not be distorted.)
|      |
|1     |
|------|

input:6
output:
|      |
|      |
|      |
|135642|
|------|

input:8
output:
|      |
|      |
|7    8|
|135642|
|------|

input:23
output:
|913 20|
|357864|
|791208|
|135642|
|------|

input:27
output:
  |913420|
  |357864|
  |791208|
  |135642|
75|------|6

input:30
output:
  |913420|
  |357864|
  |791208|
 9|135642|0
75|------|68

input:40
output:
    |913420|
    |357864|
   5|791208|6
 939|135642|040
7175|------|6828

input:54   (Maximum input for start=1)
    3|913420|4
   13|357864|42
  915|791208|620
 7939|135642|0408
57175|------|68286

Đây là mã golf nên mã ngắn nhất sẽ thắng.

JavaScript (Node.js) ,  145  143 byte

Một mô hình mã hóa cứng (xem ở đây để biết thêm toán học).

1 chỉ mục.

n=>`    g|EGIJHF|h
   e]|?ACDB@|^f
  c[U|9;=><:|V\\d
 aYSO|357864|PTZb
_WQMK|------|LNRX\``.replace(/[3-h]/g,c=>(x=Buffer(c)[0])<n+51?x%10:' ')

Hãy thử trực tuyến!

Đã lưu 2 byte nhờ @tsh

JavaScript (ES6),  144 ... 139  137 byte

Một cách tiếp cận toán học (xem ở đây để biết ít toán học hơn).

Chỉ số 0.

n=>(y=4,g=x=>~y?(X=x>8?17-x:x,k=X<y?g:X<5?24-(z=4+y-X)*~z+y*2:y*6+X*2-18,~X?X^5?k<0?'-':(k+=x>8)<n?k%10:' ':'|':`
`)+g(~X?-~x:!y--):'')()

Hãy thử trực tuyến!

Làm sao?

$y$$4$$0$$x$$0$$18$

Chúng tôi xác định:

$$X=\begin{cases}x&\text{if }x\le 8\\17-x&\text{if }x>8\end{cases}$$

Bằng cách viết các giá trị đầy đủ thay vì chỉ các chữ số đơn vị, chúng tôi nhận được bảng sau:

 x |  0  1  2  3  4  5  6  7  8 |  9 10 11 12 13 14 15 16 17 18
 X |  0  1  2  3  4  5  6  7  8 |  8  7  6  5  4  3  2  1  0 -1
---+----------------------------+-------------------------------
 4 | .. .. .. .. 52 || 18 20 22 | 23 21 19 || 53 .. .. .. .. \n
 3 | .. .. .. 50 42 || 12 14 16 | 17 15 13 || 43 51 .. .. .. \n
 2 | .. .. 48 40 34 || 6  8  10 | 11 9  7  || 35 41 49 .. .. \n
 1 | .. 46 38 32 28 || 0  2  4  | 5  3  1  || 29 33 39 47 .. \n
 0 | 44 36 30 26 24 || -- -- -- | -- -- -- || 25 27 31 37 45 \n

Bảng này về cơ bản là đối xứng qua trục y, ngoại trừ các giá trị ở phía bên trái là chẵn và các giá trị ở phía bên phải là đối tác lẻ của chúng.

Chúng tôi xác định:

$$k=\begin{cases}24+(4+y-X)(5+y-X)+2y&\text{if }X<5\\6y+2X-18&\text{if }X>5\end{cases}$$

$$k'=\begin{cases}k&\text{if }x\le 8\\k+1&\text{if }x>8\end{cases}$$

Và đối với mỗi ô, chúng tôi nối thêm:

• $X=-1$
• $X=5$
• $k<0$
• $X<y$$k'>n$$n$
• $k' \bmod 10$

Đã bình luận

n => (                                // main function taking n
  y = 4,                              // start with y = 4
  g = x =>                            // g = recursive function taking x
    ~y ?                              // if y is not equal to -1:
      ( X = x > 8 ? 17 - x : x,       //   compute X
        k = X < y ?                   //   if X is less than y:
          g                           //     set k to a non-numeric value
        :                             //   else:
          X < 5 ?                     //     if X is less than 5:
            24 - (z = 4 + y - X) * ~z //       apply the 'side numbers' formula
             + y * 2                  //
          :                           //     else:
            y * 6 + X * 2 - 18,       //       apply the 'middle numbers' formula
        ~X ?                          //   if X is not equal to -1:
          X ^ 5 ?                     //     if X is not equal to 5:
            k < 0 ?                   //       if k is less than 0:
              '-'                     //         append a hyphen
            :                         //       else:
              (k += x > 8) < n ?      //         update k to k'; if it's less than n:
                k % 10                //           append the unit digit of k'
              :                       //         else:
                ' '                   //           append a space
          :                           //     else (X = 5):
            '|'                       //       append a pipe
        :                             //   else (X = -1):
          `\n`                        //     append a linefeed
      )                               //
      + g(~X ? -~x : !y--)            //   update x and y, and do a recursive call
    :                                 // else (y = -1):
      ''                              //   stop recursion
)()                                   // initial call to g with x undefined

Python 2 , 170 byte

I=input()
s="    u|SUWXVT|v\n   sk|MOQRPN|lt\n  qic|GIKLJH|djr\n oga]|ACEFDB|^bhp\nme_[Y|------|Z\`fn"
i=1
exec"s=s.replace(chr(64+i),[`i%10`,' '][i>I]);i+=1;"*55
print s

Hãy thử trực tuyến!

Java 10, 168 byte

n->"    g|EGIJHF|h\n   e]|?ACDB@|^f\n  c[U|9;=><:|V\\d\n aYSO|357864|PTZb\n_WQMK|------|LNRX`".chars().forEach(c->System.out.print(c<46|c==124?(char)c:c<n+51?c%10:" "))

Cảng Câu trả lời JavaScript @Arnauld (cũng được lập chỉ mục 1 và xuất ra-dưới cùng). Nếu bạn thích câu trả lời này, hãy chắc chắn để nâng cao anh ấy!

Hãy thử trực tuyến.

Giải trình:

n->                      // Method with integer parameter and no return-type
  "    g|EGIJHF|h\n   e]|?ACDB@|^f\n  c[U|9;=><:|V\\d\n aYSO|357864|PTZb\n_WQMK|------|LNRX`"
                         //  String containing the bucket and magic string
   .chars().forEach(c->  //  Loop over the characters (as integers)
     System.out.print(   //   Print:
       c<46|c==124?      //    If the character is "\n", " ", "-", or "|":
        (char)c          //     Output the character as is
       :c<n+51?          //    Else-if the character value is smaller than the input + 51:
        c%10             //     Output a digit: the character value modulo-9
       :                 //    Else:
        " "))            //     Output a space

Mã máy 6502 (C64), 130 byte

00 C0 20 9B B7 A9 C0 65 65 85 FB A2 00 BD 2B C0 F0 1A 10 12 C5 FB 90 04 A9 20
D0 0A 69 70 C9 3A 90 04 E9 0A B0 F8 20 D2 FF E8 D0 E1 60 20 20 20 20 F5 7D D3
D5 D7 D8 D6 D4 7D F6 0D 20 20 20 F3 EB 7D CD CF D1 D2 D0 CE 7D EC F4 0D 20 20
F1 E9 E3 7D C7 C9 CB CC CA C8 7D E4 EA F2 0D 20 EF E7 E1 DD 7D C1 C3 C5 C6 C4
C2 7D DE E2 E8 F0 0D ED E5 DF DB D9 7D 2D 2D 2D 2D 2D 2D 7D DA DC E0 E6 EE 00

Điều này sử dụng một phiên bản sửa đổi của phương pháp "định dạng sẵn" của một số câu trả lời khác. Nó chứa một chuỗi đầy đủ của nhóm, nhưng các chữ số được thay thế bằng các giá trị bắt đầu từ 0xC1, trong khi bất kỳ ký tự nào để in trực tiếp đều nằm trong phạm vi 0x01- 0x7f.

Bộ ký tự C64 không bao gồm |ký tự pipe ( ), do đó, nó được thay thế bằng ký tự PETSCII trông tương tự 0x7d.

Bản demo trực tuyến

Cách sử dụng: SYS49152,[n](1 chỉ mục, ví dụ: SYS49152,54cho đầu ra đầy đủ)

Nhận xét tháo gỡ :

         00 C0       .WORD $C000        ; load address
.C:c000  20 9B B7    JSR $B79B          ; get unsigned byte from commandline
.C:c003  A9 C0       LDA #$C0           ; add #$C0 (+ carry = #$C1) ...
.C:c005  65 65       ADC $65            ; ... to parameter
.C:c007  85 FB       STA $FB            ; and store in $FB
.C:c009  A2 00       LDX #$00           ; loop index
.C:c00b   .loop:
.C:c00b  BD 2B C0    LDA .bucket,X      ; loop over encoded string
.C:c00e  F0 1A       BEQ .done          ; null-terminator -> done
.C:c010  10 12       BPL .out           ; positive (bit 7 clear) -> output
.C:c012  C5 FB       CMP $FB            ; compare with parameter+#$C1
.C:c014  90 04       BCC .digit         ; smaller -> convert to digit
.C:c016  A9 20       LDA #$20           ; otherwise load space character
.C:c018  D0 0A       BNE .out           ; and output
.C:c01a   .digit:
.C:c01a  69 70       ADC #$70           ; add offset to '0' (#$30)
.C:c01c   .check:
.C:c01c  C9 3A       CMP #$3A           ; greater than '9' (#$39) ?
.C:c01e  90 04       BCC .out           ; no -> to output
.C:c020  E9 0A       SBC #$0A           ; otherwise subtract 10 (#$a)
.C:c022  B0 F8       BCS .check         ; and check again
.C:c024   .out:
.C:c024  20 D2 FF    JSR $FFD2          ; output character
.C:c027  E8          INX                ; next index
.C:c028  D0 E1       BNE .loop          ; and repeat loop
.C:c02a   .done:
.C:c02a  60          RTS                ; exit ....
.C:c02b   .bucket:
.C:c02b  20 20 20    [...]              ; "encoded" string for bucket

Than , 64 byte

Ｎθ³↑⁵‖Ｍ←Ｆ²«‖Ｊ⁻³ι±¹Ｆ⊘⁺θ¬ι«↖Ｉ﹪⁺⊗κ⊕ιχＭ§”)⊟E≡≦⌈▷⊖ü∕”꧔)⊟＆hXτtD(λＭ”κ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｎθ

Nhập số.

³↑⁵‖Ｍ←

Vẽ một nửa của xô và sau đó phản chiếu nó để hoàn thành xô.

Ｆ²«

Vòng lặp cho mỗi bên của xô.

‖Ｊ⁻³ι±¹

Phản xạ xô để chúng ta có thể vẽ theo hướng nhất quán trên cả hai vòng và nhảy đến vị trí của chữ số đầu tiên ở phía đó của xô.

Ｆ⊘⁺θ¬ι«

Lặp lại số chữ số ở phía bên kia của thùng.

↖Ｉ﹪⁺⊗κ⊕ιχ

In chữ số tiếp theo và di chuyển con trỏ lên và sang trái.

Ｍ§”)⊟E≡≦⌈▷⊖ü∕”꧔)⊟＆hXτtD(λＭ”κ

Điều chỉnh vị trí con trỏ bằng cách đọc offset từ hai chuỗi được nén, 003003003005203004000500(offset ngang) và 11011011011510200300040000(offset dọc). Các độ lệch này đưa chuyển động con trỏ ở trên vào tài khoản, điều đó có nghĩa là chúng không bao giờ phải âm.