Affichez les 12 chiffres sur un cadran exactement comme ceci:

           12            
     11           1      

 10                   2  


9                       3


  8                   4  

      7           5      
            6            

Pour mieux voir la grille, en voici une avec des points:

...........12............
.....11...........1......
.........................
.10...................2..
.........................
.........................
9.......................3
.........................
.........................
..8...................4..
.........................
......7...........5......
............6............

Notez que la largeur de la grille est multipliée par deux pour la rendre plus carrée.

Notez également que les nombres à deux chiffres sont alignés avec leur chiffre en place. Le chiffre 9 doit être aligné sur la gauche.

Renvoyer ou imprimer le résultat sous forme de chaîne multiligne (et non de liste de lignes). Tous les espaces de fin sont facultatifs. La nouvelle ligne finale est également facultative.

Charbon de bois , 40 octets

Ｆ¹²«Ｍ⁻↔⁻¹⁴⊗÷×⁴鳦⁸⁻⁴↔⁻⁷÷×⁴﹪⁺³ι¹²¦³Ｐ←⮌Ｉ⊕ι

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explanation: Calcule les décalages mathématiquement entre chaque chiffre. Charbon de bois est de 0 indexée (donc la ⊕à la sortie ), de sorte que les formules des décalages horizontaux et verticaux sont les suivantes:$1 \ldots 12$

où .$i' = i + 3 \pmod {12}$

JavaScript (Node.js) , 91 octets

Ce n'est pas une approche très intelligente, mais je n'ai rien trouvé de plus court pour le moment.

_=>`K12
E11K1

A10S2


9W3


B8S4

F7K5
L6`.replace(/[A-Z]/g,c=>''.padEnd(Buffer(c)[0]&31))

Essayez-le en ligne!

05AB1E , 39 33 31 octets

Merci à Magic Octopus Urn pour avoir économisé 6 octets!

Code

6xsG12N-N•°£•NèØú«тR∞Nè¶×]\6».c

Quelques alternatives de 33 octets:

711ćŸā•Σ°w•₂вú‚øJƵt3в¶×‚ø»6xŠ».c¦
6xsŸ5L•Σ°w•₂вúõ¸ì‚ζJï2Ý«ƶ×)ø».c
6xsG¶12N-N•Θ{©•₂вNèú«ƵB∞Nè¶×]6J.c
6xsG12N-N•Θ{©•₂вNèú«тR∞Nè¶×]6s».c

Utilise le codage 05AB1E . Essayez-le en ligne!

6502 code machine (C64), 82 76 73 octets

00 C0 A2 0E BD 38 C0 29 03 A8 A9 0D 20 25 C0 BD 38 C0 4A 4A A8 A9 20 20 25 C0
BD 29 C0 20 D2 FF CA 10 E1 60 20 D2 FF 88 10 FA 60 36 35 37 34 38 33 39 32 30
31 31 31 31 32 31 31 2C 1A 4C 0B 5C 03 4C 00 06 2C 00 15 00 2C

• -6 octets, merci à Arnauld pour son idée géniale :)
• un autre -3 octets après l'idée d'Arnauld de ne pas traiter 1spécialement les premiers chiffres

L'idée ici est de ne stocker que les chiffres de tous les nombres dans l'ordre où ils sont nécessaires. Les informations supplémentaires requises sont le nombre de nouvelles lignes à ajouter et le nombre d'espaces devant.

Le nombre maximal de nouvelles lignes est égal à 32 bits 23. Par conséquent, 5 bits suffisent. Par conséquent, pour chaque chiffre à imprimer, nous pouvons compresser ces informations dans un seul "octet de contrôle".

Ainsi, les données pour cette solution prennent exactement 30 octets: 15 chiffres simples et 15 "octets de contrôle" associés.

Démo en ligne

Utilisation: SYS49152pour commencer.

Démontage commenté :

         00 C0                          ; load address
