pengantar

Di sini, di Jerman, peraturan tentang waktu kerja sangat ketat. Jika Anda bekerja 6 jam atau lebih sehari, Anda harus istirahat setidaknya 30 menit. Jika Anda bekerja 9 jam atau lebih, Anda perlu istirahat 45 menit. Jika Anda bekerja kurang dari 6 jam, Anda tidak perlu beristirahat.

Tentu saja Anda dapat membagi waktu istirahat itu, tetapi setiap bagian harus setidaknya 15 menit untuk dihitung.

Tantangan

Dalam tantangan ini, Anda akan mendapatkan daftar periode kerja dan Anda harus memeriksa apakah ada cukup istirahat, menggunakan aturan berikut:

Biarkan wmenjadi waktu kerja dalam jam:

w < 6         -> No breaks needed
6 <= w < 9    -> 30 minute break needed
w >= 9        -> 45 minute break needed

Selain itu, setiap istirahat harus setidaknya 15 menit. Anda juga selalu dapat istirahat lebih dari yang dibutuhkan. Itu semua adalah nilai "setidaknya".

Memasukkan

Masukan Anda akan menjadi daftar periode kerja. Format yang tepat terserah Anda, tetapi hanya memuat nilai waktu sebagai jam dan menit.

Contoh:

Format di sini adalah daftar tuple sementara masing-masing tuple mewakili periode kerja. Elemen pertama dalam sebuah tuple akan menjadi waktu mulai, yang kedua akan menjadi waktu akhir.

[("07:00","12:00"),("12:30","15:30"),("15:45","17:15")]

Ini menghasilkan total waktu kerja 9,5 jam dan total waktu istirahat 45 menit.

Perhatikan bahwa periode-periode kerja itu tidak harus dipisahkan oleh istirahat. Mungkin juga ada periode kerja yang hanya saling mengikuti (contoh lihat kasus uji).

Perhatikan juga bahwa waktu istirahat tidak termasuk dalam waktu kerja. Itu adalah dua nilai yang terpisah.

Anda dapat mengasumsikan bahwa periode kerja dipesan.

Keluaran

Diberikan input ini, output nilai kebenaran jika cukup istirahat dan nilai palsu jika tidak.

Aturan

• Tentukan format input yang Anda gunakan dalam kiriman Anda.
• Anda tidak harus menangani input kosong. Akan selalu ada setidaknya satu periode kerja.
• Periode kerja hanya akan berlangsung satu hari, jadi Anda tidak harus menangani pekerjaan selama tengah malam.
• Tanggal- / Waktu- / Apa Pun- Builtin diizinkan, asalkan bahasa Anda.
• Fungsi atau program lengkap diizinkan.
• Aturan default untuk input / output.
• Celah standar berlaku.
• Ini adalah kode-golf , sehingga byte-count terendah akan menang. Tie-breaker adalah pengiriman sebelumnya.

Uji kasus

Format input yang sama seperti pada contoh di atas.

[("07:00", "12:00"), ("12:30", "15:30"), ("15:45", "17:15")] -> TRUE // 9: 30 jam kerja, istirahat 45 menit -> OK
[("07:20", "07:45"), ("07:59", "11:30"), ("11:55", "15:00")] -> FALSE // 7: 01h bekerja, istirahat 39 menit, tetapi istirahat pertama tidak dihitung karena <15 menit
[("06:00", "09:00"), ("09:00", "11:50")] -> TRUE // Hanya bekerja 5: 50jam, jadi tidak perlu istirahat
[("07:30", "12:00"), ("12:30", "16:00")] -> TRUE // kerja 8 jam, istirahat 30 menit -> OK
[("08:00", "12:30"), ("13:05", "17:45")] -> FALSE // pekerjaan 9: 10jam, hanya 35 menit istirahat daripada yang dibutuhkan 45
[("08:00", "14:00")] -> FALSE // kerja 6 jam, tanpa istirahat, tapi 30 menit diperlukan

Selamat Coding!

Pyth, 56 52 byte

La.*bgsm*ydgyd15cPt_Jmid60Q2@[0030 45)hS,/syRcJ2C\´3

