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 Code-Golf , also gewinnt die kürzeste Antwort in Bytes. Standardlücken sind wie üblich nicht zulässig.

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

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.

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:'[⎕D⍳i←∊⍺':'⍵]:⎕←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

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.

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

• 279 Bytes wurden von Dylnan auf 256 reduziert .

• 256 Bytes von FlipTrack auf 255 reduziert .

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
        ]

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.

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!

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)

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!

Kohle , 59 Bytes

Ｆ012Ｆ0125Ｆ0125Ｆ015¿›‹⁺ικ25⁼⁺λμ25«ικ:λμ - Ｆ⟦μλ3κι⟧§015::2Ｉν⸿

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

Ｆ012Ｆ0125Ｆ0125Ｆ015

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.

Ｆ⟦μλ3κι⟧§015::2Ｉν⸿

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:

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

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

Ｆ¹¹Ｆ¹⁶

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.

Ｆθ§0125:λ

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

 - 

Drucken Sie den Separator.

Ｆ⮌θ§0152:λ⸿

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

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!

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!

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!

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

• +2 Steadybox - Feste E / A-Formatierung

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!