Banyak jam digital menampilkan waktu menggunakan digit sederhana yang hanya terdiri dari tujuh lampu berbeda yang menyala atau mati:

Ketika dicerminkan secara horizontal, angka 018tidak berubah karena simetris. Juga, digit 2dan 5ditukar, 2menjadi 5dan sebaliknya. Semua digit lainnya menjadi tidak valid saat dicerminkan.

Dengan demikian, mengingat jam digital 24 jam, ada banyak pembacaan jam sehingga gambar cermin dari tampilan digital juga merupakan pembacaan jam yang valid. Tugas Anda adalah untuk menampilkan semua bacaan jam tersebut bersama dengan bacaan cermin.

Misalnya, 22:21menjadi 15:55, dan 00:15menjadi 21:00. Di sisi lain, 12:34atau 16:27tidak lagi berlaku ketika dicerminkan (digit 34679menjadi tidak valid), dan juga tidak ada 22:22atau 18:21, karena, karena hanya ada 24 jam dalam sehari dan 60 menit dalam satu jam, tidak ada jam waras yang akan ditampilkan 55:55atau 12:81.

Tugas

Tulis program atau fungsi yang tidak mengambil input dan output semua pasangan yang valid dalam urutan menaik seperti yang ditunjukkan di bawah ini:

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

Trailing atau baris baru terkemuka diizinkan. Memiliki beberapa ruang langsung sebelum pemberian baris juga diperbolehkan. Waktu harus dalam format hh:mm, diisi dengan nol bila perlu.

Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang. Seperti biasa, celah standar tidak diizinkan.

05AB1E , 34 byte

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

Cobalah online!

Penjelasan

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]

Cobalah online!

Terima kasih untuk +1 Kevin Cruijssen.

APL (Dyalog Unicode) , 84 byte ^SBCS

Selesaikan program keluaran ke STDOUT. Membutuhkan ⎕IO( I ndex O rigin) sebagai 0default pada banyak sistem.

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

Cobalah online!

⍳1440 bahwa banyak t ntegers

0 60⊤ dikonversi menjadi mixed-base ∞, 60

100+ tambahkan 100 (ini memenuhi 0s yang dibutuhkan)

⍕¨ format (stringify) masing-masing

1↓¨ lepaskan karakter pertama dari masing-masing (ini menghilangkan 1s terkemuka)

{... }⌿ terapkan kolom anonim fungsi-bijaksana berikut ( ⍺adalah jam atas, ⍵adalah menit)

 0:: jika ada kesalahan, kembalikan apa-apa

 ⋄ mencoba:

  '015xx2xx8x:'[... ] mengindeks string ini dengan:

   ∊⍺':'⍵ yang ε nlisted (gepeng) daftar jam, usus besar, menit

   i← disimpan di i(untuk saya nput)

   ⎕D⍳ d ndices dari setiap karakter dalam daftar D igits

  ⌽ balikkan itu

  t← menyimpan sebagai t(untuk t ime)

  (... )⊆ grup dijalankan di mana:

   ':'≠t usus besar berbeda dari t

⍎¨ melaksanakan (mengevaluasi) masing-masing

 23 59≥ Boolean untuk masing-masing apakah mereka kurang dari atau sama dengan 23 dan 59 masing-masing

 ∧/ apakah keduanya benar

 : jika demikian, maka:

  ⍕i'-'t daftar input, tanda hubung, waktu yang diformat (dipisahkan spasi)

  1↓ drop the first (spasi)

  ⎕← output ke STDOUT

Retina , 57 byte

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

Cobalah online! Penjelasan:

 - 

Masukkan pemisah.

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

Hasilkan semua set yang mungkin dari empat digit cermin.

A`\b2?5

Hapus yang memiliki jam ilegal.

\b\d.
$&:

Masukkan titik dua.

O`

Sortir sesuai pesanan.

Python 2 , 279 277 255 byte

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

Cobalah online!

Kredit

• 279 byte dikurangi menjadi 256 oleh dylnan .

• 256 byte dikurangi menjadi 255 oleh FlipTrack .

Bersih , 269 ... 172 170 byte

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]

Cobalah online!

Tidak Disatukan:

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 byte

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

Cobalah online!

