Exiba os 12 números em um relógio exatamente como este:

           12            
     11           1      

 10                   2  


9                       3


  8                   4  

      7           5      
            6            

Para ver melhor a grade, aqui está um com pontos:

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

Observe que a grade é esticada em largura por um fator de dois para torná-la mais quadrada.

Observe também que os números de dois dígitos estão alinhados com os respectivos dígitos no lugar. O dígito 9 deve estar nivelado contra a esquerda.

Retorne ou imprima o resultado como uma sequência de múltiplas linhas (não uma lista de linhas). Quaisquer espaços à direita são opcionais. A nova linha final também é opcional.

Carvão , 40 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação: Calcula matematicamente os deslocamentos entre cada dígito. O carvão é indexado em 0 (portanto, a ⊕saída ), portanto, as fórmulas para as compensações horizontais e verticais são as seguintes:$1 \ldots 12$

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

JavaScript (Node.js) , 91 bytes

Não é uma abordagem muito inteligente, mas não consegui encontrar nada mais curto no momento.

_=>`K12
E11K1

A10S2


9W3


B8S4

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

Experimente online!

05AB1E , 39 33 31 bytes

Obrigado ao Magic Octopus Urn por salvar 6 bytes!

Código

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

Algumas alternativas de 33 bytes:

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

Usa a codificação 05AB1E . Experimente online!

Código da máquina 6502 (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, graças a Arnauld pela idéia inteligente :)
• mais -3 bytes após a ideia de Arnauld de não tratar os 1dígitos iniciais especialmente

A idéia aqui é armazenar apenas os dígitos de todos os números na ordem em que forem necessários. Informações adicionais necessárias são o número de novas linhas a serem acrescentadas e o número de espaços à frente.

O número máximo de novas linhas é 3, portanto, precisamos de 2 bits para isso, e o número máximo de espaços é 23, portanto, 5 bits são suficientes. Portanto, para cada dígito a ser impresso, podemos compactar essas informações em um único "byte de controle".

Portanto, os dados desta solução levam exatamente 30 bytes: 15 dígitos únicos e 15 "bytes de controle" associados.

Demonstração online

Uso: SYS49152para começar.

Desmontagem comentada :

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

Experimente online!

A resposta de Port of Arnauld até que eu possa pensar em algo mais curto.

R , 75 68 bytes

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

Experimente online!

Comprimiu as posições dos dígitos. Fez isso depois de passar muito tempo tentando encontrar uma resposta trigonométrica (consulte o histórico de edições).

Inspirado por essa outra resposta R, compre J.Doe - faça um voto positivo!

Economizou 7 bytes graças a J.Doe.

HTML + JavaScript (Tela), 13 + 161 = 174 bytes

O posicionamento arbitrário da tela usa 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>

Com grade para comparação:

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>

Explicação da fórmula de posicionamento

Veja meu JavaScript com resposta SVG .

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

Experimente online (NOTA: String.repeat(int)é emulado comorepeat(String,int) para a mesma contagem de bytes, porque o Java 11 ainda não está no TIO.)

A explicação é semelhante à abaixo, mas é usada " ".repeat(x-48)para os espaços em vez do formato com "%"+(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:"");}

Experimente online.

Explicação:

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

Mais explicações 92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G:

• Todos os dígitos serão substituídos por essa quantidade de espaços. (Por 11 espaços é, portanto,92 ).
• Todos os 'N' são novas linhas
• Todos ['A', 'J'] são dígitos do relógio ([0,9])

R, 168 159 125 bytes

A solução ingênua de escrever os números nos pontos prescritos em uma matriz de texto. Os pontos são armazenados como letras UTF-8 decodificadas viautf8ToInt

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

Queda de 9 bytes com a sugestão de JayCe de usar write e evitar definir a matriz.

Soltou outros 34 bytes com a sugestão de armazenamento do JayCe.

Haskell, 88 87 bytes

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

O método encode-spaces-as-letters (visto pela primeira vez na resposta de @ Arnauld ) em Haskell. Usar {e expandir para isso \né um byte mais curto do que usar \ndiretamente.

Experimente online!

Ferrugem , 96 bytes

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

 10{:20}


9{:24}


  8{:20}

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

Experimente online!

brainfuck , 240 235 bytes

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

Experimente online!

Código comentado

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

Um exemplo raro em que o texto é repetitivo o suficiente para que o programa de foda cerebral seja menor que duas vezes 1,6 vezes a duração da saída!

2 bytes salvos por sugestão de Jo King: >>>>>>-->[<]>-

3 bytes salvos movendo o terceiro downcounter de 20 lugares da extrema direita dos códigos ascii 10 30 50para imediatamente à esquerda deles. Economiza <<>>ao preencher a lacuna entre 8e4 mas adiciona 1 byte à linha >>>++.

Versão original

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

Experimente online!

Calcula todos os espaçamentos e novas linhas no loop

Geléia , 32 bytes

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

Um programa completo que imprime o resultado.

Experimente online!

Quão?

(Ainda não pensei em / encontrei algo mais curto do “¿×¿ Œ4ç4Œ!¿Ø‘que o que me parece longo para esta parte - quedas / descompressão de base / incrementos, nada parece salvar!)

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

Somente as posições das guias são codificadas: todos os espaçamentos de linha e valores de relógio são gerados no loop.

Agradecemos novamente ao tetocat pelas sugestões.

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

Experimente online!

PHP , 97 bytes

<?=gzinflate(base64_decode(U1CAA0MjLghtqIAkyMWlYGiggAmMuLi4LBWwA2OgnIKCBRYZEy6IHQrmSIKmXMhKzAA));

Experimente online!

Esta é uma sequência compactada codificada. Não consegui encontrar uma solução mais curta que essa!

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

Experimente aqui! (bytes brutos)

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

Experimente aqui! (Legível por humanos)

                              - 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

economizou 2 bytes graças ao ovs !

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

Experimente online!

tudo em um bloco de código:

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

Powershell, 94 88 82 bytes

Operador de formato direto do PowerShell . {i,w}significa um espaço reservado para um parâmetro com índice i, a largura do espaço reservado está walinhada à direita.

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

Porto de Arnauld Resposta Javascript

-6 bytes graças a @AdmBorkBork

[RegEx]::Replace("K12
E11K1

A10S2


9W3


B8S4

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

Para ver melhor a rede, use '.'vez ' '.

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 para melhor organização do loop, -13 para incluir diretamente os caracteres não imprimíveis) graças a Jonathan Frech .
• -4 bytes substituindo uma divisão por uma mudança e abusando do fato de que em muitos sistemas (como o que hospeda o TIO), sizeof(wchar_t) == sizeof(int)- não funcionará no Windows :) Obrigado ErikF pela idéia.

Experimente online!

Esta é uma porta de minha ideia geral a partir da solução de 6502 a C. É um pouco modificado: em vez de ter uma bandeira para um líder 1, o carácter é impresso como um decimal subtraindo 48, de modo que 10-12 são codificados como :para <.

Anexo , 69 bytes

{ReplaceF["l12
f11l1

b10t2


9x3


c8t4

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

Experimente online!

Isso codifica cada execução de espaços como NTS[count of spaces]:; NTSé o interno "numérico para curto", que permite que os números sejam expressos como cadeias. Por exemplo, NTS[95] = $R1e NTS[170297] = $XQO.STNé o inverso deste embutido.

Esta resposta substitui ( ReplaceF) todas as ocorrências de letras ( /\l/) na entrada pelo resultado da função sp&`*@STN, que primeiro decodifica a letra e depois repete sp(um espaço) várias vezes.

