यह इस बात पर आधारित है कि मेरी कंपनी हर कर्मचारी के लिए काम के समय की निगरानी से कैसे निपटती है। हम में से हर एक के पास एक कार्ड होता है जिसे सेंसर के सामने से गुजारा जा सकता है, ताकि एक घड़ी उस समय को पंजीकृत कर ले जिस दिन कर्मचारी कार्यालय में या उससे बाहर की जाँच करते हैं। हर बार रजिस्टर एक कोड से जुड़ा होता है:

कोड 0: कर्मचारी कार्यालय में (या वापस) आता है।
कोड 1: कर्मचारी दोपहर के भोजन के लिए कार्यालय छोड़ देता है।
कोड 2: कर्मचारी दिन के अंत में कार्यालय छोड़ देता है।
कोड 3: कर्मचारी कार्य कारणों से कार्यालय छोड़ देता है।
कोड 4: कर्मचारी व्यक्तिगत कारणों से कार्यालय छोड़ देता है।

कोड 0 रजिस्टर को कभी-कभी "शून्य रजिस्टर" के रूप में संदर्भित किया जाएगा, और कोड 1 से कोड 4 रजिस्टर को कभी-कभी "गैर-शून्य रजिस्टर" के रूप में संदर्भित किया जाएगा।

इसलिए, एक श्रमिक के लिए एक सामान्य दिन इस तरह एक रजिस्टर सूची तैयार करेगा:

Code/Time
------------
0   8:17  // The employee arrives at the office
4  11:34  // The employee leaves the office to smoke
0  11:41  // The employee returns to the office
1  13:37  // The employee leaves the office to have lunch
0  14:11  // The employee returns to the office
3  15:02  // The employee leaves the office to visit a client
0  16:48  // The employee returns to the office
2  17:29  // The employee leaves the office to go home

बहरहाल, कर्मचारी कभी-कभी गलतियाँ करते हैं। निम्नलिखित त्रुटियाँ सिस्टम द्वारा स्वचालित रूप से तय की जाती हैं:

दो लगातार गैर-शून्य रिकॉर्ड हैं। यदि पहले गैर-शून्य रिकॉर्ड में एक कोड 4 है, तो एक स्वचालित कोड 0 रजिस्टर 15 मिनट बाद, या अगले रजिस्टरों से 1 मिनट पहले जोड़ा जाता है अगर इसे 15 मिनट से कम समय के बाद पंजीकृत किया गया है। यदि पहले गैर-शून्य रिकॉर्ड में एक कोड 3 है, तो एक स्वचालित कोड 0 रजिस्टर हमेशा अगले रजिस्टर से 1 मिनट पहले जोड़ा जाता है। हर दूसरा मामला एक त्रुटि पैदा करता है। उदाहरण:
```
Code/Time
------------
0   8:17  // The employee arrives at the office
4  11:34  // The employee leaves the office to smoke
1  13:37  // The employee leaves the office to have lunch
// Automatic register with code 0 added at 11:49.

Code/Time
------------
0   8:17  // The employee arrives at the office
4  11:34  // The employee leaves the office to smoke
4  11:39  // The employee leaves again the office for personal reasons
// Automatic register with code 0 added at 11:38.

Code/Time
------------
0   8:17  // The employee arrives at the office
3  11:34  // The employee leaves the office to visit a client
1  14:09  // The employee leaves the office to have lunch
// Automatic register with code 0 added at 14:08.
```
कर्मचारी ने दो कोड 1 रजिस्टर या दो कोड 2 रजिस्टर दर्ज किए। के रूप में इन दो वास्तव में विनिमेय हैं, कि एक त्रुटि के रूप में गिनती नहीं है। यदि कोड 1 या कोड 2 रजिस्टर 2 से अधिक रजिस्टर करता है, जो एक त्रुटि पैदा करता है।

चुनौती

मुख्य उद्देश्य यह गणना करना है कि कर्मचारी ने कार्यालय में कितने घंटे और मिनट बिताए हैं। यह इनपुट रजिस्टर सूची को ठीक करने (यदि आवश्यक हो और संभव हो) के बाद किया जाता है। ध्यान दें कि एक उचित रजिस्टर सूची गैर-शून्य रजिस्टरों के साथ शून्य रजिस्टरों को वैकल्पिक करेगी।

तो, एल्गोरिथ्म एक कर्मचारी और एक दिन के लिए रजिस्टरों की सूची प्राप्त करेगा, और उस दिन के लिए काम कर रहे समय को वापस कर देगा। यदि समय त्रुटियों के मामले में बिताए गए समय की गणना नहीं कर सकता है, तो यह 0 घंटे, 0 मिनट वापस आ जाएगा।

नियम:

बिताया गया समय प्रत्येक कोड 0 रजिस्टर और निम्नलिखित गैर-शून्य रजिस्टर के बीच खर्च होने वाले समय का योग है। यदि गैर-शून्य कोड 3 है, तो उस रजिस्टर और निम्न कोड 0 रजिस्टर के बीच का समय भी गिना जाएगा।
आप मान सकते हैं कि इनपुट रजिस्टर सूची आरोही समय क्रम में होगी, और यह कि सभी रजिस्टर एक ही दिन से होंगे (कोई भी आधी रात से आगे काम नहीं करेगा)।
इनपुट रजिस्टर खाली नहीं होगा।
इनपुट फॉर्मेट आपके कोड की जरूरत के अनुसार कुछ भी हो सकता है, जब तक कि समय को घंटे के मूल्य और मिनट के मान के साथ व्यक्त किया जाता है (घंटों का एक अस्थायी बिंदु एक वैध इनपुट नहीं होगा)। उदाहरण: कोड के साथ एक सूची और तार के रूप में समय के साथ एक सूची, दोनों सूची एक ही समान होने के नाते; पूर्णांकों की सूचियों की एक सूची, पूर्णांक कोड, घंटे और रजिस्टरों के मिनट होने के नाते ...
आउटपुट समय के साथ एक स्ट्रिंग हो सकता है (किसी भी प्रारूप में जिसे आप चाहते हैं: एच: मिमी, एचएच: मिमी, एच: एम ...); घंटे और मिनट की गणना के साथ दो पूर्णांकों की एक सूची; कुछ भी जो एक घंटे के मिनट के रूप में व्याख्या किया जा सकता है (खर्च किए गए घंटों के साथ एक अस्थायी-बिंदु संख्या की अनुमति नहीं होगी)। या आप परिणाम को STDOUT में प्रिंट कर सकते हैं।

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

