Relógio digital espelhado

19

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 é , então a resposta mais curta em bytes vence. Como de costume, as brechas padrão não são permitidas.

Steadybox
fonte
Em Clean, a Stringé uma matriz de Char. É aceitável se minha resposta fornecer uma lista de Char? Os tipos parecem idênticos quando impressos.
Ousurous
@ Ourous Sim, acho que está bem. O consenso sobre a meta parece ser que uma string é uma sequência de caracteres, e é isso que é uma lista de caracteres.
Steadybox
Nesta tela de sete segmentos, o dígito 1não é exatamente idêntico à sua imagem espelhada, porque você pode dizer se os segmentos mais à direita ou mais à esquerda são usados ​​para formar a "linha" vertical que compõe o dígito. Eu entendo que nós os consideramos idênticos aqui.
Jeppe Stig Nielsen
@JeppeStigNielsen, vamos fingir que o OP usou uma imagem com 14seg em vez de 7seg, para que a 1central pudesse ser centralizada.
Sparr
3
@Steadybox Uau, tive essa ideia exata recentemente. Eu pretendo usá-lo nas pessoas durante as entrevistas de programação. BTW eu tenho um forno de microondas que não tem um relógio sã e permite especificar coisas como 83:75 :-)
JohnEye

Respostas:

2

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
Emigna
fonte
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]

Experimente online!

Obrigado por +1 Kevin Cruijssen.

Chas Brown
fonte
5

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

Adão
fonte
4

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.

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

Experimente online!

Créditos

  • 279 bytes reduzidos para 256 por dylnan .

  • 256 bytes reduzidos para 255 pelo FlipTrack .

Neil
fonte
-1 byte
FlipTack
3

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
        ]
Furioso
fonte
2

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.

FryAmTheEggman
fonte
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

Experimente online!

Xcali
fonte
2

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)
ETHproductions
fonte
1

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!

Arnauld
fonte
1

Carvão , 59 bytes

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

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

F012F0125F0125F015

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.

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

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:

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

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

F¹¹F¹⁶

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.

Fθ§0125:λ

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

 - 

Imprima o separador.

F⮌θ§0152:λ⸿

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

Neil
fonte
1

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!

dylnan
fonte
1

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!

gastropner
fonte
1

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!

James Holderness
fonte
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")}}

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

jrtapsell
fonte
Deveria haver um espaço em ambos os lados do -. Custa apenas dois bytes para adicionar: Experimente online!
Steadybox
Fixo, gostaria de saber se existe uma maneira de voltar para 205 bytes reduzindo o resto do código
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);}

Como não há resposta C, eu posto a minha. Outra abordagem pode ser mais curta.

Experimente online!

Steadybox
fonte
200 bytes
ceilingcat