Sfida:

Creare una funzione o un programma che prenderà un input N (un numero compreso tra 0 e 24) che rappresenta l'ORA.

L'uscita dovrebbe trarre un orologio analogico dagli asterischi che mostrano l'ora N.

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

Gli appunti:

• La lancetta dei minuti deve essere più lunga della lancetta delle ore (in termini di numero di asterischi utilizzati)

• La lancetta dei minuti deve essere di almeno 2 asterischi.

• Mezzogiorno, 15:00, 18:00 e 21:00 saranno sempre ortogonali. La produzione per le ore intermedie, se disposta per gradi, dovrebbe essere nello stesso ordine delle ore del giorno. Quello che voglio dire è a mezzogiorno la lancetta delle ore è 0 ° e alle 3 del pomeriggio la lancetta delle ore è di 90 ° in modo per i vostri casi di uscita di 13:00 e 2PM quanto segue deve essere vero: 0pm_deg < 1pm_deg < 2pm_deg < 3pm_deg. Oltre a questa regola, l'ammontare effettivo del grado può essere qualsiasi cosa tu decida, ovviamente cambierà in base al carattere e ad altri fattori nativi.

• Il giunto di collegamento tra la lancetta delle ore e la lancetta dei minuti è un carattere unicode circolare / ovale di qualsiasi tipo. o, O, •, 0, etc.

Esempio di input / output (può variare in base agli stili di disegno)

 N = 3;

 *
 *
 *
 O  *  *

 N = 4;

 *
 *
 *
 O
    *
       *

 N = 5;

 *
 *
 *
 0
  *
   *

 N = 6;

 *
 *
 o
 *

 N = 7;

      *
      *
      *
      •
    *
  *

 N = 0,12,24;

 *
 *
 *
 o

Esempio di uscite differenziate:

 N = 4     VS     N = 5     VS     N = 6

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

Questo è code-golf , quindi vince il programma con il byte più breve!

Javascript (ES6), 105 76 65 byte

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

  • Dimensioni ridotte della lancetta dei minuti e delle ore rispettivamente a 2 e 1 asterischi. Orologio più piccolo = meno byte :-P

• -11 byte:

  • Confronto di stringhe modificato in confronto numerico.
  • y==(N%12).toString(16)?'*':' ' -> '0x'+y^N%12?' ':'*'

Originale con lancette più lunghe: ( 105 94 byte)

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 byte

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>

Modifica: salvato 9 byte grazie a @nderscore.

Python 2 , 148 140 135 byte

-8 eliminando alcuni spazi rimanenti e una nuova riga non necessaria.

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

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

Provalo online!

C (gcc) , 144 byte

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

Provalo online!

SmileBASIC, 90 88 74 byte

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

Esempio di output:

? 5
  *
  *
  o

   *

? 3
  *
  *
  o *

Python 3 , 86 85 byte

-1 byte, quadrante migliore (credito DuctrTape, come usato nella mia risposta Jelly)

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

Provalo online!

Gelatina , 35 34 33 byte

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

Provalo online! (tI©!) o vedi tutto (0 - 24) .

Come?

ị“ 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

Si noti che “ tI©’Œ?Ḋ(permutazione all'indice, dequeued) è un salvataggio su byte “9ȧỤ_ÑḶ’b⁴(base 16 di), che è un salvataggio su byte “¦þxṙ<ȥ’ḃ13(base biiettiva 13 di).

†Per quanto riguarda il pop - abbiamo uno spazio extra nella stringa, che è dove l'asterisco per 0, 12, 24 andrà a consentire l'indicizzazione mod-12 dell'elenco degli indici, schioccare l'ultimo carattere lì è byte-più economico di facendo la concatenazione di “**o”prima e sovrascrivendo uno di quegli asterischi.

‡ Per quanto riguarda la rotazione - questo è un byte risparmiato rispetto alla costruzione di una stringa con la "** o" al centro (o con essa prima o dopo il posizionamento dell'asterisco).

Haskell, 148 byte

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 funzione c è quella che risolve il compito dato

Utilità Bash + Unix, 57 byte

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

(C'è uno spazio dopo la barra rovesciata finale.)

Provalo online!

Non è un orologio molto carino, ma soddisfa tutti i requisiti.

PHP, 71 byte

1 lancetta delle ore dell'asterisco, 2 lancette dei minuti dell'asterisco.

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

accetta input dall'argomento della riga di comando; corri con -nr.

1. definire il modello
2. mappare l'ora in posizione (decodifica dalla lettera) e impostare il carattere in posizione su asterisco
3. stampare

05AB1E , 41 byte

Questo è troppo lento per TIO.

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

Per un codice simile che funziona su TIO, prova questo

Abbastanza sicuro questo può ancora essere sia golfato che accelerato.
Spiegazione in arrivo.

Logicode 634 byte

Impossibile capire come inserire, quindi c'è un var a = ... per l'input nella parte superiore del collegamento 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)

Ho rinunciato a giocare a golf. Potrebbe renderlo più breve al costo di rendere l'orologio orribile però.

Provalo online