कम्प्यूटिंग टाइम शीट

Question

समय पत्रक

एक कार्य स्थान में आपको अक्सर समय पत्रक पूरा करना पड़ता है। इस कार्य को मदद करने के लिए कोड लिखा जाता है।

इनपुट

एक गैर-मानक 12 घंटे की घड़ी में दो बार एक स्थान द्वारा अलग किए गए दिन की शुरुआत और अंत को दर्शाता है। एक तीसरा नंबर लंच के लिए लिए गए मिनटों की संख्या को दर्शाता है। उदाहरण के लिए

9:14 5:12 30

इसका मतलब है कि आपने सुबह 9:14 बजे काम शुरू किया, शाम 5:12 बजे काम खत्म किया और दोपहर के भोजन के लिए 30 मिनट का समय लिया।

आप ऐसा मान सकते हैं

• पहले कॉलम में कोई भी समय 00:00 (मध्यरात्रि) तक है, लेकिन दोपहर 1:00 बजे तक और दूसरे कॉलम में कोई भी समय दोपहर 1:00 बजे तक नहीं है।
• लंच ब्रेक काम के दिन से अधिक नहीं है!

इनपुट प्रारूप दिए गए उदाहरणों के अनुसार होना चाहिए।

कार्य

आपका कोड इन त्रिगुणों की फ़ाइल (या मानक इनपुट) में पढ़ा जाना चाहिए, और प्रत्येक एक आउटपुट के लिए कि आपने कितने समय तक काम किया। इस आउटपुट को घंटों की संख्या का संकेत देना चाहिए। इस से ऊपर के उदाहरण के लिए है:

7hr और 58min माइनस 30 मिनट जो कि 7hr 28min है।

उत्पादन

आपके आउटपुट में घंटे और मिनटों की संख्या (संपूर्ण) निर्दिष्ट होनी चाहिए और 59 मिनट से अधिक नहीं होनी चाहिए। यही कारण है कि आप 2hr 123min आउटपुट नहीं कर सकते। इसके अलावा, आपका कोड किसी भी आसानी से पढ़े जाने वाले मानव प्रारूप में आउटपुट कर सकता है जो आपके लिए सुविधाजनक है।

उदाहरण

10:00 1:00 30    --> 2hr 30min
12:59 1:00 0     --> 0hr 1min
00:00 11:59 0    --> 23hr 59min
10:00 2:03 123   --> 2hr 0min 

Comments

मैं नहीं देखता कि कैसे सख्त इनपुट प्रारूप ( :12 घंटे की घड़ी पर सीमांकित समय) इस चुनौती के लिए कुछ भी जोड़ता है।

— झबरा

@ इनपुट फॉर्मेट को पार्सिंग पार्सिंग करना मेरे लिए कम से कम चुनौती था, क्योंकि आप कैरेक्टर पोजीशन को नहीं मान सकते क्योंकि घंटों या तो एक या दो कैरेक्टर का हो सकता है ...

— रयान

क्या कोड को कई पंक्तियों को पढ़ना है? या यह पर्याप्त है अगर यह एक पंक्ति पढ़ता है?

— लुइस मेंडू

हां कोड को कई लाइनों को स्वीकार करना होगा।

— आशु

@ mbomb007 आप डाउनवोट कर सकते हैं, लेकिन इनपुट प्रारूप को पसंद नहीं करना वीटीसी का एक कारण नहीं है।

— ओकेक्स

Answer 1

MATL , 28 बाइट्स

