Многие цифровые часы отображают время, используя упрощенные цифры, состоящие только из семи различных лампочек, которые либо включены, либо выключены:

При зеркальном отражении цифры 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 Кевин Круйссен.

APL (Dyalog Unicode) , 84 байта ^SBCS

Завершите вывод программы в STDOUT. Требуется ⎕IO( я 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)

⍕¨ форматировать (stringify) каждый

1↓¨ удалить первый символ из каждого (это удаляет первые 1)

{… }⌿ Применить следующую анонимную функцию по столбцам ( ⍺верхний час, ⍵минутный)

 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а затем манипулирует ими во времени. Они в правильном порядке, потому что они генерируются в лексикографическом порядке. Наконец, это отфильтровывает лишние недопустимые времена, удаляя строки, которые соответствуют регулярному выражению 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

Попробуйте онлайн!

Ниладическая программа. Я получил двойной продукт '0125'идеи от ответа 05AB1E от Эминьи, но остальное я сделал, не посоветовавшись с этим, так как после этого языки расходятся. Есть, вероятно, возможности для игры в гольф, возможно, много.

объяснение

Программа работает следующим образом:

• Возьмите все произведения длины четыре из списка символов '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

Попробуйте онлайн!

Котлин , 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 - исправлено форматирование ввода-вывода

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 нет, я выкладываю свой собственный. Какой-то другой подход может быть короче.

Попробуйте онлайн!