चुनौती

सबसे छोटा कोड लिखें जो स्टड में दिखाई देने वाले सभी समय अवधि को जोड़ सकता है। कार्यक्रम को केवल निम्नलिखित पैटर्न में से एक के साथ मेल खाने वाले तारों पर विचार करना चाहिए और बाकी को अनदेखा करना चाहिए।

    HH:MM:SS     (it will be interpreted as HH hours, MM minutes and SS seconds)        
    H:MM:SS      (it will be interpreted as H hours, MM minutes and SS seconds)
    MM:SS        (it will be interpreted as MM minutes, SS seconds)
    M:SS         (it will be interpreted as M minutes, SS seconds)

तार के उदाहरण जो एन्यूमरेटेड पैटर्न से मेल खाते हैं:

आउटपुट फॉर्म का होना चाहिए

    HHh MMm SSs      (that means HH hours, MM minutes and SS seconds with non-zero-padding)

उदाहरण

STDIN

वेलकम वीडियो देखें।
वीडियो: 10:37 मिनट।
पाठ्यक्रम के लिए वीडियो परिचय देखें।
वीडियो: 3:30 मिनट। सबक अवलोकन का उपयोग कैसे करें का वीडियो देखें।
वीडियो: 9:13 मिनट।
अपने काम को साझा करने के लिए एप्सिलन प्रणाली का उपयोग करने का वीडियो अवलोकन देखें।
वीडियो: 03:15 मिनट।
शैक्षणिक मूल्यांकन (STAAR) के टेक्सास आकलन के राज्य के बारे में जानने के लिए वीडियो देखें।
वीडियो: 1:05:26 मिनट।

STDOUT

1 ह 32 मी 1 स

— अल्फ्रेडो डियाज़
स्रोत

तार के बारे में क्या 10:4:56? वर्तमान विनिर्देश के अनुसार उन्हें इलाज करना होगा 4m 56s, भाग 10को नजरअंदाज कर दिया जाएगा। के बारे में एक ही सवाल 10:12:7यह की 10m 12sअनदेखी के साथ क्या मतलब है 7? या ऐसे तार को संभालने से कार्यान्वयन को परिभाषित किया जा सकता है?

— क्वर्टी

कार्यक्रम को केवल मिनट और दूसरे क्षेत्रों में शून्य-पैडिंग के साथ समय अवधि पर विचार करना चाहिए। आपके उदाहरण में स्ट्रिंग "10: 4: 56" को 4m 56s माना जाएगा। इसके अलावा स्ट्रिंग "10: 12: 7" की व्याख्या 10 मीटर 12 के रूप में की जाएगी।

— अल्फ्रेडो डियाज

अजीब बात है, लेकिन ठीक है :)

— Qwertiy

आपको 1h 19m 18sआउटपुट में कैसे मिला ? 37+30+13+15+26==121, 10+3+9+3+5==30, 1==1, इसलिए मैं उम्मीद 1h 32m 01s। इस तर्क में क्या गलत है? इसके अलावा, ऐसा आउटपुट स्वरूप वह है जो अपेक्षित है, है न?

— Qwertiy

तुम सही हो। क्षमा करें: एस

— अल्फ्रेडो डियाज

3

अजगर 105

