Вступление:

Дома у нас есть часы, которые бьют установленное количество каждый час, но также бьют один раз каждые полчаса. Таким образом, с 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), временные метки, строки (с или без начальных нулей), десятичные дроби с .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 - общая сумма всех возможных ударов.
• Временные рамки, которые вы возвращаете, могут быть в любом порядке.

Основные правила:

• Это код-гольф , поэтому выигрывает самый короткий ответ в байтах.
  Не позволяйте языкам кода-гольфа отговаривать вас от публикации ответов на языках, не относящихся к кодексу. Попробуйте найти как можно более короткий ответ для «любого» языка программирования.
• К вашему ответу применяются стандартные правила , поэтому вы можете использовать STDIN / STDOUT, функции / метод с правильными параметрами и типом возврата, полные программы. Ваш звонок.
• По умолчанию лазейки запрещены.
• Если возможно, добавьте ссылку с тестом для вашего кода.
• Также, пожалуйста, добавьте объяснение, если это необходимо.

Тестовые случаи:

(все используют 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

⍉ транспонирования

⎕=логическая матрица 48x48 с 1 с, где бы ни происходил оцененный input ( ⎕)

⍸ пары координат, где 1

.5× разделить их пополам

.4 .1∘+¨ добавить 0,4 к первой и 0,1 ко второй координате в каждой паре

12| по модулю 12

∪ уникальный

JavaScript (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 ɩ ndices 1 ... 24

48⍴ циклический г eshape длиной 48, то есть 1 ... 12 ... 12,1

.5× умножить половину на это

⊂ enclose (чтобы использовать весь этот массив в качестве правого аргумента для каждого левого аргумента)

(… ),/¨ Для каждого из перечисленных ниже вернуть все подсписки этой длины:

 ⍳48 ɩ ndices 1 ... 48

 l← хранить в l(для л engths)

Теперь у нас есть все возможные списки периодов времени для каждой возможной длины цикла.

,/ объединить (букв. сокращение-объединение) списки подсписков

⊃ раскрыть (потому что снижение понизило рейтинг с 1 до 0)

(… )¨ Применить следующую функцию к каждому:

 ⊢/ последний (горит справа-сокращение) элемент (время окончания)

 ⊃, предварять первый элемент (время начала)

 ¯.1 .1+ добавить отрицательные и положительные десятые к тем

(… )/ Отфильтруйте эти пары начала и конца с помощью:

 ⍳12 ɩ ndices 1 ... 12

 1,¨ добавить 1к каждому

 ∊ ε NLIST (Flatten)

 48⍴ циклический г eshape длиной 48, т.е. 1,1,1,2 ... 1,11,1,12

 ⊂ enclose (чтобы использовать весь этот массив в качестве правого аргумента для каждого левого аргумента)

 l+/¨ для каждого из l(1… 48) вернуть суммы всех подсписков этой длины

 ∊ ε NLIST (Flatten)

⎕= сравнить числовой ввод с этим

∪ вернуть только уникальные элементы (пары начало-конец)

Python 3 , 118 116 байт

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будучи десятичной , представляющие часы. Смещение составляет .1или 6 минут.

Пакет, 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это время , в течение полутора часов, начиная с 0для 00:30. Количество ударов в момент времени т тогда 1, 1, 1, 2, 1, и 3т.д. Вычитание 1дает последовательность 0, 0, 0, 1, 0, и 2т.д. , которые целые числа чередоваться с нулями. Это может затем быть получено путем умножением почленного последовательности 0, 0, 1, 1, 2, и 2т.д. с последовательностью 0, 1, 0, 1, 0, и 1т.д. Оба из этих последовательностей могут быть легко рассчитаны с использованием по модулю и (целое число) деления.

Затем остается зациклить все 23 возможных времени запуска, затем взять все 24 времени удара и вычесть количество ударов из входных данных, напечатав время, когда результат равен нулю.

Код проваливается после цикла, но никакого вреда не причиняется, так как ввод не может быть больше 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) возвращает все репрезентативные интервалы в 0-24 часа, которые имеют n тактов. 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