Molti orologi digitali visualizzano l'ora utilizzando cifre semplificate composte da sole sette luci diverse che sono accese o spente:

Se specchiati in orizzontale, le cifre 018non cambiano perché sono simmetriche. Inoltre, le cifre 2e 5vengono scambiate, 2diventando 5e viceversa. Tutte le altre cifre diventano non valide quando si esegue il mirroring.

Pertanto, dato un orologio digitale di 24 ore, ci sono molte letture dell'orologio in modo tale che l'immagine speculare del display digitale sia anche una lettura di orologio valida. Il tuo compito è di generare tutte queste letture dell'orologio insieme alle letture speculari.

Ad esempio, 22:21diventa 15:55e 00:15diventa 21:00. D'altra parte, 12:34o 16:27non sono più validi quando il mirroring (le cifre 34679diventano non valide), né lo sono 22:22né 18:21, poiché, poiché ci sono solo 24 ore al giorno e 60 minuti all'ora, non verrebbe visualizzato alcun orologio sano 55:55o 12:81.

Compito

Scrivi un programma o una funzione che non accetta input e restituisce tutte le coppie valide in ordine crescente come mostrato di seguito:

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

È consentita una riga finale o finale. È consentito anche avere alcuni spazi direttamente prima di un avanzamento riga. I tempi devono essere in formato hh:mm, riempiti con zeri quando necessario.

Questo è code-golf , quindi vince la risposta più breve in byte. Come al solito, le scappatoie standard non sono ammesse.

05AB1E , 34 byte

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

Provalo online!

Spiegazione

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 byte

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]

Provalo online!

Grazie per +1 Kevin Cruijssen.

APL (Dyalog Unicode) , 84 byte ^SBCS

Programma completo in uscita su STDOUT. Richiede ⎕IO( I ndex O rigin ) di essere quello 0che è predefinito su molti sistemi.

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

Provalo online!

⍳1440 che molti ɩ ntegers

0 60⊤ converti in base mista ∞, 60

100+ aggiungi 100 (questo pad gli 0 necessari)

⍕¨ formato (stringify) ciascuno

1↓¨ rilascia il primo carattere da ciascuno (questo rimuove gli 1 iniziali)

{... }⌿ applica la seguente funzione anonima in base alla colonna ( ⍺è l'ora superiore, ⍵è minuto)

 0:: se si verifica un errore, non restituire nulla

 ⋄ provare:

  '015xx2xx8x:'[... ] indicizza questa stringa con:

   ∊⍺':'⍵ il ε nlisted (appiattito) elenco di un'ora, colon, minuto

   i← memorizzato in i(per i nput)

   ⎕D⍳ d ndices di ciascun personaggio nell'elenco di D igits

  ⌽ invertire quello

  t← memorizzare t(per t ime)

  (... il )⊆ gruppo funziona dove:

   ':'≠t il colon differisce da t

⍎¨ eseguire (valutare) ciascuno

 23 59≥ Booleano per ciascuno, che siano rispettivamente inferiori o uguali a 23 e 59

 ∧/ sono entrambi veri?

 : in tal caso, quindi:

  ⍕i'-'t l'elenco formattato (separato da spazi) di input, trattino, tempo

  1↓ rilascia il primo (spazio)

  ⎕← uscita su STDOUT

Retina , 57 byte

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

Provalo online! Spiegazione:

 - 

Inserisci il separatore.

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

Genera tutti i possibili set di quattro cifre speculari.

A`\b2?5

Elimina quelli con ore illegali.

\b\d.
$&:

Inserisci i due punti.

O`

Ordina in ordine.

Python 2 , 279 277 255 byte

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

Provalo online!

Titoli di coda

• 279 byte ridotti a 256 da dylnan .

• 256 byte ridotti a 255 da FlipTrack .

Pulito , 269 ... 172 170 byte

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]

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

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

Provalo online!

