Zeigen Sie die 12 Zahlen auf einem Ziffernblatt genau so an:

           12            
     11           1      

 10                   2  


9                       3


  8                   4  

      7           5      
            6            

Um das Raster besser zu sehen, ist hier eines mit Punkten:

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

Beachten Sie, dass das Gitter um den Faktor zwei in der Breite gestreckt ist, damit es quadratischer aussieht.

Beachten Sie auch, dass zweistellige Zahlen an der richtigen Stelle ausgerichtet sind. Die 9-stellige sollte linksbündig sein.

Gibt das Ergebnis als mehrzeilige Zeichenfolge zurück oder druckt es aus (keine Zeilenliste). Alle nachfolgenden Leerzeichen sind optional. Der letzte Zeilenumbruch ist ebenfalls optional.

Kohle , 40 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung: Berechnet die Offsets zwischen den einzelnen Ziffern mathematisch. Holzkohle ist 0 indexierten (also die ⊕zur Ausgabe ), so dass die Formeln für die horizontalen und vertikalen Offsets sind wie folgt:$1 \ldots 12$

Dabei ist .$i' = i + 3 \pmod {12}$

JavaScript (Node.js) , 91 Byte

Keine sehr clevere Herangehensweise, aber ich habe im Moment keine kürzere Herangehensweise gefunden.

