소개:

집에 우리는 매 시간마다 명시된 양을 때리지만 30 분마다 한 번씩 때리는 시계를 가지고 있습니다. 따라서 0:01부터 12:00까지는 다음 순서로 발생합니다.

1, 1, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1, 12

도전:

정수가 주어지면 n총 스트라이크가 같은 시간 프레임 목록을 출력하십시오 n. 또한 항상이 시간 프레임보다 1 분 이상 시작하고이 시간 프레임 후 1 분 이상 (최대 29 분)에 종료하십시오.
예를 들어 입력이 n=8인 경우 출력은 다음과 같습니다.

[00:59-03:01, 01:29-03:31, 02:59-04:01, 05:29-06:31, 06:29-07:01, 06:59-07:31, 07:59-08:01]

이 시간 프레임의 합계는 다음과 같습니다 8.

[1+1+2+1+3, 1+2+1+3+1, 3+1+4, 1+6+1, 1+7, 7+1, 8]

도전 규칙 :

• 출력이 유연합니다. Time (또는 Date / DateTime) 객체, 타임 스탬프, 문자열 ( 앞에 0이 있거나없는), .29/ .31/ .59/가있는 소수 .01(예 : 0.29-3.01대신 00:29-03:01) 등으로 출력 할 수 있습니다. 시간 프레임 전후에 분명한 한 .
  또한 금액을 직접 선택할 수 있습니다. 내 모든 예제에서 1 분을 사용하지만 5 분, 15 분 등을 선택할 수도 있습니다. 이는 예를 들어 .4/ .6/ .9/ .1(예 : 0.4-3.1대신 00:24-03:06)를 사용할 수 있음을 의미합니다 . 목록도 유연합니다. 목록 / 컬렉션, 배열, 구분 기호로 구분 된 문자열, 줄당 STDOUT으로 인쇄 등이
  될 수 있습니다. 어떤 출력을 선택했는지 지정하십시오.참고 : 위와 같이 시간 범위의 합계를 출력 할 수 없으며 이는 설명으로 만 언급됩니다. 시간 프레임을 약간 앞뒤로 포함하여 출력해야합니다.
• 파업은 랩 어라운드 않습니다 12:00에 00:30. 따라서 n=14, 두 개의 시간 프레임은 11:29-00:31및 11:59-01:01입니다.
• 입력 범위는 1 <= n <= 90이며, 여기서 가능한 모든 스트라이크의 총합은 90입니다.
• 돌아 오는 기간은 어떤 순서로든 가능합니다.

일반 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하지 마십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 적용됩니다 답변에 되므로 STDIN / STDOUT, 적절한 매개 변수 및 리턴 유형의 전체 프로그램과 함께 함수 / 방법을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트 링크를 추가하십시오.
• 또한 필요한 경우 설명을 추가하십시오.

테스트 사례 :

(시간과 선행 0을 전후로 1 분 사용)

Input: 8
Ouput:
[00:59-03:01, 01:29-03:31, 02:59-04:01, 05:29-06:31, 06:29-07:01, 06:59-07:31, 07:59-08:01]

Input: 14
Output:
[00:29-04:01, 00:59-04:31, 02:59-05:01, 04:29-06:31, 05:59-07:01, 11:29-00:31, 11:59-01:01]

Input: 90
Output:
[00:29-00:01, 00:59-00:31, 01:29-01:01, 01:59-01:31, 02:29-02:01, 02:59-02:31, 03:29-03:01, 03:59-03:31, 04:29-04:01, 04:59-04:31, 05:29-05:01, 05:59-05:31, 06:29-06:01, 06:59-06:31, 07:29-07:01, 07:59-07:31, 08:29-08:01, 08:59-08:31, 09:29-09:01, 09:59-09:31, 10:29-10:01, 10:59-10:31, 11:29-11:01, 11:59-11:31]

Input: 1
Output:
[00:29-00:31, 00:59-01:01, 01:29-01:31, 02:29-02:31, 03:29-03:31, 04:29-04:31, 05:29-05:31, 06:29-06:31, 07:29-07:31, 08:29-08:31, 09:29-09:31, 10:29-10:31, 11:29-11:31]

Input: 2
Output:
[00:29-01:01, 00:59-01:31, 01:59-02:01]

APL (Dyalog Classic) , 34 바이트 ^SBCS

∪12|.4 .1∘+¨.5×⍸⎕=⍉∘.-⍨+\,⍪⍨1,⍪⍳12

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

이 솔루션은 ⎕io←1(1 기반 인덱싱)을 사용합니다.

오른쪽에서 왼쪽으로 :

⍳12 이다 1 2 3...12

⍪ 키가 얇은 12x1 매트릭스로 변환

1, 왼쪽에 1의 열을 추가합니다

⍪⍨ 동일한 행렬을 세로로 연결하므로 이제 24x2 행렬입니다.

, 행렬을 행 주요 순서로 병합하면 크기가 48 인 벡터가됩니다. 1 1 1 2 1 3...1 12 1 1 1 2...1 12

