Gespiegelte Digitaluhr

19

Viele Digitaluhren zeigen die Uhrzeit mit vereinfachten Ziffern an, die aus nur sieben verschiedenen Leuchten bestehen, die entweder an oder aus sind:

Bei horizontaler Spiegelung 018ändern sich die Ziffern nicht, da sie symmetrisch sind. Die Ziffern auch, 2und 5erhalten getauscht, 2immer 5und umgekehrt. Alle anderen Ziffern werden ungültig, wenn sie gespiegelt werden.

Somit gibt es bei einer 24-Stunden-Digitaluhr viele Uhrablesungen, so dass das gespiegelte Bild der Digitalanzeige auch eine gültige Uhrablesung ist. Ihre Aufgabe ist es, alle diese Taktwerte zusammen mit den gespiegelten Werten auszugeben.

Zum Beispiel 22:21wird 15:55, und 00:15wird 21:00. Auf der anderen Seite sind 12:34oder 16:27nicht mehr gültig, wenn gespiegelt (Ziffern 34679werden ungültig), und weder sind 22:22noch 18:21, weil es nur 24 Stunden am Tag und 60 Minuten in einer Stunde gibt, würde keine vernünftige Uhr 55:55oder anzeigen 12:81.

Aufgabe

Schreiben Sie ein Programm oder eine Funktion, die keine Eingabe akzeptiert und alle gültigen Paare in aufsteigender Reihenfolge ausgibt, wie unten gezeigt:

00:00 - 00:00
00:01 - 10:00
00:05 - 20:00
00:10 - 01:00
00:11 - 11:00
00:15 - 21:00
00:20 - 05:00
00:21 - 15:00
00:50 - 02:00
00:51 - 12:00
00:55 - 22:00
01:00 - 00:10
01:01 - 10:10
01:05 - 20:10
01:10 - 01:10
01:11 - 11:10
01:15 - 21:10
01:20 - 05:10
01:21 - 15:10
01:50 - 02:10
01:51 - 12:10
01:55 - 22:10
02:00 - 00:50
02:01 - 10:50
02:05 - 20:50
02:10 - 01:50
02:11 - 11:50
02:15 - 21:50
02:20 - 05:50
02:21 - 15:50
02:50 - 02:50
02:51 - 12:50
02:55 - 22:50
05:00 - 00:20
05:01 - 10:20
05:05 - 20:20
05:10 - 01:20
05:11 - 11:20
05:15 - 21:20
05:20 - 05:20
05:21 - 15:20
05:50 - 02:20
05:51 - 12:20
05:55 - 22:20
10:00 - 00:01
10:01 - 10:01
10:05 - 20:01
10:10 - 01:01
10:11 - 11:01
10:15 - 21:01
10:20 - 05:01
10:21 - 15:01
10:50 - 02:01
10:51 - 12:01
10:55 - 22:01
11:00 - 00:11
11:01 - 10:11
11:05 - 20:11
11:10 - 01:11
11:11 - 11:11
11:15 - 21:11
11:20 - 05:11
11:21 - 15:11
11:50 - 02:11
11:51 - 12:11
11:55 - 22:11
12:00 - 00:51
12:01 - 10:51
12:05 - 20:51
12:10 - 01:51
12:11 - 11:51
12:15 - 21:51
12:20 - 05:51
12:21 - 15:51
12:50 - 02:51
12:51 - 12:51
12:55 - 22:51
15:00 - 00:21
15:01 - 10:21
15:05 - 20:21
15:10 - 01:21
15:11 - 11:21
15:15 - 21:21
15:20 - 05:21
15:21 - 15:21
15:50 - 02:21
15:51 - 12:21
15:55 - 22:21
20:00 - 00:05
20:01 - 10:05
20:05 - 20:05
20:10 - 01:05
20:11 - 11:05
20:15 - 21:05
20:20 - 05:05
20:21 - 15:05
20:50 - 02:05
20:51 - 12:05
20:55 - 22:05
21:00 - 00:15
21:01 - 10:15
21:05 - 20:15
21:10 - 01:15
21:11 - 11:15
21:15 - 21:15
21:20 - 05:15
21:21 - 15:15
21:50 - 02:15
21:51 - 12:15
21:55 - 22:15
22:00 - 00:55
22:01 - 10:55
22:05 - 20:55
22:10 - 01:55
22:11 - 11:55
22:15 - 21:55
22:20 - 05:55
22:21 - 15:55
22:50 - 02:55
22:51 - 12:55
22:55 - 22:55

