Muchos relojes digitales muestran la hora utilizando dígitos simplificados que constan de solo siete luces diferentes que están encendidas o apagadas:

Cuando se refleja horizontalmente, los dígitos 018no cambian porque son simétricos. Además, los dígitos 2y 5se intercambian, 2convirtiéndose 5y viceversa. Todos los demás dígitos se vuelven inválidos cuando se reflejan.

Por lo tanto, dado un reloj digital de 24 horas, hay muchas lecturas de reloj de tal manera que la imagen reflejada de la pantalla digital también es una lectura de reloj válida. Su tarea es generar todas esas lecturas de reloj junto con las lecturas reflejadas.

Por ejemplo, se 22:21vuelve 15:55y se 00:15vuelve 21:00. Por otro lado, 12:34o 16:27ya no son válidos cuando se refleja (cifras 34679dejan de ser válidas), y tampoco lo son 22:22o 18:21, porque, como sólo hay 24 horas en un día y 60 minutos en una hora, no había reloj en su sano juicio visualizar 55:55o 12:81.

Tarea

Escriba un programa o una función que no ingrese y genere todos los pares válidos en orden ascendente como se muestra a continuación:

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

Se permite una nueva línea al final o al final. Tener algunos espacios directamente antes de un salto de línea también está permitido. Los tiempos deben estar en formato hh:mm, rellenados con ceros cuando sea necesario.

Este es el código de golf , por lo que gana la respuesta más corta en bytes. Como de costumbre, las lagunas estándar no están permitidas.

05AB1E , 34 bytes

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

Pruébalo en línea!

Explicación

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]

Pruébalo en línea!

Gracias por +1 Kevin Cruijssen.

APL (Dyalog Unicode) , ^{SBCS de} 84 bytes

Programa completo de salida a STDOUT. Requiere ⎕IO( I ndex O rigin) ser 0que es por defecto en muchos sistemas.

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

Pruébalo en línea!

⍳1440 que muchos Ɩ ntegers

0 60⊤ convertir a base mixta ∞, 60

100+ agregue 100 (esto rellena los 0s necesarios)

⍕¨ formatear (stringify) cada

1↓¨ suelte el primer carácter de cada uno (esto elimina los primeros 1)

{... }⌿ aplique la siguiente función anónima en columna ( ⍺es la hora principal, ⍵es minuto)

 0:: si ocurre algún error, no devuelva nada

 ⋄ tratar:

  '015xx2xx8x:'[... ] indexe esta cadena con:

   ∊⍺':'⍵ la ε nlisted (aplanada) lista de horas, colon, minutos

   i← almacenado en i(para i Nput)

   ⎕D⍳ Ɩ ndices de cada personaje en la lista de D igits

  ⌽ revertir eso

  t← almacenar t(por t ime)

  (... el )⊆ grupo corre donde:

   ':'≠t el colon difiere de t

⍎¨ ejecutar (evaluar) cada

 23 59≥ Booleanos para cada uno si son menores o iguales a 23 y 59 respectivamente

 ∧/ son ambos verdad?

 : si es así, entonces:

  ⍕i'-'t la lista formateada (separada por espacios) de entrada, guión, tiempo

  1↓ soltar el primero (espacio)

  ⎕← salida a STDOUT

Retina , 57 bytes

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

Pruébalo en línea! Explicación:

 - 

Insertar el separador.

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

Genere todos los conjuntos posibles de cuatro dígitos reflejados.

A`\b2?5

Eliminar aquellos con horas ilegales.

\b\d.
$&:

Insertar los dos puntos.

O`

Ordenar en orden.

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

Pruébalo en línea!

Créditos

• 279 bytes reducidos a 256 por dylnan .

• 256 bytes reducidos a 255 por FlipTrack .

Limpio , 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]

Pruébalo en línea!

Sin golf:

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

Pruébalo en línea!

