Wprowadzenie:

W domu mamy zegar, który wybija określoną wartość o każdej godzinie, ale także wybija raz na pół godziny. Tak więc od 0:01 do 12:00 włącznie uderza w następującej kolejności:

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

Wyzwanie:

Podając liczbę całkowitą n, wypisz listę przedziałów czasowych, w których suma ostrzeżeń jest równa n. Ponadto zawsze zaczynaj co najmniej 1 minutę przed tym przedziałem czasowym i zakończ co najmniej 1 minutę po tym przedziale czasowym (i co najwyżej 29 minut).
Na przykład, jeśli dane wejściowe to n=8, dane wyjściowe mogą być:

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

Dla których przedziały czasowe mają następujące sumy, wszystkie równe 8:

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

Zasady konkursu:

• Wyjście jest elastyczne. Możesz wyprowadzać jako obiekty Time (lub Date / DateTime), znaczniki czasu, ciągi znaków (z zerami wiodącymi lub bez nich), miejsca dziesiętne z .29/ .31/ .59/ .01(tj. 0.29-3.01Zamiast 00:29-03:01) itd. O ile jest to jasne, przed i po terminie .
  Ponadto możesz sam wybrać kwotę. We wszystkich moich przykładach używam 1 minuty, ale możesz również wybrać 5 minut, 15 minut itp. Oznacza to również, że możesz na przykład użyć .4/ .6/ .9/ .1(tj. 0.4-3.1Zamiast 00:24-03:06). Lista jest również elastyczna. Może to być lista / kolekcja, tablica, ciąg rozdzielany separatorem, drukowanie w wierszu do STDOUT itp.
  Proszę podać, jaki wybór wyjściowy dokonałeś.Uwaga: Nie wolno wyprowadzać sum przedziałów czasowych jak wyżej, jest to tylko wspomniane jako wyjaśnienie. Musisz przedstawić ramy czasowe, w tym nieco przed i po nim.
• Strajki owijają się od 12:00do 00:30. Więc jeśli n=14dwa przedziały czasowe to 11:29-00:31i 11:59-01:01.
• Dane wejściowe będą w zakresie 1 <= n <= 90, w którym 90 jest sumą wszystkich możliwych uderzeń.
• Zwracane ramy czasowe mogą być w dowolnej kolejności.

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Obowiązują standardowe zasadyDo odpowiedzi , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i zwracanymi typami, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem swojego kodu.
• W razie potrzeby dodaj również wyjaśnienie.

Przypadki testowe:

(wszystkie używają 1 minuty przed / po przedziałach czasowych i zerach wiodących)

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 bajty ^SBCS

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

Wypróbuj online!

To rozwiązanie wykorzystuje ⎕io←1 (indeksowanie 1).

Z prawej do lewej:

⍳12 jest 1 2 3...12

⍪ zamienia go w wysoką cienką matrycę 12x1

1, dodaje kolumnę 1s po lewej stronie

⍪⍨ konkatenuje tę samą matrycę w pionie, więc teraz jest to macierz 24x2

, spłaszcza macierz w kolejności rzędów głównych, staje się wektorem o rozmiarze 48: 1 1 1 2 1 3...1 12 1 1 1 2...1 12

+\ sumy częściowe: 1 2 3 5 6 9...

∘.-⍨ różnice między każdą parą elementów, matrycą 48x48

⍉ transponować

⎕=macierz boolowska 48x48 z 1s wszędzie tam, gdzie występuje oszacowane wejście ( ⎕)

⍸ pary współrzędnych, gdzie są jedynki

.5× połowę ich

.4 .1∘+¨ dodaj 0,4 do pierwszej i 0,1 do drugiej współrzędnej w każdej parze

12| moduł 12

∪ wyjątkowy

JavaScript (ES6), 104 bajty

Drukuje przedziały czasowe w H.MM,H.MMformacie.

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)

Wypróbuj online!

Używa zasadniczo tego samego algorytmu, co wersja nierekurencyjna poniżej.

Wersja nierekurencyjna, 117 bajtów

Wysyła rozdzielany spacjami ciąg przedziałów czasowych w H.MM,H.MMformacie.

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

Przypadki testowe

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

Skomentował

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 bajtów ^SBCS

Pełna treść programu. Monity o n. Drukuje listę dwuelementowych list w godzinach dziesiętnych.

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

Wypróbuj online!

⍳24 d ndices 1… 24

48⍴ cyklicznie r eshape do długości 48, czyli 1 ... 12,1 ... 12

.5× pomnóż przez to połowę

⊂ załącz (aby użyć tej całej tablicy jako prawego argumentu dla każdego lewego argumentu)

(… ),/¨ Dla każdego z poniższych zwraca wszystkie podlisty o tej długości:

 ⍳48 d ndices 1… 48

 l← Przechowywać w l(na l engths)

Teraz mamy wszystkie możliwe listy przebiegów dla każdej możliwej długości przebiegu.

,/ konkatenacja (dosł. redukcja konkatenacji) list podlist

⊃ ujawnij (ponieważ redukcja zmniejszyła rangę z 1 do 0)

(… )¨ Zastosuj następującą funkcję do każdego:

 ⊢/ ostatni (podświetlony prawy element redukujący) (czas zakończenia)

 ⊃, dodaj pierwszy element (czas rozpoczęcia)

 ¯.1 .1+ dodaj do nich dziesiętne ujemne i dodatnie

(… )/ Filtruj te pary początkowe za pomocą:

 ⍳12 d ndices 1… 12

 1,¨ dodawaj 1do każdego

 ∊ ε nlist (spłaszczyć)

 48⍴ cyklicznie r eshape do długości 48, tj 1,1,1,2 ... 1,11,1,12

 ⊂ załącz (aby użyć tej całej tablicy jako prawego argumentu dla każdego lewego argumentu)

 l+/¨ dla każdego z l(1… 48) zwraca sumy wszystkich podlist o tej długości

 ∊ ϵ nlist (spłaszczyć)

⎕= porównaj z tym wejście numeryczne

∪ zwracaj tylko unikalne elementy (pary początkowe)

Python 3 , 118 116 bajtów

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]

Wypróbuj online!

Czasowych są reprezentowane (t1, t2), t1i t2będąc dziesiętne reprezentujące godzin. Przesunięcie wynosi.1 lub 6 minut.

Partia, 196 bajtów

@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%

Objaśnienie: tto czas w pół godziny, zaczynający się 0od 00:30. Liczba uderzeń w czasie t jest wówczas 1, 1, 1, 2, 1, 3itp Odejmując 1daje sekwencję 0, 0, 0, 1, 0, 2itd który jest całkowite przeplatane zerami. Można wówczas uzyskać poprzez termwise pomnożenia sekwencji 0, 0, 1, 1, 2, 2itp z sekwencją 0, 1, 0, 1, 0,1 itd. Obie te sekwencje mogą być łatwo obliczone za pomocą modulo i (całkowita) podziału.

Następnie pozostaje zapętlić wszystkie 23 możliwe czasy rozpoczęcia, a następnie wziąć wszystkie 24 czasy uderzenia i odjąć liczbę uderzeń od danych wejściowych, drukując czasy, kiedy wynik jest zerowy.

Kod przechodzi przez pętlę, ale nie wyrządza żadnej szkody, ponieważ wartość wejściowa nie może być większa niż 90.

APL NARS, 559 bajtów

∇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) lub l (n) zwraca wszystkie reprezentatywne interwały w ciągu 0–24 godzin z n uderzeniami zegara. h (n) ma format zegara jako 0..11.0..59; zamiast tego l (n) ma format zegara jako test 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