18

घड़ियों पर सही समय उत्पन्न करने के लिए सबसे छोटा कोड जीतता है।

आप एक अनुभवी यात्री हैं और अपनी पत्रिकाओं के दौरान कई ग्रहों पर रुकने के लिए जाने जाते हैं। प्रत्येक ग्रह एक अलग दर पर घूमता है और इस वजह से, एक दिन की लंबाई हमारे सामान्य 24-घंटे के दिन से भिन्न होती है। नतीजतन, ग्रह विभिन्न घंटों की संख्या के साथ घड़ियों का उपयोग करते हैं। एक्स घंटे के साथ एक घड़ी पर घंटे हमारे (1, 2, 3, ..., एक्स ) के समान व्यवस्थित होते हैं, जिसमें नंबर को दक्षिणावर्त घुमाया जाता है और एक्स शीर्ष पर होता है।

इसके अतिरिक्त, प्रत्येक ग्रह में एक घंटे में मिनटों की एक अलग राशि होती है, और एक मिनट में एक अलग संख्या। आपको एक शुरुआती समय और कई बीते हुए सेकंड दिए जाएंगे जहाँ से आपको अंतिम समय निर्धारित करना होगा।

इनपुट को एक तर्क के रूप में पारित फ़ाइल से या मानक इनपुट के रूप में सीधे लिया जा सकता है। इनपुट की पहली पंक्ति उन घड़ियों की संख्या होगी जिन्हें आपको संसाधित करने की आवश्यकता है। उसके बाद, प्रत्येक घड़ी में इनपुट की तीन लाइनें होती हैं जिसमें निम्नलिखित प्रारूप में पूर्णांक होते हैं:

x y z
h m s
t

प्रत्येक अक्षर का अर्थ नीचे है।

x = एक दिन में घंटों की संख्या (2 <= x <= 99)
y = एक घंटे में मिनटों की संख्या (2 <= y <= 100)
z = एक मिनट में सेकंड की संख्या (2 <= z) <= 100)
h = प्रारंभ समय का समय (1 <= h <= x)
m = प्रारंभ समय का मिनट (0 <= m <y)
s = प्रारंभ समय का दूसरा (0 <= s) <z)
t = सेकंड की संख्या जो बीत चुकी है

टी सेकंड शुरू होने के बाद से पारित होने के बाद आउटपुट को प्रत्येक घड़ी के लिए समाप्ति समय होना चाहिए । आपका आउटपुट मानक क्लॉक टाइम (HH: MM: SS) के रूप में स्वरूपित होना चाहिए। संख्याओं को गद्देदार किया जाना चाहिए, जब आवश्यक हो, यह सुनिश्चित करने के लिए कि सभी संख्याएं दो-अंकीय हैं।

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

इनपुट

उत्पादन

04:13:08
02:08:03

इनपुट

उत्पादन

07:03:00

इनपुट

उत्पादन

05:26:10
14:00:00

code-golf

— केविन ब्राउन
स्रोत

8

मुझे आश्चर्य है कि क्या सभी ग्रह अंग्रेजों द्वारा बसाए गए हैं?

— आआआआआआ आआआआआआआ

4

@eBusiness बेहतर उन्हें पूरी तरह से चाय के विपरीत नहीं का एक अच्छा कप दे।

— मतीन उल्हाक

मुझे लगता है कि मैं उदाहरण / इनपुट प्रारूप को नहीं समझता। x दिन में घंटों की संख्या है - उस ग्रहों के समय में घंटे, या मानव / पृथ्वी के घंटे? और ज, शुरुआती समय उस ग्रहों का समय है, या फिर से, मानव / पृथ्वी का समय है? क्योंकि: यदि इनपुट 1, उदाहरण 2 में, ग्रह में केवल 6 घंटे हैं - शुरुआती समय 6 कैसे होना चाहिए? वह अमान्य समय होगा।

— उपयोगकर्ता अज्ञात

अगर मैं सही तरीके से समझूं, तो घंटे 1 से n तक जाते हैं। मिनट और सेकंड 0 से n-1 तक जाते हैं। लेकिन आधी रात n: 00: 00 या 1:00:00 है। यहीं से मेरी उलझन हो जाती है।

— 4n12

@ सीएमपी: जैसा कि अंतिम परीक्षण मामले से पता चलता है, मध्यरात्रि का समय n: 00: 00 है।

— केविन ब्राउन

