Wiele zegarów cyfrowych wyświetla czas za pomocą uproszczonych cyfr składających się tylko z siedmiu różnych lampek, które są włączone lub wyłączone:

Po odbiciu w poziomie cyfry 018nie zmieniają się, ponieważ są symetryczne. Również cyfry 2i 5zamień się, 2stając się 5i odwrotnie. Wszystkie pozostałe cyfry stają się nieprawidłowe po odbiciu lustrzanym.

Tak więc, biorąc pod uwagę 24-godzinny zegar cyfrowy, istnieje wiele odczytów tak, że lustrzany obraz wyświetlacza cyfrowego jest również prawidłowym odczytem zegara. Twoim zadaniem jest wyprowadzenie wszystkich takich odczytów zegara wraz z odczytami lustrzanymi.

Na przykład 22:21staje się 15:55i 00:15staje 21:00. Z drugiej strony, 12:34lub 16:27nie są już ważne, gdy są dublowane (cyfry 34679stają się nieważne), i nie są 22:22ani 18:21, ponieważ, ponieważ są tylko 24 godziny na dobę i 60 minut na godzinę, żaden rozsądny zegar nie wyświetli się 55:55lub 12:81.

Zadanie

Napisz program lub funkcję, która nie pobiera danych wejściowych i wyświetla wszystkie prawidłowe pary w porządku rosnącym, jak pokazano poniżej:

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

Końcowy lub wiodący nowy wiersz jest dozwolony. Dozwolone jest także posiadanie kilku spacji bezpośrednio przed przesunięciem linii. Czasy muszą być w formacie hh:mm, w razie potrzeby uzupełnione zerami.

To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach. Jak zwykle standardowe luki są niedozwolone.

05AB1E , 34 bajty

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

Wypróbuj online!

Wyjaśnienie

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 bajtów

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]

Wypróbuj online!

Dzięki za +1 Kevina Cruijssena.

APL (Dyalog Unicode) , 84 bajtów ^SBCS

Kompletny program wyjściowy do STDOUT. Wymaga ⎕IO( I ndex O rigin) 0ustawienia domyślnego w wielu systemach.

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

Wypróbuj online!

⍳1440 że wielu ɩ ntegers

0 60⊤ przelicz na mieszaną bazę ∞, 60

100+ dodaj 100 (to wstawia potrzebne 0)

⍕¨ formatuj (stringify) każdy

1↓¨ upuść pierwszy znak z każdego (usuwa to pierwsze 1)

{… }⌿ Zastosuj następującą anonimową funkcję w kolumnach ( ⍺najwyższa godzina, ⍵minuta)

 0:: jeśli wystąpi jakikolwiek błąd, nic nie zwracaj

 ⋄ próbować:

  '015xx2xx8x:'[… ] Indeksuj ten ciąg za pomocą:

   ∊⍺':'⍵ε nlisted (spłaszczone) listę godziny, okrężnicy, minuty

   i← przechowywane w i(dla i nput)

   ⎕D⍳ Wskaźniki każdego znaku na liście D igits

  ⌽ odwróć to

  t← przechować t(dla t ime)

  (… )⊆ Grupa biegnie gdzie:

   ':'≠t dwukropek różni się od t

⍎¨ wykonać (ocenić) każdy

 23 59≥ Wartość logiczna dla każdego, czy są one mniejsze lub równe odpowiednio 23 i 59

 ∧/ czy oba są prawdziwe?

 : jeśli tak, to:

  ⍕i'-'t sformatowana (oddzielona spacjami) lista danych wejściowych, myślnika, czasu

  1↓ upuść pierwszą (spację)

  ⎕← wyjście do STDOUT

Siatkówka , 57 bajtów

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

Wypróbuj online! Wyjaśnienie:

 - 

Włóż separator.

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

Wygeneruj wszystkie możliwe zestawy czterech lustrzanych cyfr.

A`\b2?5

Usuń te z nielegalnymi godzinami.

\b\d.
$&:

Wstaw dwukropki.

O`

Sortuj w kolejności.

Python 2 , 279 277 255 bajtów

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

Wypróbuj online!

Kredyty

• 279 bajtów zredukowanych do 256 przez dylnan .

• 256 bajtów zredukowanych do 255 przez FlipTrack .

Czysty , 269 ... 172 170 bajtów

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]

Wypróbuj online!

Nie golfowany:

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 bajtów

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

Wypróbuj online!

