Спочатку опублікував (і видалив) автор @Tlink , який, швидше за все, був натхненником цього питання StackOverflow .
Оскільки це було соромно, що його видалили, оскільки це загалом здавалося гарним викликом, я зрозумів, що переставлю його з належним форматуванням та правилами. (Я намагався зв’язатися з @Tlink і отримати його дозвіл на його публікацію, але він більше не відповідає, тому я вирішив опублікувати його зараз.)

Введення: Шість цифр.

Вихід: або перший, або останній дійсний час у 24-годинному форматі ( 00:00:00через 23:59:59). (Ви можете самостійно вибрати, чи буде ви перший або останній дійсний час.)

Приклад:

Якщо дані є 1,8,3,2,6,4, можна створити наступні рази:

12:36:48    12:38:46    12:46:38    12:48:36
13:26:48    13:28:46    13:46:28    13:48:26
14:26:38    14:28:36    14:36:28    14:38:26
16:23:48    16:24:38    16:28:34    16:28:43
16:32:48    16:34:28    16:38:24    16:38:42
16:42:38    16:43:28    16:48:23    16:48:32
18:23:46    18:24:36    18:26:34    18:26:43
18:32:46    18:34:26    18:36:24    18:36:42
18:42:36    18:43:26    18:46:23    18:46:32
21:36:48    21:38:46    21:46:38    21:48:36
23:16:48    23:48:16

Таким чином, ми виводимо 12:36:48або 23:48:16в цьому випадку, або першим / останнім відповідно.

Правила виклику:

• Вкажіть, чи виводить у відповіді перший чи останній дійсний час.
• Введення / виведення гнучко. Вхід може бути шістьма окремими цілими числами; рядок, що містить шість цифр; цілий список / масив; єдине (можливо восьмеричне) число; і т.д. Вихід може бути правильно упорядкованим списком / масивом цифр; a Рядок у форматі HH:mm:ss/ HHmmss/ HH mm ss; кожна цифра, надрукована роздільником нового рядка; твій дзвінок.
• Вам дозволяється брати цифри в будь-якому бажаному вами порядку, тому вони вже можуть бути відсортовані від найнижчого до найвищого або навпаки.
• Якщо не можна створити дійсний час із заданими цифрами (тобто 2,5,5,5,5,5), уточнюйте будь-який потрібний вам спосіб. Може повернутися null/ false; "Not possible"; збої з помилкою; і т.д. (Ви не можете вивести недійсний час, наприклад 55:55:52, або інший дійсний час, як 00:00:00.
• Вам не дозволяється виводити всі можливі дійсні часи. Виводити / повертати слід лише найраніші / останні.
• 24протягом годин (тобто 24:00:00) або 60хвилин / секунд (тобто 00:60:60) не є дійсними. Діапазони - це [00-23]години, [00-59]хвилини і секунди.

Загальні правила:

• Це код-гольф , тому найкоротша відповідь у байтах виграє.
  Не дозволяйте мовам коду-гольфу відштовхувати вас від публікації відповідей з не кодовими гольф-мовами. Спробуйте придумати якомога коротшу відповідь на "будь-яку" мову програмування.
• Стандартні правила застосовуються до вашої відповіді, тому вам дозволяється використовувати STDIN / STDOUT, функції / метод із відповідними параметрами та повним програмами типу "повернення". Твій дзвінок.
• Лазівки за замовчуванням заборонені.
• Якщо можливо, додайте посилання з тестом для вашого коду.
• Також, будь ласка, додайте пояснення, якщо це необхідно.

Тестові приклади:

Input:          Earliest output:     Latest output:

1,2,3,4,6,8     12:36:48             23:48:16
2,5,5,5,5,5     None possible        None possible
0,0,0,1,1,1     00:01:11             11:10:00
1,1,2,2,3,3     11:22:33             23:32:11
9,9,9,9,9,9     None possible        None possible
2,3,5,5,9,9     23:59:59             23:59:59
1,2,3,4,5,6     12:34:56             23:56:41
0,0,0,0,0,0     00:00:00             00:00:00
1,5,5,8,8,8     18:58:58             18:58:58
1,5,5,5,8,8     15:58:58             18:58:55
1,1,1,8,8,8     18:18:18             18:18:18

C (gcc) , 186 174 байт

D[7]={0,1,10,100,1e3,1e4,1e5};G(O,L,F,T,I,M,E){if(!F)O=L<24e4&L%10000<6e3&L%100<60?L:1e9;else{for(T=1e9,I=0;I++<F;M=G(O/10,L*10+E,F-1),T=T>M?M:T,O=(O/10)+E*D[F])E=O%10;O=T;}}

Спробуйте в Інтернеті!

-12 байт завдяки Кевіну Крейссену

Напевно, не оптимально, але це працює. Як не дивно чомусь із 7 аргументами, реалізація gcc на TIO вимагає, щоб ви фактично їх постачали або це segfaults. На моїй машині, однак, це непотрібно.

Формат: G (X, 0,6) -> Y, де X - це 6-розрядне число, цифри якого слід використовувати, а Y - це 6-значний номер, який при введенні як час (відповідним чином вставляючи: мінімально) є мінімальним.

Haskell , 114 96 86 байт

import Data.List
f l=minimum[x|x@[a,b,c,d,e,f]<-permutations l,a:[b]<"24",c<'6',e<'6']

Зараз з менш суворим виходом. Приймає введення як рядок цифр і порівнює перестановки з обмеженнями зі списком порівняння. З хвилин і секунд перевіряється лише перша цифра. Збиття та опіки, якщо перестановка не є дійсним часом.

Спробуйте в Інтернеті!

Python 2 , 131 115 112 109 105 88 байт

lambda s:min(d for d in permutations(s)if(2,4)>d[:2]>d[4]<6>d[2])
from itertools import*

Спробуйте в Інтернеті!

I / O - це списки цілих чисел

Якщо помилка не можлива, виникла помилка

Альтернатива:

Python 2 , 88 байт

lambda s:max(d*((2,4)>d[:2]>d[4]<6>d[2])for d in permutations(s))
from itertools import*

Спробуйте в Інтернеті!

Повертається останній час

Повертає порожній кортеж для недійсних разів

Збережено

• -21 байт, завдяки ов

05AB1E , 20 15 байт

Введіть як відсортований рядок.
Вихід - це найменший час у вигляді рядка.
У разі відсутності рішення порожній список є вихідним.

œʒ2ô•3Èñ•2ô‹P}н