Ein abschließender oder ein führender Zeilenumbruch ist zulässig. Ein paar Leerzeichen direkt vor einem Zeilenumbruch sind ebenfalls zulässig. Die Zeiten müssen formatiert hh:mmund bei Bedarf mit Nullen aufgefüllt sein.

Das ist , also gewinnt die kürzeste Antwort in Bytes. Standardlücken sind wie üblich nicht zulässig.

Steadybox
quelle
In Clean ist a Stringein Array von Char. Ist es akzeptabel, wenn meine Antwort eine Liste von enthält Char? Die Typen sehen im ungedruckten Zustand identisch aus.
Οurous
Ja, ich denke, es ist in Ordnung. Der Konsens über Meta scheint zu sein, dass ein String eine Folge von Zeichen ist, und das ist eine Liste von Zeichen.
Steadybox
In dieser Siebensegmentanzeige ist die Ziffer 1nicht exakt mit ihrem Spiegelbild identisch, da Sie erkennen können, ob die am weitesten rechts oder links liegenden Segmente zur Bildung der vertikalen "Linie" verwendet werden, aus der sich die Ziffer zusammensetzt. Ich verstehe, dass wir sie hier als identisch betrachten.
Jeppe Stig Nielsen
@JeppeStigNielsen Lass uns so tun, als ob OP ein Bild mit 14seg-Displays anstelle von 7seg verwendet, damit das 1zentriert werden könnte.
Sparr
3
@Steadybox Wow, genau diese Idee hatte ich kürzlich. Ich habe vor, es bei Programmierinterviews auf Personen anzuwenden. Übrigens habe ich einen Mikrowellenherd, der keine vernünftige Uhr hat und mit dem man Dinge wie 83:75 spezifizieren kann :-)
JohnEye

Antworten:

2

05AB1E , 34 Bytes

0125DâDâεÂ5n‡í)}ʒ€н25‹P}':ý… - ý»

Probieren Sie es online!

Erläuterung

0125                                # push "0125"
    Dâ                              # cartesian product with itself
      Dâ                            # cartesian product with itself
        ε       }                   # apply to each
         Â                          # bifurcate
          5n                       # push 25 bifurcated
             ‡                      # transliterate
              í                     # reverse each
               )                    # wrap in a list
                 ʒ      }           # filter each on
                  €н                # head of each
                    25‹             # less than 25
                       P            # product
                         ':ý        # merge on ":"
                            … - ý   # merge on " - "
                                 »  # join on newlines
Emigna
quelle
6

Python 2 , 187 180 178 177 Bytes

R=range(11)
for t in['0000111122201250125012'[j::11]+':'+'0001112255501501501015'[i::11]for i in R for j in R]:print t+' - '+''.join(map(dict(zip('0125:','0152:')).get,t))[::-1]

Probieren Sie es online!

Danke für +1 Kevin Cruijssen.

Chas Brown
quelle
5

APL (Dyalog Unicode) , 84 Byte SBCS

Komplette Programmausgabe nach STDOUT. Erfordert ⎕IO( I ndex O rigin), 0was auf vielen Systemen Standard ist.

{0::⋄∧/23 59≥⍎¨(':'t)⊆t←⌽'015xx2xx8x:'[⎕Di←∊⍺':'⍵]:⎕←1↓⍕i'-'t}⌿1↓¨⍕¨100+0 60⊤⍳1440

Probieren Sie es online!

⍳1440 dass viele ɩ ntegers

0 60⊤ konvertiere zu gemischter Base base, 60

100+ addiere 100 (dies fügt die benötigten 0s hinzu)

