특정 패턴을 따르는 시간이 정말 마음에 듭니다. 특히, 나는 모든 자릿수가 같거나 모든 자릿수가 왼쪽에서 오른쪽으로 산술적으로 증가하는 시간을 좋아합니다. 또한, 사람들이 내 시대에 편지를 쓰면 눈에 띄게 미워하므로 AM / PM의 말도 안되는 소리가 모두 나에게 죽습니다. 따라서 내가 가장 좋아하는 시간은 다음과 같습니다.

0000 0123 1111 1234 2222 2345

내 마음의 평화를 위해 현재 시간을 입력으로 제공하는 단일 프로그램을 작성해야합니다. (A) 지금 내가 좋아하는 시간 중 하나 가 아닌 경우 (i) 몇 분인지 알려주십시오. 나의 마지막 마음에 드는 시간 이후 였을뿐 아니라 (ii) 다음 몇 분간의 다음 마음에 드는 시간이 일어날 지; 및 (B) 가있는 경우 입니다 지금 내가 가장 좋아하는 시간 중 하나를, 하나의 '신호 값'을 공급한다.

입력

프로그램은 stdin다음과 같은 형식으로 현재 시간 을 어떤 방법 으로든 함수 인수 , 명령 행 인수 등으로 받아 들여야합니다 .

• 문자열로 된 네 자리 시간

• 4 자리 시간을 문자열로 만들기 위해 왼쪽에 0으로 채워질 수있는 정수

• 시퀀스의 첫 번째 정수가 시간 입력에서 가장 왼쪽 (유의 한) 숫자가되도록 정렬 된 4 개 이하의 정수 시퀀스 (예 : 또는 0951로 유효하게 표시 될 수 있음 )[0, 9, 5, 1][9, 5, 1]

  • 대표 0000길이 제로 시퀀스로 허용

문자열 입력의 경우 숫자, 콜론 또는 다른 문장 부호 만 포함 해야 합니다 . 입력은 항상 24 시간 유효한 것으로 가정 할 수 있습니다 : HHMM , where 0 <= HH <= 23및 0 <= MM <= 59. 윤초의 가능성을 무시하십시오.

산출

입력 값이 목표 시간인지 여부에 따라 프로그램이 (A) 또는 (B)stdout 중 하나 를 제공해야합니다 (함수 반환 등 ) .

(A)의 경우 :

다음과 같이 적절한 형식으로 두 개의 숫자 값을 제공하십시오.

• 적합한 구분 기호가있는 단일 문자열 출력

• 순차 정수 / 문자열 출력, 예를 들면, bash두 개의 라인을 인쇄 stdout:

  49
  34
  

• Python 목록, C 배열 등과 같은 길이가 2 개인 반환 값 : [49, 34]

값은 어느 순서로나 올 수 있습니다. 예를 들어, 다음은 모두 입력에 대한 유효한 출력입니다 1200.

49 34
34 49

그러나 모든 입력 값의 순서와 구분 기호는 동일해야합니다!

(B)의 경우 :

다른 방법으로는 얻을 수없는 결과를 생성하십시오. 같은 결과는하지만, 목표 시간의 여섯 용으로 제작해야합니다. 무한 루프는 제외됩니다.

샘플 입력 / 출력

YAY!!! 여기서는 실증적 인 예로 사용되며 규범이 아닙니다.

Input      Output
------    --------
 0000      YAY!!!
 0020      20 63
 0105      65 18
 0122      82 1
 0123      YAY!!!
 0124      1 587
 0852      449 139
 1111      YAY!!!
 1113      2 81
 1200      49 34
 1234      YAY!!!
 1357      83 505
 1759      325 263
 1800      326 262
 1801      327 261
 2222      YAY!!!
 2244      22 61
 2345      YAY!!!
 2351      6 9

입니다 코드 골프 바이트의 승리에 너무 짧은 코드. 표준 허점 은 허용되지 않습니다.

젤리 , 34 33 32 31 28 바이트

Xcoder 씨 .ị와 ³트릭 덕분에 3 바이트 .

d³ḅ60;15j83,588ṁ5¤_\ṠÞAµ.ịxẠ

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

일부는 Jonathan Allan의 답변 과 정확히 같지만 Pyth 답변 (및 더 짧은 : D)을 기반으로 독립적으로 작성된 것으로 생각되므로 게시하고 있습니다. 개선의 여지가 있어야합니다.

입력은 정수이고 출력은 이전 및 다음 시간의 배열이거나 특수한 시간의 빈 배열입니다.