+\ 부분 합계 : 1 2 3 5 6 9...

∘.-⍨ 각 요소 쌍의 차이, 48x48 행렬

⍉ 바꾸어 놓다

⎕= 평가 된 입력 (1)이있는 48x48 부울 행렬⎕ )이 발생할

⍸ 1이있는 좌표 쌍

.5× 반으로

.4 .1∘+¨ 각 쌍의 첫 번째 좌표에 0.4를 추가하고 두 번째 좌표에 0.1을 더합니다

12| 모듈로 12

∪ 독특한

자바 스크립트 (ES6), 104 바이트

시간 간격을 H.MM,H.MM형식으로 인쇄 합니다.

F=(n,f=0,s=n,t=f++)=>t<f+23?F(n,f,s-=t&1||t/2%12+1,++t,s||alert([f/2%12+.01,-~t/2%12+.01])):f<24&&F(n,f)

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

아래 비 재귀 버전과 기본적으로 동일한 알고리즘을 사용합니다.

비 재귀 버전, 117 바이트

공백으로 구분 된 시간 간격 문자열을 H.MM,H.MM형식으로 출력 합니다.

n=>[...Array(24)].map((_,f,a)=>a.map(_=>(s-=t++&1||t/2%12+.5)||(r+=[-~f/2%12+.01,-~t/2%12+.01]+' '),s=n,t=f),r='')&&r

테스트 사례

let f =

n=>[...Array(24)].map((_,f,a)=>a.map(_=>(s-=t++&1||t/2%12+.5)||(r+=[-~f/2%12+.01,-~t/2%12+.01]+' '),s=n,t=f),r='')&&r

console.log(f(8))
console.log(f(14))
console.log(f(90))
console.log(f(1))
console.log(f(2))

댓글

n =>                           // n = input
  [...Array(24)].map((_, f, a) // FOR f = 0 TO 23:
    => a.map(_ =>              //   FOR t = f TO f + 23:
      (                        //     update s
        s -=                   //       by subtracting:
          t++ & 1 ||           //         - 1 if t is odd (half hour)
          t / 2 % 12 + .5      //         - the current hour if t is even
      ) || (                   //     if s is equal to zero:
        r += [                 //       update the result string by appending:
          -~f / 2 % 12 + .01   //         - the formatted 'from' time
          ,                    //         - a comma
          -~t / 2 % 12 + .01   //         - the formatted 'to' time
        ] + ' '                //       and a padding space
      ),                       //     inner map() initialization:
      s = n,                   //     - s = target number of strikes
      t = f                    //     - 'to' time = 'from' time
    ),                         //   end of inner map()
    r = ''                     //   start with r = empty string
  )                            // end of outer map()
  && r                         // return r

APL (Dyalog Unicode) , 62 59 바이트 ^SBCS

전체 프로그램 본문. 에 대한 프롬프트가 표시됩니다 n. 십진 시간을 사용하여 두 요소 목록의 목록을 인쇄합니다.

∪(⎕=∊l+/¨⊂48⍴∊1,¨⍳12)/(¯.1 .1+⊃,⊢/)¨⊃,/(l←⍳48),/¨⊂.5×48⍴⍳24

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

⍳24 ndi 1 ~ 24 개

48⍴ 주기적 r에 길이 (48), 즉 1 ... 12,1 ... 12을 eshape

.5× 반을 곱하면

⊂ 묶음 (왼쪽 인수마다이 전체 배열을 오른쪽 인수로 사용)

(… ),/¨ 다음 각각에 대해 해당 길이의 모든 하위 목록을 반환하십시오.

 ⍳48 ndi 1 ~ 48 개

 l← 매장에서 l(용 패 engths)

이제 우리는 가능한 각 실행 길이에 대해 가능한 모든 실행 목록을 가지고 있습니다.

,/ 하위 목록의 목록을 연결 (lit. concatenation-reduction)

⊃ 공개 (감소로 인해 순위가 1에서 0으로 감소했기 때문에)

(… )¨ 각각에 다음 기능을 적용하십시오.

 ⊢/ 마지막 (lit. right-reduction) 요소 (종료 시간)

 ⊃, 첫 번째 요소 앞에 추가 (시작 시간)

 ¯.1 .1+ 그들에게 부정과 긍정적 십분의 일을 더하다

(… )/ 다음과 같이 시작-끝 쌍을 필터링하십시오.

 ⍳12 ndi 1 ~ 12 개

 1,¨1각각에  a 를 붙이다

 ∊ ε NLIST (편평한)

 48⍴ 주기적으로 r에 , 즉 1,1,1,2 길이 48 eshape을 ... 1,11,1,12

 ⊂ 묶음 (왼쪽 인수마다이 전체 배열을 오른쪽 인수로 사용)

 l+/¨l(1… 48)  각각에 대해 해당 길이의 모든 하위 목록의 합계를 반환합니다.

 ∊ ε NLIST (편평한)

⎕= 숫자 입력과 비교

∪ 고유 한 요소 만 반환 (시작-끝 쌍)

파이썬 3 , 118116 바이트

