Muitos relógios digitais exibem o tempo usando dígitos simplificados, compostos por apenas sete luzes diferentes que estão ligadas ou desligadas:

Quando espelhados horizontalmente, os dígitos 018não mudam porque são simétricos. Além disso, os dígitos 2e 5são trocados, 2tornando 5- se e vice-versa. Todos os outros dígitos se tornam inválidos quando espelhados.

Assim, dado um relógio digital de 24 horas, existem muitas leituras de relógio, de modo que a imagem espelhada do visor digital também é uma leitura válida do relógio. Sua tarefa é produzir todas essas leituras de relógio juntamente com as leituras espelhadas.

Por exemplo, 22:21torna 15:55- 00:15se e torna - se 21:00. Por outro lado, 12:34ou 16:27não são mais válidos quando espelhados (os dígitos 34679se tornam inválidos) e nem são 22:22ou 18:21, porque, como existem apenas 24 horas em um dia e 60 minutos em uma hora, nenhum relógio são exibido 55:55ou 12:81.

Tarefa

Escreva um programa ou uma função que não aceite nenhuma entrada e envie todos os pares válidos em ordem crescente, como mostrado abaixo:

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

Uma nova linha à direita ou à esquerda é permitida. Ter alguns espaços diretamente antes de um avanço de linha também é permitido. Os horários devem estar no formato hh:mm, preenchidos com zeros quando necessário.

Isso é código-golfe , então a resposta mais curta em bytes vence. Como de costume, as brechas padrão não são permitidas.

05AB1E , 34 bytes

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

Experimente online!

Explicação

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]

Experimente online!

Obrigado por +1 Kevin Cruijssen.

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

Saída do programa completo para STDOUT. Requer ⎕IO( I ndex O rigin) 0que seja o padrão em muitos sistemas.

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

Experimente online!

⍳1440 que muitas Ɩ ntegers

0 60⊤ converter para base mista ∞, 60

100+ adicione 100 (isso adiciona os 0s necessários)

⍕¨ formato (stringify) cada

1↓¨ solte o primeiro caractere de cada um (isso remove os 1s iniciais)

{… }⌿ Aplique a seguinte função anônima em colunas ( ⍺é hora principal, ⍵é minuto)

 0:: se ocorrer algum erro, não retorne nada

 ⋄ experimentar:

  '015xx2xx8x:'[… ] Indexe esta sequência com:

   ∊⍺':'⍵ o ε nlisted (achatada) lista de horas, cólon, minuto

   i← armazenado em i(para i Nput)

   ⎕D⍳ Ɩ ndices de cada personagem na lista de D igits

  ⌽ inverta isso

  t← armazenar como t(para t ime)

  (… O )⊆ grupo é executado onde:

   ':'≠t cólon difere de t

⍎¨ executar (avaliar) cada

 23 59≥ Booleano para cada um, seja menor ou igual a 23 e 59, respectivamente

 ∧/ ambos são verdadeiros?

 : Se sim, então:

  ⍕i'-'t a lista formatada (separada por espaço) de entrada, traço, hora

  1↓ largar o primeiro (espaço)

  ⎕← saída para STDOUT

Retina , 57 bytes

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

Experimente online! Explicação:

 - 

Insira o separador.

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

Gere todos os conjuntos possíveis de quatro dígitos espelhados.

A`\b2?5

Exclua aqueles com horário ilegal.

\b\d.
$&:

Insira os dois pontos.

O`

Classificar em ordem.

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

Experimente online!

Créditos

• 279 bytes reduzidos para 256 por dylnan .

• 256 bytes reduzidos para 255 pelo FlipTrack .

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

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

Pitão , 48 bytes

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

Experimente online!

Gera todas as combinações possíveis 0125e as manipula nos horários. Eles estão na ordem correta porque são gerados em ordem lexicográfica. Por fim, isso filtra os tempos extras inválidos removendo as linhas que correspondem à regex 5.:ou 25:. Infelizmente, não parece que a compactação funcione bem em nenhuma das strings que este programa usa, a menos que eu tenha cometido um erro ou supervisão.

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

Experimente online!

Japonês v2 (+ -R), 51 bytes

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

Teste online!

Explicação

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

Experimente online!

Carvão , 59 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

Ｆ012Ｆ0125Ｆ0125Ｆ015

Crie quatro loops aninhados para os dígitos não espelhados.

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

Verifique se nem as horas nem os minutos são 25. (O espelhamento dos 25 minutos resultará em 25 horas, portanto, isso é impossível).

ικ:λμ - 

Imprima o tempo não espelhado.

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

Imprima a hora espelhada convertendo os dígitos invertidos (ou 3para os dois pontos) de string em número inteiro e procurando-os em uma tabela de conversão.

Como alternativa, também para 59 bytes:

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

Experimente online!Link é a versão detalhada do código. Explicação:

Ｆ¹¹Ｆ¹⁶

Crie loops para as horas e minutos.

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

Excluir 25e também quaisquer minutos que terminem em2 .

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

Converta as horas e minutos para a base 4.

Ｆθ§0125:λ

Imprima os dígitos pesquisados ​​em uma tabela de conversão.

 - 

Imprima o separador.

Ｆ⮌θ§0152:λ⸿

Imprima os dígitos invertidos procurados em uma tabela de conversão espelhada.

Geléia , 72 66 62 55 bytes

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

Experimente online!

Programa niládico. Eu recebi o duplo produto da '0125'idéia da resposta 05AB1E de Emigna mas o resto fiz sem consultar isso, já que os idiomas divergem depois disso. Provavelmente existem oportunidades para jogar golfe, possivelmente muito.

Explicação

O programa funciona da seguinte maneira:

• Tome todos os produtos de comprimento quatro da lista de caracteres '0125'com “0152:”©ṢṖp`⁺. ©copia a sequência '0152:'no registro para uso posterior. ṢṖordena então aparece o último elemento da string → '0125'. ⁺duplica o link do produto.

• ḣ176remove qualquer horário com formato 25xxou 5xxx(horas não válidas).

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

• Ç€aplica o primeiro link a cada um desses horários. Ele encontra o índice de cada caractere na sequência '0125:'e, para cada um desses índices, obtém o caractere na sequência '0152:'e o inverte. Esta é a operação de espelhamento (reversão e troca de 2s e 5s).

• µ;" concatena a hora original com a hora espelhada → '05:2115:20'

• ⁾25ẇ$ÐṂfiltra os tempos com a substring '25'. Isso captura todos os pares de tempo com metade espelhada 25:xxou 5x:xx. Nota : Não sei por que $é necessário. Talvez alguém possa jogar com a sintaxe adequada, mas não tenho certeza.

• Divida cada um desses tempos em duas metades ( œs€2) e junte-as à sequência ' - '( j€“ - ”). '05:2115:20'→ '05:21 - 15:20'.

• Finalmente, Yjunta todas as cadeias de caracteres com uma nova linha e tudo é impresso implicitamente.

Versões antigas

62 bytes

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

Experimente online!

66 bytes

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

Experimente online!

72 bytes

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

Experimente online!

C (gcc) , 175 174 bytes

Graças 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);}}

Experimente online!

Anterior, 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

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

Embelezado

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

Teste

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

Editar% s

• +2 Steadybox - Formatação IO fixa

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 não há resposta C, eu posto a minha. Outra abordagem pode ser mais curta.

Experimente online!