8

गोल्फस्क्रिप्ट - 50 चार्ट

~](;7/{{~+.4$/\4$%])\}3*3<)@\or\+{100+`(;}%':'*n}%

मान (H / M / S) को स्टैक के सामने ले जाने से एकत्र किया जाता है ( ])\)। 0 पर घंटे 'अंडरफ्लो' के साथ नियंत्रित किया जाता है or। जीरो पैडिंग को संभाला जाता है 100+`(;, हालांकि मुझे लगता 0`\+-2>है कि यही लंबाई है।

— Nabb
स्रोत

ऊओह, 100 बात मुझे पागल कर देती है। काश मैं इसके बारे में सोचता। (यह केवल मुझे 3 वर्णों को बचाएगा, लेकिन इससे मुझे अधिक मस्तिष्क समय की बचत होगी।)

— जेसी मिलिकन

9

अजगर, 142 वर्ण

R=raw_input
for i in' '*input():x,y,z,h,m,s=map(int,(R()+i+R()).split());t=input()+h*y*z+m*z+s;print'%02d:%02d:%02d'%((t/y/z-1)%x+1,t/z%y,t%z)

— कीथ रान्डेल
स्रोत

अगर मैं गलत नहीं हूँ, के बाद से आप का उपयोग for i in ' '*input()आप वास्तव में इस्तेमाल कर सकते हैं iके बजाय ' 'में R()+' '+R()दो पात्रों की बचत,।

— दान बर्टन

वास्तव में, धन्यवाद।

— कीथ रान्डेल

आप दूसरी पंक्ति को इसके द्वारा बदल सकते हैं

exec"x,y,z,h,m,s=map(int,(R()+' '+R()).split());t=input()+h*y*z+m*z+s;print'%02d:%02d:%02d'%((t/y/z-1)%x+1,t/z%y,t%z);"*input()

— fR0DDY

t/y/z%x or xएक चरित्र छोटा है।

— नबं

5

GolfScript 62 60 अक्षर

संपादित करें: मैं पहले से ही स्टैक पर निवास करने के लिए संग्रहीत सरणी प्राप्त करने में कामयाब रहा, यह उस तरह से थोड़ा अतिरिक्त स्विचिंग लेता है हालांकि इतना बड़ा सुधार।

~](\7/\{(~+[]\{.5$/@@5$%\+@@+}3*;\;(@or\+{'0'\+-2>}%':'*n@}*

62 संस्करण:

~](\7/\{[]:a;(~{+.4$/\4$%a+:a;}3*;;;a(@or\+{'0'\+-2>}%':'*n@}*
1______a2____3_b4_5___6__7____8__9__10_____11_________12____13

मुझे यकीन है कि यह बहुत बेहतर हो सकता है, मैं अभी कुछ बेहतर नहीं सोच सकता।

1: सभी इनपुट की एक सरणी बनाएं, पहले तत्व को चुनें, बाकी को 7.
a / 13 के ब्लॉक्स में समूहित करें : लूप को चलाने के लिए इनपुट से पहले नंबर का उपभोग करें।
2: ए में एक खाली सरणी स्टोर करें।
3: 7 का एक ब्लॉक चुनें और इसे 7 अलग-अलग संख्याओं तक विस्तारित करें।
बी / 8: एक लूप को 3 बार चलाएं, प्रत्येक सेकंड, मिनट और घंटे के लिए।
4: अंतिम दो संख्याओं को एक साथ जोड़ें, पहली पुनरावृत्ति जो सेकंड और शिफ्ट करने का समय है, निम्नलिखित के लिए यह पिछले चक्र से अतिप्रवाह के साथ मिनट और घंटे है। परिणाम की दूसरी प्रति तैयार करें।
5: ओवरफ्लो का उत्पादन करने और परिणाम को एक स्थान पर वापस शिफ्ट करने के लिए इसकी कॉपी को विभाजित करें।
6: परिणाम के एक भाग का उत्पादन करने के लिए पिछले विभाजन के मोडुलो की गणना करें।
7: इस हिस्से को एक अरै में जोड़ें।
9: स्टैक से घंटे के अतिप्रवाह और दूसरी और मिनट सीमा को हटा दें।
10: घंटे का हिस्सा लें, यदि यह शून्य को घंटे की सीमा के साथ प्रतिस्थापित करता है, तो इसे वापस सरणी में रखें।
11: ए में प्रत्येक तत्व के लिए, '0' को सामने रखें, इस प्रकार स्ट्रिंग में परिवर्तित करें, और अंतिम 2 वर्णों को छोड़ दें।
12: सरणी को '': '' द्वारा संचित एकल स्ट्रिंग में संकुचित करें, एक नई रेखा रखें और शेष नौकरियों को ढेर के सामने रखने वाले सरणी को स्थानांतरित करें, इस प्रकार अगले पुनरावृत्ति की तैयारी।

— aaaaaaaaaaaa
स्रोत

और 13 क्या है? अच्छे खर्च! +1

— फ़ूजएक्सल

@FUZxxl: 13 और 8 ब्लॉक ए और बी के अंतिम मार्कर हैं।

— श्नाडर

5

जे (172/35) 137 99 107

अब सभी दिए गए परीक्षण मामलों को पास करता है।

4(1!:2)~LF,~"1([,':',])/"2,"2":"0(10 10#:1 0 0+{.#:{.&{:+{.#.1 0 0-~1&{)"2&(,&}.$~,&3 3&{.&{.)".;._2(1!:1)3

172 पूरी बात है; 35 मेरे द्वारा दिए गए पात्रों की संख्या है अगर मैं वास्तव में स्नूटी था और संकेत के रूप में आईओ करने से इनकार कर दिया। (मैं अभी भी इसे थोड़ा संशोधित करता हूं; घड़ियां एक ऐसा फंक्शन है जो फाइल नाम को जे के भीतर इंटरएक्टिव रूप से उपयोग करने के लिए होता है)

मुझे यकीन है कि यह J की तुलना में बहुत आसान है, जितना कि मैं इसे देखता हूं।

संपादित करें: यह पता लगाया कि जम्मू में बेहतर इनपुट पार्सिंग कैसे करें, चार्ब्स को समाप्त किया, कमांड लाइन इनवोकेशन और आउटपुट पर स्विच किया।

संपादित 2: 3x3 मैट्रिक्स के लिए केंद्रीय फ़ंक्शन का परिवर्तित इनपुट, कई pesky कोष्ठक को हटा दिया, नामों को समाप्त कर दिया

संपादन 3: 0-o'lock संभाला।

स्पष्टीकरण:

मेरा जे अभी भी महान नहीं है, और आईओ हमेशा की तरह एक दर्द है। तो इस के बिट्स loony हैं।

क्रिया 1 0 0+{.#:{.&{:+{.#.1 0 0-~1&{तीन मैट्रिक्स द्वारा तीन लेती है (इनपुट लाइनों से मिलकर, पिछले दो तत्व कचरा हैं)
एच / एम / एस के साथ मिल गया है। (सिर), 1 & {(दूसरा तत्व) के साथ वास्तविक समय, और {और। {: (पूंछ का सिर) के साथ दूसरी गणना।
क्रिया # का उपयोग करता है । घड़ी का समय सेकंड में बदलने के लिए। (डोक्यूमिनेशन देखें।)
यह दूसरी गणना जोड़ता है और फिर 3 तत्व उत्तर पाने के लिए # का उपयोग करता है ।
0 बजे के मामले को आधार परिवर्तन से 1 घंटे पहले 1 घटाकर और उसके बाद 1 जोड़कर नियंत्रित किया जाता है। (दो बिट्स के साथ 1 0 0)
बाकी इनपुट और आउटपुट है, जो वास्तव में ग्रब (हमेशा की तरह) है।
".;._2(1!:1)3 अपूर्ण पदों में 0s के साथ इनपुट का 3 'कॉलम' मैट्रिक्स प्राप्त करता है।
,&}.$~,&3 3&{.&{. इनपुट से पहली पंक्ति को काटता है और शेष पंक्तियों को Nx3x3 में आकार देता है।
"2संशोधित केंद्रीय क्रिया 3x3 मामलों लेने के लिए।
10 10&#:Nx3x2 मैट्रिक्स देने वाले प्रत्येक नंबर के लिए 2 दशमलव अंक देता है। (पेडिंग के लिए क्लिक करना एक दर्द था ।)
,"2":"0 अंक को ASCII (Nx3x2x1) में कनवर्ट करता है और अंतिम कॉलम को उठाता है, जिससे Nx3x2 को फिर से ASCII माना जाता है।
LF,~"1([,':',])/"2 आवेषण: प्रत्येक तत्व के बीच और उन्हें (Nx7) जोड़ देता है और प्रति (Nx8) के लिए एक पंक्ति फ़ीड जोड़ता है।
4(1!:2)~ प्रत्येक पंक्ति को प्रिंट करता है।

— जेसी मिलिकन
स्रोत

4

हास्केल, 159 अक्षर

v(_:x:y:z:h:m:s:t:r)=(w%x+1)&":"$z%y&":"$1%z&"\n"$v$t:r where w=y*z;(%)=mod.div(t+h*w-w+m*z+s)
v _=""
d&c=tail.(shows(d+100)c++)
main=interact$v.map read.words

संपादित करें: (207 -> 200) कभी-कभी divModइसके लायक नहीं होता है!
संपादित करें: (200 -> 178) सुरुचिपूर्ण foldrदृष्टिकोण का उपयोग न करने के लिए दम तोड़ दिया (जो किसी भी संख्या में घटकों के साथ समय प्रणालियों के लिए काम करता है)
संपादित करें: (178 -> 164) इनबिल्ट f
संपादित करें: (164 -> 158) अनावश्यक कोष्ठकों को हटा दिया
संपादित करें: (158 -> 160) थोड़ा सा तीन संपादन पहले शुरू किया: घंटे अब फिर से सही हैं
संपादित करें: (160 -> 159) एक कॉल करने के लिए गिरा दिया tail

— MtnViewMark
स्रोत

सभी आउटपुट में घंटे की भरपाई होती है।

— जॉय एडम्स

@ जोये: अच्छी पकड़! फिक्स्ड।

— मटनवार्क मार्क

3

रूबी, 128 वर्ण

बेशर्मी से अजगर एक से कॉपी करता है:

d=$<.read.split.map(&:to_i);d[0].times{|o|x,y,z,h,m,s,t=d[o*7+1,7];t+=z*(y*h+m)+s;puts ["%02d"]*3*':'%[(t/y/z-1)%x+1,t/z%y,t%z]}

— Ezran
स्रोत

3

हास्केल - 219 आवश्यक अक्षर

import Text.Printf
(#)=div
(%)=mod
n?d=(n-1)%d+1
e a n=mapM(\_->a)[1..n]
main=readLn>>=(e$do{
 a<-e getLine 3;
 let[x,y,z,h,m,s,t]=map read.words=<<a;
    w=y*z;e=h*w+m*z+s+t::Int
  in printf"%02d:%02d:%02d\n"(e#w?x)(e#z%y)(e%z)})

— जॉय एडम्स
स्रोत

2

PHP (241 वर्ण)

एक तर्क के रूप में पारित फ़ाइल से इनपुट लेता है।

foreach(array_chunk(array_slice(file($argv[1]),1),3)as$v){list($x,$y,$z)=split(" ",$v[0]);list($h,$m,$s)=split(" ",$v[1]);$e=($v[2]+$s+$z*($m+$h*$y))%($x*$y*$z);$s=$e%$z;$e/=$z;$m=$e%$y;$h=($e/$y)%$x;printf("%02d:%02d:%02d\n",$h?:$x,$m,$s);}

और अपुष्ट:

$input = array_chunk(array_slice(file($argv[1]),1),3);
foreach($input as $v){
    list($x,$y,$z)=split(" ",$v[0]);
    list($h,$m,$s)=split(" ",$v[1]);
    $t = $v[2];
    $seconds_in_day = $x * $y * $z;
    $total_elapsed = $t + $s + $m*$z + $h*$y*$z;
    $elapsed = $total_elapsed % $seconds_in_day;

    $sec = $elapsed % $z;
    $elapsed /= $z;

    $min = $elapsed % $y;
    $elapsed /= $y;

    $hours = $elapsed % $x;
    if ($hours == 0) $hours = $x;

    printf("%02d:%02d:%02d\n",$hours,$min,$sec);
}

और सिर्फ नोट करने के लिए, बिना सिगल्स (डॉलर के चिन्ह) के, यह 205 वर्णों में आता है।

— ऑस्टिन हाइड
स्रोत

2

जावा, 486 371 वर्ण

Ungolfed संस्करण: http://pastebin.com/6LiTdGyi

यह दिए गए उदाहरणों के समान आउटपुट देता है।

लेकिन मैं उस व्यवहार से असहमत हूं: एक घड़ी में उतने नंबर नहीं होते जितने कि एक दिन में घंटे होते हैं: यह उनमें से आधे हैं।

मतलब कि अगर आप 3600 सेकंड को 12:50:12 पर जोड़ते हैं, तो इसे 01:50:12 प्रिंट करना चाहिए, 13:50:12 (हमारे मानक 24/60/60 सिस्टम में)।

मैंने अपने कोड में इसे संभाला, लेकिन उदाहरणों से मिलान करने के लिए इसे मेरे समाधान में टिप्पणी की। बेशक, यदि आप इस पर विचार करते हैं, तो इनपुट समय को अस्पष्ट माना जा सकता है जब तक कि आप कुछ एएम / पीएम मार्कर नहीं जोड़ते।

लेकिन किसी भी मामले में, पहेली में एक असंगतता है: यदि 00 घंटे को x से बदला जाना चाहिए, तो घंटे> (x / 2) को घंटे से बदल दिया जाना चाहिए - (x / 2)।

संपादित करें: गोल्फ संस्करण:

import java.io.File;import java.util.Scanner;public class U{static int i(Scanner s){return
s.nextInt();}public static void main(String[]g)throws Exception{Scanner s=new Scanner(new File(g[0
]));int n=i(s);while(0!=n--){int J=i(s),K=i(s),L=i(s),P=(i(s)*K*L+i(s)*L+i(s)+i(s))%(J*K*L);System.
out.println(String.format("%02d:%02d:%02d",(0==P/L/K%J)?J:P/L/K%J,P/L%K,P%L));}}}

— tisek
स्रोत

हाय, एक [कोड-गोल्फ] प्रश्न के लिए वर्णों की कुल संख्या में सबसे कम उत्तर की आवश्यकता होती है। इसका मतलब है कि एक गोल्फ की प्रविष्टि, कम से कम: 1. packageघोषणाओं का उपयोग नहीं करना चाहिए ; 2. उपयोग नहीं final; 3. एकल-वर्ण चर नाम और वर्ग नाम का उपयोग करें; 4. आमतौर पर सबसे छोटा कोड संभव बनाने के लिए सबसे चतुर तरीके का उपयोग करें।

— क्रिस जस्टर-यंग

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

— क्रिस जस्टर-यंग

निकट भविष्य में, मैं एक क्लीनअप अभ्यास करूँगा जहाँ गैर-गोल्फ प्रविष्टियों को [कोड-गोल्फ] प्रश्नों से हटा दिया जाएगा। इसलिए, यदि आप एक गोल्फ संस्करण बना सकते हैं (मेरी पहली टिप्पणी देखें), कृपया करें; अन्यथा, आपका उत्तर अगली सफाई पर हटा दिया जाएगा।

— क्रिस जस्टर-यंग

नमस्ते। इसके लिए खेद है। मैं भ्रमित हो गया ... मैं समझ गया कि गोल्फ का मतलब क्या है। मैंने बिना लिंक किए संस्करण को केवल एक कड़ी के रूप में रखा। मुझे उम्मीद है कि इनपुट और अपेक्षित परिणाम के बारे में मेरे संदेह के कारण विशेष रूप से ठीक है। मैंने फिर एक बेहतर गोल्फ वाला संस्करण रखा। सही जावा सबसे अच्छा नहीं है, लेकिन मुझे लगता है कि इस गोल्फ संस्करण को यहां रखने के लिए मैंने काफी कुछ किया है। दोबारा माफी चाहूंगा।

— tisek

@tisek: आपके नए संस्करण के लिए धन्यवाद। यहां आगे भी कोड को छोटा करने का सुझाव दिया गया है: इसके बजाय int[]c={i(s),i(s),i(s),i(s),i(s),i(s),i(s)}, आप उपयोग करना चाह सकते हैं int a=i(s),b=i(s),c=i(s),d=i(s),e=i(s),f=i(s),g=i(s)। हां, आप यहां 11 वर्ण जोड़ते हैं, लेकिन आप प्रत्येक बार उपयोग किए जाने वाले तीन वर्णों को सहेजते हैं c[x], जिसका अर्थ है कि 4 ऐसे उदाहरणों के बाद, यह स्वयं के लिए भुगतान किया जाता है। मैंने 13 ऐसे उदाहरणों को गिना, जिसका मतलब है कि आप कुल मिलाकर 28 पात्रों को बचा सकते हैं!

— क्रिस जस्टर-यंग

2

बैश - 189 वर्ण:

read n
for((i=0;i<n;i++));do
read x y z
read h m s
read t
R=$(((s+m*z+h*y*z+t)%(x*y*z)))
H=$((R/y/z))
R=$((R-H*y*z))
M=$((R/z))
printf"%02d:%02d:%02d\n"$((((H-1)%x+x)%x+1))$M$((R-M*z))
done

— केविन ब्राउन
स्रोत

जैसा कि मुझे याद है कि दूसरा मोड नकारात्मक बीता हुआ सेकंड के लिए है।

वह प्रिंटफ लाइन काम नहीं करती है। के बीच रिक्त स्थान आवश्यक हैंprintfइसके तर्कों के और उन तर्कों के बीच है ...

— मार्क रीड

1

PHP, 229 228 अक्षर

<?$v=file($argv[1]);while(++$i<$v[0]*3){list($x,$y,$z)=split(" ",$v[$i++]);list($h,$m,$s)=split(" ",$v[$i++]);$s=($e=($v[$i]+$s+$m*$z+$h*$y*$z)%($x*$y*$z))%$z;$m=($e/=$z)%$y;printf("%02d:%02d:%02d\n",($e/$y)%$x?$e%$x:$x,$m,$s);}

फ़ाइल को एक तर्क के रूप में स्क्रिप्ट में पारित किया जाना चाहिए

Ungolfed:

<?php

$v = file($argv[1]); // Automatically break the file into an array by line

while(++$i < $v[0]*3){ // Loop for every three lines
  list($x, $y, $z) = explode(" ", $v[$i++]); // Break apart the first line by space
  list($h, $m, $s) = explode(" ", $v[$i++]); // Break apart the second line

  /*
    Add the starting time to the total number of seconds that have passed
    Divide by total amount of seconds in a day
  */

  $time = ($v[$i] + $s + $m * $z + $h * $y * $z) % ($x * $y * $z);

  $seconds = $time % $z;  // Get the number of seconds
  $minutes = ($time /= $z) % $y; // Remove the end amount of seconds, then get the minutes

  /*
    Remove the end amount of hours
    Determine how many hours there would be
    If the number is zero, then output the max hours
    If the number is not zero, output the amount of hours left
  */

  $hours = ($time / $y) % $x? $e % $x : $x;

  // Display the time in the correct format
  printf("%02d:%02d:%02d\n", $hours, $minutes, $seconds);
}

बदलाव का:

229 -> 228: घंटों पर विभाजन करते समय शेष समय निर्धारित करने की आवश्यकता नहीं है

— केविन ब्राउन
स्रोत

1

बैश, 139 अक्षर

read n
while((n--));do
read x y z;read h m s;read t
((t+=z*(y*h+m)+s,a=(t/y/z-1)%x+1,b=t/z%y,c=t%z))
printf %02d:%02d:%02d\\n $a $b $c
done

— मार्क रीड
स्रोत

1

स्केल 184 चार्ट:

object C extends App{val r=new java.util.Scanner(System.in)
def n=r.nextInt
for(j<-1 to n;h=n;m=n;s=n;x=n;y=n;z=n;t=n;d=(x*m+y)*s+z+t){printf("%02d:%02d:%02d\n",d/(m*s)%h,d/s%m,d%s)}
}

नियमों के विरोध में, मेरा दावा है कि, के लिए

14 15 20
1 14 0
-580

आउटपुट नहीं होना चाहिए

14:00:00

परंतु

00:00:00

और यही मेरे कोड का उत्पादन करता है। कृपया मुझे एक घड़ी दिखाएं जो 00:00:00 के बजाय 24:00:00 पृथ्वी पर प्रदर्शित होती है - शायद 24:59:59। या आप अनुक्रम की उम्मीद करते हैं:

23:59:59
24:00:00
00:00:01

के बजाय

23:59:59
00:00:00
00:00:01

— अज्ञात उपयोगकर्ता
स्रोत

पृथ्वी पर, आप 24:00:01 नहीं देखेंगे, लेकिन आप कभी-कभी 'दिन N को 24:00:00' पर 'दिन N + 1 के लिए 00:00:00' के पर्याय के रूप में देखते हैं। यह एक ही समय है, लेकिन एक अलग ध्यान केंद्रित है - 'आधी रात' बनाम 'कल सुबह आधी रात'।

— मार्क रीड

1

पायथन 2 , 137 बाइट्स

lambda T:["%02d:%02d:%02d"%((s/z/y%x,x)[s%x<1],s/z%y,s%z)for x,y,z,h,m,s,t in[T[i:i+7]for i in range(1,len(T),7)]for s in[s+m*z+h*y*z+t]]

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

अन्य पायथन उत्तर की तुलना में केवल थोड़ा छोटा है , लेकिन वहां पहुंचने के लिए एक अलग मार्ग लेता है।

असंगठित व्याख्या:

def f(T):
    # ignore first list element, split list into even chunks of length 7
    for i in range(1, len(T), 7):
        # get variables for sublist
        for x, y, z, h, m, s, t in [T[i:i + 7]]:
            # get total time in seconds, inside a list so that we can use list comprehension
            for s in [s + m*z + h*y*z + t]:
                # split total time into parts
                # seconds: convert seconds to minute, take remainder
                sec = s % z
                # minutes: convert seconds to minutes (discard remainder), convert minutes to hours, take remainder
                min = s / z % y
                # hours: convert seconds to minutes (discard remainder),
                #        convert minutes to hours (discard remainder),
                #        convert hours to days, take remainder
                # if seconds are evenly divisible by total hours, use number of hours in day instead ("midnight")
                hr = (s / z / y % x, x)[s % x < 1]

                print "%02d:%02d:%02d"%(hr, min, sec)

— Triggernometry
स्रोत

0

हास्केल ( 815 624 चार्ट गैर-गोल्फ, खाली लाइनों को छोड़कर)

~~12:00:00 या "मध्यरात्रि" के समान समय के बजाय मेरा 00:00:00 प्रिंट करता है।~~ संपादित करें: वह बदल गया।

main = readFile "in.txt" >> mapM_ print . times . map (map read . words) . tail . lines

times [] = []
times ([x,y,z]:[h,m,s]:[t]:xs) = Time x y z h m s +++ t : times xs

data Time = Time {x,y,z,h,m,s :: Int}
hr t | h t == 0 = x t | otherwise = h t

instance Show Time where show t = pad2 (hr t) ++ ':':pad2 (m t) ++ ':':pad2 (s t)

pad2 x | x < 10 = '0':show x | otherwise = show x

t +++ ss | ss < 0  = t +++ (ss + x'*y'*z') | otherwise = Time x' y' z' h' m' s'
  where (x',y',z') = (x t, y t, z t)
        (ms, s') = (s t + ss) `quotRem` z'
        (hs, m') = (m t + ms) `quotRem` y'
        (_,  h') = (h t + hs) `quotRem` x'

कुछ चीजों को और अधिक सार कर सकते हैं, लेकिन w / e। यह इनपुट फ़ाइल की पहली पंक्ति को पूरी तरह से अनदेखा करता है, और आम तौर पर अनुचित रूप से स्वरूपित फ़ाइलों के लिए आप पर चिल्लाता है।

— दान बर्टन
स्रोत

ध्यान दें कि इस समाधान में दो घंटे, मिनट और सेकंड के लिए दो से अधिक अंकों की अनुमति देना आसान होगा।

— दान बर्टन

"X घंटे वाली घड़ी हमारे (1, 2, 3, ..., x) के समान व्यवस्थित है", इसलिए 00:00:00 मान्य नहीं है। हालांकि उस के लिए समायोजित करने के लिए मुश्किल नहीं होना चाहिए।

— केविन ब्राउन

@ Bass5098 तय किया, और थोड़ा छोटा किया। मैं अभी भी इसे एक अपठनीय रूप में बाहर निकालने के लिए दिल नहीं है, यद्यपि।

— डैन बर्टन

द टाइम ट्रैवलर

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

गोल्फस्क्रिप्ट - 50 चार्ट

अजगर, 142 वर्ण

GolfScript 62 60 अक्षर

जे (172/35) 137 99 107

हास्केल, 159 अक्षर

रूबी, 128 वर्ण

हास्केल - 219 आवश्यक अक्षर

PHP (241 वर्ण)

जावा, 486 371 वर्ण

बैश - 189 वर्ण:

PHP, 229 228 अक्षर

बैश, 139 अक्षर

स्केल 184 चार्ट:

पायथन 2 , 137 बाइट्स

हास्केल ( 815 624 चार्ट गैर-गोल्फ, खाली लाइनों को छोड़कर)