कार्य अवधि की जाँच करें

Question

परिचय

यहां जर्मनी में काम के समय पर शासन बहुत सख्त है। यदि आप दिन में 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 मिनट है।

ध्यान दें कि उन कार्य अवधियों को विराम द्वारा अलग नहीं किया जाना है। ऐसे कार्य अवधि भी हो सकते हैं जो सिर्फ एक-दूसरे का अनुसरण करते हैं (उदाहरण देखें परीक्षण मामले)।

यह भी ध्यान दें कि ब्रेक काम के समय में नहीं गिना जाता है। वे दो अलग मूल्य हैं।

आप मान सकते हैं कि कार्य अवधि का आदेश दिया गया है।

उत्पादन

इस इनपुट, आउटपुट एक को देखते हुए truthy मूल्य यदि पर्याप्त टूटता ले जाया गया है और एक falsy मूल्य नहीं तो।

नियम

• आपके द्वारा सबमिट किए जा रहे इनपुट प्रारूप को निर्दिष्ट करें।
• आपको खाली इनपुट को संभालने की आवश्यकता नहीं है। हमेशा कम से कम एक कार्य अवधि होगी।
• काम की अवधि केवल एक दिन होगी, इसलिए आपको आधी रात को काम संभालने की जरूरत नहीं है।
• दिनांक- / समय- / जो भी-जब तक आपकी भाषा के साथ आता है, तब तक निर्मित अनुमति।
• कार्य या पूर्ण कार्यक्रम की अनुमति है।
• इनपुट / आउटपुट के लिए डिफ़ॉल्ट नियम ।
• मानक खामियां लागू होती हैं।
• यह कोड-गोल्फ है , इसलिए सबसे कम बाइट-काउंट जीतता है। टाई-ब्रेकर पहले जमा करना है।

परीक्षण के मामलों

ऊपर के उदाहरण के समान इनपुट प्रारूप।

[("07:00", "12:00"), ("12:30", "15:30"), ("15:45", "17:15")] -> TRUE // 9: 30h काम, 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: 50h काम, तो कोई ब्रेक की जरूरत नहीं
[("07:30", "12:00"), ("12:30", "16:00")] -> TRUE // 8h वर्क, 30 मिनट का ब्रेक -> OK
[("08:00", "12:30"), ("13:05", "17:45")] -> FALSE // 9: 10h काम, 45 की बजाय केवल 35 मिनट का ब्रेक
[("08:00", "14:00")] -> FALSE // 6h काम, कोई ब्रेक नहीं, लेकिन 30 मिनट की जरूरत

हैप्पी कोडिंग!

Answer 1

पायथ, 56 52 बाइट्स

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

[[hh,mm], [hh,mm], ...]बिना किसी अग्रणी 0s के साथ फॉर्म में इनपुट लेता है

स्पष्टीकरण:

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

इसे यहाँ आज़माएँ

या यहां सभी परीक्षण मामलों का प्रयास करें

Answer 2

जावास्क्रिप्ट, 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>'

Answer 3

पायथन 3, 135

डीएसएम के लिए 3 बाइट्स को सहेजा गया।

यह थोड़ी देर में मेरे गणित के समाधान में से एक है।

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