⍕¨ jeweils formatieren (stringifizieren)

1↓¨ lösche das erste Zeichen von jedem (dies entfernt die führenden Einsen)

{}⌿ Wende die folgende anonyme Funktion spaltenweise an ( ist die höchste Stunde, ist die Minute)

0:: Wenn ein Fehler auftritt, wird nichts zurückgegeben

 Versuchen:

  '015xx2xx8x:'[] Indexiere diesen String mit:

   ∊⍺':'⍵ die ε nlisted (abgeflacht) Liste der Stunde, Dickdarm-, Minute

   i← gespeichert i(für i Nput)

   ⎕D⍳ɩ ndices jedes Zeichen in der Liste von D igits

   kehre das um

  t← speichern als t(für t ime)

  ()⊆ Gruppenläufe wo:

   ':'≠t Doppelpunkt unterscheidet sich von t

⍎¨ jeweils ausführen (auswerten)

23 59≥ Boolescher Wert für jeden Wert, unabhängig davon, ob er kleiner oder gleich 23 bzw. 59 ist

∧/ sind beide wahr?

: wenn ja, dann:

  ⍕i'-'t Die formatierte (durch Leerzeichen getrennte) Liste von Eingaben, Strichen und Zeiten

  1↓ Lass das erste (Leerzeichen) fallen

  ⎕← Ausgabe an STDOUT

Adam
quelle
4

Retina , 57 Bytes


 - 
+m`^.{3,9}$
0$&0¶1$&1¶2$&5¶5$&2
A`\b2?5
\b\d.
$&:
O`

Probieren Sie es online! Erläuterung:


 - 

Setzen Sie das Trennzeichen ein.

+m`^.{3,9}$
0$&0¶1$&1¶2$&5¶5$&2

Generieren Sie alle möglichen Sätze von vier gespiegelten Ziffern.

A`\b2?5

Löschen Sie die mit illegalen Stunden.

\b\d.
$&:

Setzen Sie die Doppelpunkte ein.

O`

In Reihenfolge sortieren.

Neil
quelle
4

Python 2 , 279 277 255 Bytes

for h in range(1440):
 q=[[[0,(a+"52")[(a=="2")+(a=="5")*2]][a in"01825"]for a in c]for c in[("%02d"%e)[::-1]for e in[h%60,h/60]]]
 if all(q[0]+q[1]):
	z=[int(''.join(j))for j in q]
	if(z[1]<60)*(z[0]<24):print"%02d:%02d - %02d:%02d"%(h/60,h%60,z[0],z[1])

Probieren Sie es online!

Credits

Neil
quelle
-1 Byte
FlipTack
3

Sauber , 269 ... 172 170 Bytes

import StdEnv
?n=toChar n+'0'
$c|c<2=c=7-c
n=[0,1,2,5]
t=flatlines[u++[' - ':v]\\[u,v]<-[[map?[a,b,10,x,y],map?[$y,$x,10,$b,$a]]\\a<-n,b<-n,x<-n,y<-n]|['23:59']>=max u v]

Probieren Sie es online!

Ungolfed:

import StdEnv
numeral n = toChar (n+48)
mirror 2 = 5
mirror 5 = 2
mirror c = c
digits = [0, 1, 2, 5]
times
    = flatlines [ // flatten with interspersed newlines
        original ++ [' - ' : reflection] // insert separator
        \\ // generate all pairs of times and their mirrored copies
        [original, reflection] <- [
            [map numeral [a, b, 10, x, y], map (numeral o mirror) [y, x, 10, b, a]]
            \\ // generate every combination of display digits
            a <- digits,
            b <- digits,
            x <- digits,
            y <- digits
            ]
        | ['23:59'] >= max original reflection // make sure both times actually exist
        ]
Οurous
quelle
2

Pyth , 48 Bytes

