Muestre los 12 números en una esfera del reloj exactamente así:

           12            
     11           1      

 10                   2  


9                       3


  8                   4  

      7           5      
            6            

Para ver mejor la cuadrícula, aquí hay uno con puntos:

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

Tenga en cuenta que la cuadrícula se estira en ancho por un factor de dos para que se vea más cuadrada.

También tenga en cuenta que los números de dos dígitos están alineados con sus dígitos en su lugar. Los 9 dígitos deben estar al ras de la izquierda.

Devuelva o imprima el resultado como una cadena multilínea (no una lista de líneas). Todos los espacios finales son opcionales. La nueva línea final también es opcional.

Carbón , 40 bytes.

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación: Calcula los desplazamientos entre cada dígito matemáticamente. El carbón vegetal está indexado en 0 (por lo tanto, ⊕para generar ), por lo que las fórmulas para las compensaciones horizontal y vertical son las siguientes:$1 \ldots 12$

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

JavaScript (Node.js) , 91 bytes

No es un enfoque muy inteligente, pero no he podido encontrar nada más corto en este momento.

_=>`K12
E11K1

A10S2


9W3


B8S4

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

Pruébalo en línea!

05AB1E , 39 33 31 bytes

¡Gracias a Magic Octopus Urn por guardar 6 bytes!

Código

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

Algunas 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

Utiliza la codificación 05AB1E . Pruébalo en línea!

6502 código máquina (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, gracias a Arnauld por la idea inteligente :)
• otros -3 bytes después de la idea de Arnauld de no tratar 1especialmente los dígitos iniciales

La idea aquí es almacenar solo los dígitos de todos los números en el orden en que se necesitan. La información adicional requerida es la cantidad de líneas nuevas a anteponer y la cantidad de espacios al frente.

El número máximo de líneas nuevas es 3, por lo que necesitamos 2 bits para esto, y el número máximo de espacios es 23, por lo tanto, 5 bits son suficientes. Por lo tanto, para cada dígito a imprimir, podemos exprimir esta información en un solo "byte de control".

Entonces, los datos para esta solución toman exactamente 30 bytes: 15 dígitos individuales y 15 "bytes de control" asociados.

Demostración en línea

Uso: SYS49152para comenzar.

Desmontaje comentado :

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

Pruébalo en línea!

La respuesta de Port of Arnauld hasta que pueda llegar a algo más corto.

R , 75 68 bytes

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

Pruébalo en línea!

Comprimió las posiciones de los dígitos. Hicimos esto después de pasar mucho tiempo tratando de encontrar una respuesta trigonométrica (ver el historial de ediciones).

Inspirado por esta otra respuesta R, compre J.Doe - ¡vote por él!

Guardado 7 bytes gracias a J.Doe.

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

El posicionamiento arbitrario del lienzo utiliza 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>

Con rejilla para comparar:

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>

Explicación de la fórmula de posicionamiento

Vea mi JavaScript con la respuesta 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));}

Pruébelo en línea (NOTA: String.repeat(int)se emula repeat(String,int)para el mismo recuento de bytes, porque Java 11 aún no está en TIO).

La explicación es similar a la siguiente, pero se usa " ".repeat(x-48)para los espacios en lugar del formato con "%"+(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:"");}

Pruébalo en línea.

Explicación:

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

Explicación adicional 92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G:

• Todos los dígitos serán reemplazados por esa cantidad de espacios. (Por lo tanto, para 11 espacios 92).
• Todas las 'N' son líneas nuevas
• Todos ['A', 'J'] son ​​dígitos de reloj ([0,9])

R, 168 159 125 bytes

La solución ingenua de escribir los números en los puntos prescritos en una matriz de texto. Los puntos se almacenan como letras UTF-8 decodificadas a través deutf8ToInt

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

Se eliminaron 9 bytes con la sugerencia de JayCe de usar writey evitar definir la matriz.

Se eliminaron otros 34 bytes con la sugerencia de almacenamiento de 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]

El método de codificar espacios como letras (visto por primera vez en la respuesta de @ Arnauld ) en Haskell. Usarlo {y expandirlo \nes un byte más corto que usarlo \ndirectamente.

Pruébalo en línea!

Óxido , 96 bytes

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

 10{:20}


9{:24}


  8{:20}

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

Pruébalo en línea!

brainfuck , 240 235 bytes

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

Pruébalo en línea!

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

¡Un raro ejemplo en el que el texto es lo suficientemente repetitivo como para que el programa brainfuck sea menos de dos veces 1.6 veces la longitud de la salida!

2 bytes guardados por sugerencia de Jo King: >>>>>>-->[<]>-

Se guardan 3 bytes moviendo el tercer conteo descendente de 20 lugares desde el extremo derecho de los códigos ASCII 10 30 50a inmediatamente a la izquierda de ellos. Se guarda <<>>al llenar el espacio entre 8y, 4pero agrega 1 byte a la línea >>>++.

Versión 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)

Pruébalo en línea!

Calcula todos los espacios y líneas nuevas en el bucle

Jalea , 32 bytes

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

Un programa completo que imprime el resultado.

Pruébalo en línea!

¿Cómo?

(Todavía no he pensado / encontrado algo más corto que “¿×¿ Œ4ç4Œ!¿Ø‘lo que me parece largo para esta parte: rebotes / descompresión 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

Solo las posiciones de las pestañas están codificadas: todos los espacios entre líneas y valores de reloj se generan en el bucle.

Gracias de nuevo a ceilingcat por las sugerencias.

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

Pruébalo en línea!

PHP , 97 bytes

<?=gzinflate(base64_decode(U1CAA0MjLghtqIAkyMWlYGiggAmMuLi4LBWwA2OgnIKCBRYZEy6IHQrmSIKmXMhKzAA));

Pruébalo en línea!

Esta es una cadena comprimida codificada. ¡No pude encontrar una solución más corta que esta!

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

Pruébalo aquí! (bytes sin procesar)

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

Pruébalo aquí! (Legible 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

ahorrado 2 bytes gracias a los ovs !

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

Pruébalo en línea!

todo en un bloque de código:

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

Powershell, 94 88 82 bytes

Operador directo de formato Powershell . {i,w}significa un marcador de posición para un parámetro con índice i, el ancho del marcador de posición está walineado a la derecha.

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

Respuesta Javascript del Puerto de Arnauld

-6 bytes gracias a @AdmBorkBork

[RegEx]::Replace("K12
E11K1

A10S2


9W3


B8S4

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

Para ver mejor la cuadrícula, use '.'en su lugar ' '.

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 una mejor disposición del bucle, -13 para incluir directamente los caracteres no imprimibles) gracias a Jonathan Frech .
• -4 bytes reemplazando una división para un turno y abusando del hecho de que en muchos sistemas (como el que aloja TIO), sizeof(wchar_t) == sizeof(int)- no funcionará en Windows :) Gracias ErikF por la idea.

Pruébalo en línea!

Este es un puerto de mi idea general de la solución de 6502 a C. Es un poco modificado: En lugar de tener una bandera para un líder 1, el carácter se imprime como un decimal restando 48, por lo que 10 - 12 se codifican como :a <.

Adjunto , 69 bytes

{ReplaceF["l12
f11l1

b10t2


9x3


c8t4

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

Pruébalo en línea!

Esto codifica cada corrida de espacios como NTS[count of spaces]:; NTSes el valor incorporado "numérico a corto", que permite que los números se expresen como cadenas. Por ejemplo, NTS[95] = $R1y NTS[170297] = $XQO. STNes el inverso de este incorporado.

Esta respuesta reemplaza ( ReplaceF) todas las ocurrencias de letras ( /\l/) en la entrada con el resultado de la función sp&`*@STN, que primero decodifica la letra y luego repite sp(un espacio) tantas veces.

