นาฬิกาดิจิตอลจำนวนมากแสดงเวลาโดยใช้ตัวเลขแบบง่ายประกอบด้วยแสงที่แตกต่างกันเจ็ดแบบเท่านั้นที่เปิดหรือปิด:

เมื่อมิเรอร์ในแนวนอนตัวเลข018จะไม่เปลี่ยนเพราะมันมีความสมมาตร นอกจากนี้ตัวเลข2และ5รับแลกเปลี่ยน2กลายเป็น5และในทางกลับกัน ตัวเลขอื่น ๆ ทั้งหมดจะไม่ถูกต้องเมื่อทำมิเรอร์

ดังนั้นด้วยนาฬิกาดิจิตอลตลอด 24 ชั่วโมงจึงมีการอ่านนาฬิกาจำนวนมากเช่นนั้นภาพสะท้อนของจอแสดงผลดิจิตอลก็เป็นนาฬิกาที่ถูกต้องเช่นกัน งานของคุณคือการส่งออกการอ่านนาฬิกาดังกล่าวทั้งหมดพร้อมกับการอ่านมิร์เรอร์

ยกตัวอย่างเช่น22:21กลายเป็น15:55และจะกลายเป็น00:15 21:00บนมืออื่น ๆ , 12:34หรือ16:27จะไม่ถูกต้องเมื่อมิเรอร์ (ตัวเลข34679กลายเป็นที่ไม่ถูกต้อง) และไม่เป็น22:22หรือ18:21เพราะเป็นมีเพียง 24 ชั่วโมงในหนึ่งวันและ 60 นาทีในชั่วโมงไม่มีนาฬิกาสติจะแสดงหรือ55:5512:81

งาน

เขียนโปรแกรมหรือฟังก์ชั่นที่ไม่มีอินพุตและเอาต์พุตคู่ที่ถูกต้องทั้งหมดตามลำดับจากน้อยไปมากดังแสดงด้านล่าง:

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

อนุญาตให้ใช้การต่อท้ายหรือขึ้นบรรทัดใหม่ การมีช่องว่างเพียงเล็กน้อยก่อนที่จะอนุญาตให้ป้อนบรรทัด เวลาจะต้องอยู่ในรูปแบบhh:mmเบาะด้วยศูนย์เมื่อจำเป็น

นี่คือโค้ดกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ ตามปกติช่องโหว่มาตรฐานจะไม่ได้รับอนุญาต

05AB1E , 34 ไบต์

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

ลองออนไลน์!

คำอธิบาย

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 ไบต์

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]

ลองออนไลน์!

ขอบคุณสำหรับ +1 Kevin Cruijssen

APL (Dyalog Unicode) , 84 ไบต์^SBCS

เสร็จสิ้นโปรแกรมที่ส่งออกไปยัง STDOUT ต้องการ⎕IO( I ndex O rigin) 0ซึ่งเป็นค่าเริ่มต้นในหลายระบบ

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

ลองออนไลน์!

⍳1440 ที่หลายɩ ntegers

0 60⊤ แปลงเป็นฐานผสม∞, 60

100+ เพิ่ม 100 (แผ่นนี้ 0s ที่จำเป็น)

⍕¨ รูปแบบ (stringify) แต่ละรายการ

1↓¨ ปล่อยอักขระตัวแรกจากแต่ละตัว (จะเป็นการลบ 1s นำหน้า)

{… }⌿ ใช้ฟังก์ชันคอลัมน์ที่ไม่ระบุชื่อต่อไปนี้ ( ⍺เป็นชั่วโมงสูงสุด⍵คือนาที)

 0:: หากมีข้อผิดพลาดเกิดขึ้นส่งคืนอะไร

 ⋄ ลอง:

  '015xx2xx8x:'[... ทำ] ดัชนีสตริงนี้ด้วย:

   ∊⍺':'⍵ รายการϵ nlisted (แบน) ของชั่วโมง, ลำไส้ใหญ่, นาที

   i← เก็บไว้ในi(สำหรับฉัน nput)

   ⎕D⍳ ɩ ndices ของตัวละครแต่ละตัวในรายการของD igits

  ⌽ ย้อนกลับที่

  t← เก็บไว้เป็นt(สำหรับเสื้อ IME)

  (... )⊆ กลุ่มทำงานที่:

   ':'≠t ลำไส้ใหญ่แตกต่างจาก t