Lj\:c2bjf!:T"5.:|25:"0mj" - ",ydyX_d`25)^"0125"4

Probieren Sie es online!

Erzeugt alle möglichen Kombinationen von 0125und manipuliert sie dann in die Zeit. Diese befinden sich in der richtigen Reihenfolge, da sie in lexikografischer Reihenfolge generiert werden. Schließlich werden die zusätzlichen ungültigen Zeiten herausgefiltert, indem Zeilen entfernt werden, die mit dem regulären Ausdruck 5.:oder übereinstimmen 25:. Leider scheint die Komprimierung bei keinem der in diesem Programm verwendeten Strings gut zu funktionieren, es sei denn, ich habe einen Fehler gemacht oder einen Fehler übersehen.

FryAmTheEggman
quelle
2

Perl 5 , 147 Bytes

map{$h=0 x($_<10).$_;map{$_="0$_"if$_<10;say"$h:$_ - $q:$i"if($i=reverse$h=~y/25/52/r)<60&&"$h$_"!~/[34679]/&&($q=reverse y/25/52/r)<24}0..59}0..23

Probieren Sie es online!

Xcali
quelle
2

Japt v2 (+ -R), 51 Bytes

G²Çs4 ùT4 i':2î+" - "+Zw r\d_^Z>1})r3,5Ãkf/5.|25):

Testen Sie es online!

Erläuterung

G²Ç   s4 ùT4 i':2à ®   +" - "+Zw r\d_  ^Z>1})r3,5à kf/5.|25):
G²oZ{Zs4 ùT4 i':2} mZ{Z+" - "+Zw r\dZ{Z^Z>1})r3,5} kf/5.|25):/   Ungolfed

G²              Calculate 16**2, or 256.
  oZ{       }   Create the range [0...256) and map each integer Z to:
Zs4               Convert Z to a base-4 string.  [0, 1, 2, 3, 10, ..., 3331, 3332, 3333]
    ùT4           Pad-left with 0's to length 4. [0000, 0001, 0002, ..., 3331, 3332, 3333]
        i':2      Insert a colon at index 2.     [00:00, 00:01, 00:02, ..., 33:31, 33:32, 33:33]

mZ{      }      Map each string Z in the resulting array to:
Zw r\dZ{     }    Reverse Z, and replace each digit Z' with
        Z^Z>1       Z' xor'd with (Z>1). This turns 2 to 3 and vice versa.
                  We now have [00:00, 10:00, 30:00, 20:00, 01:00, ..., 12:22, 32:22, 22:22]
Z+" - "+          Append this to Z with " - " in between. This gives
                    [00:00 - 00:00, 00:01 - 10:00, 00:02 - 30:00, ..., 33:32 - 32:22, 33:33 - 22:22]
r3,5              Replace all 3s in the result with 5s.
                    [00:00 - 00:00, 00:01 - 10:00, 00:02 - 50:00, ..., 55:52 - 52:22, 55:55 - 22:22]

k               Remove all results that
 f/5.|25):/       match the regex /(5.|25):/g. This removes times with impossible hours.

                Implicit: output result of last expression, joined with newlines (-R)
ETHproductions
quelle
1

JavaScript (ES6), 142 Byte

f=(n=0)=>n<176?(s=(g=n=>d[n>>2]+d[n&3])(n%4*4|n/4&3,d='0152')+':'+g(n>>6|(n/4&12)),s<'25'?g(n>>4,d='0125')+`:${g(n&15)} - ${s}
`:'')+f(n+1):''

Probieren Sie es online!

Arnauld
quelle
1

Kohle , 59 Bytes

F012F0125F0125F015¿›‹⁺ικ25⁼⁺λμ25«ικ:λμ - F⟦μλ3κι⟧§015::2Iν⸿

Probieren Sie es online!Link ist eine ausführliche Version des Codes. Erläuterung:

F012F0125F0125F015

Erstellen Sie vier verschachtelte Schleifen für die nicht gespiegelten Ziffern.

¿›‹⁺ικ25⁼⁺λμ25«

Stellen Sie sicher, dass weder die Stunden noch die Minuten 25 sind. (Wenn Sie die 25 Minuten spiegeln, erhalten Sie 25 Stunden.)

ικ:λμ - 

Drucken Sie die nicht gespiegelte Zeit.

F⟦μλ3κι⟧§015::2Iν⸿

Geben Sie die gespiegelte Zeit aus, indem Sie die umgekehrten Ziffern (oder 3den Doppelpunkt) von Zeichenfolge in Ganzzahl konvertieren und in einer Übersetzungstabelle nachschlagen.

Alternativ auch für 59 Bytes:

F¹¹F¹⁶¿⁻¹¹κ¿⁻²﹪κ⁴«≔⟦÷ι⁴﹪ι⁴¦⁴÷κ⁴﹪κ⁴⟧θFθ§0125:λ - F⮌θ§0152:λ⸿

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

F¹¹F¹⁶

Erstellen Sie Schleifen für die Stunden und Minuten.

¿⁻¹¹κ¿⁻²﹪κ⁴«

Ausschließen 25und auch alle Minuten, die auf enden 2.

≔⟦÷ι⁴﹪ι⁴¦⁴÷κ⁴﹪κ⁴⟧θ

Konvertieren Sie die Stunden und Minuten zur Basis 4.

Fθ§0125:λ

Drucken Sie die Ziffern aus, die in einer Übersetzungstabelle nachgeschlagen wurden.

 - 

Drucken Sie den Separator.

F⮌θ§0152:λ⸿

Drucken Sie die umgekehrten Ziffern, die in einer gespiegelten Übersetzungstabelle nachgeschlagen wurden.

Neil
quelle
1

Jelly , 72 66 62 55 Bytes

®ṢiЀUị®
“0152:”©ṢṖp`⁺ḣ176j€“:”µ;"Ç€⁾25ẇ$ÐṂœs€2j€“ - ”Y