Mengambil input dalam bentuk [[hh,mm], [hh,mm], ...]tanpa 0s terkemuka

Penjelasan:

La.*bgsm*ydgyd15cPt_Jmid60Q2@[0030 45)hS,/syRcJ2C\´3

La.*b                                                - def y(b): return absdiff(*b)

                    Jmid60Q                          - Unpack the input to mins and assign to J
                    J                                - autoassign J = V
                     m    Q                          - [V for d in Q]
                      id60                           - conv_base(V, 60)

      sm*ydgyd15cPt_J      2                         - Get the total break
                   _J                                - reverse(J)
                 Pt                                  - ^[1:-1]
                c          2                         - chop(2, ^)
                                                     -
       m                                             - [V for d in ^]
            yd                                       - y(d)
           g  15                                     - >= 15
         yd                                          - y(d)
        *                                            - y(d) * (y(d)>=15)
                                                     -
      s                                              - sum(^)

                            @[0030 45)hS,/syRcJ2C\´3 - Get the break required
                                             cJ2     - chop(J, 2)
                                           yR        - map(y, ^)
                                          s          - sum(^)
                                                     - Now have the total time worked in mins
                                         /      C\´  - ^/ord("`")
                                                     - (^/180)
                                                     - Now have the time worked in 3 hour intervals
                                      hS,          3 - sorted([^, 3])[0]
                                                     - (min(^, 3))
                                                     - Now have hours worked in 3 hour intervals capped at 9 hours
                            @[0030 45)               - [0,0,30,45][^]
                                                     - Get the break required for that time

     g                                               - break >= break required

Coba di sini

Atau coba semua test case di sini

Javascript, 108 106 byte

m=>(k=t=0,m.map(l=>(a=l[0]*60+l[1],k+=t?a-b<15?0:a-b:0,b=l[2]*60+l[3],t+=b-a)),t/=60,t<6||k>44||t<9&&k>29)

Mengambil array array. Setiap larik dalam memiliki jam awal dan menit dan masing-masing akhir jam dan menit untuk setiap periode.

f=m=>(                           // assign function to f
    k=t=0,                       // k break // t work
    m.map(l=>(                   // for each period
        a=l[0]*60+l[1],          // started time in minutes 
        k+=t?a-b<15?0:a-b:0,     // if there was a break add it
        b=l[2]*60+l[3],          // ended time in minutes
        t+=b-a                   // sum worked time (the difference)
    )),                          //
    t/=60,                       // turn t from minutes to hours
    t<6||k>44||t<9&&k>29         // the main logic
)                                //

document.body.innerHTML = '<pre>' +
  f([[07,00,12,00],[12,30,15,30],[15,45,17,15]]) + '\n' +
  f([[07,20,07,45],[07,59,11,30],[11,55,15,00]]) + '\n' +
  f([[06,00,09,00],[09,00,11,50]]) + '\n' +
  f([[07,30,12,00],[12,30,16,00]]) + '\n' +
  f([[08,00,12,30],[13,05,17,45]]) + '\n' +
  f([[08,00,14,00]]) + '\n' +
'</pre>'

Python 3, 135

Disimpan 3 byte berkat DSM.

Ini adalah salah satu solusi matematis saya dalam beberapa saat.

def f(l):
 h=r=e=0
 for(a,b)in l:a+=a%1*2/3;b+=b%1*2/3;h+=b-a;r-=(e-a)*(e and(a-e)>.24);e=b
 return(h<6)|(6<=h<9and.5<=r)|(h>9and.74<r)

Inilah kasus pengujian saya, ini juga menunjukkan bagaimana saya mengharapkan fungsi dipanggil.

assert f([(07.00, 12.00), (12.30, 15.30), (15.45, 17.15)])
assert not f([(07.20, 07.45), (07.59, 11.30), (11.55, 15.00)])
assert f([(06.00, 09.00), (09.00, 11.50)])
assert f([(07.30, 12.00), (12.30, 16.00)])
assert not f([(08.00, 12.30), (13.05, 17.45)])
assert not f([(08.00, 14.00)])