Nhiều đồng hồ kỹ thuật số hiển thị thời gian bằng cách sử dụng các chữ số đơn giản chỉ bao gồm bảy đèn khác nhau bật hoặc tắt:

Khi được nhân đôi theo chiều ngang, các chữ số 018không thay đổi vì chúng đối xứng. Ngoài ra, các chữ số 2và 5được hoán đổi, 2trở thành 5và ngược lại. Tất cả các chữ số khác trở nên không hợp lệ khi được nhân đôi.

Do đó, với một đồng hồ kỹ thuật số 24 giờ, có nhiều cách đọc đồng hồ sao cho hình ảnh được nhân đôi của màn hình kỹ thuật số cũng là một đồng hồ đọc hợp lệ. Nhiệm vụ của bạn là xuất ra tất cả các số đọc đồng hồ như vậy cùng với các số đọc được nhân đôi.

Ví dụ, 22:21trở thành 15:55, và 00:15trở thành 21:00. Mặt khác, 12:34hoặc 16:27không còn giá trị khi nhân đôi (chữ số 34679trở thành không hợp lệ), và không phải là 22:22hay 18:21, bởi vì, như chỉ có 24 giờ trong một ngày và 60 phút trong một giờ, không có đồng hồ lành mạnh sẽ hiển thị 55:55hoặc 12:81.

Bài tập

Viết chương trình hoặc hàm không có đầu vào và đầu ra tất cả các cặp hợp lệ theo thứ tự tăng dần như dưới đây:

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

Một dấu vết hoặc một dòng mới hàng đầu được cho phép. Có một vài khoảng trắng trực tiếp trước khi cho ăn theo dòng cũng được cho phép. Thời gian phải ở định dạng hh:mm, được đệm bằng số không khi cần thiết.

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng. Như thường lệ, sơ hở tiêu chuẩn không được phép.

05AB1E , 34 byte

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

Hãy thử trực tuyến!

Giải trình

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 byte

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]

Hãy thử trực tuyến!

Cảm ơn vì +1 Kevin Cruijssen.

APL (Dyalog Unicode) , 84 byte ^SBCS

Hoàn thành chương trình xuất ra STDOUT. Yêu cầu ⎕IO( I ndex O rigin) 0là mặc định trên nhiều hệ thống.

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

Hãy thử trực tuyến!

⍳1440 mà nhiều ɩ ntegers

0 60⊤ chuyển đổi sang cơ sở hỗn hợp ∞, 60

100+ thêm 100 (phần đệm này là 0s cần thiết)

⍕¨ định dạng (xâu chuỗi) mỗi

1↓¨ thả ký tự đầu tiên từ mỗi ký tự (cái này loại bỏ các ký tự hàng đầu)

{... }⌿ áp dụng các chức năng ẩn danh sau cột khôn ngoan ( ⍺là giờ đầu, ⍵là phút)

 0:: nếu có lỗi xảy ra, không trả lại

 ⋄ thử:

  '015xx2xx8x:'[... ] chỉ số chuỗi này với:

   ∊⍺':'⍵ các ε nlisted (phẳng) danh sách các giờ, ruột kết, phút

   i← được lưu trữ trong i(cho i nput)

   ⎕D⍳ thông tin của từng nhân vật trong danh sách D igits

  ⌽ đảo ngược điều đó

  t← lưu trữ dưới dạng t(cho t ime)

  (... )⊆ nhóm chạy nơi:

   ':'≠t đại tràng khác với t

⍎¨ thực hiện (đánh giá) từng

 23 59≥ Boolean cho mỗi cho dù chúng nhỏ hơn hoặc bằng 23 và 59 tương ứng

 ∧/ đều đúng

 : nếu vậy, thì:

  ⍕i'-'t danh sách định dạng (phân tách không gian) của đầu vào, dấu gạch ngang, thời gian

  1↓ thả cái đầu tiên

  ⎕← xuất ra STDOUT

Võng mạc , 57 byte

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

Hãy thử trực tuyến! Giải trình:

 - 

Chèn dải phân cách.

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

Tạo tất cả các bộ có thể có bốn chữ số được nhân đôi.

A`\b2?5

Xóa những người có giờ bất hợp pháp.

\b\d.
$&:

Chèn dấu hai chấm.

O`

Sắp xếp theo thứ tự.

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

Hãy thử trực tuyến!

Tín dụng

• 279 byte giảm xuống còn 256 bởi dylnan .

• 256 byte giảm xuống còn 255 bởi FlipTrack .

Sạch , 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]

Hãy thử trực tuyến!

Ung dung:

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
        ]

Bình thường , 48 byte

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

Hãy thử trực tuyến!

