Pengantar:

Di rumah kami memiliki jam yang menyerang jumlah yang dinyatakan pada setiap jam, tetapi juga mogok setiap setengah jam. Jadi dari 0:01 hingga dan termasuk 12:00 itu menyerang dalam urutan ini:

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

Tantangan:

Diberikan bilangan bulat n, mengeluarkan daftar kerangka waktu di mana total teguran sama dengan n. Selain itu, selalu mulai setidaknya 1 menit sebelum kerangka waktu ini dan berakhir setidaknya 1 menit setelah kerangka waktu ini (dan paling banyak 29 menit).
Misalnya, jika inputnya adalah n=8, outputnya bisa:

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

Di mana kerangka waktu ini memiliki jumlah berikut, semuanya sama dengan 8:

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

Aturan tantangan:

• Keluaran fleksibel. Anda dapat menampilkan sebagai Waktu (atau Tanggal / Tanggal Waktu) objek, cap waktu, string (dengan atau tanpa angka nol di depan), desimal dengan .29/ .31/ .59/ .01(yaitu 0.29-3.01alih-alih 00:29-03:01), dll. Selama jelas, sebelum dan sesudah kerangka waktu .
  Selain itu, Anda dapat memilih sendiri jumlahnya. Dalam semua contoh saya, saya menggunakan 1 menit, tetapi Anda juga dapat memilih 5 menit, 15 menit, dll. Ini juga berarti Anda dapat menggunakan .4/ .6/ .9/ .1(mis. 0.4-3.1Alih-alih 00:24-03:06) misalnya. Daftar ini juga fleksibel. Dapat berupa daftar / koleksi, larik, string yang dipisahkan pembatas, mencetak per baris ke STDOUT, dll.
  Sebutkan pilihan output yang Anda buat.Catatan: Anda tidak diizinkan untuk menampilkan jumlah kerangka waktu seperti di atas, ini hanya disebutkan sebagai klarifikasi. Anda harus menampilkan kerangka waktu, termasuk sedikit sebelum dan sesudahnya.
• Serangan itu membungkus dari 12:00ke 00:30. Jadi jika n=14, dua kerangka waktu adalah 11:29-00:31dan 11:59-01:01.
• Input akan berada dalam kisaran 1 <= n <= 90, di mana 90 adalah jumlah total dari semua kemungkinan serangan.
• Kerangka waktu yang Anda kembalikan bisa dalam urutan apa pun.

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa non-codegolf. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa pun'.
• Aturan standar berlaku untuk jawaban Anda, jadi Anda diperbolehkan menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat dan tipe pengembalian, program penuh. Panggilanmu.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda.
• Juga, silakan tambahkan penjelasan jika perlu.

Kasus uji:

(semua menggunakan 1 menit sebelum / sesudah kerangka waktu dan nol terkemuka)

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

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

Cobalah online!

Solusi ini menggunakan ⎕io←1 (pengindeksan berbasis 1).

Dari kanan ke kiri:

⍳12 adalah 1 2 3...12

⍪ mengubahnya menjadi matriks 12x1 tipis tinggi

1, menambahkan kolom 1s ke kiri

⍪⍨ menggabungkan matriks yang sama secara vertikal, jadi sekarang menjadi matriks 24x2

, meratakan matriks dalam urutan baris-utama, itu menjadi vektor ukuran 48: 1 1 1 2 1 3...1 12 1 1 1 2...1 12

+\ jumlah parsial: 1 2 3 5 6 9...

∘.-⍨ perbedaan antara setiap pasangan elemen, sebuah matriks 48x48

⍉ mengubah urutan

⎕=sebuah matriks boolean 48x48 dengan 1s di mana pun input yang dievaluasi ( ⎕) terjadi

⍸ pasang koordinat di mana 1s berada

.5× membagi dua mereka

.4 .1∘+¨ tambahkan 0,4 ke yang pertama dan 0,1 ke koordinat kedua di setiap pasangan