Спробуйте в Інтернеті!

JavaScript (ES6), 93 89 88 байт

Очікує масив із 6 цифр, відсортований від найнижчого до найвищого. Повертає або 6-розрядний рядок першого дійсного часу, або falseякщо рішення не існує.

f=(a,t='')=>t<24e4&/..([0-5].){2}/.test(t)?t:a.some((v,i)=>s=f(a.filter(_=>i--),t+v))&&s

Спробуйте в Інтернеті!

Прокоментував

Ми рекурсивно пробуємо всі перестановки вхідних даних, поки не знайдемо те, що проходить гібридний тест, використовуючи як арифметичний, так і регулярний вираз.

f = (                       // f = recursive function taking
  a, t = ''                 // a[] = input array and t = current time
) =>                        //
  t < 24e4 &                // if t is less than 240000
  /..([0-5].){2}/.test(t) ? // and it matches "hhMmSs" with M and S in [0-5]:
    t                       //   return t
  :                         // else:
    a.some((v, i) =>        //   for each digit v at position i in a[]:
      s = f(                //     save in s the result of a recursive call with:
        a.filter(_ => i--), //       a copy of a[] with the current digit removed
        t + v               //       the current digit appended to t
      )                     //     end of recursive call
    ) && s                  //   end of some(); if truthy, return s

Japt , 17 байт

Приймає введення як рядок цифр і виводить перший дійсний час; петлі нескінченно, якщо немає дійсного часу.

á
@øXr':}a@ÐX ¤¯8

Спробуй це

Попередження: Надзвичайно повільно - додайте *1000після другого, Xщоб дещо прискорити його. І не забувайте, що недійсний вхід створить нескінченний цикл і може збоїти ваш браузер.

Пояснення

                   :Implicit input of string U
