De nombreuses horloges numériques affichent l'heure en utilisant des chiffres simplifiés composés de seulement sept lumières différentes qui sont allumées ou éteintes:

Lorsqu'ils sont mis en miroir horizontalement, les chiffres 018ne changent pas car ils sont symétriques. En outre, les chiffres 2et 5échangent, 2devenant 5et vice versa. Tous les autres chiffres deviennent invalides lorsqu'ils sont mis en miroir.

Ainsi, étant donné une horloge numérique de 24 heures, il existe de nombreuses lectures d'horloge telles que l'image miroir de l'affichage numérique est également une lecture d'horloge valide. Votre tâche consiste à générer toutes ces lectures d'horloge avec les lectures en miroir.

Par exemple, 22:21devient 15:55et 00:15devient 21:00. En revanche, 12:34ou 16:27ne sont plus valides lorsqu'ils sont mis en miroir (les chiffres 34679deviennent invalides), et ni l'un 22:22ni l'autre 18:21, car, comme il n'y a que 24 heures par jour et 60 minutes par heure, aucune horloge saine ne s'afficherait 55:55ou 12:81.

Tâche

Écrivez un programme ou une fonction qui ne prend aucune entrée et sort toutes les paires valides dans l'ordre croissant comme indiqué ci-dessous:

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

Une nouvelle ligne de fin ou de début est autorisée. Il est également permis d'avoir quelques espaces juste avant un saut de ligne. Les heures doivent être au format hh:mm, complétées de zéros si nécessaire.

Il s'agit de code-golf , donc la réponse la plus courte en octets l'emporte. Comme d'habitude, les failles standard sont interdites.

05AB1E , 34 octets

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

Essayez-le en ligne!

Explication

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 octets

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]

Essayez-le en ligne!

Merci pour +1 Kevin Cruijssen.

APL (Dyalog Unicode) , 84 octets ^SBCS

Sortie complète du programme vers STDOUT. Nécessite ⎕IO( I ndex O rigin) d'être 0celui par défaut sur de nombreux systèmes.

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

Essayez-le en ligne!

⍳1440 que beaucoup de ɩ ntegers

0 60⊤ convertir en base mixte ∞, 60

100+ ajouter 100 (cela ajoute les 0 nécessaires)

⍕¨ formater (stringify) chacun

1↓¨ supprimer le premier caractère de chacun (cela supprime les 1 premiers)

{… }⌿ Appliquez la fonction anonyme suivante colonne par colonne ( ⍺est l'heure supérieure, ⍵est la minute)

 0:: si une erreur se produit, ne renvoyez rien

 ⋄ essayer:

  '015xx2xx8x:'[… ] Indexez cette chaîne avec:

   ∊⍺':'⍵ la liste ϵ nlistée (aplatie) des heures, deux points, minutes

   i← stocké dans i(pour i nput)

   ⎕D⍳ ɩ ndices de chaque caractère dans la liste des D igits

  ⌽ inverser cela

  t← stocker en tant que t(pour t ime)

  (… Le )⊆ groupe court où:

   ':'≠t le côlon diffère de t

⍎¨ exécuter (évaluer) chacun

 23 59≥ Booléen pour chacun, qu'ils soient respectivement inférieurs ou égaux à 23 et 59

 ∧/ sont les deux vrais?

 : si oui, alors:

  ⍕i'-'t la liste formatée (séparée par des espaces) des entrées, tiret, heure

  1↓ déposez le premier (espace)

  ⎕← sortie vers STDOUT

Rétine , 57 octets

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

Essayez-le en ligne! Explication:

 - 

Insérez le séparateur.

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

Générez tous les ensembles possibles de quatre chiffres en miroir.

A`\b2?5

Supprimez ceux avec des heures illégales.

\b\d.
$&:

Insérez les deux points.

O`

Trier dans l'ordre.

Python 2 , 279 277 255 octets

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

Essayez-le en ligne!

Crédits

• 279 octets réduits à 256 par dylnan .

• 256 octets réduits à 255 par FlipTrack .

Nettoyer , 269 ... 172 170 octets

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]

Essayez-le en ligne!

Non 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 octets

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

Essayez-le en ligne!