Menghasilkan semua kombinasi yang mungkin 0125dan kemudian memanipulasi mereka ke dalam zaman. Ini berada dalam urutan yang benar karena dihasilkan dalam urutan leksikografis. Akhirnya, ini menyaring waktu ekstra tidak valid dengan menghapus garis yang cocok dengan regex 5.:atau 25:. Sayangnya, sepertinya kompresi tidak berfungsi dengan baik pada string apa pun yang digunakan program ini, kecuali saya membuat kesalahan atau kekeliruan.

Perl 5 , 147 byte

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

Cobalah online!

Japt v2 (+ -R), 51 byte

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

Uji secara online!

Penjelasan

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 byte

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

Cobalah online!

Arang , 59 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

Ｆ012Ｆ0125Ｆ0125Ｆ015

Buat empat loop bersarang untuk digit yang tidak dikoreksi.

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

Pastikan tidak ada jam atau menit 25. (Mencerminkan 25 menit akan menghasilkan 25 jam, jadi itu tidak jalan.)

ικ:λμ - 

Cetak waktu yang tidak dikhawatirkan.

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

Cetak waktu cermin dengan mengonversi angka yang terbalik (atau 3untuk titik dua) dari string ke integer dan mencarinya di tabel terjemahan.

Atau, juga untuk 59 byte:

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

Ｆ¹¹Ｆ¹⁶

Buat loop untuk jam dan menit.

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

Kecualikan 25dan juga menit apa pun yang berakhir dengan 2.

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

Konversikan jam dan menit menjadi basis 4.

Ｆθ§0125:λ

Cetak angka yang terlihat di tabel terjemahan.

 - 

Cetak pemisah.

Ｆ⮌θ§0152:λ⸿

Cetak angka yang terbalik dan lihat dalam tabel terjemahan cermin.

Jelly , 72 66 62 55 byte

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

Cobalah online!

Program niladik. Saya mendapat produk ganda '0125'ide dari jawaban 05AB1E oleh Emigna tetapi sisanya saya lakukan tanpa berkonsultasi karena bahasa berbeda setelah itu. Mungkin ada peluang untuk bermain golf, mungkin dengan banyak.

Penjelasan

Program ini bekerja sebagai berikut:

• Ambil semua produk panjang empat dari daftar karakter '0125'dengan “0152:”©ṢṖp`⁺. ©menyalin string '0152:'ke register untuk digunakan nanti. ṢṖsortir kemudian muncul elemen terakhir dari string → '0125'. ⁺menduplikasi tautan produk.

• ḣ176menghapus kapan saja dengan format 25xxatau 5xxx(bukan jam yang valid).

• j€“:”bergabung dengan masing-masing pasangan digit dengan a ':'. misalnya ['05'],['21']]→ '05:12'.

• Ç€berlaku tautan pertama ke masing-masing waktu ini. Ia menemukan indeks masing-masing karakter dalam string '0125:'kemudian untuk masing-masing indeks mendapatkan karakter dalam string '0152:'dan membalikkannya. Ini adalah operasi cermin (membalikkan dan menukar 2s dan 5s).

• µ;" menyatukan waktu asli dengan waktu cermin → '05:2115:20'

• ⁾25ẇ$ÐṂmenyaring waktu dengan substring '25'. Ini menangkap pasangan waktu dengan setengah cermin 25:xxatau 5x:xx. Catatan : Saya tidak tahu mengapa $itu perlu. Mungkin seseorang bisa bermain golf dengan sintaks yang tepat, tetapi saya tidak yakin.

• Bagi masing-masing waktu menjadi dua bagian ( œs€2) lalu gabungkan dengan string ' - '( j€“ - ”). '05:2115:20'→ '05:21 - 15:20'.

• Akhirnya, Ygabungkan semua string dengan baris baru dan semuanya dicetak secara implisit.

versi lama

62 byte

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

Cobalah online!

66 byte

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

Cobalah online!

72 byte

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

Cobalah online!

C (gcc) , 175 174 byte

Sekali terima kasih kepada @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);}}

Cobalah online!

Befunge, 178 byte

>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

Cobalah online!

Kotlin , 205 207 byte

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

Yg diperindahkan

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

Uji

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

Suntingan

• +2 Steadybox - Memperbaiki pemformatan IO

C, 225 byte

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

Karena tidak ada jawaban C, saya memposting jawaban saya sendiri. Beberapa pendekatan lain mungkin lebih pendek.

Cobalah online!