Défi:

Créez une fonction ou un programme qui prendra une entrée N (un nombre de 0 à 24) qui représente l'HEURE.

La sortie doit dessiner une horloge analogique sur des astérisques indiquant l'heure N.

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

Remarques:

• L'aiguille des minutes doit être plus longue que l'aiguille des heures (en termes de nombre d'astérisques utilisés)

• L'aiguille des minutes doit être composée d'au moins 2 astérisques.

• Midi, 15 h, 18 h et 21 h seront toujours orthogonaux. Votre sortie pour les heures intermédiaires, lorsqu'elle est organisée par degrés, doit être dans le même ordre que les heures de la journée. Ce que je veux dire, c'est qu'à midi, l'aiguille des heures est à 0 ° et à 15 h, l'aiguille des heures est à 90 ° 0pm_deg < 1pm_deg < 2pm_deg < 3pm_deg. En dehors de cette règle, le montant réel du diplôme peut être ce que vous décidez, il est évident qu'il changera en fonction de la police et d'autres facteurs natifs.

• Le joint de liaison entre l'aiguille des heures et l'aiguille des minutes est un caractère unicode circulaire / ovale de toute nature. o, O, •, 0, etc.

Exemple d'entrée / sortie (peut varier selon les styles de dessin)

 N = 3;

 *
 *
 *
 O  *  *

 N = 4;

 *
 *
 *
 O
    *
       *

 N = 5;

 *
 *
 *
 0
  *
   *

 N = 6;

 *
 *
 o
 *

 N = 7;

      *
      *
      *
      •
    *
  *

 N = 0,12,24;

 *
 *
 *
 o

Exemple de sorties différenciantes:

 N = 4     VS     N = 5     VS     N = 6

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

Il s'agit de code-golf , donc le programme avec le nombre de bytecount le plus court gagne!

Javascript (ES6), 105 76 65 octets

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

  • Taille des aiguilles des minutes et des heures réduite à 2 et 1 astérisques respectivement. Horloge plus petite = moins d'octets :-P

• -11 octets:

  • Modification de la comparaison de chaînes en comparaison numérique.
  • y==(N%12).toString(16)?'*':' ' -> '0x'+y^N%12?' ':'*'

Original avec des mains plus longues: ( 105 94 octets)

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 octets

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>

Edit: 9 octets enregistrés grâce à @nderscore.

Python 2 , 148 140 135 135 octets

-8 en supprimant certains espaces restants et une nouvelle ligne inutile.

-5 en passant (' ','*')à' *'

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

Essayez-le en ligne!

C (gcc) , 144 octets

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

Essayez-le en ligne!

SmileBASIC, 90 88 74 octets

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

Exemple de sortie:

? 5
  *
  *
  o

   *

? 3
  *
  *
  o *

Python 3 , 86 85 octets

-1 octet, meilleure horloge (crédit DuctrTape, tel qu'utilisé dans ma réponse Jelly)

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

Essayez-le en ligne!

Gelée , 35 34 33 octets

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

Essayez-le en ligne! (tI©!) ou tout voir (0 - 24) .

Comment?

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

Notez que “ tI©’Œ?Ḋ(permutation à l'index, retiré de la file d'attente) est une sauvegarde d'octet sur “9ȧỤ_ÑḶ’b⁴(base 16 de), qui est une sauvegarde d'octet sur “¦þxṙ<ȥ’ḃ13(base bijective 13 de).

†En ce qui concerne la pop - nous avons un espace supplémentaire dans la chaîne, où l'astérisque pour 0, 12, 24 ira pour permettre l'indexation mod-12 de la liste des index, faire sauter le dernier caractère là-bas est moins cher en octets que faire la concaténation d' “**o”avance et écraser l'un de ces astérisques.

‡ En ce qui concerne la rotation - il s'agit d'un enregistrement d'octets sur la construction d'une chaîne avec le «** o» au milieu (soit avec avant, soit après le placement de l'astérisque).

Haskell, 148 octets

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 fonction c est celle qui résout la tâche donnée

Utilitaires Bash + Unix, 57 octets

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

(Il y a un espace après la dernière barre oblique inverse.)

Essayez-le en ligne!

Pas une très jolie horloge, mais elle répond à toutes les exigences.

PHP, 71 octets

1 aiguille des heures astérisque, 2 aiguilles des minutes astérisque.

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

prend l'entrée de l'argument de la ligne de commande; courir avec -nr.

1. définir un modèle
2. mapper l'heure à la position (décoder à partir de la lettre) et définir le caractère à la position sur un astérisque
3. impression

05AB1E , 41 octets

C'est trop lent pour TIO.

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

Pour un code similaire fonctionnant sur TIO, essayez ceci

Je suis sûr que cela peut encore être joué au golf et accéléré.
Explication à venir plus tard.

Logicode 634 octets

Impossible de comprendre comment entrer, donc il y a un var a = ... pour l'entrée en haut du lien 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)

J'ai renoncé à jouer au golf. Pourrait le raccourcir au prix de rendre l'horloge horrible.

Essayez-le en ligne