Cocokkan Jam yang Menyerang

14

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 , 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]
Kevin Cruijssen
sumber
1
Saya akan pergi untuk apa pun yang paling fleksibel. Ini termasuk angka jam desimal, selama angka hasil jatuh di antara dua kali dering.
Adám
@ Adám Kira Anda benar. Saya telah mengedit jawaban saya sesuai dengan itu. Anda harus memiliki setidaknya 1 menit dan paling banyak 29 menit, sehingga .4/ .6/ .9/ .1diizinkan (menjadi 6 menit seperti yang Anda nyatakan: :24/ :36/ :54/ :06).
Kevin Cruijssen
1
Mungkin menyebutkan bahwa pasangan waktu dapat dikembalikan dalam urutan apa pun?
Adm
Ok n adalah dalam 0,90, saya tidak menemukan jelas berapa periode waktu untuk menghitung pemogokan n: Sudah 12 jam? Mereka 24 jam? Apakah 48 jam? Daripada diizinkan mengembalikan waktu dalam format 0..24: 0..60?
RosLuP
@RosLuP Kerangka waktu adalah jam analog biasa, jadi dari 00:01 hingga 12:00. Jadi alih-alih 0..24: 0..60, seharusnya 0..12: 0..60. Bagaimana itu bisa menghilangkan kebingungan.
Kevin Cruijssen

Jawaban:

3

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

ngn
sumber
Apa interval waktu yang diwakili oleh .1dalam output? Juga, jawaban yang bagus.
Erik the Outgolfer
2
Oh, dan inilah yang memungkinkan ini menjadi 34 byte, mungkin ingin menautkannya atau menulis <sup>SBCS</sup>seperti jawaban Adám.
Erik the Outgolfer
@EriktheOutgolfer masalah secara eksplisit memungkinkan .1 / .4 / .6 / .9 bukannya: 01 /: 29 /: 31 /: 59. Saya tidak perlu pengkodean khusus untuk jawaban ini, itu dalam Dyalog Classic yang memiliki pengodean byte tunggal.
ngn
tidak ada dalam Dyalog Classic. Dan ya, saya tahu itu diizinkan secara eksplisit, saya hanya ingin tahu berapa menit 0.1dalam output;)
Erik the Outgolfer
@EriktheOutgolfer "SBCS" menambahkan, terima kasih; .1 × 60 menit adalah 6 menit
ngn
5

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

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
Arnauld
sumber
4

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!

⍳24d 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:

⍳48d 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:

⍳12d 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)

Adm
sumber
0.1 0.5dapat menjadi.1 .5
Kritixi Lithos
@ Cowsquack Ya, saya perhatikan juga. Terimakasih Meskipun.
Adám
3

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.

ovs
sumber
1

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.

Neil
sumber
1

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 
RosLuP
sumber