您的任务是在存储桶中填充最多一个给定输入的数字。

规则

数字占据最左侧的位置，然后是最右侧，然后是最左侧，依此类推。

溢出后，数字开始以类似的方式聚集在存储桶周围。他们对角地占据位置。

这些示例应清楚说明预期的输出是什么（示例中提到了一些规则）。

如果超过10，请使用最右边的数字

例子：

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

这是代码高尔夫球，因此最短的代码获胜。

的JavaScript（Node.js的）， 145个  143字节

硬编码模式（有关更多数学信息，请参见此处）。

1个索引。

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:' ')

在线尝试！

@tsh节省了2个字节

JavaScript（ES6）， 144 ...  139137 字节

数学方法（请参阅 此处）。

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

在线尝试！

怎么样？

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

我们定义：

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

通过写完整值而不只是单位数字，我们得到下表：

 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

该表在y轴上基本上是对称的，除了左侧的值是偶数，而右侧的值是奇数。

我们定义：

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

对于每个单元格，我们附加：

• 如果换行$X=-1$
• 的管道$X=5$
• 如果连字符$k<0$
• $X<y$$k'>n$$n$
• $k' \bmod 10$

已评论

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个字节

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

在线尝试！

Java 10，168个字节

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:" "))

@Arnauld的JavaScript答案的端口（因此也是1索引的，并-作为底部输出）。如果您喜欢此答案，请确保也对他进行投票！

在线尝试。

说明：

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

6502机器代码（C64），130字节

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

这使用了其他答案的“预格式化”方法的修改版本。它包含存储桶的完整字符串，但是数字由开头的值代替0xC1，而任何直接打印的字符都在0x01-0x7f。

C64字符集不包含竖线（|）字符，因此已替换为外观类似的PETSCII字符0x7d。

在线演示

用法：SYS49152,[n]（1索引，例如SYS49152,54用于完整输出）

已评论拆解：

         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

木炭，64字节

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

在线尝试！链接是详细版本的代码。说明：

Ｎθ

输入号码。

³↑⁵‖Ｍ←

绘制桶的一半，然后镜像以完成桶。

Ｆ²«

在桶的每一侧循环。

‖Ｊ⁻³ι±¹

反射存储桶，以便我们可以在两个循环上以一致的方向绘制，并跳转到存储桶那侧的第一个数字的位置。

Ｆ⊘⁺θ¬ι«

循环遍历存储桶那侧的位数。

↖Ｉ﹪⁺⊗κ⊕ιχ

打印下一位并向上和向左移动光标。

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

通过读取两个压缩字符串的偏移量003003003005203004000500（水平偏移量）和11011011011510200300040000（垂直偏移量）来调整光标位置。这些偏移量考虑了上述光标的移动，这方便地意味着它们永远不必为负。