12| modulo 12

∪ unik

JavaScript (ES6), 104 byte

Mencetak interval waktu dalam H.MM,H.MMformat.

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)

Cobalah online!

Pada dasarnya menggunakan algoritma yang sama dengan versi non-rekursif di bawah ini.

Versi non-rekursif, 117 byte

Menghasilkan string interval waktu yang dibatasi ruang dalam H.MM,H.MMformat.

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

Uji kasus

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

Berkomentar

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

Badan program penuh. Anjuran untuk n. Mencetak daftar daftar dua elemen menggunakan jam desimal.

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

Cobalah online!

⍳24 d ndices 1… 24

48⍴ secara siklis r eshape dengan panjang 48, yaitu 1 ... 12,1 ... 12

.5× kalikan setengahnya dengan itu

⊂ menyertakan (untuk menggunakan seluruh array ini sebagai argumen yang tepat untuk setiap argumen kiri)

(... ),/¨ untuk masing-masing berikut ini, kembalikan semua sub-daftar dengan panjang itu:

 ⍳48 d ndices 1… 48

 l← simpan di l(untuk l engths)

Sekarang kita memiliki semua daftar kemungkinan run kali untuk setiap run-length yang mungkin.

,/ concatenate (lit. concatenation-reduction) daftar sub-daftar

⊃ mengungkapkan (karena pengurangan mengurangi peringkat dari 1 menjadi 0)

(... )¨ terapkan fungsi berikut untuk masing-masing:

 ⊢/ elemen (pengurangan kanan) terakhir (waktu akhir)

 ⊃, tambahkan dulu elemen pertama (waktu mulai)

 ¯.1 .1+ tambahkan persepuluhan negatif dan positif bagi mereka

(... )/ filter pasangan awal-akhir dengan:

 ⍳12 d ndices 1… 12

 1,¨ tambahkan satu 1untuk masing-masing

 ∊ ϵ daftar (ratakan)

 48⍴ siklis r eshape dengan panjang 48, yaitu 1,1,1,2 ... 1,11,1,12

 ⊂ menyertakan (untuk menggunakan seluruh array ini sebagai argumen yang tepat untuk setiap argumen kiri)

 l+/¨ untuk masing-masing l(1 ... 48) kembalikan jumlah semua sub-daftar dengan panjang itu

 ∊ ϵ daftar (ratakan)

⎕= bandingkan input numerik dengan itu

∪ kembalikan hanya elemen unik (pasangan mulai-akhir)

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]

Cobalah online!

Kerangka waktu direpresentasikan sebagai (t1, t2), t1dan t2menjadi desimal mewakili jam. Offsetnya adalah .1atau 6 menit.

Batch, 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%

Penjelasan: tadalah waktu dalam setengah jam, mulai dari 0untuk 00:30. Jumlah pemogokan pada waktu t kemudian 1, 1, 1, 2, 1, 3dll Mengurangkan 1memberikan urutan 0, 0, 0, 1, 0, 2dll yang merupakan bilangan bulat disisipkan dengan nol. Ini kemudian dapat diperoleh dengan termwise perkalian dari urutan 0, 0, 1, 1, 2, 2dll dengan urutan 0, 1, 0, 1, 0, 1dll Kedua urutan ini mudah dihitung dengan menggunakan modulo dan (integer) divisi.

Kemudian tetap untuk mengulang semua 23 waktu mulai yang mungkin, kemudian mengambil semua 24 kali menyerang dan mengurangi jumlah serangan dari input, mencetak waktu ketika hasilnya adalah nol.

Kode jatuh setelah loop tetapi tidak ada salahnya dilakukan karena input tidak boleh lebih dari 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) atau l (n) mengembalikan semua interval yang representatif dalam 0-24 jam yang memiliki n jam mogok. h (n) memiliki format jam sebagai 0..11.0..59; sebaliknya l (n) memiliki format jam sebagai uji 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