Genera tutte le possibili combinazioni di 0125e quindi le manipola nei tempi. Questi sono nell'ordine corretto perché sono generati in ordine lessicografico. Infine, questo filtra i tempi extra non validi rimuovendo le righe che corrispondono al regex 5.:o 25:. Purtroppo, non sembra che la compressione funzioni bene su nessuna delle stringhe utilizzate da questo programma, a meno che non abbia commesso un errore o una svista.

Perl 5 , 147 byte

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

Provalo online!

Japt v2 (+ -R), 51 byte

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

Provalo online!

Spiegazione

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

Provalo online!

Carbone , 59 byte

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

Provalo online!Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｆ012Ｆ0125Ｆ0125Ｆ015

Crea quattro cicli nidificati per le cifre non contrassegnate.

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

Controlla che né le ore né i minuti siano 25. (Il mirroring dei 25 minuti comporterà 25 ore, quindi è un non-andare.)

ικ:λμ - 

Stampa l'ora non ammirata.

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

Stampa il tempo speculare convertendo le cifre invertite (o 3per i due punti) da stringa a numero intero e cercandole in una tabella di traduzione.

In alternativa, anche per 59 byte:

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｆ¹¹Ｆ¹⁶

Crea loop per le ore e i minuti.

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

Escludere 25e anche i minuti che finiscono 2.

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

Converti le ore e i minuti in base 4.

Ｆθ§0125:λ

Stampa le cifre cercate in una tabella di traduzione.

 - 

Stampa il separatore.

Ｆ⮌θ§0152:λ⸿

Stampa le cifre invertite cercate in una tabella di traduzione speculare.

Gelatina , 72 66 62 55 byte

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

Provalo online!

Programma niladico. Ho ottenuto il doppio prodotto '0125'dell'idea dalla risposta 05AB1E di Emigna ma il resto l'ho fatto senza consultarlo dal momento che le lingue divergono dopo. Probabilmente ci sono opportunità per giocare a golf, possibilmente da molto.

Spiegazione

Il programma funziona come segue:

• Prendi tutti i prodotti di lunghezza quattro dell'elenco di caratteri '0125'con “0152:”©ṢṖp`⁺. ©copia la stringa '0152:'nel registro per utilizzarla in seguito. ṢṖordina quindi l'ultimo elemento della stringa → '0125'. ⁺duplica il collegamento del prodotto.

• ḣ176rimuove in qualsiasi momento con formato 25xxo 5xxx(ore non valide).

• j€“:”unisce ogni coppia di cifre con a ':'. ad es . ['05'],['21']]→ '05:12'.

• Ç€applica il primo collegamento a ciascuna di queste volte. Trova l'indice di ciascun carattere nella stringa '0125:'quindi per ciascuno di quegli indici ottiene il carattere nella stringa'0152:' e lo inverte. Questa è l'operazione speculare (invertire e scambiare se 2e 5).

• µ;" concatena l'ora originale con l'ora speculare → '05:2115:20'

• ⁾25ẇ$ÐṂfiltra i tempi con la sottostringa '25'. In questo modo ogni coppia di tempo viene catturata con metà speculare 25:xxo 5x:xx.Nota : non so perché $sia necessario. Forse qualcuno potrebbe giocare a golf con la sintassi corretta ma non ne sono sicuro.

• Dividi ciascuna di queste volte in due metà ( œs€2) quindi uniscili con la stringa ' - '( j€“ - ”). '05:2115:20'→ '05:21 - 15:20'.

• Infine, Y unisce tutte le stringhe con una nuova riga e tutto viene implicitamente stampato.

Vecchie versioni

62 byte

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

Provalo online!

66 byte

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

Provalo online!

72 byte

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

Provalo online!

C (gcc) , 175 174 byte

Una tantum grazie a @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);}}

Provalo online!

Befunge, 178 byte

>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

Provalo online!

Kotlin , 205 207 byte

(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")}}

Abbellire

    (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
        }

Test

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

Le modifiche

• +2 Steadybox - Corretta la formattazione IO

C, 225 byte

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

Dal momento che non esiste una risposta C, inserisco la mia. Qualche altro approccio potrebbe essere più breve.

Provalo online!