Génère toutes les combinaisons possibles 0125puis les manipule dans le temps. Celles-ci sont dans le bon ordre car elles sont générées dans l'ordre lexicographique. Enfin, cela filtre les temps non valides supplémentaires en supprimant les lignes qui correspondent à l'expression régulière 5.:ou 25:. Malheureusement, il ne semble pas que la compression fonctionne bien sur l'une des chaînes que ce programme utilise, sauf si j'ai fait une erreur ou une erreur.

Perl 5 , 147 octets

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

Essayez-le en ligne!

Japt v2 (+ -R), 51 octets

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

Testez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Fusain , 59 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｆ012Ｆ0125Ｆ0125Ｆ015

Créez quatre boucles imbriquées pour les chiffres non mis en miroir.

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

Vérifiez que ni les heures ni les minutes ne sont égales à 25. (La mise en miroir des 25 minutes se traduira par 25 heures, donc ce n'est pas possible.)

ικ:λμ - 

Imprimez l'heure sans miroir.

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

Imprimez l'heure en miroir en convertissant les chiffres inversés (ou 3pour les deux-points) de la chaîne en entier et en les recherchant dans une table de traduction.

Alternativement, également pour 59 octets:

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｆ¹¹Ｆ¹⁶

Créez des boucles pour les heures et les minutes.

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

Exclure 25et également toutes les minutes se terminant par 2.

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

Convertissez les heures et les minutes en base 4.

Ｆθ§0125:λ

Imprimez les chiffres recherchés dans une table de traduction.

 - 

Imprimez le séparateur.

Ｆ⮌θ§0152:λ⸿

Imprimer les chiffres inversés recherchés dans une table de traduction en miroir.

Gelée , 72 66 62 55 octets

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

Essayez-le en ligne!

Programme Niladic. J'ai eu le double produit de l' '0125'idée de la réponse 05AB1E d'Emigna mais le reste j'ai fait sans consulter ça puisque les langues divergent ensuite. Il y a probablement des opportunités pour le golf, peut-être beaucoup.

Explication

Le programme fonctionne comme suit:

• Prenez tous les produits de la longueur quatre de la liste des personnages '0125'avec “0152:”©ṢṖp`⁺. ©copie la chaîne '0152:'dans le registre pour une utilisation ultérieure. ṢṖtrie puis affiche le dernier élément de la chaîne → '0125'. ⁺duplique le lien du produit.

• ḣ176supprime toutes les heures au format 25xxou 5xxx(heures non valides).

• j€“:”joint chaque paire de chiffres avec un ':'. par exemple ['05'],['21']]→ '05:12'.

• Ç€applique le premier lien à chacune de ces heures. Il trouve l'index de chaque caractère dans la chaîne '0125:'puis pour chacun de ces indices obtient le caractère dans la chaîne '0152:'et l'inverse. Il s'agit de l'opération miroir (inversion et échange de 2s et 5s).

• µ;" concatène l'heure d'origine avec l'heure en miroir → '05:2115:20'

• ⁾25ẇ$ÐṂfiltre les temps avec la sous-chaîne '25'. Cela attrape les paires de temps avec la moitié 25:xxou en miroir 5x:xx. Remarque : je ne sais pas pourquoi cela $est nécessaire. Peut-être que quelqu'un pourrait jouer au golf avec la syntaxe appropriée, mais je ne suis pas sûr.

• Divisez chacun de ces temps en deux moitiés ( œs€2) puis joignez-les à la chaîne ' - '( j€“ - ”). '05:2115:20'→ '05:21 - 15:20'.

• Enfin, Yjoint toutes les chaînes avec une nouvelle ligne et tout est implicitement imprimé.

anciennes versions

62 octets

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

Essayez-le en ligne!

66 octets

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

Essayez-le en ligne!

72 octets

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

Essayez-le en ligne!

C (gcc) , 175 174 octets

Une seule grâce à @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);}}

Essayez-le en ligne!

Befunge, 178 octets

>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

Essayez-le en ligne!

Kotlin , 205 207 octets

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

Embellie

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

Tester

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

Modifications

• +2 Steadybox - Formatage IO fixe

C, 225 octets

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

Puisqu'il n'y a pas de réponse C, je poste la mienne. Une autre approche pourrait être plus courte.

Essayez-le en ligne!