Ihre Aufgabe ist es, den Eimer mit Zahlen bis zu einer bestimmten Eingabe zu füllen.

Regeln

Zahlen stehen ganz links, ganz rechts, ganz links und so weiter.

Nach dem Überlauf sammeln sich die Zahlen auf ähnliche Weise um den Eimer. Sie nehmen diagonal Stellung ein.

Die Beispiele sollen verdeutlichen, wie hoch die erwartete Ausgabe ist (einige Regeln werden in den Beispielen erwähnt).

Verwenden Sie für mehr als 10 die am weitesten rechts stehende Ziffer

Beispiele:

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

Das ist Code-Golf, also gewinnt der kürzeste Code.

JavaScript (Node.js) ,  145  143 Bytes

Ein hartcodiertes Muster (siehe hier für mehr Mathe).

1-indiziert.

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

Probieren Sie es online!

2 Bytes dank @tsh gespeichert

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

Ein mathematischer Ansatz (siehe hier für weniger Mathematik).

0-indiziert.

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

Probieren Sie es online!

Wie?

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

Wir definieren:

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

Wenn Sie nicht nur die Ziffern der Einheit, sondern die vollständigen Werte eingeben, erhalten Sie die folgende Tabelle:

 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

Diese Tabelle ist über die y-Achse im Wesentlichen symmetrisch, mit der Ausnahme, dass die Werte auf der linken Seite gerade und die Werte auf der rechten Seite ihre ungeraden Gegenstücke sind.

Wir definieren:

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

Und für jede Zelle fügen wir Folgendes hinzu:

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

Kommentiert

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 Bytes

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

Probieren Sie es online!

Java 10, 168 Bytes

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

Port von @Arnauld 's JavaScript Antwort (also auch 1-indiziert und -als Bottom- Ausgabe ). Wenn dir diese Antwort gefällt, solltest du ihn auch unterstützen!

Probieren Sie es online aus.

Erläuterung:

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 Maschinencode (C64), 130 Bytes

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

Hierbei wird eine modifizierte Version des "vorformatierten" Ansatzes einiger anderer Antworten verwendet. Es enthält eine vollständige Zeichenfolge des Buckets, die Ziffern werden jedoch durch Werte ab ersetzt 0xC1, während sich alle Zeichen für den direkten Druck im Bereich befinden0x01 - befinden 0x7f.

Der C64-Zeichensatz enthält kein pipe ( |) -Zeichen und wird daher durch das ähnlich aussehende PETSCII- Zeichen ersetzt0x7d .

Online-Demo

Verwendung: SYS49152,[n](1-indiziert, zSYS49152,54 für die volle Ausgabe)

Kommentierte Demontage :

         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

Kohle , 64 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｎθ

Geben Sie die Nummer ein.

³↑⁵‖Ｍ←

Zeichnen Sie die Hälfte des Eimers und spiegeln Sie ihn dann, um den Eimer zu vervollständigen.

Ｆ²«

Schleife für jede Seite des Eimers.

‖Ｊ⁻³ι±¹

Reflektieren Sie den Eimer, so dass wir auf beiden Schleifen in einer einheitlichen Richtung zeichnen und zur Position der ersten Ziffer auf dieser Seite des Eimers springen können.

Ｆ⊘⁺θ¬ι«

Überfliege die Anzahl der Stellen auf dieser Seite des Eimers.

↖Ｉ﹪⁺⊗κ⊕ιχ

Gib die nächste Ziffer aus und bewege den Cursor nach oben und links.

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

Passen Sie die Cursorposition an, indem Sie die Offsets aus zwei komprimierten Zeichenfolgen 003003003005203004000500(horizontale Offsets) und 11011011011510200300040000(vertikale Offsets) lesen . Diese Offsets berücksichtigen die obige Cursorbewegung, was günstigerweise bedeutet, dass sie niemals negativ sein müssen.