설명

예제 입력 사용 1200.

• d³시간을 기본 100으로 시간과 분으로 변환합니다 [12,0].
• ḅ60기본 60에서 변환하여 총 분을 얻습니다 720..
• ;1515와 쌍을 이룹니다 [720, 15].
• 83,588배열을 만듭니다 [83, 588].
• ṁ5길이를 5 :로 만듭니다 [83, 588, 83, 588, 83].
• ¤위의 두 동작을 결합합니다. 기술 일뿐입니다.
• j쌍을 배열과 결합합니다 [720, 83, 588, 83, 588, 83, 15].
• _\첫 번째 배열에서 각 배열 값을 빼고 중간 결과를 얻습니다 [720, 637, 49, -34, -622, -705, -720].
• ṠÞ signum을 기준 으로 안정적으로 정렬합니다 [-34, -622, -705, -720, 720, 637, 49].
• A절대 값을받습니다 : [34, 622, 705, 720, 720, 637, 49].
• µ새로운 모나 딕 체인을 시작합니다. 다시 한 번 기술입니다.
• .ị마지막 항목과 첫 번째 항목을 가져옵니다 [49, 34].
• ×Ạ0이 없으면 한 번, 그렇지 않으면 0 번 반복합니다 [49, 34].

자바 스크립트 (ES6), 87 83 바이트

@ l4m2 덕분에 4 바이트 절약

입력을 문자열로받습니다. 0또는 요소를 2 개 가진 배열을 반환합니다 .

t=>[i=0,83,588,83,588,83,15].every(d=>(k=t-(t/25>>2)*40)>(j=i,i+=d))|i-k&&[k-j,i-k]

테스트 사례

let f =

t=>[i=0,83,588,83,588,83,15].every(d=>(k=t-(t/25>>2)*40)>(j=i,i+=d))|i-k&&[k-j,i-k]

console.log(f('0000')) // YAY!!!
console.log(f('0020')) // 20 63
console.log(f('0105')) // 65 18
console.log(f('0122')) // 82 1
console.log(f('0123')) // YAY!!!
console.log(f('0124')) // 1 587
console.log(f('0852')) // 449 139
console.log(f('1111')) // YAY!!!
console.log(f('1113')) // 2 81
console.log(f('1200')) // 49 34
console.log(f('1234')) // YAY!!!
console.log(f('1357')) // 83 505
console.log(f('1759')) // 325 263
console.log(f('1800')) // 326 262
console.log(f('1801')) // 327 261
console.log(f('2222')) // YAY!!!
console.log(f('2244')) // 22 61
console.log(f('2345')) // YAY!!!
console.log(f('2351')) // 6 9

어떻게?

.every()루프 의 결과는 신경 쓰지 않습니다 . 입력이 유효하면 항상 허위입니다. 우리가 정말로 관심을 가지는 것은 이 루프를 빠져 나갈 때 입니다.

i참조 시간 k( t분 단위로 변환 된 입력 시간 )보다 크거나 같은 선호 시간 (분으로 표시)을 찾으면 종료 합니다. 그런 다음 0if i == k또는 2는 그렇지 않으면 지연됩니다.

Befunge-93, 88 85 86 80 74 바이트

&:"d"/58**-:"S"-:"b"6*-:"S"v
@._v#!:<\-*53:-"S":-*6"b":-<
:$#<$$\^@.._\#`0

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

마지막 즐겨 찾기 시간 이후의 분 수와 다음 즐겨 찾기 시간까지의 시간 (분, 공백, 하이픈으로 구분)을 출력합니다. 이미 좋아하는 시간이면 단일 0이 반환됩니다.

C, 121 바이트

*p,l[]={0,83,671,754,1342,1425,1440};f(t){t=t%100+t/100*60;for(p=l;t>*p;++p);*p-t?printf("%d %d",t-p[-1],*p-t):puts("");}

시간이 선호하는 시간 인 경우 개행을 출력합니다.

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

클린 , 126 바이트

import StdEnv
f=[1440,1425,1342,754,671,83,0]
?t#t=t rem 100+t/100*60
=(\(a,b)=(t-hd b,last a-t))(span(\a=t<a||isMember t f)f)

함수 ?를 가져 와서 Int리턴 (Int, Int)합니다.
인수가 자주 사용되는 시간 인 경우 호출 프로그램이와 충돌합니다 hd of [].

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

Pyth, 48 45 42 바이트

&*FJ.u-NY+P*3,83 588 15isMcz2 60,eK._DJ_hK

