Visualizza i 12 numeri su un quadrante esattamente come questo:

           12            
     11           1      

 10                   2  


9                       3


  8                   4  

      7           5      
            6            

Per vedere meglio la griglia, eccone una con i punti:

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

Si noti che la griglia è allungata in larghezza di un fattore due per renderla più quadrata.

Si noti inoltre che i numeri a due cifre sono allineati con i loro numeri in posizione. Le 9 cifre dovrebbero essere allineate a sinistra.

Restituisce o stampa il risultato come una stringa multilinea (non un elenco di righe). Tutti gli spazi finali sono opzionali. La nuova riga finale è facoltativa.

Carbone , 40 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione: calcola matematicamente gli offset tra ogni cifra. Il carbone è indicizzato 0 (quindi l' ⊕output ), quindi le formule per gli offset orizzontale e verticale sono le seguenti:$1 \ldots 12$

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

JavaScript (Node.js) , 91 byte

Non è un approccio molto intelligente, ma al momento non sono riuscito a trovare qualcosa di più corto.

_=>`K12
E11K1

A10S2


9W3


B8S4

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

Provalo online!

05AB1E , 39 33 31 byte

Grazie a Magic Octopus Urn per aver salvato 6 byte!

Codice

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

Alcune alternative a 33 byte:

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

Utilizza la codifica 05AB1E . Provalo online!

6502 codice macchina (C64), 82 76 73 byte

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 byte, grazie ad Arnauld per l'idea intelligente :)
• altri -3 byte dopo l'idea di Arnauld di non trattare in modo 1speciale le cifre iniziali

L'idea qui è di memorizzare solo le cifre di tutti i numeri nell'ordine in cui sono necessari. Ulteriori informazioni richieste sono il numero di newline da anteporre e il numero di spazi davanti.

Il numero massimo di newline è 3, quindi abbiamo bisogno di 2 bit per questo, e il numero massimo di spazi è 23, quindi sono sufficienti 5 bit. Pertanto, per ogni cifra da stampare, possiamo comprimere queste informazioni in un singolo "byte di controllo".

Pertanto, i dati per questa soluzione richiedono esattamente 30 byte: 15 cifre singole e 15 "byte di controllo" associati.

Demo online

Utilizzo: SYS49152per iniziare.

Smontaggio commentato :

         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 byte

$_="K12
E11K1

A10S2


9W3


B8S4

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

Provalo online!

La risposta di Port of Arnauld finché non riesco a trovare qualcosa di più breve.

R , 75 68 byte

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

Provalo online!

Compresso le posizioni delle cifre. Lo ha fatto dopo aver trascorso molto tempo cercando di trovare una risposta trigonometrica (vedi la cronologia delle modifiche).

Ispirato da questa altra risposta R acquista J.Doe - votalo!

Salvato 7 byte grazie a J.Doe.

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

Il posizionamento arbitrario della tela utilizza 6 byte.

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>

Con griglia per il confronto:

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>

Spiegazione della formula di posizionamento

Vedi il mio JavaScript con risposta SVG .

Java 8 11, 141 138 byte

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

Provalo online (NOTA: String.repeat(int)è emulato come repeat(String,int)per lo stesso conteggio byte, poiché Java 11 non è ancora su TIO.)

La spiegazione è simile alla seguente, ma utilizza " ".repeat(x-48)per gli spazi anziché formattarli con "%"+(x-48)+"s".

Java 8, 141 byte

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

Provalo online.

Spiegazione:

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

Ulteriore spiegazione 92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G:

• Tutte le cifre saranno sostituite con quella quantità di spazi. (Per 11 spazi è quindi 92.)
• Tutte le "N" sono nuove righe
• Tutte ['A', 'J'] sono cifre dell'orologio ([0,9])

R, 168 159 125 byte

La soluzione ingenua di scrivere i numeri nei punti prescritti in una matrice di testo. I punti sono memorizzati come lettere UTF-8 decodificate tramiteutf8ToInt

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

Eliminati 9 byte con il suggerimento di JayCe di utilizzare writeed evitare di definire la matrice.

Eliminati altri 34 byte con il suggerimento di archiviazione di JayCe.

Haskell, 88 87 byte

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

Il metodo codifica-spazi-come-lettere (visto per la prima volta nella risposta di @Arnauld ) in Haskell. L'utilizzo {e l'espansione a \nè di un byte più breve rispetto all'utilizzo \ndiretto.

Provalo online!

Ruggine , 96 byte

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

 10{:20}


9{:24}


  8{:20}

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

Provalo online!

Brainfuck , 240 235 byte

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

Provalo online!

Codice commentato

++++++++++                              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 raro esempio in cui il testo è abbastanza ripetitivo che il programma Brainfuck è meno di due volte 1,6 volte la lunghezza dell'output!

2 byte salvati su suggerimento da Jo King: >>>>>>-->[<]>-

3 byte salvati spostando il terzo downcounter di 20 posizioni dall'estrema destra dei codici ASCII 10 30 50immediatamente a sinistra di essi. Salva <<>>quando riempie lo spazio tra 8e 4ma aggiunge 1 byte alla linea >>>++.

Versione 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 byte

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)

Provalo online!

Calcola tutte le spaziature e le nuove linee nel loop

Gelatina , 32 byte

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

Un programma completo che stampa il risultato.

Provalo online!

Come?

(Non ho ancora pensato / trovato qualcosa di più breve di quello “¿×¿ Œ4ç4Œ!¿Ø‘che mi sembra lungo per questa parte - rimbalzare / decompressione base / incrementi, nulla sembra salvare!)

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

Solo le posizioni delle tabulazioni sono codificate: tutte le spaziature di linea e i valori di clock vengono generati nel loop.

Grazie ancora a ceilingcat per i suggerimenti.

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

Provalo online!

PHP , 97 byte

<?=gzinflate(base64_decode(U1CAA0MjLghtqIAkyMWlYGiggAmMuLi4LBWwA2OgnIKCBRYZEy6IHQrmSIKmXMhKzAA));

Provalo online!

Questa è una stringa compressa codificata. Non sono riuscito a trovare una soluzione più breve di questa!

Pyke , 37 byte

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

Provalo qui! (byte grezzi)

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

Provalo qui! (Leggibile dagli umani)

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

salvato 2 byte grazie a ovs !

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

Provalo online!

tutto in un blocco di codice:

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

Powershell, 94 88 82 byte

Operatore formato Powershell diretto . {i,w}indica un segnaposto per un parametro con indice i, la larghezza del segnaposto è wallineata a destra.

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

La risposta Javascript di Port of Arnauld

-6 byte grazie a @AdmBorkBork

[RegEx]::Replace("K12
E11K1

A10S2


9W3


B8S4

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

Per vedere meglio la griglia, utilizzare '.'invece ' '.

C (gcc) , 125 109 105 byte

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 byte (-3 per una migliore disposizione del loop, -13 per l'inclusione diretta dei caratteri non stampabili) grazie a Jonathan Frech .
• -4 byte sostituendo una divisione per un turno e abusando del fatto che su molti sistemi (come quello che ospita TIO), sizeof(wchar_t) == sizeof(int)- non funzionerà su Windows :) Grazie ErikF per l'idea.

Provalo online!

Questa è una porta della mia idea generale di soluzione 6502 a C. È un po 'modificata: Invece di avere un flag per un leader 1, il carattere viene stampato come decimale sottraendo 48, quindi 10 - 12 sono codificati come :a <.

Attache , 69 byte

{ReplaceF["l12
f11l1

b10t2


9x3


c8t4

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

Provalo online!

Questo codifica ogni serie di spazi come NTS[count of spaces]:; NTSè l'integrale "numerico a breve", che consente ai numeri di essere espressi come stringhe. Ad esempio, NTS[95] = $R1e NTS[170297] = $XQO. STNè l'inverso di questo builtin.

Questa risposta sostituisce ( ReplaceF) tutte le occorrenze di lettere ( /\l/) nell'input con il risultato della funzione sp&`*@STN, che in primo luogo decodifica la lettera e quindi ripete sp(uno spazio) più volte.

Rapido , 178 165 byte

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)

