Wyświetl 12 cyfr na tarczy zegara dokładnie tak:

           12            
     11           1      

 10                   2  


9                       3


  8                   4  

      7           5      
            6            

Aby lepiej zobaczyć siatkę, oto jedna z kropkami:

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

Zauważ, że siatka jest rozciągnięta na szerokość dwa razy, aby wyglądała bardziej kwadratowo.

Należy również pamiętać, że liczby dwucyfrowe są wyrównane z cyframi na miejscu. Cyfra 9 powinna być wyrównana do lewej.

Zwróć lub wydrukuj wynik jako ciąg wielowierszowy (nie listę wierszy). Wszelkie spacje końcowe są opcjonalne. Ostateczna nowa linia jest również opcjonalna.

Węgiel drzewny , 40 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Objaśnienie: Oblicza przesunięcia między każdą cyfrą matematycznie. Węgiel drzewny jest indeksowany 0 (a więc ⊕do wyjścia ), więc wzory dla przesunięć poziomych i pionowych są następujące:$1 \ldots 12$

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

JavaScript (Node.js) , 91 bajtów

Niezbyt sprytne podejście, ale w tej chwili nie znalazłem nic krótszego.

_=>`K12
E11K1

A10S2


9W3


B8S4

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

Wypróbuj online!

05AB1E , 39 33 31 bajtów

Dzięki Magic Octopus Urn za uratowanie 6 bajtów!

Kod

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

Około 33 bajtów alternatywnych:

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

Wykorzystuje kodowanie 05AB1E . Wypróbuj online!

Kod maszynowy 6502 (C64), 82 76 73 bajty

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 bajtów, dzięki Arnauldowi za sprytny pomysł :)
• kolejne -3 bajty po pomyśle Arnaulda, aby nie traktować 1specjalnie cyfr wiodących

Chodzi o to, aby przechowywać cyfry wszystkich liczb w kolejności, w jakiej są potrzebne. Wymagane dodatkowe informacje to liczba nowych wierszy do dodania i liczba spacji z przodu.

Maksymalna liczba znaków nowej linii wynosi 32 bity, a maksymalna liczba spacji to 235 bitów. Dlatego dla każdej cyfry do wydrukowania możemy wycisnąć tę informację w jednym „bajcie kontrolnym”.

Tak więc dane dla tego rozwiązania zajmują dokładnie 30 bajtów: 15 pojedynczych cyfr i 15 powiązanych „bajtów kontrolnych”.

Demo online

Zastosowanie: SYS49152na początek.

Skomentowany demontaż :

         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 bajtów

$_="K12
E11K1

A10S2


9W3


B8S4

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

Wypróbuj online!

Odpowiedź Portu Arnaulda, dopóki nie wymyślę czegoś krótszego.

R , 75 68 bajtów

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

Wypróbuj online!

Skompresowane pozycje cyfr. Zrobił to po spędzeniu dużo czasu próbując znaleźć odpowiedź trygonometryczną (patrz historia zmian).

Zainspirowany inną odpowiedzią R. Kup J.Doe - głosuj!

Zaoszczędź 7 bajtów dzięki J.Doe.

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

Arbitralne pozycjonowanie obszaru roboczego zajmuje 6 bajtów.

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>

Z siatką do porównania:

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>

Objaśnienie wzoru pozycjonowania

Zobacz mój JavaScript z odpowiedzią SVG .

Java 8 11, 141 138 bajtów

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

Wypróbuj online (UWAGA: String.repeat(int)jest emulowany jak repeat(String,int)dla tej samej liczby bajtów, ponieważ Java 11 nie jest jeszcze w TIO).

Wyjaśnienie jest podobne do poniższego, ale wykorzystuje " ".repeat(x-48)spacje zamiast formatować za pomocą "%"+(x-48)+"s".

Java 8, 141 bajtów

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

Wypróbuj online.

Wyjaśnienie:

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

Dalsze wyjaśnienie 92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G:

• Wszystkie cyfry zostaną zastąpione taką ilością spacji. (Dlatego dla 11 spacji 92.)
• Wszystkie „N” są znakami nowej linii
• Wszystkie [„A”, „J”] są cyframi zegarowymi ([0,9])

R, 168 159 125 bajtów

Naiwne rozwiązanie polegające na zapisywaniu liczb w wyznaczonych punktach w matrycy tekstowej. Punkty są przechowywane jako litery UTF-8 dekodowane za pomocąutf8ToInt

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

Usunięto 9 bajtów z sugestią JayCe, aby używać writei unikać definiowania macierzy.

Usunięto kolejne 34 bajty z sugestią JayCe dotyczącą przechowywania.

Haskell, 88 87 bajtów

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

Metoda kodowania spacji jako liter (po raz pierwszy zobaczona w odpowiedzi @ Arnaulda ) w Haskell. Używanie {i rozwijanie go \njest o jeden bajt krótsze niż \nbezpośrednie.

Wypróbuj online!

Rdza , 96 bajtów

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

 10{:20}


9{:24}


  8{:20}

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

Wypróbuj online!

pieprzenie mózgu , 240 235 bajtów

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

Wypróbuj online!

Skomentowany kod

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

Rzadki przykład, w którym tekst jest wystarczająco powtarzalny, że program pieprzenia mózgu jest mniej niż dwa razy 1,6 razy dłuższy niż wynik!

2 bajty zapisane według sugestii Jo Kinga: >>>>>>-->[<]>-

3 bajty zaoszczędzone poprzez przeniesienie trzeciego 20-miejscowego licznika w dół z skrajnie prawej strony kodów ascii 10 30 50bezpośrednio na lewo od nich. Oszczędność <<>>przy wypełnianiu luki między 8i 4, ale dodaje 1 bajt do linii >>>++.

Orginalna wersja

++++++++++                              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 bajtów

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)

Wypróbuj online!

Oblicza wszystkie odstępy i znaki nowej linii w pętli

Galaretka , 32 bajty

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

Pełny program, który drukuje wynik.

Wypróbuj online!

W jaki sposób?

(Jeszcze nie pomyślałem / nie znalazłem nic krótszego niż to, “¿×¿ Œ4ç4Œ!¿Ø‘co wydaje mi się długie w tej części - odbijanie / dekompresja / przyrosty, nic nie wydaje się oszczędzać!)

⁶ẋ“¿×¿ Œ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 bajtów

Tylko pozycje tabulatorów są zakodowane na stałe: wszystkie odstępy między wierszami i wartości zegara są generowane w pętli.

Jeszcze raz dziękuję sufitowi za sugestie.

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

Wypróbuj online!

PHP , 97 bajtów

<?=gzinflate(base64_decode(U1CAA0MjLghtqIAkyMWlYGiggAmMuLi4LBWwA2OgnIKCBRYZEy6IHQrmSIKmXMhKzAA));

Wypróbuj online!

Jest to mocno skompresowany ciąg znaków. Nie mogłem znaleźć rozwiązania krótszego niż to!

Pyke , 37 bajtów

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

Wypróbuj tutaj! (surowe bajty)

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

Wypróbuj tutaj! (Czytelny dla człowieka)

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

pieprzenie mózgu , 315 313 bajtów

zapisane 2 bajty dzięki ovs !

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

Wypróbuj online!

wszystko w jednym bloku kodu:

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

PowerShell, 94 88 82 bajtów

Bezpośredni operator formatu PowerShell . {i,w}oznacza symbol zastępczy parametru z indeksem i, szerokość symbolu zastępczego jest wwyrównana do prawej.

"{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 bajtów

Odpowiedź JavaScript na Port of Arnauld

-6 bajtów dzięki @AdmBorkBork

[RegEx]::Replace("K12
E11K1

A10S2


9W3


B8S4

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

Aby lepiej zobaczyć siatkę, użyj '.'zamiast tego ' '.

C (gcc) , 125 109 105 bajtów

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 bajtów (-3 dla lepszego uporządkowania pętli, -13 dla bezpośredniego włączenia znaków niedrukowalnych) dzięki Jonathanowi Frechowi .
• -4 bajty, zastępując podział na zmianę i nadużywając faktu, że na wielu systemach (takich jak ten obsługujący TIO), sizeof(wchar_t) == sizeof(int)- nie będzie działał na Windowsie :) Dzięki ErikF za pomysł.

Wypróbuj online!

Jest to część mojego ogólnego pomysłu z rozwiązania 6502 na C. Jest to nieco zmodyfikowane: Zamiast flagi na początku 1, znak jest drukowany po przecinku przez odjęcie 48, więc 10-12 jest zakodowanych co :do tego <.

Attache , 69 bajtów

{ReplaceF["l12
f11l1

b10t2


9x3


c8t4

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

Wypróbuj online!

To koduje każdy ciąg spacji jako NTS[count of spaces]:; NTSjest wbudowanym „numerycznym do krótkiego”, który umożliwia wyrażanie liczb jako ciągów znaków. Na przykład, NTS[95] = $R1i NTS[170297] = $XQO. STNjest odwrotnością tego wbudowanego.

Ta odpowiedź zastępuje ( ReplaceF) wszystkie wystąpienia liter ( /\l/) na wejściu wynikiem funkcji sp&`*@STN, która najpierw dekoduje literę, a następnie powtarza sp(spację) wiele razy.

