Вступление

Здесь, в Германии, правила рабочего времени очень строгие. Если вы работаете 6 или более часов в день, вы должны сделать перерыв не менее 30 минут. Если вы работаете 9 или более часов, вам нужно сделать 45-минутный перерыв. Если вы работаете менее 6 часов, вам не нужно делать перерывы.

Конечно, вы можете разделить эти перерывы, но каждая часть должна быть не менее 15 минут, чтобы быть посчитанным.

Соревнование

В этом задании вы получите список периодов работы и вам необходимо проверить, достаточно ли было сделано перерывов, используя следующие правила:

Позвольте wбыть время работы в часах:

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

Кроме того, каждый перерыв должен быть не менее 15 минут. Также вы всегда можете сделать больше перерывов, чем нужно. Это все «как минимум» значения.

вход

Ваш вклад будет список рабочих периодов. Точный формат зависит от вас, но он должен содержать только значения времени в виде часов и минут.

Пример:

Формат здесь представляет собой список кортежей, в то время как каждый кортеж представляет рабочий период. Первый элемент в кортеже будет временем начала, второй - временем окончания.

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

В результате общее рабочее время составляет 9,5 часов, а общее время перерыва - 45 минут.

Обратите внимание, что эти рабочие периоды не должны быть разделены перерывами. Также могут быть рабочие периоды, которые просто следуют друг за другом (пример см. Контрольные примеры).

Также обратите внимание, что перерывы не учитываются в рабочее время. Это две разные ценности.

Вы можете предположить, что рабочие периоды заказаны.

Выход

Учитывая этот входной сигнал, выведите истинное значение, если было сделано достаточно перерывов и неточности значение, если нет.

правила

Укажите формат ввода, который вы используете в своем представлении.
Вам не нужно обрабатывать пустой ввод. Всегда будет хотя бы один рабочий период.
Рабочие периоды будут охватывать только один день, поэтому вам не придется выполнять работу в полночь.
Разрешено использование даты / времени / безотносительно встроенных функций, если это предусмотрено вашим языком.
Функция или полная программа разрешены.
Правила по умолчанию по для ввода / вывода.
Применяются стандартные лазейки .
Это код-гольф , поэтому выигрывает меньшее количество байт. Тай-брейк является более ранней подачей.

Контрольные примеры

Тот же формат ввода, что и в примере выше.

[("07:00", "12:00"), ("12:30", "15:30"), ("15:45", "17:15")] -> TRUE // 9: 30 часов работы, 45 минут перерыва -> ОК
[("07:20", "07:45"), ("07:59", "11:30"), ("11:55", "15:00")] -> FALSE // 7: 01 час работы, 39 минут перерыва, но первый перерыв не считается, потому что <15 минут
[("06:00", "09:00"), ("09:00", "11:50")] -> TRUE // Работает только 5:50, поэтому перерыв не требуется
[("07:30", "12:00"), ("12:30", "16:00")] -> TRUE // 8-часовая работа, 30-минутный перерыв -> OK
[("08:00", "12:30"), ("13:05", "17:45")] -> FALSE // 9: 10 часов работы, только 35 минут перерыва вместо необходимых 45
[("08:00", "14:00")] -> FALSE // 6 часов работы, без перерывов, но нужно 30 минут

Удачного кодирования!

code-golf array-manipulation date

— Denker
источник

1

Pyth, 56 52 байта

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

Принимает входные данные в форме [[hh,mm], [hh,mm], ...]без начальных 0секунд

Объяснение:

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

Попробуй здесь

Или попробуйте все контрольные примеры здесь

— синий
источник

5

Javascript, 108 106 байт

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)

Принимает массив массивов. Каждый внутренний массив имеет начальный час и минуту и конечный час и минуту соответственно для каждого периода.

Показать фрагмент кода

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

Развернуть фрагмент

— удален
источник

3

Питон 3, 135

Сохранено 3 байта благодаря DSM.

Это одно из моих математических решений за последнее время.

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)

Вот мои тесты, они также показывают, как я ожидаю, что функция будет вызвана.

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

— Морган Трепп
источник

Проверьте периоды работы