Sulla base di ciò che ha pubblicato Downgoat, l'ho ridotto a 165 byte:

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

Espanso, con $0convertito in una variabile denominata:

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 stringa di input è codificata come segue: Le lettere maiuscole ( A-Z) rappresentano blocchi di spazi, sfalsati di 65. Quindi Asignifica 0 spazi, Bsignifica 1 spazio, i primi Lsignifica 11 spazi, ecc n. Vengono convertiti in newline. Tutti gli altri personaggi sono stampati così come sono.

Eseguilo online qui (grazie, mbomb007)

Pure Bash , 123

printf fa il sollevamento pesi qui:

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

Provalo online!

Rosso , 151 byte

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

Provalo online!

JavaScript con SVG, 188 byte

L'altezza della linea arbitraria del 120% utilizza 4 byte.

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)

Con griglia per il confronto:

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)

Spiegazione della formula di posizionamento

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

Supponendo che l'origine sia il centro dell'orologio, le coordinate della griglia della cifra più a destra di ogni dato numero di orologio xè [ f(x) * 2, f(9 - x)].

Bash, 225 byte

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

Questa è fastidiosamente più lunga della soluzione ingenua di stampare ogni riga in un ciclo (132 caratteri se si utilizzano tabstops).

Python 3 , 112 88 87 byte

Una soluzione che utilizza l'interpolazione di stringhe.

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

 10{2:20}


9{3:24}


  8{4:20}

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

Provalo online!

-25 byte grazie a ovs e Herman L.

C (gcc) , 135 123 110 110 byte

Questo utilizza una semplice codifica in cui qualsiasi ctra 'a'e 'z'rappresenta c-'a'+1spazi ripetuti, '`'rappresenta una nuova riga e tutti gli altri caratteri rimangono invariati.

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

Provalo online!

T-SQL, 132 byte

PRINT SPACE(11)+'12
     11           1

 10'+SPACE(20)+'2


9'+SPACE(23)+'3


  8'+SPACE(19)+'4

      7           5
            6'

Solo 12 byte in meno rispetto alla banale soluzione ( PRINTdell'intera stringa così com'è).

Ho trovato una variante che mi piace che è molto più lunga ( 235 226 byte), ma molto più simile a 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_SPLITlo divide in righe alle virgole e PARSENAMEdivide ogni riga in corrispondenza dei punti. Il 1o e il 3o sono usati per quanti spazi stampare, il 2o e il 4o sono usati per cosa visualizzare.

(le interruzioni di riga in questo sono solo per leggibilità)

Perl 6 , 116 byte

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

Provalo online!

(Ta @JoKing per il salvataggio di 26 byte)

Perl 6 , 142 byte

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

Provalo online!

Volevo fare qualcosa di diverso. Quindi questo calcola le posizioni di tutte le cifre, tramite coppie di caratteri, rimuove lo spazio iniziale e stampa le linee.

Facilmente modificabile per diversi parametri, ad esempio una versione larga 45 caratteri con 17 cifre .