Szybki , 178 165 bajtów

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)

Na podstawie tego, co napisał Downgoat, zmniejszyłem to do 165 bajtów:

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

Rozwinięty, $0przekształcony w nazwaną zmienną:

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

Łańcuch wejściowy jest kodowany w następujący sposób: Wielkie litery ( A-Z) oznaczają bloki spacji, przesunięte o 65. AOznacza to 0 spacji, B1 spację, pierwsze L11 spacji itp. nS są konwertowane na znaki nowej linii. Wszystkie pozostałe znaki są drukowane w obecnej postaci.

Uruchom tutaj online (dzięki, mbomb007)

Pure Bash , 123

printf wykonuje tutaj podnoszenie ciężarów:

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

Wypróbuj online!

Czerwony , 151 bajtów

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

Wypróbuj online!

JavaScript z SVG, 188 bajtów

Dowolna wysokość linii wynosząca 120% wykorzystuje 4 bajty.

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)

Z siatką do porównania:

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)

Objaśnienie wzoru pozycjonowania

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

Zakładając, że początek jest środkiem zegara, współrzędne siatki najbardziej prawej cyfry danego numeru zegara xto [ f(x) * 2, f(9 - x)].

Bash, 225 bajtów

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

Irytujące jest to dłuższe niż naiwne rozwiązanie polegające na drukowaniu każdego wiersza w pętli (132 znaki w przypadku korzystania z tabstops).