`jYb0&)YOd.5+wgU13L/- 15XODT

इसे ऑनलाइन आज़माएं!

Comments

यह बहुत प्रभावशाली है!

— आशु

क्या आउटपुट इस प्रारूप में नहीं होना चाहिए "XXhr YYmin"?

— इब्राहिम माहिर

@ibrahimmahrir चुनौती कहती है कि आपका कोड किसी भी आसानी से पढ़े जाने वाले मानव प्रारूप में आउटपुट कर सकता है जो आपके लिए सुविधाजनक है

— लुइस मेंडू

ओह समझा! मैं इसे छोटा करने के लिए अपने उत्तर को संपादित करने जा रहा हूं। धन्यवाद!

— इब्राहिम माहिर

Answer 2

रेटिना 0.8.2 , 83 बाइट्स

\d+
$*
 (1+:)
 12$*1$1
+`1:
:60$*
(1*) :\1(1*)(1*) \2
$3
:(1{60})*(1*)
$#1hr $.2min

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

\d+
$*

इनपुट को unary में बदलें।

 (1+:)
 12$*1$1

स्टॉप टाइम में 12 घंटे जोड़ें।

+`1:
:60$*

घंटे को 60 से गुणा करें और मिनटों में जोड़ें।

(1*) :\1(1*)(1*) \2
$3

स्टार्ट टाइम को घटाएं और स्टॉप टाइम से टाइम को ब्रेक करें।

:(1{60})*(1*)
$#1hr $.2min

60 से Divmod। (अधिक उबाऊ आउटपुट प्रारूप के लिए 5 बाइट्स सहेजें।)

Answer 3

पर्ल 5- पीपीएल, 80 74 71 बाइट्स

/:(\d+) (\d+):(\d+) /;$m=720+($2-$`)*60+$3-$1-$';$_=($m/60|0).":".$m%60

इसे ऑनलाइन आज़माएं!

Answer 4

पायथन 3, 161 बाइट्स

मुझे पता है कि यह सबसे छोटा भी नहीं होगा, लेकिन यह एक फाइल में पढ़ा जाता है:

for l in open('t'):
    l=l[:-1].split(':')
    m=-int(l[0])*60+int(l[1][:2])+(int(l[1][3:])*60+720+int(l[2][:2])-int(l[2][2:]))
    print(f'{m//60}hr {m-(m//60*60)}min')

मुझे ऐसा करने के लिए अपनी टाइमशीट को विराम देने की विडंबना महसूस हो रही है ...

पायथन 2.7, 133 बाइट्स

टिप्पणियों में सुझाव के लिए धन्यवाद! अजगर 2.7 पर स्विच करने से कुछ और बाइट्स बचते हैं क्योंकि यह पूर्णांक विभाजन में चूक करता है:

for l in open('t'):i,h,l=int,60,l[:-1].split(':');m=-i(l[0])*h+i(l[1][:2])+(i(l[1][3:])*h+720+i(l[2][:2])-i(l[2][2:]));print m/h,m%60

Python3 के साथ एक ही दृष्टिकोण 135 बाइट्स है क्योंकि प्रिंट स्टेटमेंट और फ्लोट डिवीजन को डिफ़ॉल्ट करना है:

for l in open('t'):i,h,l=int,60,l[:-1].split(':');m=-i(l[0])*h+i(l[1][:2])+(i(l[1][3:])*h+720+i(l[2][:2])-i(l[2][2:]));print(m//h,m%60)

Comments

आप i=intशुरुआत में डालकर 4 बाइट्स बचा सकते थे और तीसरी लाइन को बदलकरm=-i(l[0])*60+i(l[1][:2])+(i(l[1][3:])*60+720+i(l[2][:2])-i(l[2][2:]))

— जेम्स

@DJMcMayhem धन्यवाद! मैं उन लोगों को सरल बनाने का एक तरीका सोचने की कोशिश कर रहा था ...

— रयान

बहुत अच्छा पहला जवाब, प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! थोड़ी सी गोल्फिंग में मदद करने के लिए, आप एसटीडीआईएन से इनपुट लेने में सक्षम हो सकते हैं, एक से अधिक बाइट्स को बचाने के map(int,l[:-1].split(':'))लिए इंडेंटेशन को रिप्लेस करके ;आदि को एक-लाइनर के लिए सब कुछ समाप्‍त करने के लिए कई रूपांतरणों का उपयोग करें और छोड़ें । इसके अतिरिक्त, आप पायथन में गोल्फ के लिए टिप्स पर जा सकते हैं कुछ अन्य स्वच्छ चाल के लिए जो अन्य उपयोगकर्ता अपने गोल्फर के जीवन के दौरान खोजते हैं :)।

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