.C:c000  A2 0E       LDX #$0E           ; table index, start from back (14)
.C:c002   .mainloop:
.C:c002  BD 38 C0    LDA .control,X     ; load control byte
.C:c005  29 03       AND #$03           ; lowest 3 bits are number of newlines
.C:c007  A8          TAY                ; to Y register for counting
.C:c008  A9 0D       LDA #$0D           ; load newline character
.C:c00a  20 25 C0    JSR .output        ; repeated output subroutine
.C:c00d  BD 38 C0    LDA .control,X     ; load control byte
.C:c010  4A          LSR A              ; and shift by two positions for ...
.C:c011  4A          LSR A              ; ... number of spaces
.C:c012  A8          TAY                ; to Y register for counting
.C:c013  A9 20       LDA #$20           ; load space character
.C:c015  20 25 C0    JSR .output        ; repeated output subroutine
.C:c018  BD 29 C0    LDA .digits,X      ; load current digit
.C:c01b  20 D2 FF    JSR $FFD2          ; output
.C:c01e  CA          DEX                ; decrement table index
.C:c01f  10 E1       BPL .mainloop      ; still positive -> repeat
.C:c021  60          RTS                ; and done.
.C:c022   .outputloop:
.C:c022  20 D2 FF    JSR $FFD2          ; output a character
.C:c025   .output:
.C:c025  88          DEY                ; decrement counting register
.C:c026  10 FA       BPL .outputloop    ; still positive -> branch to output
.C:c028  60          RTS                ; leave subroutine
.C:c029   .digits:
.C:c029  36 35 37 34 .BYTE "6574"
.C:c02d  38 33 39 32 .BYTE "8392"
.C:c031  30 31 31 31 .BYTE "0111"
.C:c035  31 32 31    .BYTE "121"
.C:c038   .control:
.C:c038  31 2C 1A 4C .BYTE $31,$2C,$1A,$4C
.C:c03c  0B 5C 03 4C .BYTE $0B,$5C,$03,$4C
.C:c040  00 06 2C 00 .BYTE $00,$06,$2C,$00
.C:c044  15 00 2C    .BYTE $15,$00,$2C

Perl 6 , 76 74 octets

$_="K12
E11K1

A10S2


9W3


B8S4

F7K5
L6";say S:g/<:Lu>/{" "x$/.ord-64}/

Essayez-le en ligne!

Réponse du port d'Arnauld jusqu'à ce que je puisse proposer quelque chose de plus court.

R , 75 68 octets

write("[<-"(rep("",312),utf8ToInt('*`®÷ĥĹĚä—M'),1:12),1,25)

Essayez-le en ligne!

Compresse les positions des chiffres. Cela après avoir passé beaucoup de temps à essayer de trouver une réponse trigonométrique (voir l'historique des modifications).

Inspiré par cette autre réponse R achetez J.Doe - votez-le!

Sauvegardé 7 octets grâce à J.Doe.

HTML + JavaScript (Canvas), 13 + 161 = 174 octets

Le positionnement arbitraire de la toile utilise 6 octets.

with(C.getContext`2d`)with(Math)for(font='9px monospace',textAlign='end',f=x=>round(sin(x*PI/6)*6)*measureText(0).width*2,x=13;--x;)fillText(x,f(x)+80,f(9-x)+80)

<canvas id=C>

Avec grille de comparaison:

with(C.getContext`2d`)with(Math){
    for(font='9px monospace',textAlign='end',f=x=>round(sin(x*PI/6)*6)*measureText(0).width*2,x=13;--x;)fillText(x,f(x)+80,f(9-x)+80)
    for(globalAlpha=0.2,y=-6;y<=6;y++)fillText('.'.repeat(25),6*measureText('.').width*2+80,y*measureText(0).width*2+80)
}

<canvas id=C>

Explication de la formule de positionnement

Voir mon JavaScript avec réponse SVG .

Java 8 11, 141 138 octets

v->{for(var x:"92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G".getBytes())System.out.print(x<59?" ".repeat(x-48):(char)(x>76?10:x-17));}

Essayez-le en ligne (NOTE: String.repeat(int)est émulé commerepeat(String,int) pour le même nombre d'octets, car Java 11 n'est pas encore sur TIO.)

L'explication est similaire à celle ci-dessous, mais elle utilise " ".repeat(x-48)pour les espaces au lieu du format avec "%"+(x-48)+"s".

Java 8, 141 octets

v->{for(var x:"92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G".getBytes())System.out.printf("%"+(x>58?"c":x-48+"s"),x>76?10:x>58?x-17:"");}

Essayez-le en ligne.

Explication:

v->{                        // Method with empty unused parameter and no return-type
  for(var x:"92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G".getBytes())
                            //  Loop over the bytes of the above String:
    System.out.printf("%"+  //   Print with format:
     (x>58?                 //    If the character is a letter / not a digit:
       "c"                  //     Use "%c" as format
      :                     //    Else:
       x-48+"s"),           //     Use "%#s" as format, where '#' is the value of the digit
     x>76?                  //    If the byte is 'N':
      10                    //     Use 10 as value (newline)
     :x>58?                 //    Else-if the byte is not a digit:
      x-17                  //     Use 48-58 as value (the 0-9 numbers of the clock)
     :                      //    Else:
      "");}                 //     Use nothing, because the "%#s" already takes care of the spaces

Explication complémentaire 92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G:

• Tous les chiffres seront remplacés par cette quantité d'espaces. (Pour 11 espaces c'est donc92 .)
• Tous les 'N' sont des lignes nouvelles
• Tous ['A', 'J'] sont des chiffres d'horloge ([0,9])