á                  :Get all permutations of U
\n                 :Reassign that array to U
      }a           :Loop until true and then return the argument that was passed
        @          :By default that argument is an integer X which increments on each loop so first we'll pass X through a function
         ÐX        :  new Date(X)
            ¤      :  Get the time
             ¯8    :  Slice to the 8th character to get rid of the timezone info
@                  :The function that tests for truthiness
  Xr':             :  Remove all colons in X
 ø                 :  Does U contain the resulting string?

Сітківка , 77 74 69 65 62 байт

$
:
6+Lv$`(.)(.*):
$%`$2:$1$%'
O`
0L`([01].|2[0-3])([0-5].){2}

Спробуйте в Інтернеті! Виводить найдавніший час або порожній рядок, якщо часу не знайти. Редагувати: Збережено 5 8 байт завдяки @TwiNight. Пояснення:

$
:
6+Lv$`(.)(.*):
$%`$2:$1$%'

Створіть усі перестановки. :Працює свій шлях , хоча рядок , як перестановки генеруються, в кінцевому підсумку на старті.

O`

Сортувати часи за порядком.

0L`([01].|2[0-3])([0-5].){2}

Виведіть перший дійсний час.

Червоний , 157 124 байт

Дякую Кевіну Крейсейну за те, що він нагадав мені більш уважно читати описи!

func[s][a: 0:0:0 loop 86400[b: to-string a a: a + 1 if b/1 =#"0"[insert b"0"]if s = sort replace/all copy b":"""[return b]]]

Спробуйте в Інтернеті!

Приймає відсортований рядок як вхідний. Повертається, noneякщо не вдається зробити час.

Пояснення:

f: func[s][                                    ; the argument is a sorted string of digits
    a: 0:0:0                                   ; time object, set to 00:00:00 h 
    loop 86400 [                               ; loop through all seconds in 24 h
        b: to-string a                         ; convert the time to string 
        a: a + 1                               ; add 1 second to the current time   
        if b/1 = #"0" [                        ; prepend "0" if necessary
            insert b "0"                       ; (Red omits the leading 0)
        ]
        if s = sort replace/all copy b ":" ""[ ; compare the input with the sorted time
            return b                           ; return it if they are equal 
        ]
    ]
]

Python 2 , 78 байт

lambda s:min(x for x in range(62**3)if x%100<60>x/100%100<s==sorted('%06d'%x))

Спробуйте в Інтернеті!

Арнольд врятував байт. Спасибі!

Очікує список, як ['1','2','3','4','6','8']у відсортованому порядку:

Вам дозволяється брати цифри в будь-якому бажаному вами порядку, тому вони вже можуть бути відсортовані від найнижчого до найвищого або навпаки.

Виводить ціле число, як 123648для 12:36:48. Я сподіваюся, що це прийнятно.

Желе , 15 байт

Œ!s€2Ḍf«¥“ç;;‘Ṃ

Спробуйте в Інтернеті!

Опубліковано після запиту. Підхід такий самий, як і у відповіді, але ця відповідь була розроблена самостійно.

Japt , 39 23 байт

Напевно, є коротший спосіб зробити це, але я хотів спробувати використовувати об'єкти Date в Japt.

á ®¬ò q':Ãf@T<ÐXiSiKÅ
Ì

á                     // Get all permutations of the input array.
  ®¬ò q':à            // [1,2,3,4,5,6] -> "12:34:56"
          f@          // Filter the results, keeping those that
            T<        // are valid dates
              ÐXiSiKÅ // when made into a date object.
Ì                     // Return the last remaining item, if any.

Приймає введення як відсортований масив чисел, повертає останній дійсний час або порожній вихід, якщо такого немає.
Втратив 10 кілограмів байт завдяки Шаггі .

Спробуйте тут .

Рубі , 68 67 62 56 55 байт

->*b{b.permutation.find{|a,b,c,d,e|c<6&&e<6&&a*9+b<22}}

Спробуйте в Інтернеті!

Введення: відсортований масив цифр (як цілі числа).

Вихід: масив цифр або nilякщо рішення не знайдено

Желе , 17 байт

^{Я майже впевнений, що це не найкоротший підхід ... переглянемо це знову пізніше :)}