Generuje wszystkie możliwe kombinacje, 0125a następnie manipuluje nimi w czasie. Są w prawidłowej kolejności, ponieważ są generowane w kolejności leksykograficznej. Wreszcie, odfiltrowuje dodatkowe nieprawidłowe czasy, usuwając linie pasujące do wyrażenia regularnego 5.:lub 25:. Niestety, nie wydaje się, aby kompresja działała ładnie na dowolnym łańcuchu używanym przez ten program, chyba że popełniłem błąd lub przeoczenie.

Perl 5 , 147 bajtów

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

Wypróbuj online!

Japt v2 (+ -R), 51 bajtów

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

Przetestuj online!

Wyjaśnienie

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 bajty

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

Wypróbuj online!

Węgiel drzewny , 59 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

Ｆ012Ｆ0125Ｆ0125Ｆ015

Utwórz cztery zagnieżdżone pętle dla niezaznajomionych cyfr.

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

Sprawdź, czy ani godzina, ani minuty nie są równe 25. (Odbicie lustrzane 25 minut spowoduje 25 godzin, więc nie ma mowy.)

ικ:λμ - 

Wydrukuj niezaznajomiony czas.

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

Wydrukuj czas lustrzany, przekształcając odwrócone cyfry (lub 3 dwukropek) z łańcucha na liczbę całkowitą i przeglądając je w tabeli translacji.

Alternatywnie, również dla 59 bajtów:

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

Ｆ¹¹Ｆ¹⁶

Twórz pętle dla godzin i minut.

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

Wyklucz, 25a także wszelkie minuty kończące się w 2.

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

Przelicz godziny i minuty na bazę 4.

Ｆθ§0125:λ

Wydrukuj cyfry wyszukiwane w tabeli tłumaczeń.

 - 

Wydrukuj separator.

Ｆ⮌θ§0152:λ⸿

Wydrukuj odwrócone cyfry sprawdzone w lustrzanej tabeli translacji.

Galaretka , 72 66 62 55 bajtów

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

Wypróbuj online!

Program Niladic. Dostałem podwójny '0125'pomysł od odpowiedzi Emabny 05AB1E, ale resztę zrobiłem bez konsultacji, ponieważ języki się rozeszły . Prawdopodobnie istnieje wiele możliwości gry w golfa.

Wyjaśnienie

Program działa w następujący sposób:

• Weź wszystkie produkty o długości czterech z listy znaków za '0125'pomocą “0152:”©ṢṖp`⁺. ©kopiuje ciąg '0152:'do rejestru, aby użyć go później. ṢṖsortuje, a następnie wyskakuje ostatni element ciągu → '0125'. ⁺duplikuje link do produktu.

• ḣ176usuwa wszystkie czasy z formatem 25xxlub 5xxx(nieprawidłowe godziny).

• j€“:”łączy każdą parę cyfr za pomocą ':'. np . ['05'],['21']]→'05:12'

• Ç€stosuje pierwszy link do każdego z tych czasów. Znajduje indeks każdego znaku w ciągu, '0125:'a następnie dla każdego z tych wskaźników pobiera znak w ciągu '0152:'i odwraca go. To jest operacja dublowania (cofanie i zamiana 2s i 5s).

• µ;" łączy pierwotny czas z czasem lustrzanym → '05:2115:20'

• ⁾25ẇ$ÐṂodfiltrowuje czasy z podciągiem '25'. Łapie to za każdym razem pary z lustrzaną połową 25:xxlub 5x:xx. Uwaga : nie wiem, dlaczego $jest to konieczne. Być może ktoś mógłby zagrać w golfa z odpowiednią składnią, ale nie jestem pewien.

• Podziel każdy z tych czasów na dwie połowy ( œs€2), a następnie połącz je za pomocą ciągu ' - '( j€“ - ”). '05:2115:20'→'05:21 - 15:20' .

• Na koniec Yłączy wszystkie ciągi z nową linią i wszystko jest domyślnie drukowane.

Stare wersje

62 bajty

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

Wypróbuj online!

66 bajtów

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

Wypróbuj online!

72 bajty

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

Wypróbuj online!

C (gcc) , 175 174 bajtów

Jednorazowo dzięki @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);}}

Wypróbuj online!

Befunge, 178 bajtów

>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

Wypróbuj online!

Kotlin , 205 207 bajtów

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

Upiększony

    (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

Edycje

• +2 Steadybox - Naprawiono formatowanie IO

C, 225 bajtów

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

Ponieważ nie ma odpowiedzi w języku C, zamieszczam własną. Inne podejście może być krótsze.

Wypróbuj online!