Python 3 , 112 88 87 bajtów

Rozwiązanie wykorzystujące interpolację łańcuchów.

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

 10{2:20}


9{3:24}


  8{4:20}

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

Wypróbuj online!

-25 bajtów dzięki ovs i Hermanowi L.

C (gcc) , 135 123 110 bajtów

Wykorzystuje to proste kodowanie, w którym dowolne cpomiędzy 'a'i 'z'reprezentuje c-'a'+1powtarzające się spacje, '`'reprezentuje nowy wiersz, a wszystkie pozostałe znaki pozostają niezmienione.

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

Wypróbuj online!

T-SQL, 132 bajty

PRINT SPACE(11)+'12
     11           1

 10'+SPACE(20)+'2


9'+SPACE(23)+'3


  8'+SPACE(19)+'4

      7           5
            6'

Tylko 12 bajtów krótszych niż trywialne rozwiązanie (PRINT całego łańcucha bez zmian).

Znalazłem wariant, który podoba mi się, jest znacznie dłuższy ( 235 226 bajtów), ale znacznie bardziej podobny do 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_SPLIT dzieli go na wiersze w przecinkach i PARSENAME dzieli każdy wiersz na kropki. 1. i 3. są używane do określenia liczby spacji do wydrukowania, 2. i 4. są używane do wyświetlania.

(podział wiersza w tym jest tylko dla czytelności)

Perl 6 , 116 bajtów

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

Wypróbuj online!

(Ta @JoKing za zapisanie 26 bajtów)

Perl 6 , 142 bajtów

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

Wypróbuj online!

Chciałem zrobić coś ... innego. Więc ten oblicza pozycje wszystkich cyfr, za pomocą par znaków, usuwa początkową spację i drukuje linie.

Łatwo modyfikowalny dla różnych parametrów, np. Wersja o szerokości 45 znaków z 17 cyframi .