Œ!s2Ḍ<ẠʋÐṀ“ð<<‘ṢḢ

Спробуйте в Інтернеті!

Мова Вольфрама (Mathematica) , 63 байти

FirstCase[Permutations@#,{a:0|1|2,b_,c_,_,d_,_}/;a*b-4<6>d>=c]&

Спробуйте в Інтернеті!

Приймає впорядкований список цифр. Повернення Missing[NotFound]для недійсних входів.

Пояснення

Permutations@#

Знайдіть усі перестановки вхідних даних. Оскільки вхід сортується, гарантується, що всі дійсні часи в порядку зростання.

FirstCase[ ... ]

Знайдіть перший список, який відповідає ...

{a:0|1|2,b_,c_,_,d_,_}

Перший елемент, позначений a, дорівнює 0, 1 або 2, і маркують другий, третій і п'ятий елементи b, cі , dвідповідно , ...

... /;a*b-4<6>d>=c

... таким чином, що a*bне перевищує 10, а dй cменш ніж 6, з d >= c.

Хитрість полягає в тому, що для всіх чисел 00до 24добутку двох цифр дорівнює щонайменше 9, а можливі недійсні числа 25до 29(оскільки ми змушуємо першу цифру дорівнювати 0, 1 або 2) мають добуток не менше 10.

Pyth , 37 байт

j\:hf&&<shT24<s@T1 60<seT60mcs`Md2S.p

Тестовий набір

j\:hf&&<shT24<s@T1 60<seT60mcs`Md2S.pQ # Code with implicit variables
   h                                   # The first element of
                                   .pQ # The list of all permutations of the input list
                                  S    # Sorted
                           mcs`Md2     # Mapped to three two digit long strings
    f                                  # Filtered on whether
       <shT24                          #  The first number is less than 24
      &      <s@T1 60                  #  AND the second number is less than 60
     &               <seT60            #  AND the third number is less than 60
j\:                                    # Joined by a colon

Perl 5 з -palF, 73 байти

$"=",";($_)=grep@F~~[sort/./g]&/([01]\d|2[0-3])([0-5]\d){2}/,glob"{@F}"x6

Спробуйте в Інтернеті!

Виводи, як HHmmssі видає порожній рядок для недійсних записів.

Кожна відповідь, яку я нещодавно зробив, використовувала globдля перестановок ... Дивно!

Bash + GNU sed, 83 , 72 , 69 байт

• Приймає введення як 6 окремих аргументів;
• Повертає найшвидший час (якщо його знайдено);
• Повертає нічого (порожній вихід), якщо не існує дійсної комбінації.

seq 0 86399|sed "s/^/date +%T -ud@/e;h;`printf s/%d//\; $@`/\w/d;x;q"

Як це працює

Попередньо генеруйте всі можливі часові рядки для часових позначок в діапазоні від 0 до 86399, використовуючи команду GNU-sed e (xecute) + date.

%seq 0 86399|sed "s/^/date +%T -ud@/e;h;"

00:00:00
00:00:01
...
23:59:59

Створіть sedсценарій з 6 послідовних команд заміни для кожної вхідної цифри.

%echo sed `printf s/%d//\; $@`

sed s/1//;s/2//;s/3//;s/4//;s/6//;s/8//;

Потім застосуйте підстановки, видаліть усі вхідні рядки, у яких залишилось принаймні одна цифра, надрукуйте перший рядок, що відповідає (початковий часовий рядок витягується із простору утримування x).

%echo 23:45:12|sed 's/1//;s/2//;s/3//;s/4//;s/6//;s/8//;'
:5:2 //non-matching, delete

%echo 12:36:48|sed 's/1//;s/2//;s/3//;s/4//;s/6//;s/8//;'
:: //matching, print and stop

Тест

%./timecomb 1 2 3 4 6 8
12:36:48
%./timecomb 2 5 5 5 5 5
%./timecomb 0 0 0 1 1 1
00:01:11
%./timecomb 1 1 2 2 3 3
11:22:33
%./timecomb 9 9 9 9 9 9
%./timecomb 2 3 5 5 9 9
23:59:59
%./timecomb 1 2 3 4 5 6
12:34:56
%./timecomb 0 0 0 0 0 0
00:00:00
%./timecomb 1 5 5 8 8 8
18:58:58
%./timecomb 1 5 5 5 8 8
15:58:58
%./timecomb 1 1 1 8 8 8
18:18:18

Спробуйте в Інтернеті!

Котлін , 396 391 389 байт

Немає поняття, як зробити це менше. Я думаю, що це подвійно, ніж це можливо. Проводиться якнайшвидше. Дякую Кевіну за 7 байт!

fun p(d:Array<Int>)={val s=Array(6,{0})
val f=Array(6,{1>0})
val t=Array(3,{0})
val o=Array(3,{60})
fun r(i:Int){if(i>5){var l=0>1
var e=!l
for(p in 0..2){t[p]=s[p*2]*10+s[p*2+1]
l=l||(e&&t[p]<o[p])
e=e&&t[p]==o[p]}
if(t[0]<24&&t[1]<60&&t[2]<60&&l)for(p in 0..2)o[p]=t[p]}
else
for(p in 0..5)if(f[p]){f[p]=0>1
s[i]=d[p]
r(i+1)
f[p]=1>0}}
r(0)
if(o[0]>23)0
else "${o[0]}:${o[1]}:${o[2]}"}()

Спробуйте в Інтернеті!

MATL , 31 30 байт

Y@3Xy[X1]X*!Y*t[4XX]6*<!AY)1Y)