इसके अतिरिक्त, ओपी आउटपुट प्रारूप के बारे में कम प्रतिबंधात्मक लगता है, इसलिए मुझे लगता है print(m,m%60)कि पर्याप्त होगा। (इसके m%60स्थान पर उपयोग पर भी ध्यान दें m-(m//60*60))

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

@ Mr.Xcoder धन्यवाद!

— रयान

Answer 5

सी, 105 बाइट्स

a,b,c,d,e;f(){for(;scanf("%d:%d%d:%d%d",&a,&b,&c,&d,&e);)a=(12+c-a)*60+d-b-e,printf("%d:%d ",a/60,a%60);}

पूरी तरह से सीधा। इसे यहाँ ऑनलाइन आज़माएँ ।

Ungolfed:

a, b, c, d, e; // start hours, minutes; end hours, minutes; break - all implicitly int
f() { // function - return type is implicitly int (unused)
    for(; scanf("%d:%d%d:%d%d", &a, &b, &c, &d, &e) ;) // until EOF is hit, read line by line
        a = (12 + c - a) * 60 + d - b - e, printf("%d:%d,", a / 60, a % 60); // calculate the minutes and store, then output separated: "h m"
}

Comments

के a,b,c,d;f(e)बजाय a,b,c,d,e;f()और के ;printf("%d:%d ",a/60,a%60))a=(12+c-a)*60+d-b-e;}बजाय ;)a=(12+c-a)*60+d-b-e,printf("%d:%d ",a/60,a%60);

— सुझाव

Answer 6

वोल्फ्राम भाषा 125 119 111 बाइट्स

