처음 게시 된 (삭제)에 의해 @Tlink 가장 가능성이되었고, 이 StackOverflow의 질문에서 영감을 .
그것은 일반적으로 좋은 도전처럼 보이기 때문에 삭제 된 수치 였기 때문에 적절한 형식과 규칙으로 다시 게시 할 것이라고 생각했습니다. ( @Tlink에 연락 하여 게시 할 수있는 권한을 얻었지만 더 이상 응답하지 않기 때문에 지금 직접 게시하기로 결정했습니다.)

입력 : 6 자리

출력 : 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각각의 경우 첫 번째 / 마지막을 출력합니다 .

도전 규칙 :

• 답변에 첫 번째 또는 마지막 유효 시간을 출력할지 여부를 명시하십시오.
• I / O는 유연합니다. 입력은 6 개의 분리 된 정수일 수 있습니다. 6 자리를 포함하는 문자열; 정수리스트 / 배열; 단일 (8 진수) 숫자; 등. 출력은 올바르게 정렬 된 숫자 목록 / 배열 일 수 있습니다. 형식의 문자열 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]분 및 초입니다.

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 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;}}

온라인으로 사용해보십시오!

Kevin Cruijssen 덕분에 -12 바이트

아마 최적은 아니지만 작동합니다. 이상하게도 7 개의 인수를 사용하여 TIO에서 gcc를 구현하려면 실제로 제공하거나 segfaults를 제공해야합니다. 그러나 내 컴퓨터에서는 불필요합니다.

형식 : G (X, 0,6)-> Y 여기서 X는 숫자를 사용하는 6 자리 숫자이고 Y는 6 자리 숫자입니다.

하스켈 , 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']

이제 덜 엄격한 출력으로. 입력을 문자열로 받아서 목록 비교를 통해 순열과 한계를 비교합니다. 분과 초를 사용하면 첫 번째 숫자 만 확인됩니다. 순열이 유효한 시간이 아니면 충돌 및 화상입니다.

온라인으로 사용해보십시오!

파이썬 (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는 정수 목록입니다

시간이 없으면 오류가 발생합니다.

대안 :

파이썬 2 , 88 바이트

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

온라인으로 사용해보십시오!

최근 시간을 반환

유효하지 않은 시간에 대해 빈 튜플을 반환합니다

저장되었습니다

• ovs 덕분에 -21 바이트

05AB1E , 20 15 바이트

정렬 된 문자열로 입력하십시오.
출력은 문자열로 가장 작은 시간입니다.
솔루션이없는 경우 빈 목록이 출력됩니다.

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

온라인으로 사용해보십시오!

자바 스크립트 (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려면 1 초 후에 추가하십시오 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}

온라인으로 사용해보십시오! 가장 빠른 시간 또는 시간을 찾을 수없는 경우 빈 문자열을 출력합니다. 편집 : @TwiNight 덕분에 5 8 바이트가 절약되었습니다. 설명:

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

모든 순열을 생성하십시오. 는 :시작에 끝나는, 순열과 같은 문자열이 발생하지만 그 방식으로 작동합니다.

O`

시간을 순서대로 정렬하십시오.

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

첫 번째 유효 시간을 출력하십시오.

빨강 , 157124 바이트

설명을 더 자세히 읽어 보라고 상기시켜 준 Kevin Cruijssen에게 감사합니다!

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

파이썬 2 , 78 바이트

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

온라인으로 사용해보십시오!

Arnauld는 바이트를 저장했습니다. 감사!

['1','2','3','4','6','8']정렬 된 순서대로 목록이 필요합니다.

원하는 순서대로 숫자를 입력 할 수 있으므로 이미 낮은 순서에서 높은 순서로 또는 그 반대로 정렬 할 수 있습니다.

12364812:36:48 과 같은 정수를 출력합니다 . 나는 그것이 받아 들여지기를 바랍니다.

젤리 , 15 바이트

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

온라인으로 사용해보십시오!

요청 후 게시됩니다. 접근 방식은 다른 답변 중 하나와 동일하지만이 답변은 독립적으로 개발되었습니다.

apt , 39 23 바이트

이 작업을 수행하는 더 짧은 방법이 있지만 Japt에서 Date 객체를 사용 해보고 싶었습니다.

á ®¬ò 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.

입력을 정렬 된 숫자 형 배열로 취하고, 최신 유효 시간을 반환하거나 존재하지 않는 경우 빈 출력을 반환합니다. Shaggy 덕분에
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Ḍ<ẠʋÐṀ“ð<<‘ṢḢ

온라인으로 사용해보십시오!

Wolfram Language (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_,_}

표시된 첫 번째 요소는, a0, 1 또는 2이고, 제 번째, 레이블 및 제 요소 b, c및 d각각 ...

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

... a*b10보다 작은, d그리고c 함께, 6 개 미만이다 d >= c.

트릭은 모든 숫자이다 00에 24두 자릿수의 제품이 가능 유효 숫자 9 가장에 있고,25 에29 적어도 10의 생성물을 (우리는 0, 1 또는 2가 될 첫번째 자리를 강제 때문에).

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

펄 5 와 -palF73 바이트,

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

온라인으로 사용해보십시오!

같은 출력 HHmmss 및 잘못된 항목에 대한 빈 줄을 출력합니다.

내가 최근에 한 모든 대답 glob은 순열에 ing을 사용했습니다 ...

Bash + GNU sed, 83 , 72 , 69 바이트

• 입력을 6 개의 개별 인수로 허용합니다.
• 가장 빠른 시간 (발견 된 경우)을 반환합니다.
• 유효한 조합이 없으면 아무것도 출력하지 않습니다 (빈 출력).

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

작동 원리

GNU-sed e (xecute) 명령 +를 사용하여 0에서 86399 범위의 타임 스탬프에 대해 가능한 모든 시간 문자열을 미리 생성하십시오 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 바이트의 Kevin에게 감사합니다!

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 개의 정수이고 출력은 배열에서 최소시, 분 및 초입니다. 그러한 시간이 불가능한 입력에 대해 충돌이 발생합니다.

(@Luis Mendo 덕분에 1 바이트)

펄 6 , 43 바이트

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

온라인으로 사용해보십시오!

정렬 된 입력 배열을 예상합니다. Nil유효하지 않은 입력을 반환 합니다.

Stax , 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 자리이거나 유효 시간이없는 경우 빈 문자열입니다.

편집 : 나는 바보, -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].

유효한 시간 인 경우에만 문자열을 유지합니다