Спробуйте в Інтернеті!

Вхід - 6 цілих чисел, вихід - мінімальна година, хвилини та секунди в масиві. Збої для входів, де немає такого часу.

(-1 байт завдяки @Luis Mendo.)

Perl 6 , 43 байти

*.permutations.first:{24e4>.join&&6>.[2&4]}

Спробуйте в Інтернеті!

Очікує відсортований вхідний масив. Повернення Nilдля недійсного введення.

Стакс , 15 байт

╝a╣=→aá≈#8(⌂≈58

Запустіть і налагоджуйте його

Для введення потрібен рядок відсортованих цифр. Він повертає першу перестановку, яка відповідає декільком критеріям.

• лексикографічно менше "24"
• усі три пари символів лексикографічно менше "6"

Сітківка , 58 47 байт

+,V^2`[0-5][6-9]{2}
G`([01].|2[0-3])([0-5].){2}

Спробуйте в Інтернеті!

Введено 6 цифр у відсортованому порядку. Вихід - 6 цифр, що представляють найдавніший дійсний час, або порожній рядок, якщо не існує дійсного часу.

EDIT: Я був ідіот, -9 байт

Пояснення

Алгоритм

Для стислості давайте визначимо низьку цифру як 0-5, а високу цифру - 6-9.

По-перше, переставляйте цифри так, щоб «низька ність» або «висока ність» кожної позиції були правильними. Правильне розташування для кожної кількості високих цифр на вході:

# of highs  arrangment
0           LLLLLL
1           LLLLLH
2           LLLHLH
3           LHLHLH
4+          Not possible

Оскільки будь-яка перебудова не зможе остаточна перевірка на вході має 4+ високих цифр, ми можемо повністю проігнорувати цей випадок.

Потім сортуйте мінімум і максимуми. Поєднавшись із перестановкою, це дає найменше значення, яке задовольняє хвилинні та другі обмеження. Таким чином, це дає найдавніший термін дії, якщо такий існує.

Нарешті, перевірте, чи є у нас дійсний час. Якщо ні, відмовтеся від рядка.

Програма

+,V^2`[0-5][6-9]{2}

Збігається LHHта замінює перші дві цифри в цьому (стає HLH) і повторює, поки більше не LHHіснує. Це дає правильне розташування.

Власне, я збрехав. Не потрібно сортувати, оскільки 1) заміна відбувається лише між суміжними цифрами і лише між низькими та високими; і 2) вхід сортується. Тож мінімуми та максимуми окремо вже впорядковані.

G`([01].|2[0-3])[0-5].[0-5].

Зберігає рядок, лише якщо це дійсний час