R, 168 159 125 octets

La solution naïve d'écrire les nombres aux points prescrits dans une matrice de texte. Les points sont stockés sous forme de lettres UTF-8 décodées viautf8ToInt

"!"=utf8ToInt
write("[<-"(matrix(" ",25,13),cbind(!"LMFGSBCWAYCWGSM",!"AABBBDDDGGJJLLM")-64,-64+!"ABAAAA@BICHDGEF"),1,25,,"")

Supprimé 9 octets avec la suggestion de JayCe d'utiliser write et d'éviter de définir la matrice.

Supprimé 34 octets supplémentaires avec la suggestion de stockage de JayCe.

Haskell, 88 87 octets

f=<<"k12{e11k1{{a10s2{{{9w3{{{b8s4{{f7k5{l6"
f c|c>'z'="\n"|c>'9'=' '<$['a'..c]|1<2=[c]

La méthode encode-espaces-comme-lettres (apparue pour la première fois dans la réponse de @ Arnauld ) en Haskell. L’utiliser {et le développer \nest un octet plus court que l’utiliser \ndirectement.

Essayez-le en ligne!

Rouille , 96 octets

||format!(r"{:13}
     11{:12}

 10{:20}


9{:24}


  8{:20}

{:7}{:12}
{:13}",12,1,2,3,4,7,5,6)

Essayez-le en ligne!

brainfuck , 240 235 octets

++++++++++[>++>+>+++>+++++>++>++[<]>-]>>>++...........>-.+.<<.>.....>-..<...........>.<<..>.>.-.>-[<<.>>-]<++.<<...>>+++++++.>>+++[<<<.>>>-]<<------.<<...>..>+++++.<<<-[>>.<<-]>>>----.<<..>......>+++.<...........>--.<<.>............>+.

Essayez-le en ligne!

Code commenté

++++++++++                              Put 10 in cell 0
[>++>+>+++>+++++>++>++[<]>-]            Loop 10 times incrementing to leave 0 20 10 30 50 20 20 in memory 
>>>++                                   30 plus 2 = 32 (ascii space)
...........>-.+.                        print 11spaces followed by 12 (ascii 49 50)
<<.>.....>-..<...........>.             print 1newline 5spaces 11 11spaces 1 
<<..>.>.-.>-[<<.>>-]<++.                print 2newlines 1space 10 19spaces 2
<<...>>+++++++.>>+++[<<<.>>>-]<<------. print 3newlines         9 23spaces 3
<<...>..>+++++.<<<-[>>.<<-]>>>----.     print 3newlines 2spaces 8 19spaces 4
<<..>......>+++.<...........>--.        print 2newlines 6spaces 7 11spaces 5
<<.>............>+.                     print 1newline  12spaces 6

Un exemple rare où le texte est suffisamment répétitif pour que le programme brainfuck soit inférieur à deux fois 1,6 fois la longueur de la sortie!

2 octets enregistrés sur proposition de Jo King: >>>>>>- ->[<]>-

Économisez 3 octets en déplaçant le troisième décompteur de 20 places de l'extrême droite des codes ASCII 10 30 50vers leur gauche. Enregistre <<>>lors du remplissage de l'écart entre 8et4 mais ajoute 1 octet à la ligne >>>++.

Version originale

++++++++++                              Put 10 in cell 0
[>+>+++>+++++>++>++>++<<<<<<-]          Loop 10 times incrementing to leave 0 10 30 50 20 20 20 in memory 
>>++                                    30 plus 2 = 32 (ascii space)
...........>-.+.                        print 11spaces followed by 12 (ascii 49 50)
<<.>.....>-..<...........>.             print 1newline 5spaces 11 11spaces 1 
<<..>.>.-.>-[<<.>>-]<++.                print 2newlines 1space 10 19spaces 2
<<...>>+++++++.>>+++[<<<.>>>-]<<------. print 3newlines         9 23spaces 3
<<...>..>+++++.>>>-[<<<<.>>>>-]<<<----. print 3newlines 2spaces 8 19spaces 4
<<..>......>+++.<...........>--.        print 2newlines 6spaces 7 11spaces 5
<<.>............>+.                     print 1newline  12spaces 6

Python 2 , 97 octets

for i in range(7):w=abs(3-i);print'%*d'%(1-~w*w,12-i),'%*d'%(24-3**w-2*w,i)*(w<3),'\n'*min(i,5-i)

Essayez-le en ligne!

Calcule tous les espacements et les nouvelles lignes dans la boucle

Gelée , 32 octets

⁶ẋ“¿×¿ Œ4ç4Œ!¿Ø‘ż“øn0œ’Œ?D¤Fs25Y

Un programme complet qui affiche le résultat.

Essayez-le en ligne!

Comment?

(Je n'ai pas encore pensé à / trouvé quelque chose de plus court que “¿×¿ Œ4ç4Œ!¿Ø‘ce qui me semble long pour cette partie - rebondissant / décomposition de base / incréments, rien ne semble économiser!)

⁶ẋ“¿×¿ Œ4ç4Œ!¿Ø‘ż“øn0œ’Œ?D¤Fs25Y - Main Link: no arguments
⁶                                - space character
  “¿×¿ Œ4ç4Œ!¿Ø‘                 - code-page indices list = [11,17,11,32,19,52,23,52,19,33,11,18]
 ẋ                               - repeat (vectorises) -> [' '*11, ' '*17, ...]
                          ¤      - nilad followed by link(s) as a nilad:
                 “øn0œ’          -   base 250 number = 475699781
                       Œ?        -   first natural number permutation which would be at
                                 -   index 475699781 if all permutations of those same
                                 -   natural numbers were sorted lexicographically
                                 -   = [12,11,1,10,2,9,3,8,4,7,5,6]
                         D       -   to decimal lists = [[1,2],[1,1],[1],[1,0],[2],[9],[3],[8],[4],[7],[5],[6]]
                ż                - zip together = [[' '*11, [1,2]], [' '*17, [1,1]], ...]
                           F     - flatten = [' ',' ',...,1,2,' ',' ',...,1,1,...]
                            s25  - split into chunks of 25 (trailing chunk is shorter)
                               Y - join with new line characters
                                 - implicit print

C (gcc) , 145 137 125 octets

Seules les positions de tabulation sont codées en dur: tous les espacements de ligne et les valeurs d'horloge sont générés dans la boucle.

Merci encore à ceilingcat pour les suggestions.

i,j,k;f(char*t){for(i=7;i--;t=memset(t+sprintf(t,"%*d%*d"+3*!j,"NHDA"[j]-65,6+i,"AMUY"[j]-65,6-i),10,k=j+i/4)+k)j=i>3?6-i:i;}

Essayez-le en ligne!

PHP , 97 octets

<?=gzinflate(base64_decode(U1CAA0MjLghtqIAkyMWlYGiggAmMuLi4LBWwA2OgnIKCBRYZEy6IHQrmSIKmXMhKzAA));

Essayez-le en ligne!

C'est une chaîne comprimée codée en dur. Je ne pouvais pas trouver une solution plus courte que celle!

Pyke , 37 octets

3B 32 35 75 07 0d 13 0c 22 14 35 18 44 74 5F 74 2B 46 6F 68 32 C4 52 7D 74 2A 31 32 25 31 32 7C 60 52 2D 29 73

Essayez-le ici! (octets bruts)

;25Dt_t+Foh2.DR}t*12%12|`R-)s

Essayez-le ici! (Lisible par l'homme)

                              - o = 0
;25                           - set line width to 25 characters
                              -      `[13, 19, 12, 34, 20, 53, 24]`
                              -       (In hex version, encoded in base 256, regular version in input field)
    t_t                       -     reversed(^[1:])[1:]
   D   +                      -    ^^ + ^
        Foh2.DR}t*12%12|`R-)  -   for i in ^:
         o                    -            o++
          h                   -           ^+1
           2.DR               -          divmod(^, 2)
               }t             -         (remainder*2)-1
                 *            -        quotient * ^
                  12%         -       ^ % 12
                     12|      -      ^ or 12 (12 if 0 else ^)
                        `     -     str(^)
                         R-   -    ^.rpad(i) (prepend spaces such that length i)
                            s -  sum(^)
                              - output ^ (with newlines added)

brainfuck , 315 313 octets

sauvé 2 octets grâce à ovs !

++++[>++++<-]>[>+++>+++>+++>+++>>++>+++>+++>+++<<<<<<<<<-]>+++++>++++>+++>++>++++++++++>>+++++++>+><<<...........>>.<<<<.>.>.....>>..<<...........>>.<<<..>.>>.>.<<<...................<<.>...>>++.<.......................<<<.>>...>..>-.<...................<<<<.>>>..>......>-.<...........<<<<<.>>>>.>............>-.

Essayez-le en ligne!

tout en un bloc de code:

++++[>++++<-]>[>+++>+++>+++>+++>>++>+++>+++>+
++<<<<<<<<<-]>+++++>++++>+++>++>++++++++++>>+
++++++>+><<<...........>>.<<<<.>.>.....>>..<<
...........>>.<<<..>.>>.>.<<<................
...<<.>...>>++.<.......................<<<.>>
...>..>-.<...................<<<<.>>>..>.....
.>-.<...........<<<<<.>>>>.>............>-.

Powershell, 94 88 82 octets

Opérateur de format direct Powershell . {i,w}signifie un espace réservé pour un paramètre avec index i, la largeur de l'espace réservé est wavec alignement à droite.

"{11,13}
{10,7}{0,12}

 10{1,20}


9{2,24}


  8{3,20}

{6,7}{4,12}
{5,13}"-f1..12

Powershell, 88 octets

Réponse Javascript du port d' Arnauld

-6 octets grâce à @AdmBorkBork

[RegEx]::Replace("K12
E11K1

A10S2


9W3


B8S4

F7K5
L6",'[A-Z]',{' '*("$args"[0]-64)})

Pour mieux voir la grille, utilisez '.'plutôt ' '.

C (gcc) , 125 109 105 octets

x,*d=L"<;1:2938475640P`P05";main(i){for(;i=d[12];printf("%*d",i/4,*d++-48))for(x=i&3;x--;)puts("");}

