Mostrar una esfera del reloj

39

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.

xnor
fuente

Respuestas:

25

Carbón , 40 bytes.

F¹²«M⁻↔⁻¹⁴⊗÷×⁴鳦⁸⁻⁴↔⁻⁷÷×⁴﹪⁺³ι¹²¦³P←⮌I⊕ι

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...12

δX=El |14-24 4yo3El |-8δy=4 4-El |7 7-4 4yo3El |

donde .yo=yo+3(mod12)

Neil
fuente
22

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!

Arnauld
fuente
44
Me encanta el uso de Buffer () como alternativa acharCodeAt()
Downgoat
1
@Downgoat Lo que me hace preguntarme si deberíamos tener un Consejo para jugar al golf en la pregunta Node.js , para las características específicas de Node. Sin embargo, no estoy seguro de que valga la pena.
Arnauld
¿Quizás agregar una respuesta separada que contenga todas las características específicas del Nodo, o al menos una lista que vincule todas las respuestas diferentes?
15

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!

Adnan
fuente
¡Buena respuesta! Me gusta el uso de ÿcon .V, muy original! Y es curioso cómo solías 12¤tener ambos 12y 2en la pila. Probablemente lo hubiera usado 12Y, pero supongo que es irrelevante, ya que ambos tienen 12 y 2 en la pila. Si hubiera intentado este desafío en 05AB1E, habría terminado mucho más alto en el conteo de bytes. Supongo que todavía tengo mucho que aprender. ;)
Kevin Cruijssen
@KevinCruijssen Oh sí, me olvidé Y. Esa hubiera sido una opción más fácil jajaja.
Adnan
No sé si estoy arreglando el 6 en menos de 6 bytes: 6xsŸ5L•δ;Ì’•2ôúð.ø‚ζJ012∞S¶×‚ζJ.cpero puedes usar cualquier cosa aquí.
Urna de pulpo mágico
1
@MagicOctopusUrn Buen truco con la cremallera, no pensé en eso.
Adnan
1
@adnan también apoya 6xŠ», nunca hubiera pensado en eso.
Urna de pulpo mágico el
10

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
Felix Palmen
fuente
2
¿Podría ahorrar 2 bytes utilizando una subrutina que JSR $FFD2 / DEY / BNE loop / LDA .control,X / RTSrequiera tanto líneas nuevas como espacios? Creo que tendría +10 bytes de longitud y guardaría -12 bytes en el código principal.
Arnauld
1
En realidad, creo que puede guardar más bytes si la subrutina está funcionando JSR $FFD2 / DEY / BPL loop / LDA .control,X / RTSy el punto de entrada es el DEY. De esta manera, no tiene que probar 0en el código principal.
Arnauld
Gracias buena idea, editaré más tarde. Sin embargo, este último no funcionará, necesito un caso que omita todo el bucle.
Felix Palmen
1
Si Y = 0, DEY / BPL / RTSsaldrá inmediatamente sin procesar ninguno JSR $FFD2. (Tenga en cuenta que con ese esquema, el punto de entrada de la subrutina debe ser DEY).
Arnauld
1
@Arnauld después de bastante experimentación, creo que es más corto mantener la subrutina mientras usas tu sugerencia de almacenar todos los dígitos :)
Felix Palmen
6

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.

Jo King
fuente
6

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.

JayCe
fuente
68 bytes : se modificó el hash para evitar la aritmética y se modificó la writellamada para usar el separador predeterminado.
J.Doe
1
@ J.Doe Tiene más sentido de esta manera. Por supuesto, no haber documentado mi golf, no tengo idea de por qué hice un hash complicado en primer lugar ...
JayCe
5

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 .

Darrylyeo
fuente
8
No creo que esto cuente porque, dado que se trata de un arte ASCII, se supone que debemos generar el flujo de bytes exacto especificado en el desafío, mientras que esto genera una imagen que parece salida.
Downgoat
5

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])
Kevin Cruijssen
fuente
5

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.

J.Doe
fuente
Hola y bienvenidos a PPCG! Creo que se supone que los puntos ayudan a visualizar el patrón, pero no son parte de la salida.
Jonathan Frech
Bienvenido a PPCG! puede evitar que algunos bytes no definan my usen write: TIO . PD: no está obligado a incluir un enlace TIO en su respuesta, pero la formatea muy bien, vea el icono de enlace en la parte superior de la página TIO.
JayCe
Puede almacenar los puntos en una cadena y sobrecargar al !operador para llegar a 125 caracteres . Muy buena solución!
JayCe
5

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!

nimi
fuente
5

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
Level River St
fuente
4

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

TFeld
fuente
4

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
Jonathan Allan
fuente
LOL Estoy realmente sorprendido de que este sea el enfoque ingenuo.
Erik the Outgolfer
4

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!

ErikF
fuente
Sugerir en "\r\7\3"[j]lugar de"NHDA"[j]-65
ceilingcat
3

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!

