Reto:

Cree una función o programa que tomará una entrada N (un número de 0 a 24) que representa la HORA.

La salida debería extraer un reloj analógico de asteriscos que muestre la hora N.

🕛🕐🕑🕒🕓🕔🕕🕖🕗🕘🕙🕚🕛🕐🕑🕒🕓🕔🕕🕖🕗🕘🕙🕚🕛

Notas:

• La manecilla de minutos debe ser más larga que la manecilla de hora (en términos de número de asteriscos utilizados)

• El minutero debe tener al menos 2 asteriscos.

• Mediodía, 3pm, 6pm y 9pm siempre serán ortogonales. Su producción para horas intermedias, cuando se organizan por grados, debe estar en el mismo orden que las horas del día. Lo que quiero decir es al mediodía la aguja de las horas es 0º y en la mano 15:00 horas es de 90º por lo que para los casos de salida de la 1 pm y 2 pm el siguiente debe ser verdad: 0pm_deg < 1pm_deg < 2pm_deg < 3pm_deg. Además de esta regla, la cantidad de grados real puede ser lo que usted decida, obviamente cambiará dependiendo de la fuente y otros factores nativos.

• La unión de conexión entre la manecilla de hora y la manecilla de minutos es un carácter unicode circular / ovalado de cualquier tipo. o, O, •, 0, etc.

Ejemplo de entrada / salida (puede variar según los estilos de dibujo)

 N = 3;

 *
 *
 *
 O  *  *

 N = 4;

 *
 *
 *
 O
    *
       *

 N = 5;

 *
 *
 *
 0
  *
   *

 N = 6;

 *
 *
 o
 *

 N = 7;

      *
      *
      *
      •
    *
  *

 N = 0,12,24;

 *
 *
 *
 o

Ejemplo de salidas diferenciadoras:

 N = 4     VS     N = 5     VS     N = 6

  *                *                *
  *                *                *
  O                O                O
      *              *              *

Este es el código de golf , por lo que gana el programa con el bytecount más corto.

Javascript (ES6), 105 76 65 bytes

F=N=>`  *
ab*12
 9@3
87654`.replace(/\w/g,y=>'0x'+y^N%12?' ':'*')

<!-- Snippet Demo: -->
N =  <input type="number" min="0" max="24" value="2" id="I" />
<button onclick="console.log(F(I.value))">Run</button>

• -29 bytes:

  • Tamaño reducido de minutos y horas a 2 y 1 asteriscos respectivamente. Reloj más pequeño = menos bytes :-P

• -11 bytes:

  • Se cambió la comparación de cadenas a la comparación numérica.
  • y==(N%12).toString(16)?'*':' ' -> '0x'+y^N%12?' ':'*'

Original con manos más largas: ( 105 94 bytes)

F=N=>`    *
a b * 1 2
  ab*12
  99@33
  87654
8 7 6 5 4`.replace(/\w/g,y=>'0x'+y^N%12?' ':'*')

<!-- Snippet Demo: -->
N =  <input type="number" min="0" max="24" value="2" id="I" />
<button onclick="console.log(F(I.value))">Run</button>

CSS / HTML (JavaScript), 62 + 106 = 180 168 bytes

pre{position:absolute;left:99px;bottom:99px;transform-origin:50% 80%}

<input oninput=h.style.transform=`rotate(${this.value*30}deg)`><pre>*
*
o</pre><pre id=h>*

</pre>

Editar: Guardado 9 bytes gracias a @nderscore.

Python 2 , 148 140 135 bytes

-8 eliminando algunos espacios sobrantes y una nueva línea innecesaria.

-5 cambiando (' ','*')a' *'

a=input()
b='''    *
a b * 1 2
  ab*12
9 9 o 3 3
  87654
8 7 6 5 4'''
for x in range(1,12):b=b.replace(hex(x)[2],' *'[x==a%12])
print b

Pruébalo en línea!

C (gcc) , 144 bytes

#define v ,t
h;t(i){putchar(i>12?i-9:h^i?32:42);}n(i){h=i%12;puts("  *")v(10)v(11)v(h)v(1)v(2)v(19)v(12)v(9)v(57)v(3)v(19)v(8)v(7)v(6)v(5)v(4);}

Pruébalo en línea!

SmileBASIC, 90 88 74 bytes

INPUT H?("  *"+" "*47)*2;"  o
R=H/1.9LOCATE 2.5+SIN(R)*2,3.5-COS(R)*2?"*

Salida de ejemplo:

? 5
  *
  *
  o

   *

? 3
  *
  *
  o *

Python 3 , 86 85 bytes

-1 byte, mejor esfera del reloj (crédito DuctrTape, como se usa en mi respuesta Jelly)

def f(h):print(*([c,' *'[h%12+64==ord(c)]][c>'@']for c in'''
K*A
J*B
I0C
HFD
G E'''))

Pruébalo en línea!

Jalea , 35 34 33 bytes

ị“ tI©’Œ?Ḋ¤µ⁶ẋ13”*⁸¦Ṗ;“**o”ṙ7s5ZY

Pruébalo en línea! (tI©!) o ver todo (0 - 24) .