i=Interpreter;j=IntegerPart;Row@{j[t=(i["Time"][#2<>"pm"]-i["Time"][#])[[1]]-#3/60],"hr ",j[60Mod[t,1]],"min"}&

---

8 बाइट्स ने उपयोगकर्ता को 202729 के लिए धन्यवाद बचाया

उदाहरण

तर्क का पालन करने के लिए आसान बनाने के लिए, यहाँ संक्षिप्तताओं का उपयोग नहीं किया जाता है।

Row[{IntegerPart[
 t = (Interpreter["Time"][#2 <> "pm"] - 
      Interpreter["Time"][#])[[1]] - #3/60], "hr ",
IntegerPart[60 Mod[t,1]], "min"}] &["9:00", "4:12", 20]

6hr 51min

Interpreter["Time"][#2 <> "pm"] एक समय के रूप में दूसरे पैरामीटर "दोपहर" के बाद की व्याख्या करता है, अर्थात्, इस मामले में, "4:12 बजे", एक TimeObjectसंगत 4:12 बजे लौटता है ।

-Interpreter["Time"][# <> "am"])[[1]] - #3/60]। #3तीसरा पैरामीटर है, जिसका नाम 20min है। माइनस साइन शिफ्ट टाइम के अंत से लंच आवर के अंतराल को घटा देता है। यह शिफ्ट समय के समायोजित छोर को लौटाता है, अर्थात, शिफ्ट का अंत जो लागू होता है वह व्यक्ति लंच ब्रेक नहीं लेता था।

Interpreter["Time"][#] एक समय में पहले पैरामीटर के रूप में व्याख्या करता है, इस मामले में, "9:00", जो TimeObject9:00 पूर्वाह्न के अनुरूप होता है।

शिफ्ट टाइम पैदावार के समायोजित अंत से शिफ्ट शुरू करना t, समय अंतराल को घंटों में व्यक्त किया जाता है। IntegerPart[t]पूर्ण किए गए घंटों की संख्या लौटाता है। IntegerPart[60 Mod[t,1]], "min"}]अतिरिक्त मिनट काम किया।

Comments

हाँ। धन्यवाद। पहली बार मैंने Mod[x, 1]इस्तेमाल किया देखें ।

— डेविड जूल

इसे (हटाए गए) युक्तियों से लिया गया । / वास्तव में मॉड 1 ऋणात्मक संख्या के लिए भिन्न भाग से भिन्न व्यवहार करता है। / के Floorलिए इस्तेमाल किया जा सकता है IntegerPart?

— user202729

-6hr 52minमेरे द्वारा उपयोग किए गए नमूना मूल्यों के लिए मंजिल एक, मेरे लिए, अकथनीय परिणाम देता है । मुझे यह समझने की ज़रूरत है कि घंटों (और स्पष्ट रूप से मिनटों) के लिए एक नकारात्मक मूल्य क्यों उत्पन्न किया गया था।

— डेविड

Answer 7

जावास्क्रिप्ट, 83 बाइट्स 76 बाइट्स

s=>(r=s.match(/\d+/g),r=(r[2]-r[0]+12)*60-r[4]-r[1]+ +r[3],(r/60|0)+':'+r%60)

बस नीचे दिए गए समाधान से आंतरिक अंतःकरण से छुटकारा पा लिया (मैं क्या सोच रहा था?)। साथ ही आउटपुट फॉर्मेट में बदलाव किया।

इसे ऑनलाइन आज़माएं!

---

OLD: जावास्क्रिप्ट, 112 बाइट्स 111 बाइट्स 110 बाइट्स

s=>(t=(h,m,a)=>(a?12+h:h)*60+m,r=s.match(/\d+/g),r=t(+r[2],r[3]-r[4],1)-t(r[0],+r[1]),`${r/60|0}hr ${r%60}min`)

स्पष्टीकरण:

मुख्य फ़ंक्शन के अंदर, हम दूसरे को परिभाषित करके शुरू करते हैं जो हमें एक समय देने के समय की गणना करने में मदद करेगा, तीसरा पैरामीटर सत्य होने पर 12 घंटे को घंटे के पैरामीटर में जोड़ देगा:

(hours, minutes, addTwelve) =>
    (addTwelve? hours + 12: hours) * 60 + minutes

अगला, हम स्ट्रिंग को या तो विभाजित करते हैं ' 'या':' स्ट्रिंग के अंदर संख्याओं का मिलान करते हैं जिसके परिणामस्वरूप स्ट्रिंग में सभी संख्याओं की एक सरणी होती है।

फिर हम अंत समय के अंतर की गणना करते हैं और समय शुरू करते हैं और पहले से परिभाषित फ़ंक्शन का उपयोग करके दोपहर के भोजन के समय को घटाते हैं (स्ट्रिंग्स को आवश्यकतानुसार संख्याओं में परिवर्तित करते हैं)।

अंत में हम परिणाम स्ट्रिंग पैदा करते हैं: घंटे पूर्णांक का हिस्सा हैं r/60और मिनट हैं r%60।

इसे ऑनलाइन आज़माएं!

Comments

@ जाकोब मैं एक नया कोडगोल्फ उपयोगकर्ता हूँ। मुझे अभी तक नहीं पता है कि टीआईओ सहित चीजें यहां कैसे काम करती हैं। इसके अलावा मैंने इस टिप्पणी में पूछा है कि मैं जावास्क्रिप्ट का उपयोग करके इसे कैसे देखूंगा लेकिन किसी ने भी जवाब नहीं दिया।

— इब्राहिम माहिर

@ जाकोब तियो तय और मैं NodeJS का उपयोग नहीं कर रहा हूं, मैं ब्राउज़र के कंसोल का उपयोग कर रहा हूं। NodeJS को TIO द्वारा जोड़ा गया था।

— इब्राहिम माहिर

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

— जैकब

@Jakob अधिक दिनों इनपुट के रूप में इस्तेमाल किया जाना चाहिए, तो मैं सिर्फ समारोह एक सरणी और उपयोग को स्वीकार कर सकता है map: a=>a.map(...)। यह मेरे जवाब में 5 बाइट जोड़ देगा। लेकिन मैं अभी भी अपनी टिप्पणी के लिए ओपी (या किसी) की प्रतिक्रिया की प्रतीक्षा कर रहा हूं।

— इब्राहिम माहिर

चूंकि शुद्ध जावास्क्रिप्ट में मानक इनपुट या फ़ाइलों तक पहुंच नहीं है , इसलिए मेरा सुझाव है कि आप GUI प्रॉम्प्ट का उपयोग करने की डिफ़ॉल्ट विधि के साथ जाएं: codegolf.meta.stackexchange.com/a/2459/79343

— OOBalance

Answer 8

अजगर 2 , 100 बाइट्स

for I in open('x'):x,y,z,w,l=map(int,I.replace(':',' ').split());d=60*(12+z-x)+w-y-l;print d/60,d%60

इसे ऑनलाइन आज़माएं!

पूर्ण प्रोग्राम जो एक पाठ फ़ाइल से कई पंक्तियों को पढ़ता है, जैसा कि ओपी द्वारा निर्देशित है। एक फ़ंक्शन जो केवल एक लाइन को पार्स करता है वह अल 10 बाइट्स को जोड़ देगा।

Comments

यह भी मेरे प्रयास से अधिक सुपाठ्य है!

— रयान

Answer 9

जावा 10, 194 191 बाइट्स

u->{var s=new java.util.Scanner(System.in).useDelimiter("\\D");for(int i,a[]=new int[5];;i=(12+a[2]-a[0])*60+a[3]-a[1]-a[4],System.out.println(i/60+":"+i%60))for(i=0;i<5;)a[i++]=s.nextInt();}

I / O जावा में दर्दनाक है। जब पढ़ने के लिए इनपुट की अगली पंक्ति नहीं होती है, तो असामान्य रूप से निर्देश देता है। इसे यहाँ ऑनलाइन आज़माएँ ।

Ungolfed:

u -> { // lambda taking a dummy input – we're not using it, but it saves a byte
var s = new java.util.Scanner(System.in).useDelimiter("\\D"); // we use this to read integers from standard input; the delimiter is any character that is not part of an integer
for(int i, a[] = new int[5]; ; // infinite loop; i will be used to loop through each line and to store the result in minutes between lines; a will hold the inputs
    i = (12 + a[2] - a[0]) * 60 + a[3] - a[1] - a[4], // after each line, calculate the result in minutes ...
    System.out.println(i / 60 + ":" + i % 60)) // ... and output the result in hours:minutes, followed by a newline
    for(i = 0; i < 5; ) // read the five integers on the current line ...
        a[i++] = s.nextInt(); // ... into the array
}

Answer 10

लाल , 35 बाइट्स

func[s e l][e + 12:0 - s -(l * 60)]

इसे ऑनलाइन आज़माएं!

नोट: आउटपुट प्रारूप में है hh:mm:ss

Comments

वाह! यह बहुत आश्चर्य की बात है :)

— अनुष

@ आंशु हां, रेड (और निश्चित रूप से रेबो) का समय अच्छा है।

— गैलेन इवानोव

Answer 11

आर , 97 बाइट्स

s=matrix(strtoi(unlist(strsplit(scan(,""),':'))),5,,T)%*%c(-60,-1,60,1,-1);paste(12+s%/%60,s%%60)

इसे ऑनलाइन आज़माएं!

प्रत्येक लाइन के लिए रिटर्न "hours minutes"

• -16 बाइट्स जेसीई को धन्यवाद!

Comments

मैंने data.frameकुछ बाइट्स को बचाने के लिए एक का उपयोग करने की कोशिश की - अभी तक काम नहीं कर रहा है । लेकिन यह साधारण परिवर्तन :)

— JayCe

यह बेहतर है (97)

— JayCe

महान! धन्यवाद :)

— DigEmAll