Remplissez le seau

14

Votre tâche consiste à remplir le seau de chiffres jusqu'à une entrée donnée.

Règles

Les nombres occupent la position la plus à gauche puis la plus à droite, puis la plus à gauche et ainsi de suite.

Après le débordement, les chiffres commencent à se rassembler autour du seau de manière similaire. Ils occupent la position en diagonale.

Les exemples doivent indiquer clairement le résultat attendu (certaines règles sont mentionnées dans les exemples).

Pour plus de 10, utilisez le chiffre le plus à droite

Exemples:

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

C'est le code-golf donc le code le plus court gagne.

Vedant Kandoi
la source
Que voulez-vous dire exactement par "vous pouvez commencer à partir de 0 ou 1" ? La séquence de chiffres elle-même peut-elle être indexée 0 (c'est- |024531|à- dire pour ) ou uniquement l'entrée? n=6
Arnauld
@Arnauld, oui, la séquence peut commencer à partir de 0
Vedant Kandoi
C'est l'un des meilleurs défis de codage pour le golf de code que j'ai vu ici!
Michael Karas

Réponses:

9

JavaScript (Node.js) ,  145  143 octets

Un modèle codé en dur (voir ici pour plus de mathématiques).

1 indexé.

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

Essayez-le en ligne!

Sauvegardé 2 octets grâce à @tsh

Arnauld
la source
1
/[^\s|-]/->/[0-z]/
tsh
@tsh D'oh! J'ai totalement raté cette simplification. Je vous remercie!
Arnauld
7

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

Une approche mathématique (voir ici pour moins de maths).

0 indexé.

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

Essayez-le en ligne!

Comment?

y40X018 sur chaque ligne.

Nous définissons:

X={Xsi X817-Xsi X>8

En écrivant les valeurs complètes plutôt que seulement les chiffres des unités, nous obtenons le tableau suivant:

 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

Ce tableau est essentiellement symétrique sur l'axe des y, sauf que les valeurs du côté gauche sont paires et les valeurs du côté droit sont leurs homologues impaires.

Nous définissons:

k={24+(4+yX)(5+yX)+2yif X<56y+2X18if X>5

k={kif x8k+1if x>8

Et pour chaque cellule, nous ajoutons:

  • X=1
  • X=5
  • k<0
  • X<yk>nn
  • kmoddix

Commenté

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
Arnauld
la source
3

Python 2 , 170 octets

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

Essayez-le en ligne!

TFeld
la source
3

Java 10, 168 octets

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 de la réponse JavaScript de @Arnauld (donc également indexé 1, et sortie -en bas). Si vous aimez cette réponse, assurez-vous de lui aussi voter positivement!

Essayez-le en ligne.

Explication:

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
Kevin Cruijssen
la source
1

6502 code machine (C64), 130 octets

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

Cela utilise une version modifiée de l'approche "préformatée" de certaines autres réponses. Il contient une chaîne complète du compartiment, mais les chiffres sont remplacés par des valeurs à partir de 0xC1, tandis que tous les caractères pour l'impression directe sont dans la plage0x01 -0x7f .

Le jeu de caractères C64 n'inclut pas de caractère pipe ( |), il est donc remplacé par le caractère PETSCII similaire 0x7d.

Démo en ligne

Utilisation: SYS49152,[n](1 indexé, par exempleSYS49152,54 pour la sortie complète)

Démontage commenté :

         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
Felix Palmen
la source
0

Fusain , 64 octets

Nθ³↑⁵‖M←F²«‖J⁻³ι±¹F⊘⁺θ¬ι«↖I﹪⁺⊗κ⊕ιχM§”)⊟E≡≦⌈▷⊖ü∕”꧔)⊟&hXτtD(λM”κ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Nθ

Saisissez le numéro.

³↑⁵‖M←

Dessinez la moitié du seau, puis mettez-la en miroir pour terminer le seau.

F²«

Boucle pour chaque côté du seau.

‖J⁻³ι±¹

Réfléchissez le seau afin que nous puissions dessiner dans une direction cohérente sur les deux boucles et sauter à la position du premier chiffre de ce côté du seau.

F⊘⁺θ¬ι«

Faites une boucle sur le nombre de chiffres de ce côté du seau.

↖I﹪⁺⊗κ⊕ιχ

Imprimez le chiffre suivant et déplacez le curseur vers le haut et vers la gauche.

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

Ajustez la position du curseur en lisant les décalages de deux chaînes compressées 003003003005203004000500(décalages horizontaux) et 11011011011510200300040000(décalages verticaux). Ces décalages tiennent compte du mouvement du curseur ci-dessus, ce qui signifie qu'ils ne doivent jamais être négatifs.

Neil
la source