⍎¨ ดำเนินการ (ประเมิน) แต่ละรายการ

 23 59≥ บูลีนสำหรับแต่ละรายการไม่ว่าจะน้อยกว่าหรือเท่ากับ 23 และ 59 ตามลำดับ

 ∧/ จริงหรือ

 : ถ้าเป็นเช่นนั้น:

  ⍕i'-'t รายการที่จัดรูปแบบ (คั่นด้วยเว้นวรรค) ของอินพุต, ขีดกลาง, เวลา

  1↓ วางแรก (ช่องว่าง)

  ⎕← ส่งออกไปยัง STDOUT

เรติน่า , 57 ไบต์

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

ลองออนไลน์! คำอธิบาย:

 - 

แทรกตัวคั่น

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

สร้างชุดที่เป็นไปได้ทั้งหมดของตัวเลขสี่หลักที่มิร์เรอร์

A`\b2?5

ลบผู้ที่มีชั่วโมงที่ผิดกฎหมาย

\b\d.
$&:

ใส่เครื่องหมายจุดคู่

O`

เรียงลำดับ

Python 2 , 279 277 255 ไบต์

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

ลองออนไลน์!

เครดิต

• 279 ไบต์ลดลงไป 256 โดยdylnan

• 256 ไบต์ลดลงถึง 255 โดยFlipTrack

ทำความสะอาด , 269 ... 172 170 ไบต์

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]

ลองออนไลน์!

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
        ]

Pyth , 48 ไบต์

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

ลองออนไลน์!

สร้างชุดค่าผสมที่เป็นไปได้ทั้งหมดจาก0125นั้นปรับเปลี่ยนชุดค่าผสมตามเวลา สิ่งเหล่านี้อยู่ในลำดับที่ถูกต้องเพราะถูกสร้างขึ้นตามลำดับพจนานุกรม สุดท้ายฟิลเตอร์นี้ออกครั้งที่ไม่ถูกต้องเป็นพิเศษโดยการลบเส้นที่ตรงกับ regex ไม่หรือ5.: 25:น่าเศร้าที่ดูเหมือนว่าการบีบอัดจะทำงานได้ดีกับสตริงใด ๆ ที่โปรแกรมนี้ใช้เว้นแต่ว่าฉันได้ทำผิดพลาดหรือควบคุม

Perl 5 , 147 ไบต์

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

ลองออนไลน์!

Japt v2 (+ -R), 51 ไบต์

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

ทดสอบออนไลน์!

คำอธิบาย

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 ไบต์

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

ลองออนไลน์!

ถ่าน , 59 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

Ｆ012Ｆ0125Ｆ0125Ｆ015

สร้างลูปซ้อนกันสี่ลูปสำหรับตัวเลขที่ไม่มีใครติชม

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

ตรวจสอบว่าทั้งชั่วโมงและนาทีไม่ใช่ 25 (การทำมิรเรอร์ 25 นาทีจะส่งผลใน 25 ชั่วโมงดังนั้นจึงไม่มีการหยุด)

ικ:λμ - 

พิมพ์เวลา unmirrored

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

พิมพ์เวลามิร์เรอร์โดยแปลงตัวเลขที่กลับด้าน (หรือ3เครื่องหมายโคลอน) จากสตริงเป็นจำนวนเต็มและค้นหาในตารางการแปล

อีกทางเลือกหนึ่งเช่นกันสำหรับ 59 ไบต์:

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

Ｆ¹¹Ｆ¹⁶

สร้างลูปสำหรับชั่วโมงและนาที

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

