Herausforderung:

Erstellen Sie eine Funktion oder ein Programm, das eine Eingabe N (eine Zahl von 0 bis 24) für die STUNDE annimmt.

Die Ausgabe sollte eine analoge Uhr aus den Sternchen zeichnen, die die Stunde N anzeigen.

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

Anmerkungen:

• Der Minutenzeiger muss länger als der Stundenzeiger sein (in Bezug auf die Anzahl der verwendeten Sternchen)

• Der Minutenzeiger muss aus mindestens 2 Sternchen bestehen.

• Mittag, 15 Uhr, 18 Uhr und 21 Uhr sind immer orthogonal. Ihre Ausgabe für Zwischenstunden sollte, wenn nach Grad geordnet, in der gleichen Reihenfolge wie die Stunden des Tages erfolgen. Was ich meine , ist mittags der Stundenzeiger ist 0 ºC und bei 03.00 der Stundenzeiger ist 90º so für die Ausgabe Fälle von 01.00 und 2Pm Folgendes muss wahr sein: 0pm_deg < 1pm_deg < 2pm_deg < 3pm_deg. Abgesehen von dieser Regel kann der tatsächliche Gradbetrag beliebig sein. Dies hängt natürlich von der Schriftart und anderen nativen Faktoren ab.

• Die Verbindungsstelle zwischen Stunden- und Minutenzeiger ist ein kreisförmiger / ovaler Unicode. o, O, •, 0, etc.

Beispiel für Eingabe / Ausgabe (kann je nach Zeichnungsstil variieren)

 N = 3;

 *
 *
 *
 O  *  *

 N = 4;

 *
 *
 *
 O
    *
       *

 N = 5;

 *
 *
 *
 0
  *
   *

 N = 6;

 *
 *
 o
 *

 N = 7;

      *
      *
      *
      •
    *
  *

 N = 0,12,24;

 *
 *
 *
 o

Beispiel für die Differenzierung von Ausgaben:

 N = 4     VS     N = 5     VS     N = 6

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

Das ist Code-Golf , also gewinnt das Programm mit dem kürzesten bytecount!

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:

  • Die Größe des Minuten- und Stundenzeigers wurde auf 2 bzw. 1 Sternchen reduziert. Kleinerer Takt = weniger Bytes :-P

• -11 Bytes:

  • Stringvergleich in numerischen Vergleich geändert.
  • y==(N%12).toString(16)?'*':' ' -> '0x'+y^N%12?' ':'*'

Original mit längeren Zeigern: ( 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 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>

Bearbeiten: 9 Bytes dank @nderscore gespeichert.

Python 2 , 148 140 135 Bytes

-8 durch Löschen von Leerzeichen und nicht mehr benötigten Zeilenumbrüchen.

-5 durch Ändern (' ','*')auf' *'

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

Probieren Sie es online!

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

Probieren Sie es online!

SmileBASIC, 90 88 74 Bytes

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

Beispielausgabe:

? 5
  *
  *
  o

   *

? 3
  *
  *
  o *

Python 3 , 86-85 Bytes

-1 Byte, besseres Zifferblatt (Kredit DuctrTape, wie in meiner Gelee-Antwort verwendet)

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

Probieren Sie es online!

Jelly , 35 34 33 Bytes

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

Probieren Sie es online! (tI©!) oder alle anzeigen (0 - 24) .

Wie?

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

Beachten Sie, dass “ tI©’Œ?Ḋ(Permutation am Index, aus der Warteschlange entfernt) eine Byte-Speicherung über “9ȧỤ_ÑḶ’b⁴(Basis 16 von) ist, die eine Byte-Speicherung über “¦þxṙ<ȥ’ḃ13(bijektive Basis 13 von) ist.

†In Bezug auf den Pop - wir haben ein zusätzliches Leerzeichen in der Zeichenkette, in dem der Stern für 0, 12, 24 angezeigt wird, um die Mod-12-Indizierung der Indexliste zu ermöglichen, wobei das letzte Zeichen von dort wegspringt, ist bytegünstiger als Vorab die Verkettung durchführen “**o”und eines dieser Sternchen überschreiben.

‡ In Bezug auf die Rotation ist dies eine Byte-Ersparnis gegenüber der Erstellung eines Strings mit dem "** o" in der Mitte (entweder vor oder nach der Platzierung des Sternchens).

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

Funktion c ist diejenige, die die gegebene Aufgabe löst

Bash + Unix-Dienstprogramme, 57 Bytes

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

(Nach dem letzten Backslash ist ein Leerzeichen.)

Probieren Sie es online!

Keine sehr schöne Uhr, aber sie erfüllt alle Anforderungen.

PHP, 71 Bytes

1 Sternchen-Stundenzeiger, 2 Sternchen-Minutenzeiger.

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

Nimmt Eingaben vom Kommandozeilenargument entgegen; renn mit -nr.

1. vorlage definieren
2. Karte Stunde bis Position (aus dem Buchstaben entschlüsseln) und Zeichen an Position auf Stern setzen
3. drucken

05AB1E , 41 Bytes

Dies ist für TIO zu langsam.

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

Versuchen Sie dies, um ähnlichen Code für TIO zu erhalten

Ich bin mir ziemlich sicher, dass das sowohl Golfspielen als auch Beschleunigen ist.
Erklärung kommt später.

Logikcode 634 Bytes

Konnte nicht herausfinden, wie man eingibt, so gibt es ein var a = ... für die Eingabe am oberen Rand des tio-Links

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)

Habe das Golfen aufgegeben. Könnte es allerdings kürzer machen, wenn die Uhr schrecklich aussieht.

Probieren Sie es online