당신의 임무는 주어진 입력까지 숫자로 양동이를 채우는 것입니다.

규칙

숫자는 가장 왼쪽 위치, 가장 오른쪽 위치, 가장 왼쪽 위치 등을 차지합니다.

오버플로 후 유사한 방식으로 버킷 주위에 숫자가 모이기 시작합니다. 그들은 대각선으로 위치를 차지합니다.

예제는 예상되는 결과가 무엇인지 명확히해야합니다 (일부 규칙이 예제에 언급되어 있음).

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

이것은 코드 골프 이므로 가장 짧은 코드가 승리합니다.

자바 스크립트 (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 바이트 절약

자바 스크립트 (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

파이썬 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

온라인으로 사용해보십시오!

자바 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(수직 오프셋) 의 오프셋을 읽어 커서 위치를 조정합니다 . 이러한 오프셋은 위의 커서 이동을 고려하여 편리하게 음수가 될 필요가 없음을 의미합니다.