Code/Time
------------
0   8:17  // Check in
4  11:34  // Check out. Time spent since check in:  3:17
0  11:41  // Check in
1  13:37  // Check out. Time spent since check in:  1:56
0  14:11  // Check in
3  15:02  // Check out. Time spent since check in:  0:51
0  16:48  // Check in.  Time spent working outside: 1:46
2  17:29  // Check out. Time spent since check in:  0:41
// Total time (value returned): 8:31

Code/Time
------------
0   8:17
4  11:34  // Time spent: 3:17
1  15:52  // Time spent since 11:49 (automatic register 15 minutes after
          // a code 4 register): 4:03
// Total time: 7:20

Code/Time
------------
0   8:17
4  15:47  // Time spent: 7:30
1  15:52  // Time spent since 15:51 (automatic register after a code 4
          // register 1 minute before the next register as it is too
          // close in time): 0:01
// Total time: 7:31

Code/Time
------------
0   8:17
1  13:34  // Time spent: 5:17
0  14:04
1  17:55  // Time spent: 3:51 (last code 1 should be a code 2 but it does not matter)
// Total time: 9:08

Code/Time
------------
0   8:17
1  13:34
0  14:04
1  17:05
0  17:08
2  17:44
// Total time: 0:00 (too many code 1 and code 2 registers)

Code/Time
------------
0   8:17
1  13:34  // A code 1 register does not generate an automatic code 0 register
2  17:41
// Total time: 0:00 (there's a code 0 register missing)

Code/Time
------------
0   8:17
0  13:34  // what happened between these two check in registers?
2  17:41
// Total time: 0:00 (there's a check out register missing)

Code/Time
------------
0   8:17
0  13:37  // This should probably be a code 1 register, but we cannot be sure
0  14:11
2  17:29
// Total time: 0:00

मुझे पता है कि यह भ्रामक हो सकता है (वास्तविक दुनिया की समस्या पर विचार करने के लिए और भी मामले थे, इसलिए मुझे पता है कि)। कृपया, अधिक उदाहरण के लिए पूछने में संकोच न करें।

ये है कोड गोल्फ, इसलिए प्रत्येक भाषा की जीत के लिए सबसे छोटा कोड हो सकता है!

आप टिप्पणी कर सकते हैं कि यदि आप चाहें तो सिस्टम को कैसे सुधारें, लेकिन यह बात नहीं है। मेरे बॉस को इसे बदलने में समय बिताने का कोई खतरा नहीं है। :-)

— चार्ली
स्रोत

सैंडबॉक्स ।

— चार्ली

पायथन 3 , 327 322 318 317 बाइट्स

कुछ बाइट्स से छुटकारा पाने के लिए @JonathanFrech और @ Mr.Xcoder का धन्यवाद।

कोड की सूची के रूप में इनपुट लेता है ( C) और समय की सूची ( T) ( (hours, minutes)ट्यूपल्स)। (hours, minutes)टपल लौटाता है ।

def f(C,T):
 T,L=[m+h*60for h,m in T],C.count
 for z in range(len(C))[::-1]:
  c=C[~-z]
  if c*C[z]:
   if c<3:return 0,0
   C.insert(z,0);b=~-T[z];T.insert(z,b if c-4else min(T[~-z]+15,b))
 while L(3):i=C.index(3);del C[i:i+2],T[i:i+2]
 return(0,0)if L(1)+L(2)>2or 0in C[1::2]else divmod(sum(T[1::2])-sum(T[::2]),60)

दिए गए उदाहरणों के विरुद्ध सत्यापित।

Ungolfed

def f(C, T):
    # use minutes since midnight instead of (hours, minutes)
    T=[m+h*60 for h,m in T]

    # error correction
    for z in range(len(C))[::-1]:
        if C[z-1] and C[z]:
            if C[z-1]<3:
                return 0,0

            C.insert(z,0)
            b=T[z]-1
            T.insert(z, b if C[z-1] != 4 else min(T[z-1]+15, b))

    # simplification (remove work trips (code 3))
    while L(3): # 3 in C
        i=C.index(3)
        del C[i:i+2]
        del T[i:i+2]

    # error check
    if 0 in C[1::2] or 2 < C.count(1) + C.count(2):
        return 0,0

    # sum
    s = sum(T[1::2])-sum(T[::2])

    # to (hours, minutes)
    return divmod(s, 60)

— हनीस करपिला
स्रोत

318 बाइट्स ।

— जोनाथन फ्रीच

उस नकार के बारे में मैंने नहीं सोचा था। अच्छी चाल।

— हेंस कारपिला

आप उपयोग कर सकते हैं L(3)के बजाय 3in C।

— श्री एक्सकोडर

कार्य समय कैलकुलेटर

पायथन 3 , 327 322 318 317 बाइट्स

Ungolfed