lambda n:[(a/2+.4,b%24/2+.1)for a in range(24)for b in range(48)if sum((sum(zip([1]*12,range(1,13)),())*2)[a:b])==n]

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

시간 프레임은 다음과 같이 표현되고 (t1, t2), t1그리고 t2시간을 표현되는 소수. 오프셋은 .16 분입니다.

배치, 196 바이트

@for /l %%i in (0,1,23)do @set s=%1&for /l %%j in (0,1,23)do @call:c %%i %%j
:c
@set/at=%2+%1,s-=t%%2*(t/2%%12)+1,h=%1/2,i=%1%%2*30+15,t=-~t%%24/2,u=-~t%%2*30+15
@if %s%==0 echo %h%:%i% %t%:%u%

설명 : t에서 시작하여 30 분의 시간 0입니다 00:30. 시간 t에서의 공격의 수는이고 1, 1, 1, 2, 1, 3등 감산 1순차 범 0, 0, 0, 1, 0, 2제로 인터리빙 정수 등등. 이것은 다음의 시퀀스 termwise 곱함으로써 얻어 질 수있다 0, 0, 1, 1, 2, 2시퀀스 등으로 0, 1, 0,1 , 0, 1등이 서열은 모두 쉽게 모듈러스 (정수) 분할을 이용하여 계산된다.

그런 다음 23 개의 가능한 시작 시간을 모두 반복 한 다음 24 개의 타격 시간을 모두 취하고 입력에서 스트라이크 수를 빼고 결과가 0 일 때 시간을 인쇄합니다.

루프 후 코드가 통과하지만 입력이 90보다 클 수 없으므로 아무런 해가 없습니다.

APL NARS, 559 바이트

∇r←l w;t;i;j;c;k;m;p
p←{0=2∣¯1+⍵:.01+2÷⍨¯1+⍵⋄¯0.19+2÷⍨¯1+⍵}
m←{0=2∣¯1+⍵:¯.41+2÷⍨¯1+⍵⋄¯0.21+2÷⍨¯1+⍵}
   r←⍬⋄i←0⋄t←∊(¯1+⍳13),¨13⍴1⋄t←t,2↓t⋄k←⍴t
A: j←i+←1⋄→0×⍳i≥k⋄c←0
B: c+←j⊃t⋄:if(c=w)∧(0≤(m i))∧(24≥(p j))⋄r←r,⊂(m i),(p j)⋄:endif⋄→A×⍳c≥w⋄j+←1⋄→B×⍳j≤k⋄→A
∇
∇r←g w;v;i;k;m
   v←{12≤⌊⍵:⍵-12⋄⍵}
   i←1⋄k←⍴w⋄r←⍬
A: →0×⍳i>k⋄r←r,⊂v¨i⊃w⋄i+←1⋄→A
∇   
h←g∘l

h (n) 또는 l (n)은 n 개의 클럭 스트라이크가있는 모든 대표 간격을 0-24 시간으로 반환합니다. h (n)은 클럭 형식이 0..11.0..59이며; 대신 l (n)은 0..23.0..59 테스트와 같은 클럭 형식을 갖습니다.

  h 8
    0.59 3.01  1.29 3.31  2.59 4.01  5.29 6.31  6.29 7.01  6.59 7.31  
    7.59 8.01  0.59 3.01  1.29 3.31  2.59 4.01  5.29 6.31  6.29 7.01  
    6.59 7.31  7.59 8.01 
  h 14
    0.29 4.01  0.59 4.31  2.59 5.01  4.29 6.31  5.59 7.01  11.29 0.31  
    11.59 1.01  0.29 4.01  0.59 4.31  2.59 5.01 4.29 6.31  5.59 7.01 
  h 90
    0.29 0.01  0.59 0.31  1.29 1.01  1.59 1.31  2.29 2.01  2.59 2.31  
    3.29 3.01  3.59 3.31  4.29 4.01  4.59 4.31  5.29 5.01  5.59 5.31  
    6.29 6.01  6.59 6.31  7.29 7.01  7.59 7.31  8.29 8.01  8.59 8.31  
    9.29 9.01  9.59 9.31  10.29 10.01  10.59 10.31  11.29 11.01  11.59 11.31    
  h 1
    0.29 0.31  0.59 1.01  1.29 1.31  2.29 2.31  3.29 3.31  4.29 4.31  
    5.29 5.31  6.29 6.31  7.29 7.31  8.29 8.31  9.29 9.31  10.29 10.31  
    11.29 11.31  0.29 0.31  0.59 1.01  1.29 1.31  2.29 2.31  3.29 3.31  
    4.29 4.31  5.29 5.31  6.29 6.31  7.29 7.31  8.29 8.31  9.29 9.31  
    10.29 10.31  11.29 11.31 
  h 2
    0.29 1.01  0.59 1.31  1.59 2.01  0.29 1.01  0.59 1.31  1.59 2.01 
  l 2
    0.29 1.01  0.59 1.31  1.59 2.01  12.29 13.01  12.59 13.31  13.59 14.01