_=>`K12
E11K1

A10S2


9W3


B8S4

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

Probieren Sie es online!

05AB1E , 39 33 31 Bytes

Danke an Magic Octopus Urn für das Speichern von 6 Bytes!

Code

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

Einige 33-Byte-Alternativen:

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

Verwendet die 05AB1E- Codierung . Probieren Sie es online!

6502 Maschinencode (C64), 82 76 73 Bytes

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 Bytes, danke an Arnauld für die clevere Idee :)
• weitere -3 Bytes nach Arnauld's Idee, führende 1Ziffern nicht speziell zu behandeln

Die Idee hier ist, nur die Ziffern aller Zahlen in der Reihenfolge zu speichern, in der sie benötigt werden. Zusätzliche Informationen sind die Anzahl der Zeilenvorschübe und die Anzahl der vorangestellten Leerzeichen.

Die maximale Anzahl von Zeilenumbrüchen ist 32 Bit, und die maximale Anzahl von Leerzeichen ist 235 Bit. Daher können wir diese Informationen für jede zu druckende Ziffer in einem einzigen "Steuerbyte" zusammenfassen.

Die Daten für diese Lösung benötigen also genau 30 Bytes: 15 einzelne Ziffern und 15 zugeordnete "Steuerbytes".

Online-Demo

Verwendung: um SYS49152zu beginnen.

Kommentierte Demontage :

         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 Bytes

$_="K12
E11K1

A10S2


9W3


B8S4

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

Probieren Sie es online!

Die Antwort von Port of Arnauld, bis ich mir etwas kürzeres einfallen lassen kann.

R , 75 68 Bytes

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

Probieren Sie es online!

Komprimiert die Ziffernpositionen. Haben Sie dies getan, nachdem Sie viel Zeit damit verbracht haben, eine trigonometrische Antwort zu finden (siehe Änderungsverlauf).

Inspiriert von dieser anderen Antwort von R buy J.Doe - upvote it!

7 Bytes gespart dank J.Doe.

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

Die willkürliche Canvas-Positionierung verwendet 6 Bytes.

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>

Mit Gitter zum Vergleich:

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>

Erklärung der Positionierungsformel

Siehe mein JavaScript mit SVG-Antwort .

Java 8 11, 141 138 Bytes

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

Probieren Sie es online aus (HINWEIS: String.repeat(int)wird emuliert alsrepeat(String,int) für die gleiche Anzahl von Bytes , da Java 11 noch nicht auf TIO läuft.)

Die Erklärung ist ähnlich wie unten, wird jedoch " ".repeat(x-48)für die Leerzeichen anstelle des Formats mit verwendet "%"+(x-48)+"s".

Java 8, 141 Bytes

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

Probieren Sie es online aus.

Erläuterung:

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

Weitere Erklärung 92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G:

• Alle Ziffern werden durch diese Anzahl von Leerzeichen ersetzt. (Für 11 Felder ist es daher 92.)
• Alle 'N' sind neue Zeilen
• Alle ['A', 'J'] sind Uhrziffern ([0,9])

R, 168 159 125 Bytes

Die naive Lösung, die Zahlen an den vorgegebenen Stellen in eine Textmatrix zu schreiben. Punkte werden als UTF-8-Buchstaben gespeichert, die mit dekodiert wurdenutf8ToInt

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

9 Bytes mit dem Vorschlag von JayCe entfernt write, die Matrix zu verwenden und zu vermeiden.

Weitere 34 Bytes mit JayCes Speicherempfehlung gelöscht.

Haskell, 88 87 Bytes

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

Die Methode zum Codieren von Leerzeichen als Buchstaben (erstmals in der Antwort von @ Arnauld zu sehen ) in Haskell. Die Verwendung {und Erweiterung auf \n1 Byte ist kürzer als die \ndirekte Verwendung .

Probieren Sie es online!

Rust , 96 Bytes

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

 10{:20}


9{:24}


  8{:20}

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

Probieren Sie es online!

Brainfuck , 240 235 Bytes

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

Probieren Sie es online!

Kommentierter Code

++++++++++                              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

Ein seltenes Beispiel, bei dem sich der Text so oft wiederholt, dass das Brainfuck-Programm weniger als zweimal ausgeführt wird oft 1,6-fachen Länge der Ausgabe beträgt!

2 Bytes gespart durch Vorschlag von Jo King: >>>>>>-->[<]>-

Durch Verschieben des dritten 20-stelligen Abwärtszählers von ganz rechts neben den ASCII-Codes 10 30 50nach unmittelbar links von ihnen werden 3 Bytes gespart . Speichert, <<>>wenn die Lücke zwischen 8und gefüllt wird 4, fügt der Zeile jedoch 1 Byte hinzu >>>++.

Originalfassung

++++++++++                              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 Bytes

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)

Probieren Sie es online!

Berechnet alle Abstände und Zeilenumbrüche in der Schleife

Gelee , 32 Bytes

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

Ein vollständiges Programm, das das Ergebnis druckt.

Probieren Sie es online!

Wie?

(Ich habe noch nicht an etwas gedacht / gefunden, was “¿×¿ Œ4ç4Œ!¿Ø‘mir für diesen Teil lang erscheint - Prellen / Basis-Dekomprimieren / Inkrementieren, nichts scheint zu retten!)

⁶ẋ“¿×¿ Œ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 Bytes

Nur die Tabulatorpositionen sind fest codiert: Alle Zeilenabstände und Taktwerte werden in der Schleife generiert.

Nochmals vielen Dank an ceilingcat für die Vorschläge.

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

Probieren Sie es online!

PHP , 97 Bytes

<?=gzinflate(base64_decode(U1CAA0MjLghtqIAkyMWlYGiggAmMuLi4LBWwA2OgnIKCBRYZEy6IHQrmSIKmXMhKzAA));

Probieren Sie es online!

Dies ist eine hartcodierte komprimierte Zeichenfolge. Ich konnte keine kürzere Lösung finden!

Pyke , 37 Bytes

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

Probieren Sie es hier aus! (Rohbytes)

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

Probieren Sie es hier aus! (Für Menschen lesbar)

                              - 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 Bytes

2 bytes gespart dank ovs !

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

Probieren Sie es online!

Alles in einem Codeblock:

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

Powershell, 94 88 82 Bytes

Direkter Powershell-Format-Operator . {i,w}Bedeutet einen Platzhalter für einen Parameter mit Index i. Die Breite des Platzhalters ist wrechtsbündig.

"{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 Bytes

Port of Arnauld's Javascript Antwort

-6 Bytes dank @AdmBorkBork

[RegEx]::Replace("K12
E11K1

A10S2


9W3


B8S4

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

Verwenden Sie '.'stattdessen , um das Raster besser zu sehen ' '.

C (GCC) , 125 109 105 Bytes

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 Bytes (-3 für eine bessere Schleifenanordnung, -13 für die direkte Einbeziehung der nicht druckbaren Zeichen) dank Jonathan Frech .
• -4 Bytes durch Ersetzen einer Division für eine Schicht und Missbrauch der Tatsache, dass auf vielen Systemen (wie demjenigen, auf dem TIO gehostetsizeof(wchar_t) == sizeof(int) wird ) - unter Windows nicht funktioniert :) Vielen Dank an ErikF für die Idee.

Probieren Sie es online!

Dies ist ein Port meine allgemeinen Idee von der 6502 - Lösung auf C. Es ist ein wenig geändert: Anstatt eine Flag für eine Leitung von mit 1, wird das Zeichen als Dezimalzahl gedruckt von 48 subtrahiert, so 10 - 12 codiert sind , als :zu <.

Attache , 69 Bytes

{ReplaceF["l12
f11l1

b10t2


9x3


c8t4

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

Probieren Sie es online!

Dies kodiert jede Reihe von Leerzeichen als NTS[count of spaces]:; NTSist die integrierte Funktion "Numerisch zu Kurz", mit der Zahlen als Zeichenfolgen ausgedrückt werden können. ZB NTS[95] = $R1und NTS[170297] = $XQO. STNist das Gegenteil von diesem eingebauten.

Diese Antwort ersetzt ( ReplaceF) alle Vorkommen von Buchstaben ( /\l/) in der Eingabe mit dem Ergebnis der Funktion sp&`*@STN, die den Buchstaben zuerst dekodiert und dann so spoft (ein Leerzeichen) wiederholt .