온라인으로 사용해보십시오. 테스트 스위트.

코드는 시간 문자열을 가져 와서 이전 및 다음 시간을 배열로 출력하거나 0시간이 특수한 경우 출력합니다 .

흥미롭게도 명령 방식은 42 바이트입니다.

V+_isMcz2 60+P*3,83 588 15KZIg0=-ZNIZK)_ZB

설명

• cz2입력 ( z)을 두 문자 조각으로 나눕니다 .
• sM 정수로 평가합니다.
• i… 60결과로 생성 된 두 항목 배열을 기본 60으로 구문 분석합니다.
• ,83 588배열을 나타냅니다 [83, 588].
• *3그것을 세 번 [83, 588, 83, 588, 83, 588].
• P마지막을 제거합니다 588.
• +… 끝에 15추가 15합니다.
• .u-NY구문 분석 된 숫자에서 시작하여 배열의 각 숫자를 빼고 중간 값을 반환합니다. 이것은 각각의 특별한 시간과의 차이점입니다.
• J이러한 차이점을에 할당합니다 J.
• *F차이의 곱을 계산합니다. 시간이 특별하면 0이됩니다.
• & 여기서 평가를 중지하고 시간이 특별하면 0을 반환합니다.
• ._DJ 안정적으로 차이를 부호별로 정렬합니다.
• K해당 배열을에 저장합니다 K.
• e 배열의 마지막 항목을 가져옵니다.
• _hK 배열의 첫 번째 항목을 가져 와서 무시합니다.
• , 둘을 배열로 반환합니다.

젤리 ,  33 32  34 바이트

 +3  +2 바이트로 수정하여 좋아하는 모든 시간 출력이 동일합니다.

^{더 짧은 길이어야 해요!}

s2Ḍḅ60
83,588ṁ5“¡Ð‘j+\ṡ2>E¥ÞÇḢạÇa\

네 자리의 목록을 가져와 두 개의 정수를 포함하는 목록을 반환하는 모나드 링크
-좋아하는 시간이면 결과는 두 항목이 모두 0입니다.

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

어떻게?

s2Ḍḅ60 - helper link, getMinuteOfDay: list of digits, D   e.g. [1,2,3,3]
 2     - literal two                                           2
s      - split into chunks of length                           [[1,2],[3,3]]
  Ḍ    - un-decimal (convert from base 10) (vectorises)        [12,33]
    60 - literal sixty                                         60
   ḅ   - un-base (convert from base)                           753

83,588ṁ5“¡Ð‘j+\ṡ2>E¥ÞÇḢạÇa\ - Link: list of digits        e.g. [1,2,3,3]
83,588                      - literal list of integers         [83,588]
       5                    - literal five                     5
      ṁ                     - mould like (implicit range of) [83,588,83,588,83]
        “¡Ð‘                - code-page index list             [0,15]
            j               - join                           [0,83,588,83,588,83,15]
              \             - cumulative reduce with:
             +              -   addition                     [0,83,671,754,1342,1425,1440]
                2           - literal two                      2
               ṡ            - overlapping slices of length     [[0,83],[83,671],[671,754],[754,1342],[1342,1425],[1425,1440]]
                     Ç      - last link (1) as a monad f(D)    753
                    Þ       - sort by:
                   ¥        -   last two links as a dyad:
                 >          -     greater than? (vectorises)    [0, 0] [ 0,  0] [  0,  1] [  1,   1] [   1,   1] [   1,   1]
                  E         -     equal?                          1       1         0         1           1           1
                            -                             -->  [[671,754],[0,83],[83,671],[754,1342],[1342,1425],[1425,1440]]
                      Ḣ     - head                             [671,754]
                        Ç   - last link (1) as a monad f(D)    753
                       ạ    - absolute difference (vectorises) [ 82,  1]
                          \ - cumulative reduce with:
                         a  -   AND                            [ 82,  1]
                            -   -- such that if "liked" then the [0,x] result becomes [0,0] so they are all equal

껍질 , 36 바이트

?↑2↑0Πṙ_1†aÖ±↔Ġ-::15t*3e588 83B60†d½

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

대화에서 삼항이 작동하는 방식을 설명해 준 Zgarb 에게 감사합니다 . 골프를 치려고 ↑0하지만 어떤 이유로 든 작동하지 못했습니다 (?). 이것은 나의 첫 번째 사소한 허 스크 대답이며, 위에서 언급 한 것을 제쳐두고, 나는 그것에 꽤 만족합니다. 대신에 사용되는 값 YAY!!!은 [](그러나 골프 목적으로 변경되기를 바랍니다).