Genera todas las combinaciones posibles 0125y luego las manipula en los tiempos. Estos están en el orden correcto porque se generan en orden lexicográfico. Finalmente, esto filtra los tiempos inválidos adicionales al eliminar líneas que coinciden con la expresión regular 5.:o 25:. Lamentablemente, no parece que la compresión funcione bien en ninguna de las cadenas que utiliza este programa, a menos que haya cometido un error o supervisión.

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

Pruébalo en línea!

Japt v2 (+ -R), 51 bytes

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

¡Pruébalo en línea!

Explicación

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 bytes

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

Pruébalo en línea!

Carbón , 59 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｆ012Ｆ0125Ｆ0125Ｆ015

Cree cuatro bucles anidados para los dígitos no reflejados.

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

Verifique que ni las horas ni los minutos sean 25. (Duplicar los 25 minutos dará como resultado 25 horas, así que no se puede ir).

ικ:λμ - 

Imprime el tiempo sin reflejos.

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

Imprima el tiempo reflejado al convertir los dígitos invertidos (o 3para los dos puntos) de cadena a entero y buscarlos en una tabla de traducción.

Alternativamente, también para 59 bytes:

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｆ¹¹Ｆ¹⁶

Crea bucles para las horas y minutos.

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

Excluir 25y también cualquier minuto que termine en 2.

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

Convierta las horas y minutos a base 4.

Ｆθ§0125:λ

Imprima los dígitos buscados en una tabla de traducción.

 - 

Imprime el separador.

Ｆ⮌θ§0152:λ⸿

Imprima los dígitos invertidos en una tabla de traducción reflejada.

Gelatina , 72 66 62 55 bytes

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

Pruébalo en línea!

Programa niladic. Obtuve el doble producto de la '0125'idea de la respuesta 05AB1E de Emigna, pero el resto lo hice sin consultarlo ya que los idiomas difieren después de eso. Probablemente hay oportunidades para jugar al golf, posiblemente por mucho.

Explicación

El programa funciona de la siguiente manera:

• Tome todos los productos de longitud cuatro de la lista de caracteres '0125'con “0152:”©ṢṖp`⁺. ©copia la cadena '0152:'en el registro para su uso posterior. ṢṖordena y luego muestra el último elemento de la cadena → '0125'. ⁺duplica el enlace del producto.

• ḣ176elimina cualquier momento con formato 25xxo 5xxx(horas no válidas).

• j€“:”une cada par de dígitos con a ':'. por ejemplo ['05'],['21']]→ '05:12'.

• Ç€aplica el primer enlace a cada uno de estos tiempos. Encuentra el índice de cada carácter en la cadena y '0125:'luego, para cada uno de esos índices, obtiene el carácter en la cadena '0152:'y lo invierte. Esta es la operación de espejo (de marcha atrás y el intercambio de 2s y 5s).

• µ;" concatena el tiempo original con el tiempo reflejado → '05:2115:20'

• ⁾25ẇ$ÐṂfiltra los tiempos con la subcadena '25'. Esto captura cualquier momento en pares con la mitad 25:xxo espejo 5x:xx. Nota : No sé por qué $es necesario. Quizás alguien podría jugarlo con la sintaxis adecuada, pero no estoy seguro.

• Divida cada uno de estos tiempos en dos mitades ( œs€2) y luego únalas con la cuerda ' - '( j€“ - ”). '05:2115:20'→ '05:21 - 15:20'.

• Finalmente, Yune todas las cadenas con una nueva línea y todo se imprime implícitamente.

versiones antiguas

62 bytes

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

Pruébalo en línea!

66 bytes

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

Pruébalo en línea!

72 bytes

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

Pruébalo en línea!

C (gcc) , 175 174 bytes

Único gracias 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);}}

Pruébalo en línea!

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

Pruébalo en línea!

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

Embellecido

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

Prueba

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

Ediciones

• +2 Steadybox : formato de E / S fijo

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

Como no hay una respuesta C, publico la mía. Algún otro enfoque podría ser más corto.

Pruébalo en línea!