Rápido , 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)

Com base no que o Downgoat postou, reduzi isso para 165 bytes:

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

Expandido, com $0convertido em uma variável nomeada:

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 sequência de entrada é codificada da seguinte forma: Letras maiúsculas ( A-Z) representam blocos de espaços, deslocados por 65. Portanto, Asignifica 0 espaços, Bsignifica 1 espaço, o primeiro Lsignifica 11 espaços, etc. ns são convertidos em novas linhas. Todos os outros caracteres são impressos como estão.

Execute-o online aqui (obrigado, mbomb007)

Pure Bash , 123

printf faz o trabalho pesado aqui:

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

Experimente online!

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

Experimente online!

JavaScript com SVG, 188 bytes

A altura da linha arbitrária de 120% usa 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)

Com grade para comparação:

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)

Explicação da fórmula de posicionamento

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

Supondo que a origem seja o centro do relógio, as coordenadas da grade do dígito mais à direita de qualquer número de relógio xsão [ 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/ //'

Irritantemente, isso é mais longo do que a solução ingênua de apenas imprimir cada linha em um loop (132 caracteres se usar tabstops).

Python 3 , 112 88 87 bytes

Uma solução usando interpolação de string.

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

 10{2:20}


9{3:24}


  8{4:20}

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

Experimente online!

-25 bytes graças a ovs e Herman L.

C (gcc) , 135 123 110 bytes

Isso usa uma codificação simples onde qualquer um centre 'a'e 'z'representac-'a'+1 espaços repetidos, '`'representa uma nova linha e todos os outros caracteres permanecem inalterados.

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

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

Apenas 12 bytes mais curtos que a solução trivial ( PRINTde toda a cadeia como está).

Encontrei uma variação que gosto muito mais longa ( 235 226 bytes), mas muito mais parecida com 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_SPLITquebra em linhas nas vírgulas e PARSENAMEdivide cada linha nos pontos. O 1º e o 3º são usados ​​para quantos espaços imprimir, o 2º e o 4º são usados ​​para o que exibir.

(quebras de linha neste são apenas para facilitar a leitura)

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

Experimente online!

(Ta @JoKing para salvar 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

Experimente online!

Eu queria fazer algo diferente. Portanto, este calcula as posições de todos os dígitos, através de pares de caracteres, retira o espaço inicial e imprime as linhas.

Facilmente modificável para diferentes parâmetros, por exemplo, uma versão com 45 caracteres e 17 dígitos .