Tạo ra tất cả các kết hợp có thể 0125và sau đó thao túng chúng vào thời đại. Đây là theo đúng thứ tự bởi vì chúng được tạo ra theo thứ tự từ điển. Cuối cùng, điều này lọc ra thời gian không hợp lệ thêm bằng cách xóa các dòng khớp với biểu thức chính quy 5.:hoặc 25:. Đáng buồn thay, có vẻ như nén không hoạt động tốt trên bất kỳ chuỗi nào mà chương trình này sử dụng, trừ khi tôi đã gây ra lỗi hoặc giám sát.

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

Hãy thử trực tuyến!

Japt v2 (+ -R), 51 byte

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

Kiểm tra nó trực tuyến!

Giải trình

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

Hãy thử trực tuyến!

Than , 59 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｆ012Ｆ0125Ｆ0125Ｆ015

Tạo bốn vòng lặp lồng nhau cho các chữ số chưa được chỉnh sửa.

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

Kiểm tra xem cả giờ và phút không phải là 25. (Phản chiếu 25 phút sẽ có kết quả sau 25 giờ, vì vậy đó là điều không nên.)

ικ:λμ - 

In thời gian không mong muốn.

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

In thời gian được nhân đôi bằng cách chuyển đổi các chữ số đảo ngược (hoặc 3cho dấu hai chấm) từ chuỗi sang số nguyên và tìm kiếm chúng trong bảng dịch.

Ngoài ra, cũng cho 59 byte:

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｆ¹¹Ｆ¹⁶

Tạo các vòng lặp cho giờ và phút.

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

Không bao gồm 25và bất kỳ phút nào kết thúc bằng 2.

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

Chuyển đổi giờ và phút sang cơ sở 4.

Ｆθ§0125:λ

In các chữ số nhìn lên trong một bảng dịch.

 - 

In dải phân cách.

Ｆ⮌θ§0152:λ⸿

In các chữ số đảo ngược nhìn lên trong một bảng dịch được nhân đôi.

Thạch , 72 66 62 55 byte

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

Hãy thử trực tuyến!

Chương trình Niladic. Tôi đã nhận được sản phẩm kép của '0125'ý tưởng từ câu trả lời 05AB1E của Emigna nhưng phần còn lại tôi đã làm mà không tham khảo ý kiến ​​vì các ngôn ngữ chuyển hướng sau đó. Có lẽ có nhiều cơ hội để chơi golf, có thể rất nhiều.

Giải trình

Chương trình hoạt động như sau:

• Lấy tất cả các sản phẩm có độ dài bốn trong danh sách các nhân vật '0125'với “0152:”©ṢṖp`⁺. ©sao chép chuỗi '0152:'vào thanh ghi để sử dụng sau. ṢṖsắp xếp sau đó bật phần tử cuối cùng của chuỗi → '0125'. ⁺nhân đôi liên kết sản phẩm.

• ḣ176xóa bất kỳ thời gian nào với định dạng 25xxhoặc 5xxx(không phải giờ hợp lệ).

• j€“:”nối mỗi cặp chữ số với a ':'. ví dụ ['05'],['21']]→ '05:12'.

• Ç€áp dụng liên kết đầu tiên cho mỗi thời điểm này. Nó tìm chỉ mục của từng ký tự trong chuỗi '0125:'sau đó cho mỗi chỉ số đó lấy ký tự trong chuỗi '0152:'và đảo ngược nó. Đây là hoạt động nhân bản (đảo ngược và hoán đổi 2s và 5s).

• µ;" nối thời gian ban đầu với thời gian được nhân đôi → '05:2115:20'

• ⁾25ẇ$ÐṂlọc ra thời gian với chuỗi con '25'. Điều này bắt bất kỳ cặp thời gian với một nửa nhân đôi 25:xxhoặc 5x:xx. Lưu ý : Tôi không biết tại sao $cần thiết. Có lẽ ai đó có thể chơi nó với cú pháp thích hợp nhưng tôi không chắc.

• Chia mỗi lần này thành hai nửa ( œs€2) sau đó nối chúng với chuỗi ' - '( j€“ - ”). '05:2115:20'→ '05:21 - 15:20'.

• Cuối cùng, Ytham gia tất cả các chuỗi với một dòng mới và mọi thứ được in ngầm.

phiên bản cũ

62 byte

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

Hãy thử trực tuyến!

66 byte

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

Hãy thử trực tuyến!

72 byte

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

Hãy thử trực tuyến!

C (gcc) , 175 174 byte

Một lần cảm ơn @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);}}

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

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

Làm đẹp

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

Kiểm tra

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

Dùng thử

Chỉnh sửa

• +2 Steadybox - Đã sửa lỗi định dạng 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);}

Vì không có câu trả lời C, tôi tự đăng bài. Một số cách tiếp cận khác có thể ngắn hơn.

Hãy thử trực tuyến!