• -16 octets (-3 pour une meilleure organisation des boucles, -13 pour inclure directement les caractères non imprimables) grâce à Jonathan Frech .
• -4 octets en remplaçant une division pour une équipe et en abusant du fait que sur de nombreux systèmes (comme celui hébergeant TIO), sizeof(wchar_t) == sizeof(int)- ne fonctionnera pas sous Windows :) Merci ErikF pour cette idée.

Essayez-le en ligne!

Ce port est de mon idée générale de la solution 6502 à C. Il est un peu modifiée: au lieu d'avoir un drapeau pour un chef de file 1, le caractère est imprimé sous forme décimale en soustrayant 48, donc 10 - 12 sont encodées comme :à <.

Attaché , 69 octets

{ReplaceF["l12
f11l1

b10t2


9x3


c8t4

g7l5
m6",/"\\l",sp&`*@STN]}

Essayez-le en ligne!

Ce code pour chaque série d'espaces que: NTS[count of spaces]; NTSest le "numeric to short" intégré, qui permet aux nombres d'être exprimés sous forme de chaînes. Par exemple, NTS[95] = $R1et NTS[170297] = $XQO. STNest l'inverse de cette fonction intégrée.

Cette réponse remplace ( ReplaceF) toutes les occurrences de lettres ( /\l/) dans l'entrée par le résultat de la fonction sp&`*@STN, qui décode d'abord la lettre puis se répète sp(un espace) autant de fois.

Rapide , 178 165 octets

var b="";for c in"L12nF11L1nnB10T2nnn9X3nnnC8T4nnG7L5nM6"{let i=c.unicodeScalars.first!.value;if c=="n"{b+="\n"}else if i>64{for _ in 0..<(i-65){b+=" "}}else{b+="(c)"}};print(b)

D'après ce que Downgoat a posté, j'ai réduit ce nombre à 165 octets:

print("L12nF11L1nnB10T2nnn9X3nnnC8T4nnG7L5nM6".unicodeScalars.map{let x=Int($0.value);return x==110 ?"\n":(x>64 ?String(repeating:" ",count:x-65):"($0)")}.joined())

Développé, avec $0converti en une variable nommée:

print("L12nF11L1nnB10T2nnn9X3nnnC8T4nnG7L5nM6".unicodeScalars.map { c in let x = Int(c.value) return x == 110 ? "\n" : (x>64 ? String(repeating:" ", count: x-65) : "(c)") }.joined())

La chaîne d'entrée est codée comme suit: Les lettres majuscules ( A-Z) représentent des blocs d'espaces, décalés de 65. Cela Asignifie 0 espaces, B1 espace, les premiers L11, etc. ns sont convertis en traits nouveaux. Tous les autres caractères sont imprimés tels quels.

Exécutez-le en ligne ici (merci, mbomb007)

Pure Bash , 123

printf fait le gros du travail ici:

n=" 0 a 0 a"
printf -vo %*s%*s\\n 0 a 13 12 7 11 12 1 $n 3 10 20 2$n$n 1 9 24 3$n$n 3 8 20 4$n 7 7 12 5 13 6
echo "${o//a}"

Essayez-le en ligne!

Rouge , 151 octets

foreach[a b c d][13 12 1""7 11 12 1 1""1""3 10 20 2 1""1"^/"0 9 24 3 1""1"^/"3 8 20 4 1""1""7 7 12 5 13 6 1""][print rejoin[pad/left b a pad/left d c]]

Essayez-le en ligne!

JavaScript avec SVG, 188 octets

Une hauteur de ligne arbitraire de 120% utilise 4 octets.

with(Math)for(s='<pre><svg viewBox=-8-8+16+16 style=font-size:1;text-anchor:end>',f=x=>round(sin(x*PI/6)*6),x=13;--x;)s+=`<text x=${f(x)*2}ch y=${f(9-x)*1.2}>${x}</text>`
document.write(s)

Avec grille de comparaison:

with(Math)for(s='<pre><svg viewBox=-8-8+16+16 style=font-size:1;text-anchor:end>',f=x=>round(sin(x*PI/6)*6),x=13;--x;)s+=`<text x=${f(x)*2}ch y=${f(9-x)*1.2}>${x}</text>`
for(y=-6;y<=6;y++)s+=`<text x=12ch y=${y*1.2} style=fill:#0002>${'.'.repeat(25)}</text>`
document.write(s)

Explication de la formule de positionnement

Let f(x) = round(sin(x * π/6) * 6).

En supposant que l'origine soit le centre de l'horloge, les coordonnées de la grille du chiffre le plus à droite d'un numéro d'horloge donné xsont [ f(x) * 2, f(9 - x)].

Bash, 225 octets

s=(12 0 6 11 0 0 2 19 0 0 0 0 1 23 0 0 0 0 3 19 0 0 7 11 13 0)
n=(12 11 1 10 2 9 3 8 4 7 5 6) j=0;for i in {0..25};{
[ ${s[i]} = 0 ]||{ printf %${s[i]}s " ";echo -n ${n[j]}
j=$((j+1));};[ $((i%2)) -gt 0 ]&&echo;}|sed 's/ //'

Ce qui est ennuyeux est plus long que la solution naïve consistant à n’imprimer que chaque ligne en boucle (132 caractères si vous utilisez des tabulations).

Python 3 , 112 88 87 octets

Une solution utilisant l'interpolation de chaîne.

print(f'''{12:13}
{11:7}{1:12}

 10{2:20}


9{3:24}


  8{4:20}

{7:7}{5:12}
{6:13}''')

Essayez-le en ligne!

-25 octets grâce aux ovs et à Herman L.

C (gcc) , 135 123 110 octets

Ceci utilise un encodage simple où tout centre 'a'et 'z'représente c-'a'+1des espaces répétés, '`'représente une nouvelle ligne, et tous les autres caractères restent inchangés.

f(i){char*s="k12`e11k1``a10s2```9w3```b8s4``f7k5`l6`";for(;i=*s;s++)i>96?printf("%*s",i-96,""):putchar(i%86);}

Essayez-le en ligne!

T-SQL, 132 octets

PRINT SPACE(11)+'12
     11           1

 10'+SPACE(20)+'2


9'+SPACE(23)+'3


  8'+SPACE(19)+'4

      7           5
            6'

Seulement 12 octets plus court que la solution triviale ( PRINTde la chaîne entière telle quelle).

J'ai trouvé une variation que j'apprécie beaucoup plus longue ( 235 226 octets), mais beaucoup plus semblable à SQL:

SELECT CONCAT(SPACE(PARSENAME(value,4)),PARSENAME(value,3),
              SPACE(PARSENAME(value,2)),PARSENAME(value,1))
FROM STRING_SPLIT('11.1..2,5.11.11.1,. .. ,1.10.20.2,. .. ,. .. ,.9.23.3,
                   . .. ,. .. ,2.8.19.4,. .. ,6.7.11.5,12.6.. ',',')

STRING_SPLITle divise en rangées au niveau des virgules et PARSENAMEdivise chaque rangée en points. Les 1er et 3ème sont utilisés pour combien d'espaces à imprimer, les 2ème et 4ème sont utilisés pour ce qu'il faut afficher.

(les sauts de ligne dans celui-ci sont juste pour la lisibilité)

Perl 6 , 116 octets

my@a=["  "xx 13]xx 13;($_=pi/6*++$;@a[0+|6*(1.1-.cos);0+|6*(1.1+.sin)]=fmt ++$: "%2s")xx 12;@a>>.join>>.&{say S/.//}

Essayez-le en ligne!

(Ta @JoKing pour économiser 26 octets)

Perl 6 , 142 octets

my@a=[[[32,32]xx 13]xx 13];for 1..12 {$_=$^b*pi/6;@a[round 6*(1-.cos);round 6*(1+.sin)]=[" $b".ords.tail(2)]}
{say S/^.//}(.[*;*].chrs) for @a

Essayez-le en ligne!

Je voulais faire quelque chose de différent. Donc, celui-ci calcule les positions de tous les chiffres, via des paires de caractères, supprime l’espace initial et affiche les lignes.

Facilement modifiable pour différents paramètres, par exemple une version large de 45 caractères à 17 chiffres .