Introduzione:

A casa abbiamo un orologio che colpisce la quantità dichiarata ogni ora, ma che suona anche una volta ogni mezz'ora. Quindi, dalle 0:01 alle 12:00 incluse, colpisce in questo ordine:

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

Sfida:

Dato un numero intero n, genera un elenco di intervalli di tempo in cui gli strike totali sono uguali n. Inoltre, inizia sempre almeno 1 minuto prima di questo intervallo di tempo e termina almeno 1 minuto dopo questo intervallo di tempo (e al massimo 29 minuti).
Ad esempio, se l'input è n=8, l'output potrebbe essere:

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

Per cui questi intervalli di tempo hanno le seguenti somme, tutte uguali 8:

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

Regole della sfida:

• L'output è flessibile. È possibile generare come oggetti Time (o Date / DateTime), timestamp, stringhe (con o senza zero iniziale), decimali con .29/ .31/ .59/ .01(cioè 0.29-3.01anziché 00:29-03:01), ecc. Finché è chiaro è prima e dopo l'intervallo di tempo .
  Inoltre, puoi scegliere tu stesso l'importo. In tutti i miei esempi uso 1 minuto, ma puoi anche scegliere 5 minuti, 15 minuti, ecc. Questo significa anche che puoi usare .4/ .6/ .9/ .1( 0.4-3.1invece di 00:24-03:06) per esempio. L'elenco è anche flessibile. Può essere un elenco / raccolta, matrice, stringa separata da delimitatore, stampa per riga su STDOUT, ecc.
  Indicare quale scelta di output è stata effettuata.Nota: non è consentito produrre le somme dei tempi come sopra, questo è menzionato solo come chiarimento. È necessario generare i tempi, anche leggermente prima e dopo.
• Gli scioperi si concludono da 12:00a 00:30. Quindi n=14, se , due dei tempi sono 11:29-00:31e 11:59-01:01.
• L'input sarà compreso nell'intervallo 1 <= n <= 90, dove 90 è la somma totale di tutti i colpi possibili.
• I tempi di restituzione possono essere in qualsiasi ordine.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Le scappatoie predefinite sono vietate.
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi test:

(tutti usando 1 minuto prima / dopo i tempi e gli zero iniziali)

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) , ^{SBCS da} 34 byte

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

Provalo online!

Questa soluzione utilizza ⎕io←1(indicizzazione basata su 1).

Da destra a sinistra:

⍳12 è 1 2 3...12

⍪ lo trasforma in una matrice 12x1 alta e sottile

1, aggiunge una colonna di 1 secondo a sinistra

⍪⍨ concatena verticalmente la stessa matrice, quindi ora è una matrice 24x2

, appiattisce la matrice in ordine di riga maggiore, diventa un vettore di dimensione 48: 1 1 1 2 1 3...1 12 1 1 1 2...1 12

+\ somme parziali: 1 2 3 5 6 9...

∘.-⍨ le differenze tra ogni coppia di elementi, una matrice 48x48

⍉ trasporre

⎕=una matrice booleana 48x48 con 1s ovunque si ⎕verifichi l' input valutato ( )

⍸ le coppie di coordinate di dove sono gli 1

.5× dimezzali

.4 .1∘+¨ aggiungere 0,4 alla prima e 0,1 alla seconda coordinata in ciascuna coppia

12| modulo 12

∪ unico

JavaScript (ES6), 104 byte

Stampa gli intervalli di tempo nel H.MM,H.MMformato.

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)

Provalo online!

Utilizza essenzialmente lo stesso algoritmo della versione non ricorsiva riportata di seguito.

Versione non ricorsiva, 117 byte

Emette una stringa delimitata da spazi di intervalli di tempo in H.MM,H.MMformato.

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

Casi test

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

Commentate

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

Corpo del programma completo. Richiede n. Stampa un elenco di elenchi a due elementi utilizzando le ore decimali.

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

Provalo online!

⍳24 d ndices 1 ... 24

48⍴ ciclicamente r eshape di lunghezza 48, cioè 1 ... 12,1 ... 12

.5× moltiplicare la metà per quello

⊂ racchiudi (per utilizzare l'intero array come argomento giusto per ogni argomento sinistro)

(... ),/¨ per ciascuno dei seguenti, restituisci tutti gli elenchi secondari di quella lunghezza:

 ⍳48 d ndices 1 ... 48

 l← conservare in l(per l engths)

Ora abbiamo tutti i possibili elenchi di periodi di tempo per ogni possibile periodo di tempo.

,/ concatenare (lett. concatenazione-riduzione) gli elenchi dei sotto-elenchi

⊃ divulgare (perché la riduzione ha ridotto il grado da 1 a 0)

(... )¨ applica la seguente funzione a ciascuno:

 ⊢/ l'ultimo elemento (lett. riduzione a destra) (l'ora di fine)

 ⊃, anteporre il primo elemento (l'ora di inizio)

 ¯.1 .1+ aggiungere decimi negativi e positivi a quelli

(... )/ filtra quelle coppie inizio-fine con:

 ⍳12 d ndices 1 ... 12

 1,¨ anteporre a 1a ciascuno

 ∊ ϵ nlist (appiattisci)

 48⍴ ciclicamente r eshape di lunghezza 48, ovvero 1,1,1,2 ... 1,11,1,12

 ⊂ racchiudi (per utilizzare l'intero array come argomento giusto per ogni argomento sinistro)

 l+/¨ per ciascuno di l(1… 48) restituisce le somme di tutti gli elenchi secondari di quella lunghezza

 ∊ ϵ nlist (appiattisci)

⎕= confrontare l'input numerico con quello

∪ restituisce solo gli elementi unici (coppie inizio-fine)

Python 3 , 118 116 byte

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]

Provalo online!

Un intervallo di tempo è rappresentato come (t1, t2), t1ed t2essendo decimali che rappresentano le ore. L'offset è .1o 6 minuti.

Lotto, 196 byte

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

Spiegazione: tè il tempo in mezz'ora, a partire da 0per 00:30. Il numero di colpi al tempo t è allora 1, 1, 1, 2, 1, 3ecc sottrazione 1dà la sequenza 0, 0, 0, 1, 0, 2ecc, che sono gli interi intercalati con zeri. Questo può quindi essere ottenuta con termwise moltiplicazione della sequenza 0, 0, 1, 1, 2, 2ecc, con la sequenza 0, 1, 0,1 , 0, 1etc. Entrambe queste sequenze sono facilmente calcolata utilizzando modulo e divisione (intero).

Resta quindi da ripetere tutti i 23 possibili tempi di avvio, quindi prendendo tutti i 24 tempi di stripping e sottraendo il numero di strike dall'input, stampando i tempi quando il risultato è zero.

Il codice cade dopo il ciclo ma non viene fatto alcun danno poiché l'ingresso non può essere superiore a 90.

APL NARS, 559 byte

∇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) o l (n) restituisce tutti gli intervalli rappresentativi in ​​0-24 ore che non hanno n. h (n) ha il formato dell'orologio come 0..11.0..59; invece l (n) ha il formato dell'orologio come 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