许多数字时钟使用简化的数字显示时间，这些数字仅由七个打开或关闭的不同指示灯组成：

水平镜像时，数字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:55或12: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（这将填充所需的0）

⍕¨ 格式化（字符串化）每个

1↓¨ 从每个字符中删除第一个字符（这将删除前导1）

{… }⌿ 按列应用以下匿名函数（⍺以小时为单位，⍵以分钟为单位）

 0:: 如果发生任何错误，则什么也不返回

 ⋄ 尝试：

  '015xx2xx8x:'[…用以下方式] 索引此字符串：

   ∊⍺':'⍵ 的ε nlisted（扁平）小时，结肠，分钟的列表

   i← 存储在i（为我 NPUT）

   ⎕D⍳ ɩ在列表中的每个字符的ndices d igits

  ⌽ 扭转那个

  t← 存储为t（用于时间）

  (… )⊆ 小组在以下地方跑：

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

在线尝试！

学分

• dylnan将 279个字节减少为256个字节。

• FlipTrack将 256个字节减少为255个字节。

干净，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]

在线尝试！

取消高尔夫：

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小时，因此无法进行。）

ικ:λμ - 

打印未镜像的时间。

Ｆ⟦μλ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'从Emigna的05AB1E回答中得到了想法的双重产物，但是其余的我没有咨询，因为语言在此之后有所不同。可能会有打高尔夫球的机会，可能很多。

说明

该程序的工作方式如下：

• 以文字列表的长度为4的所有产品'0125'用“0152:”©ṢṖp`⁺。©将字符串复制'0152:'到寄存器中以备后用。ṢṖ然后排序，然后弹出字符串→的最后一个元素'0125'。⁺复制产品链接。

• ḣ176删除任何格式为25xx或5xxx（无效时间）的时间。

• j€“:”将每个数字对与相连':'。例如['05'],['21']]→ '05:12'。

• Ç€将第一个链接应用于所有这些时间。它找到字符串中每个字符的索引，'0125:'然后为每个索引获取字符串中的字符'0152:'并将其反转。这是镜像操作（反转和交换2s和5s）。

• µ;" 将原始时间与镜像时间连接起来→ '05:2115:20'

• ⁾25ẇ$ÐṂ用substring过滤时间'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

在线尝试！

科特林，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")}}

蒂奥

在线试用

编辑

• +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答案，因此我发布了自己的答案。其他一些方法可能会更短。

在线尝试！