Probieren Sie es online!

Niladic Programm. Ich habe das doppelte Produkt der '0125'Idee aus der 05AB1E-Antwort von Emigna erhalten aber den Rest habe ich ohne Rücksprache gemacht, da die Sprachen danach auseinander gehen. Es gibt wahrscheinlich Möglichkeiten zum Golfen, möglicherweise um einiges.

Erläuterung

Das Programm funktioniert wie folgt:

  • Nehmen Sie alle Produkte der Länge vier aus der Liste der Zeichen '0125'mit “0152:”©ṢṖp`⁺. ©kopiert die Zeichenfolge '0152:'zur späteren Verwendung in das Register. ṢṖSORTIERT dann das letzte Element der Zeichenfolge → '0125'. dupliziert den Produktlink.

  • ḣ176Entfernt alle Zeiten mit Format 25xxoder 5xxx(ungültigen Stunden).

  • j€“:”verbindet jedes Ziffernpaar mit einem ':'. zB ['05'],['21']]'05:12'.

  • Ç€Wendet den ersten Link auf jede dieser Zeiten an. Es findet den Index jedes Zeichens in der Zeichenkette '0125:', erhält dann für jeden dieser Indizes das Zeichen in der Zeichenkette '0152:'und kehrt es um. Dies ist die Spiegeloperation (Umkehren und Vertauschen von 2s und 5s).

  • µ;" verkettet die ursprüngliche Zeit mit der gespiegelten Zeit → '05:2115:20'

  • ⁾25ẇ$ÐṂfiltert mal mit dem teilstring raus '25'. Dies fängt zu jeder Zeit Paare mit gespiegelten Hälften 25:xxoder 5x:xx. Hinweis : Ich weiß nicht, warum das $notwendig ist. Vielleicht könnte jemand mit der richtigen Syntax Golf spielen, aber ich bin mir nicht sicher.

  • Teilen Sie diese Zeiten in zwei Hälften ( œs€2) und verbinden Sie sie mit der Zeichenfolge ' - '( j€“ - ”). '05:2115:20''05:21 - 15:20'.

  • Zum Schluss werden Yalle Zeichenfolgen mit einem Zeilenumbruch verbunden und alles wird implizit gedruckt.

alte Versionen

62 Bytes

i@€®ị“:0152”
“:0125”©Ḋp`⁺ḣ176j€“:”µ,"UÇ€$F€⁾25ẇ$ÐṂœs€2j€“ - ”Y