K"smh"J"\D\D+|\d+:(?=\d:)|:\d\D"W:QJ1=Q:QJd;FN_msdCfn2lTm+*]0</k\:2msbck\:cQ)~k+d+hK_`%+NZ60=Z/N60=KtK;_k

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

यह उसी तरह से STDIN से इनपुट की आवश्यकता है जिस तरह से जावास्क्रिप्ट उत्तर करता है, जैसा कि पाठ को \nएस के रूप में newlines के साथ उद्धृत किया गया है ।

नमूना:

"View the Welcome video.\nVideo: 10:37 min.\nView the video introduction to the course.\nVideo: 3:30 min. View the video of how to use the Lesson Overview.\nVideo: 9:13 min.\nView the video overview of how to use the Epsilen system to share your work.\nVideo: 03:15 min.\nView the video to learn about the State of Texas Assessment of Academic Readiness (STAAR).\nVideo: 1:05:26 min."

उत्पादन

1h 32m 1s

Weirder दिनांक के साथ काम करने वाला उदाहरण:

"10:10:5 and 5:1:10 and 27 or 16: or 1:1:1 or 11:1\n"

उत्पादन

0h 11m 20s

(केवल 10:10 और 1:10 वैध समय हैं)

मुख्य कारण यह है कि यह इतना लंबा है कि Pyth आपको सकारात्मक मैचों को निकालने नहीं देगा। इसके बजाय यह सब कुछ से मेल खाता है जो एक वैध समय नहीं है, और इसे एक अंतरिक्ष चरित्र के साथ बदल देता है। फिर, व्हॉट्सएप पर बंटवारे केवल बार और कुछ स्वच्छंद संख्याओं को छोड़ते हैं। :वर्णों की जाँच करके अतिरिक्त संख्याएँ हटा दी जाती हैं , जिन्हें गैर-वैध समय से हटा दिया जाता है। यह लगभग निश्चित रूप से आगे गोल्फ हो सकता है;)

— FryAmTheEggman
स्रोत

लकी कमीने कि Pyth में भी rexx है !

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र: डी हालांकि यह एक वास्तविक दर्द था। मैं सुझाव दे रहा हूं कि आप जिस arg के आधार पर बदलाव कर रहे हैं उसे "मैच है" व्यवहार को बदल दें (वर्तमान में यह केवल जांचता है कि यह एक गैर-स्ट्रिंग है)

— FryAmTheEggman

6

जावास्क्रिप्ट ईएस 6, 138 चार्ट

फंक्शन, 139

स्ट्रिंग को एक तर्क के रूप में लेता है और कंसोल को आउटपुट लिखता है:

f=s=>(r=0,s.replace(/(\d\d?):(\d\d)(:(\d\d))?/g,(m,a,b,x,c)=>r+=x?+c+b*60+a*3600:+b+a*60),console.log("%dh %dm %ds",r/3600,r%3600/60,r%60))

कार्यक्रम, 138

prompt(r=0).replace(/(\d\d?):(\d\d)(:(\d\d))?/g,(m,a,b,x,c)=>r+=x?+c+b*60+a*3600:+b+a*60),console.log("%dh %dm %ds",r/3600,r%3600/60,r%60)

फ़ंक्शन के लिए परीक्षण करें

f("View the Welcome video.\n\
Video: 10:37 min.\n\
View the video introduction to the course.\n\
Video: 3:30 min. View the video of how to use the Lesson Overview.\n\
Video: 9:13 min.\n\
View the video overview of how to use the Epsilen system to share your work.\n\
Video: 03:15 min.\n\
View the video to learn about the State of Texas Assessment of Academic Readiness (STAAR).\n\
Video: 1:05:26 min.")

उत्पादन

"1h 32m 1s"

— Qwertiy
स्रोत

ठीक है। फ़ायरफ़ॉक्स डेवलपर संस्करण 36.0a2 में ठीक काम करता है, स्वरूपण केवल फ़ायरफ़ॉक्स 34.0 में विफल रहता है।

— मैनावर्क

Promt मल्टीलाइन स्ट्रिंग्स की अनुमति नहीं देता है। लेकिन मैं प्रॉम्प्ट के साथ संस्करण जोड़ सकता हूं () वर्णों की समान संख्या में कॉल करें :) मैं इसे 1 प्रतीक भी छोटा करता हूं)))

— Qwertiy

@Optimizer उन्हें कैसे दर्ज करें?

— Qwertiy

@ ऑप्टिमाइज़र एक नई लाइन डालने से मेरा FF 35.0 में काम नहीं करता है।

— Qwertiy

मैं इसे काम नहीं कर सकता। मैंने इसे ideone.com ideone.com/56EHgV

— अल्फ्रेडो डियाज़

4

जावास्क्रिप्ट, ईएस 6, 208 200 197 बाइट्स

मुझे पता है कि यह सुपर लंबा है, लेकिन मैं ES6, रिवर्स, मैप-कम, एरो फ़ंक्शंस और एरो कॉम्प्रिहेंशन (प्रसार ऑपरेटर) की नवीनतम विशेषताओं का पता लगाना चाहता था।

alert(prompt().match(/\d\d?:\d\d(:\d\d)?/g).map(x=>[...x.split(":").reverse(),z=0].slice(0,3)).reduce((a,b)=>b.map((y,i)=>+y+ +a[i])).map((x,i)=>(z=(t=x+z|0)/60,t%60+"smh"[i])).reverse().join(" "))

स्निपेट का विस्तार करें

बस एक नवीनतम फ़ायरफ़ॉक्स में स्निपेट चलाएं।

यह कैसे काम करता है (थोड़ा सा अनगढ़)

alert(                              // Alert the final result
  prompt()                          // Take the input via prompt
  .match(/\d\d?:\d\d(:\d\d)?/g)     // Match only correct time formats
  .map(                             // Map all matches using this method
    x=>[                            // Take each element as argument x
      ...x.split(":").reverse(),    // split x on ":" and reverse the array, then spread it
      z=0                           // put 0 as last element of return array
    ].slice(0,3)                    // Take only first 3 elements of the array
  ).reduce(                         // Reduce the result using this method
    (a,b)=>                         // Pairwise elements of the array
    b.map(                          // Map array b
      (y,i)=>~~y+~~a[i]             // Convert b[i] to b[i]+a[i]
    )                               // Now we have array like [SS, MM, HH]
  ).map(                            // Map these three values for carry over calculation
    (x,i)=>(
      t=x+z,                        // z contains carryover amount, add it to this value
      z=(t/60)|0,                   // Carryover is now floor(t/60)
      t%60+"smh"[i]                 // Remove overflow from t and add "s", "m" or "h"
    )                               // Now we have array like ["SSs", "MMm", "HHh"]
  ).reverse().join(" ")             // Reverse it and join by space
)

— अनुकूलक
स्रोत

4

बैश (grep, sed, awk और date के साथ): 124 बाइट्स, 120 बाइट्स

इसमें केवल टेक्स्ट को पाइप करें:

grep -o '[:0-9]*'|sed 's/^[^:]*:[^:]*$/:\0/'|awk -F: '{T+=3600*$1+60*$2+$3}END{print"@"T}'|xargs date +"%Hh %Mm %Ss" -ud

यह काम किस प्रकार करता है

grep: केवल इनपुट वाले स्ट्रिंग्स को आउटपुट करता है 0123456789:
sed: मुड़ता है MM: SS और M: SS में: M: SS
awk: सेकंड की गणना करता है, खाली स्ट्रिंग 0 है
xargs: इनपुट को तर्क के रूप में दिनांकित करता है
दिनांक: आवश्यक प्रारूप में युगांतर (@ के साथ उपसर्ग) के बाद सेकंड परिवर्तित करता है

— PGY
स्रोत

क्या यह समय आपके समयक्षेत्र से संबंधित नहीं है?

— Qwertiy 20

तुम सही हो, अच्छी पकड़ है :) जोड़ा -u झंडा।

— पेज

3

पर्ल - 228 201

use integer;$h=0,$m=0,$s=0;while(<>){if(/(\d+:){1,2}\d+/){@a=reverse(split(/:/,$&));push @a,(0)x(3-@a);$s+=@a[0];$m+=@a[1];$h+=@a[2];}}$m+=$s/60;$s=$s%60;$h+=$m/60;$m=$m%60;print $h."h ".$m."m ".$s."s"

यह ऑप्टिमाइज़र (grep, स्प्लिट, रिवर्स, ऐड) के समान ही एल्गोरिदम होता है।

मैं कोई पर्ल विशेषज्ञ नहीं हूं, इसलिए शायद बाइट की गिनती कम हो सकती है।

Ungolfed

use integer;                              # will do integer division
$h=0,$m=0,$s=0;
while(<>){
    if(/(\d+:){1,2}\d+/) {                # extract date formats
        @a = reverse(split(/:/,$&));      # split by ":" and reverse
        push @a,(0)x(3-@a);               # pad with zeros (minutes and hours)
        $s+=@a[0];                        # sum seconds
        $m+=@a[1];                        # sum minutes
        $h+=@a[2];                        # sum hours
    }
}

# convert seconds as minutes    
$m += $s / 60;
$s = $s % 60;

# convert minutes as hours
$h += $m / 60;
$m = $m % 60;

print $h."h ".$m."m ".$s."s";

— कोर निपात
स्रोत

मेरे लिए, यह एक जावास्क्रिप्ट की तुलना में लंबे समय तक पर्ल समाधान देखने के लिए अजीब है :)

— Qwertiy

खैर, अगर शेबंग की गिनती भी की जाती है, तो लंबे समय तक रहना सामान्य है।

— मैनटवर्क

@ क्वर्टी मैं सहमत हूँ। मेरी आशा है कि कुछ पर्ल गुरु मुझे इसे ठीक करने में मदद करेंगे।

— coredump

@manatwork इसकी गिनती क्यों होती है?

— Qwertiy

@ क्वर्टी, क्योंकि कोरपम्प इसे गिनती से बाहर करना भूल गया। : एस को केवल हटाया जा सकता है (उन सभी myकीवर्ड के साथ)।

— मैनटवर्क

3

प्रतिबल - 174

n: charset"1234567890"a:[1 2 n]b:[":"2 n]c: 0 parse input[any[copy x[a b b](c: c + do x)| copy x[a b](c: c + do join"0:"x)| skip]]print reword"$1h $2m $3s"[1 c/1 2 c/2 3 c/3]

अनगुल्ड + एनोटेट:

n: charset "1234567890"                      ; setup \d regex equiv
a: [1 2 n]                                   ; parse rule for \d{1,2} 
b: [":" 2 n]                                 ; parse rule for :\d\d
c: 0                                         ; time counter

parse input [                                ; parse the input (STDIN)
                                             ; (no regex in Rebol)

  any [                                      ; match zero or more... 
                                             ;
      copy x [a b b] (c: c + do x)           ;  HH:MM:SS or H:MM:SS
                                             ;    - copy match to x
                                             ;    - increment time (c) by x
                                             ; OR
    | copy x [a b] (c: c + do join "0:" x)   ;  MM:SS or M:SS
                                             ;    - copy match to x
                                             ;    - "MM:SS" into "0:MM:SS" (join)
                                             ;    - then increment time (c)
                                             ; OR
    | skip                                   ;   no match so move through input
  ]
]

print reword "$1h $2m $3s" [1 c/1 2 c/2 3 c/3]

Rebol अपने स्वयं के time!डेटाटाइप के साथ आता है । आप देख सकते हैं कि उपरोक्त कोड नीचे दिए गए उदाहरण से (Rebol कंसोल के भीतर से) इसका उपयोग कैसे करता है:

>> 0:10:37 + 0:3:30 + 0:9:13 + 0:3:15 + 1:05:26
== 1:32:01

;; Rebol would treat 10:37 as 10 hours & 37 minutes (and not MM:SS)
;; So we have to prefix the "0:"

>> join "0:" 10:37
== "0:10:37"

;; This is a string so we use Rebol DO evaluator to convert to time!

>> do join "0:" 10:37 
== 0:10:37

>> type? do join "0:" 10:37
== time!

>> hms: do join "0:" 10:37
== 0:10:37

>> hms/hour
== 0

>> hms/second
== 37

>> hms/minute
== 10

— draegtun
स्रोत

2

ग्रूवी - 195

M=60
r=(System.in.text=~/((\d?\d):)?(\d\d):(\d\d)/).collect{it[2..4]*.toInteger().inject{s,i->(s?:0)*M+i}}.inject{s,i->s+=i}
f=[];(2..0).each{j=M**it;s=r%j;f<<(r-s)/j;r=s}
printf("%sh %sm %ss",f)

मैं यह पता नहीं लगा सकता कि इसे और अधिक कैसे संपीड़ित किया जाए।

Ungolfed

M=60
r=(System.in.text=~/((\d?\d):)?(\d\d):(\d\d)/).collect{  // extract dates
    it[2..4]*.toInteger().inject{ s,i ->                 // convert to seconds
        (s?:0)*M+i
    }
}.inject{s,i ->
    s+=i                                                 // sum seconds
}

f=[];
(2..0).each{                                             // convert to h,m,s
    j=M**it;
    s=r%j;
    f<<(r-s)/j;
    r=s
}

printf("%sh %sm %ss",f)

— अल्फ्रेडो डियाज़
स्रोत

1

गणितज्ञ 300 वर्ण

इस छोटे से अभ्यास ने मैथमेटिका के लिए बहुत सारे कोड लिए। निश्चित रूप से ऐसा करने के अधिक कुशल तरीके हैं।

golfed

यह मानते हुए कि इनपुट में संग्रहीत है txt,

n=NumberString;
t=ToExpression;
o=TimeObject;

QuotientRemainder[QuantityMagnitude[Plus@@((o[#]-o[{0,0,0}])&/@
(StringSplit[StringCases[w,{(n~~":"~~n~~":"~~n),(n~~":"~~n)}],":"]
/.{{a_,b_}:> {0,t@a,t@b},{a_,b_,c_}:> {t@a,t@b,t@c}}))],60]/.{h_,m_}:> 
Row[{h,"h ",IntegerPart@m,"m ",Round[60 FractionalPart[m]],"s "}]

यह कैसे काम करता है (बिना कोड वाले कोड का उपयोग करके):

1-समय का पता लगाएं।

StringCases[txt,{(NumberString~~":"~~NumberString~~":"~~NumberString),
(NumberString~~":"~~NumberString)}];

{"10:37", "3:30", "9:13", "03:15", "1:05:26"}

2-घंटे, मिनट, सेकंड में तोड़ो

StringSplit[%,":"]/.{{a_,b_}:> {0,ToExpression@a,ToExpression@b},{a_,b_,c_}:> 
{ToExpression@a,ToExpression@b,ToExpression@c}}

{{0, 10, 37}, {0, 3, 30}, {0, 9, 13}, {0, 3, 15}, {1, 5, 26}}

3-सम काल। समय की वस्तुएं घड़ी समय हैं। एक समय की वस्तु को दूसरे से घटाकर एक अवधि लौटाता है, इस मामले में 92.0167 मिनट। QuantityMagnitudeमाप की इकाई को गिराता है।

q=QuantityMagnitude[Plus@@((TimeObject[#]-TimeObject[{0,0,0}])&/@%)]

92.0167

4-92.0167 मिनटों को घंटे, मिनट, सेकंड में बदलें।

QuotientRemainder[q,60]/.{h_,m_}:> Row[{h,"h ",IntegerPart@m,"m ",
Round[60 FractionalPart[m]],"s "}]

1 ह 32 मी 1 स

— डेविड
स्रोत

1

पर्ल, 146

मेरी प्रविष्टि आउटपुट को एक अनुगामी स्थान के साथ प्रिंट करती है - मुझे आशा है कि यह ठीक है

while(<>){for(/(\d?\d(?::\d\d){1,2})/g){$m=1;for(reverse split/:/,$_){$t+=$m*$_;$m*=60}}}for('s','m'){$o=($t%60)."$_ $o";$t/=60}print int$t,"h $o"

यदि हम मान सकते हैं कि इनपुट की प्रति पंक्ति केवल एक बार होगी, तो हम 4 वर्णों को काट सकते हैं:

while(<>){if(/(\d?\d(:\d\d){1,2})/){$m=1;for(reverse split/:/,$&){$t+=$m*$_;$m*=60}}}for('s','m'){$o=($t%60)."$_ $o";$t/=60}print int$t,"h $o"

ये काम कुल सेकंड्स संचित करके और बाद में उस मान को स्वरूपित करके काम करते हैं।

— केजेपी
स्रोत

समय अवधि योग

चुनौती

उदाहरण

अजगर 105

जावास्क्रिप्ट ईएस 6, 138 चार्ट

फंक्शन, 139

कार्यक्रम, 138

फ़ंक्शन के लिए परीक्षण करें

उत्पादन

जावास्क्रिप्ट, ईएस 6, 208 200 197 बाइट्स

बैश (grep, sed, awk और date के साथ): 124 बाइट्स, 120 बाइट्स

पर्ल - 228 201

Ungolfed

प्रतिबल - 174

ग्रूवी - 195

Ungolfed

गणितज्ञ 300 वर्ण

पर्ल, 146