¿Cómo?

ị“ tI©’Œ?Ḋ¤µ⁶ẋ13”*⁸¦Ṗ;“**o”ṙ7s5ZY - Main link: h
          ¤                       - nilad followed by link(s) as a nilad:
 “ tI©’                           -     base 250 number: 522956007
       Œ?                         - shortest permutation of [1,N] that would be at
                                     that index in a lexicographically sorted
                                     list: [2,3,4,5,6,7,1,12,11,10,9,8,13]
         Ḋ                        - dequeue: [3,4,5,6,7,1,12,11,10,9,8,13]
ị                                 - index into (1-based and modular, so h=2 picks 4,
                                     as does h=14 [as do h=26, h=-10, etc.])
           µ                      - monadic chain separation (call the result j)
            ⁶                     - space character
             ẋ13                  - repeat 13 times
                   ¦              - apply to index...
                  ⁸               - ...left argument (j)
                ”*                -     an asterisk character (replacemes the space
                                         at index j with an asterisk)
                    Ṗ             - pop the last character off the list †
                     ;“**o”       - concatenate "**o"
                           ṙ7     - rotate left by 7 ‡
                             s5   - split into chunks of length 5 (columns)
                               Z  - transpose (get the rows of the clock)
                                Y - join with line feeds
                                  - implicit print

Tenga en cuenta que “ tI©’Œ?Ḋ(permutación en el índice, dequeued) es un byte save over “9ȧỤ_ÑḶ’b⁴(base 16 de), que es un byte save over “¦þxṙ<ȥ’ḃ13(base biyectiva 13 de).

†Con respecto al pop: tenemos un espacio adicional en la cadena, que es donde irá el asterisco para 0, 12, 24 para permitir la indexación mod-12 de la lista de índices, sacando el último carácter de allí es byte-más barato que haciendo la concatenación de “**o”antemano y sobrescribiendo uno de esos asteriscos.

‡ Con respecto a la rotación: este es un byte guardado sobre la construcción de una cadena con el "** o" en el medio (ya sea antes o después de la colocación del asterisco).

Haskell, 148 bytes

c n=mapM_ putStrLn$(t(n-3)!(t n!(\_->'*')))(map(\x->(2!(\_->x))"     ")"**O  ")
n!f=(\(x,a:y)->x++f a:y).splitAt n
t n=2+truncate(2.5*sin(n*pi/6))

La función c es la que resuelve la tarea dada

Bash + Unix utilities, 57 bytes

tr `dc -e12o$1O%p` \*<<<'B*1
A*2
9O3
864
7 5'|tr 1-9AB \ 

(Hay un espacio después de la barra invertida final).

Pruébalo en línea!

No es un reloj muy bonito, pero cumple con todos los requisitos.

PHP, 71 bytes

Manecilla de 1 hora de asterisco, manecilla de 2 minutos de asterisco.

$s="  *
  *  
  O  
";$s[ord(BGHNTSRQPJDE[$argv[1]%12])&31]="*";echo$s;

toma datos del argumento de la línea de comando; correr con -nr.

1. definir plantilla
2. mapear la hora a la posición (decodificar desde la letra) y establecer el carácter en la posición en asterisco
3. impresión

05AB1E , 41 bytes

Esto es demasiado lento para TIO.

14Ýœ•2!&ô÷‰•èv… *@y_2L11+¹12%0‚ìyå+èJ}3ô»

Para código similar trabajando en TIO intente esto

Estoy bastante seguro de que esto puede ser tanto golfizado como acelerado.
Explicación que viene más tarde.

Logicode 634 bytes

No se pudo entender cómo ingresar, por lo que hay una var a = ... para la entrada en la parte superior del enlace tio

circ v(a)->cond((a&1000)+0)&a->0/a
circ n(a)->cond a&10000->((a&100)+0)|!(a&100)&((a&011)|100)/a
circ y(a)->cond((a&100)+0)&a->a&10011/a
var s=@100000
var m=@101010
var x=y(n(v(a)))
var e=x&1000
var f=(x&100)+0
var t=(x&10)+00
var o=(x&1)+000
circ r(a,b)->cond(a)->b/@a
out s+s+s+s+m
out r(e&t&!o,m)+s+r(o&e&t,m)+s+m+s+r(o&!e&!f&!t,m)+s+r(t&!o&!f&!e,m)
out s+s+r(e&t&!o,m)+r(e&t&o,m)+m+r(o&!t&!f&!e,m)+r(t&!o&!f&!e,m)
out r(e&o&!t,m)+s+r(e&o&!t,m)+s+@110000+s+r(t&o&!f&!e,m)+s+r(t&o&!f&!e,m)
out s+s+r(e&!t&!o,m)+r((f&t&o),m)+r(f&t&!o,m)+r(f&!t&o,m)+r(f&!t&!o,m)
out r(e&!t&!o,m)+s+r(f&t&o,m)+s+r(f&t&!o,m)+s+r(f&o&!t,m)+s+r(f&!t&!o,m)

He dejado de jugar al golf. Sin embargo, podría hacerlo más corto a costa de hacer que el reloj se vea horrible.

Pruébalo en línea