Probieren Sie es online!

66 Bytes

“0125”
i@€¢ị“0152”
UṚÇ€
Ñp`⁺ḣ176µ,"Ç€j€€“:”j€“ - ”¹⁾2 ẇ$ÐṂ⁾25ẇ$ÐṂY

Probieren Sie es online!

72 Bytes

⁾25
i@€¢µẋ@€¢ṙ"
Ṛµ;@""Ç€Ḣ€€
“0125”p`⁺j€“:”ḣ176µ,"Ç€j€“ - ”¹⁾2 ẇ$ÐṂÑẇ$ÐṂY

Probieren Sie es online!

dylnan
quelle
1

C (GCC) , 175 174 Bytes

Einmalig dank @Steadybox.

char*p,s[14],*e;f(t){for(t=0;sprintf(p=s,"%02d:%02d -",t/100,t%100),t<2400;)if(t++%10^2&&!strpbrk(s,"346789")&&t%100^26){for(e=s+12;p<e;p++)*e--=*p^7*(*p>49&*p<58);puts(s);}}

Probieren Sie es online!

Gastropner
quelle
1

Befunge, 178 Bytes

>0>:5g"7"`>v1\,+55<
v_^#`+87:+1_4>99p\ :99gg48 *-:55+/"0"+,55+%"0"+,":",\v
>$1+:55v v,," - "_^#-5g99,+"0"%+55,+"0"/+55:-*84gg99:<
v_@#!`+< >,\5^
 !"%*+,/4569RSTW
 *R4!+S5%/W9",T6

Probieren Sie es online!

James Holderness
quelle
1

Kotlin , 205 207 Bytes

(0..1439).map{"%02d : %02d".format(it/60,it%60)}.let{it.map{i->i to i.reversed().map{x->"25180:X52180:".let{it[it.indexOf(x)+7]}}.joinToString("")}.filter{(_,b)->it.contains(b)}.map{(a,b)->println("$a-$b")}}

Verschönert

    (0..1439)
        .map { "%02d : %02d".format(it / 60, it % 60) }              // Make the times
        .let { it.map {i->
                i to i.reversed().map {x->                         // Pair it with the reversed times
                    "25180:X52180:".let{ it[it.indexOf(x)+7] }     // - X means bad times are removed
                }.joinToString("")                                 // - Make the string
            }.filter {(_,b)-> it.contains(b) }                     // Remove the unpaired times
                .map { (a, b) -> println("$a - $b") }              // Print out the pairs
        }

Prüfung

fun main(args: Array<String>) {
    f()
}

fun f() =
(0..1439).map{"%02d:%02d".format(it/60,it%60)}.let{it.map{i->i to i.reversed().map{x->"25180:X52180:".let{it[it.indexOf(x)+7]}}.joinToString("")}.filter{(_,b)->it.contains(b)}.map{(a,b)->println("$a-$b")}}

TIO

TryItOnline

Bearbeitungen

jrtapsell
quelle
Auf beiden Seiten der soll ein Leerzeichen sein -. Das Hinzufügen kostet nur zwei Bytes: Probieren Sie es online aus!
Steadybox
Behoben, ich frage mich, ob es eine Möglichkeit gibt, den Rest des Codes auf 205 Bytes zu reduzieren
jrtapsell
0

C 225 Bytes

h,m,l,r,d=10,L[]={0,1,5,9,9,2,9,9,8,9};M(h,m){l=L[h%d]*d+L[h/d];r=L[m%d]*d+L[m/d];return L[h%d]<9&L[h/d]<9&L[m%d]<9&L[m/d]<9;}f(){for(h=0;h<24;++h)for(m=0;m<60;++m)M(h,m)&l<60&r<24&&printf("%02d:%02d - %02d:%02d\n",h,m,r,l);}

Da es keine C-Antwort gibt, poste ich meine eigene. Ein anderer Ansatz könnte kürzer sein.

Probieren Sie es online!

Steadybox
quelle
200 Bytes
Ceilingcat