설명

? ↑ 2 ↑ 0Πṙ_1 † aÖ ± ↔Ġ-:: 15t * 3e588 83B60 † d½ | CLA에서 숫자 목록으로 입력하고 STDOUT에 출력합니다.

                                   ½ | 목록을 두 부분으로 나눕니다.
                                 † d | 각 반을 10 진수로 바꿉니다.
                              B60 | 베이스 60에서 변환합니다.
                : | 위의 내용을 ↓에 추가하십시오 ([15, 83, 588, 83, 588, 83]).
                       588 회 | 두 요소 목록을 작성하십시오 [588, 83].
                     * 3 | 세 번 반복하십시오.
                    t | 첫 번째 요소를 제거하십시오.
                 : 15 | 15를 앞에 붙입니다.
              Ġ- | 오른쪽에서 누적 빼기를 적용합니다.
             ↔ | 역.
           Ö ± | 부호 (-1, 0 또는 1)로 안정적인 정렬.
         † a | 절대 값을 매핑하십시오.
      ṙ_1 | 오른쪽으로 돌리십시오.
? Π | 제품이 진실한 경우 :
 ↑ 2 | 처음 두 요소를 가져옵니다.
   ↑ 0 | 그렇지 않으면 빈 목록을 반환하십시오.

코 틀린 , 293 바이트

{fun i(l:List<Int>)=l.all{it==l[0]}|| l.mapIndexed{a,b->b-a}.all{it==l[0]}
val a=(0..1439+0).map{val h=it/60
val m=it%60
listOf(h/10,h%10,m/10,m%10)}+listOf(listOf(0,0,0,0))
val s=a.indexOf(it)
if(i(it))0 to 0 else
s-a.subList(0,s).indexOfLast{i(it)}to a.subList(s,a.size).indexOfFirst{i(it)}}

미화

{
    fun i(l:List<Int>)=l.all { it ==l[0] } || l.mapIndexed { a, b -> b - a }.all { it ==l[0] }
    val a = (0..1439 + 0).map {
        val h = it/60
        val m = it%60
        listOf(h/10,h%10,m/10,m%10)
    } + listOf(listOf(0,0,0,0))
    val s = a.indexOf(it)
    if (i(it)) 0 to 0 else
        s - a.subList(0, s).indexOfLast {i(it)} to a.subList(s, a.size).indexOfFirst {i(it)}
}

테스트

var t:(i:List<Int>)-> Pair<Int, Int> =
{fun i(l:List<Int>)=l.all{it==l[0]}|| l.mapIndexed{a,b->b-a}.all{it==l[0]}
val a=(0..1439+0).map{val h=it/60
val m=it%60
listOf(h/10,h%10,m/10,m%10)}+listOf(listOf(0,0,0,0))
val s=a.indexOf(it)
if(i(it))0 to 0 else
s-a.subList(0,s).indexOfLast{i(it)}to a.subList(s,a.size).indexOfFirst{i(it)}}

data class Test(val input: List<Int>, val output: Pair<Int, Int>)

val TEST = listOf(
    Test(listOf(0,0,0,0), 0 to 0),
    Test(listOf(0,0,2,0), 20 to 63),
    Test(listOf(0,1,0,5), 65 to 18),
    Test(listOf(0,1,2,2), 82 to 1),
    Test(listOf(0,1,2,3), 0 to 0),
    Test(listOf(0,1,2,4), 1 to 587),
    Test(listOf(0,8,5,2), 449 to 139),
    Test(listOf(1,1,1,1), 0 to 0),
    Test(listOf(1,1,1,3), 2 to 81),
    Test(listOf(1,2,0,0), 49 to 34),
    Test(listOf(1,2,3,4), 0 to 0),
    Test(listOf(1,3,5,7), 83 to 505),
    Test(listOf(1,7,5,9), 325 to 263),
    Test(listOf(1,8,0,0), 326 to 262),
    Test(listOf(1,8,0,1), 327 to 261),
    Test(listOf(2,2,2,2), 0 to 0),
    Test(listOf(2,2,4,4), 22 to 61),
    Test(listOf(2,3,4,5), 0 to 0),
    Test(listOf(2,3,5,1), 6 to 9)
)

fun main(args: Array<String>) {
    for (t in TEST) {
        val v = t(t.input)
        if (v != t.output) {
            throw AssertionError("$t $v")
        }
    }
}

TIO

TryItOnline