ยกเว้น25และนาทีใด ๆ ที่ลงท้าย2ด้วย

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

แปลงชั่วโมงและนาทีเป็นเบส 4

Ｆθ§0125:λ

พิมพ์ตัวเลขที่ค้นหาในตารางการแปล

 - 

พิมพ์ตัวคั่น

Ｆ⮌θ§0152:λ⸿

พิมพ์ตัวเลขที่กลับด้านที่ค้นหาในตารางการแปลที่มิเรอร์

เยลลี่ , 72 66 62 55 ไบต์

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

ลองออนไลน์!

โปรแกรม Niladic ฉันได้รับแนวคิดสองอย่าง'0125'จากคำตอบของ 05AB1E โดย Emignaแต่ที่เหลือฉันก็ไม่ได้ให้คำปรึกษาเลยตั้งแต่ภาษาต่าง ๆ หลังจากนั้น อาจมีโอกาสในการเล่นกอล์ฟ

คำอธิบาย

โปรแกรมทำงานดังนี้:

• ใช้ผลิตภัณฑ์ทั้งหมดของความยาวสี่ของรายการของตัวละครด้วย'0125' คัดลอกสตริงไปยังรีจิสเตอร์เพื่อใช้ในภายหลัง เรียงลำดับจากนั้นปรากฏองค์ประกอบสุดท้ายของสตริง→ ทำซ้ำลิงค์ผลิตภัณฑ์“0152:”©ṢṖp`⁺©'0152:'ṢṖ'0125'⁺

• ḣ176ลบทุกครั้งที่มีรูปแบบ25xxหรือ5xxx(ไม่ใช่ชั่วโมงที่ถูกต้อง)

• j€“:”':'ร่วมคู่ของตัวเลขกับแต่ละ เช่น→['05'],['21']]'05:12'

• Ç€ใช้ลิงก์แรกกับแต่ละครั้งเหล่านี้ ค้นหาดัชนีของอักขระแต่ละตัวในสตริง'0125:'จากนั้นดัชนีแต่ละตัวจะได้รับอักขระในสตริง'0152:'และกลับด้าน นี่คือการทำงานของมิเรอร์ (การย้อนกลับและการสลับ2s และ5s)

• µ;" ต่อเวลาดั้งเดิมกับเวลามิร์เรอร์→ '05:2115:20'

• ⁾25ẇ$ÐṂ'25'กรองเอาเวลาที่มีอักขระย่อย นี้จับคู่เวลาใด ๆ กับครึ่งมิเรอร์หรือ25:xx หมายเหตุ : ฉันไม่รู้ว่าทำไม5x:xx$มีความจำเป็น บางทีบางคนอาจตีกอล์ฟด้วยไวยากรณ์ที่เหมาะสม แต่ฉันไม่แน่ใจ

• แยกแต่ละช่วงเวลาเหล่านี้ออกเป็นสองส่วน ( œs€2) จากนั้นเข้าร่วมกับสตริง' - '( j€“ - ”) →'05:2115:20''05:21 - 15:20'

• ในที่สุดก็Yเข้าร่วมสายทั้งหมดที่มีการขึ้นบรรทัดใหม่และทุกอย่างจะถูกพิมพ์โดยปริยาย

รุ่นเก่า

62 ไบต์

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

ลองออนไลน์!

66 ไบต์

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

ลองออนไลน์!

72 ไบต์

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

ลองออนไลน์!

C (gcc) , 175 174 ไบต์

ขอขอบคุณ @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);}}

ลองออนไลน์!

Befunge ขนาด 178 ไบต์

>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

ลองออนไลน์!

Kotlin , 205 207 ไบต์

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

เชิดชู

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

ทดสอบ

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

การแก้ไข

• +2 Steadybox - แก้ไขการจัดรูปแบบ IO

C, 225 ไบต์

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

เนื่องจากไม่มีคำตอบ C ฉันจึงโพสต์ของตัวเอง วิธีการอื่นอาจสั้นกว่านี้

ลองออนไลน์!