Swift , 178165 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)

Según lo publicado por Downgoat, he reducido esto a 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, con $0convertido a una variable con nombre:

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 cadena de entrada se codifica de la siguiente manera: las letras mayúsculas ( A-Z) representan bloques de espacios, compensados ​​por 65. Entonces Asignifica 0 espacios, Bsignifica 1 espacio, el primero Lsignifica 11 espacios, etc. ns se convierten en líneas nuevas. Todos los demás caracteres se imprimen tal cual.

Ejecútelo en línea aquí (gracias, mbomb007)

Pure Bash , 123

printf hace el trabajo pesado aquí:

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

Pruébalo en línea!

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

Pruébalo en línea!

JavaScript con SVG, 188 bytes

La altura de línea arbitraria del 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)

Con rejilla para comparar:

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)

Explicación de la fórmula de posicionamiento

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

Suponiendo que el origen es el centro del reloj, las coordenadas de la cuadrícula del dígito más a la derecha de cualquier número de reloj dado xson [ 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/ //'

Es molesto que esto sea más largo que la solución ingenua de simplemente imprimir cada línea en un bucle (132 caracteres si se usan tabuladores).

Python 3 , 112 88 87 bytes

Una solución usando interpolación de cadenas.

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

 10{2:20}


9{3:24}


  8{4:20}

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

Pruébalo en línea!

-25 bytes gracias a ovs y Herman L.

C (gcc) , 135 123 110 bytes

Esto utiliza una codificación simple donde cualquiera centre 'a'y 'z'representa c-'a'+1espacios repetidos, '`'representa una nueva línea y todos los demás caracteres se dejan sin cambios.

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

Pruébalo en línea!

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'

Solo 12 bytes más cortos que la solución trivial ( PRINTde la cadena completa tal como está).

Encontré una variación que me gusta que es mucho más larga ( 235 226 bytes), pero mucho más similar 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 en filas en las comas y PARSENAMEdivide cada fila en los puntos. El 1er y 3er se usan para cuántos espacios imprimir, el 2do y 4to se usan para qué mostrar.

(los saltos de línea en este son solo para facilitar la lectura)

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

Pruébalo en línea!

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

Pruébalo en línea!

Yo quería hacer algo diferente. Entonces, este calcula las posiciones de todos los dígitos, a través de pares de caracteres, elimina el espacio inicial e imprime las líneas.

Fácilmente modificable para diferentes parámetros, por ejemplo, una versión de 45 caracteres de ancho con 17 dígitos .