Вступ:

Вдома у нас є годинник, який вражає заявлену суму щогодини, але також б’є раз на кожні півгодини. Отже, з 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

⍪ перетворює його у високу тонку матрицю 12х1

1, додає стовпчик 1s зліва

⍪⍨ з'єднує ту саму матрицю вертикально, тож тепер вона є матрицею 24x2

, вирівнюється матриця в рядковому порядку, вона стає вектором розміру 48: 1 1 1 2 1 3...1 12 1 1 1 2...1 12

+\ часткові суми: 1 2 3 5 6 9...

∘.-⍨ відмінності між кожною парою елементів, матриця 48x48

⍉ переносити

⎕=булева матриця розміром 48x48 з 1s, де б не відбувся оцінений вхід ( ⎕)

⍸ пари координат, де знаходяться 1s

.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⍴ циклічно r- форму до довжини 48, тобто 1… 12,1… 12

.5× помножте на це половину

⊂ додавати (використовувати весь цей масив як правий аргумент для кожного лівого аргументу)

(… ),/¨ Повертайте всі підсписи такої довжини:

 ⍳48 ɩ ndices 1… 48

 l← зберігати в l (для л англ.)

Тепер у нас є всі можливі списки прогонів разів для кожної можливої ​​довжини пробігу.

,/ конкатенати (літ. concatenation-скорочення) списки під-списків

⊃ розкрити (оскільки скорочення знизило ранг з 1 до 0)

(… )¨ Застосувати наступну функцію до кожного:

 ⊢/ останній (літ. право зменшення) елемент (час закінчення)

 ⊃, додайте перший елемент (час початку)

 ¯.1 .1+ додайте до них негативні та позитивні десяті частини

(… )/ Фільтруйте ці пари початкового кінця за допомогою:

 ⍳12 ɩ ndices 1… 12

 1,¨ додайте а 1до кожного

 ∊ ϵ nlist (згладити)

 48⍴ циклічно r- форму до довжини 48, тобто 1,1,1,2… 1,11,1,12

 ⊂ додавати (використовувати весь цей масив як правий аргумент для кожного лівого аргументу)

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

 ∊ ϵ nlist (згладити)

⎕= порівняйте числовий вхід з цим

∪ повернути лише унікальні елементи (пари початкового кінця)

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