Swift , 178 165 Bytes

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)

Basierend auf dem, was Downgoat gepostet hat, habe ich dies auf 165 Bytes reduziert:

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

Erweitert, mit $0in eine benannte Variable konvertiert:

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

Die Eingabezeichenfolge wird wie folgt codiert: Großbuchstaben ( A-Z) stehen für um 65 versetzte Leerzeichenblöcke. Bedeutet Aalso 0 Leerzeichen, Bbedeutet 1 Leerzeichen, die erste Lbedeutet 11 Leerzeichen usw.n s werden in Zeilenumbrüche konvertiert. Alle anderen Zeichen werden unverändert gedruckt.

Führe es hier online aus (danke, mbomb007)

Pure Bash , 123

printf macht das schwere heben hier:

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

Probieren Sie es online!

Rot , 151 Bytes

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]]

Probieren Sie es online!

JavaScript mit SVG, 188 Bytes

Eine willkürliche Zeilenhöhe von 120% verwendet 4 Bytes.

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)

Mit Gitter zum Vergleich:

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)

Erklärung der Positionierungsformel

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

Unter der Annahme, dass der Ursprung die Mitte der Uhr ist, sind die Gitterkoordinaten der am weitesten rechts stehenden Stelle einer bestimmten Uhrennummer x[ f(x) * 2, f(9 - x)].

Bash, 225 Bytes

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/ //'

Ärgerlicherweise ist dies länger als die naive Lösung, jede Zeile in einer Schleife auszudrucken (132 Zeichen, wenn Tabstopps verwendet werden).

Python 3 , 112 88 87 Bytes

Eine Lösung mit String-Interpolation.

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

 10{2:20}


9{3:24}


  8{4:20}

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

Probieren Sie es online!

-25 Bytes dank ovs und Herman L.

C (gcc) , 135 123 110 Bytes

Dieser verwendet eine einfache Codierung , wo jeder czwischen 'a'und 'z'stellt c-'a'+1wiederholt Räume, '`'eine neue Zeile darstellt und alle anderen Zeichen unverändert bleiben.

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

Probieren Sie es online!

T-SQL, 132 Bytes

PRINT SPACE(11)+'12
     11           1

 10'+SPACE(20)+'2


9'+SPACE(23)+'3


  8'+SPACE(19)+'4

      7           5
            6'

Nur 12 Bytes kürzer als die einfache Lösung ( PRINTder gesamten Zeichenfolge wie sie ist).

Ich habe eine Variation gefunden, die viel länger ist ( 235 226 Bytes), aber viel mehr wie 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_SPLITBricht es an den Kommas in Zeilen auf und PARSENAMEteilt jede Zeile an den Punkten auf. Die Felder 1 und 3 geben an, wie viele Stellen gedruckt werden sollen, die Felder 2 und 4 geben an, was angezeigt werden soll.

(Zeilenumbrüche dienen nur der Lesbarkeit)

Perl 6 , 116 Bytes

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/.//}

Probieren Sie es online!

(Ta @JoKing zum Speichern von 26 Bytes)

Perl 6 , 142 Bytes

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

Probieren Sie es online!

Ich wollte etwas anderes machen. Also berechnet dieser die Positionen aller Ziffern über Zeichenpaare, entfernt den Anfangsraum und druckt die Zeilen.

Einfach für verschiedene Parameter änderbar, z. B. eine 45 Zeichen breite Version mit 17 Stellen .