Noche2
fuente
¿Puede poner la cadena comprimida binaria en el archivo fuente y omitir el código base64_decode? Intenté esto y obtengo un 'error de datos gzinflate (): pero podría ser posible si el archivo fuente fue escrito con un editor hexadecimal en lugar de un editor de texto.
bdsl
@bdsl en realidad lo hice antes y no necesita un editor HEX, solo puede usar PHP file_put_contents($path, '<?=gzinflate("'.gzdeflate($clockString,9).'");');, pero no estoy seguro de cómo publicar un código con datos binarios dentro. Un archivo como ese tiene 70 bytes.
Noche2
3

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)
Azul
fuente
3

brainfuck , 315 313 bytes

ahorrado 2 bytes gracias a los ovs !

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

Pruébalo en línea!

todo en un bloque de código:

++++[>++++<-]>[>+++>+++>+++>+++>>++>+++>+++>+
++<<<<<<<<<-]>+++++>++++>+++>++>++++++++++>>+
++++++>+><<<...........>>.<<<<.>.>.....>>..<<
...........>>.<<<..>.>>.>.<<<................
...<<.>...>>++.<.......................<<<.>>
...>..>-.<...................<<<<.>>>..>.....
.>-.<...........<<<<<.>>>>.>............>-.
Conor O'Brien
fuente
Puedes usar ++++[>++++<-]>para los 16 al principio.
Ovs
@ovs Ah, por supuesto, gracias !!
Conor O'Brien el
Lol, tienes ><en tu código
Jo King
3

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

mazzy
fuente
1
¿Por qué no multiplicar cadenas en lugar de .PadLeft88 bytes? ¡ Pruébelo en línea!
AdmBorkBork
Ese es un uso inteligente de -f. ¿Por qué no incluye enlaces para probarlo en línea! para que otros puedan ver cómo funciona tu código?
AdmBorkBork
Solo tengo el error This site can’t be reached. Lo siento.
mazzy
Ah, eso es una pena. Es un buen recurso. :-(
AdmBorkBork
Estoy de acuerdo. Gracias.
mazzy
3

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

Felix Palmen
fuente
1
109 bytes .
Jonathan Frech
@JonathanFrech reorganización de bucle agradable, me pregunto cómo me perdí esa: o Pero realmente no esperaba que gcc aceptara caracteres no imprimibles en la fuente :)
Felix Palmen
Mientras el personaje pueda ser representado en UTF-8, es técnicamente aceptable por el compilador. Si eso es algo bueno depende de lo que estás haciendo :-)
ErikF
Hablando de Unicode, puede guardar 3 bytes más utilizando caracteres anchos: ¡ Pruébelo en línea!
ErikF
1
Es por eso que me gusta el golf de código: ¡puedo abusar de UB y usar todas esas "cosas que no debes hacer" que recoges con el tiempo!
ErikF
2

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.

Conor O'Brien
fuente
2

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)

Ezekiel Elin
fuente
Bienvenido a PPCG! Muchos de nosotros usamos Try It Online (TIO) para que los intérpretes en línea incluyan un hipervínculo al programa en nuestras respuestas. Aquí está la respuesta: tio.run/##JY1BC4IwGIb/yvpOSjScqRW2DgV1sVMeOgQx14SBfMacdhB/…
mbomb007
Aquí hay un campo de golf de tu respuesta de 172 bytes. En su lugar, utiliza una función: {"L12NF11L1NNB10T2NNN9X3NNNC8T4NNG7L5NM6".unicodeScalars.map({(c)->String in let x=c.value;return x==78 ? "\n" : x>64 ?String(repeating:" ",count:x-65) : "\(c)"}).joined()}(swift 3 ( -swift-version 3en respuesta) porque swift 4 dejó caer la resta parece)
Downgoat
@Downgoat Lo reduje otros 3 bytes y lo hice compatible con Swift 4. Ver publicación actualizada.
Ezequiel Elin el
2

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!

Trauma digital
fuente
1

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!

Galen Ivanov
fuente
1

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

Darrylyeo
fuente
1

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

crystalgecko
fuente
¿Funcionaría tr -d \<space>(dónde <space>está el carácter de espacio) en lugar de la sustitución sed?
Kritixi Lithos
@Cowsquack lamentablemente no, tr -d\ sería equivalente ased 's/ //g'
crystalgecko
1

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.

mbomb007
fuente
Y si usa la cadena de formato Hermans , puede obtener esto a ~ 85 bytes.
ovs
Un byte más con {11:7}.
ovs
1

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!

Curtis Bechtel
fuente
Sugerir en *s=L"...";f(i){lugar def(i){char*s="...";
ceilingcat
1

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)

BradC
fuente
1

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 .

Phil H
fuente
116 bytes
Jo King
@JoKing: Ta, lo pegué y lo hice un wiki.
Phil H