समय की Qeng हो इकाइयों

Question

वर्नर विंग की उत्कृष्ट और आकर्षक पुस्तक ए डीपनेस इन द स्काई (जो कि, मैं अत्यधिक अनुशंसा करता हूं ¹ ) में, Qeng Ho , एक संस्कृति जो विभिन्न स्टार सिस्टमों को फैलाती है, "दिनों," "महीनों," की कोई धारणा नहीं है। वर्ष, "आदि, और इसलिए एक अद्वितीय टाइमकीपिंग सिस्टम है जो पूरी तरह से सेकंड में समय को मापता है। सबसे अधिक इस्तेमाल किया इकाइयां हैं Ksec (kilosecond), msec (megasecond), और GSEC (gigasecond)। यहाँ पुस्तक की अपनी प्रति से एक आसान चार्ट है (क्योंकि मैं इसे ऑनलाइन नहीं पा सकता):

आप वर्तमान में फाम नुवेन पर उड़ रहे हैं , और आपको " पृथ्वी " नामक एक अजीब, अज्ञात ग्रह से एक संदेश मिला है । ² वे आपकी तुलना में अलग-अलग समय इकाइयों का उपयोग करते हैं, और आपके कंप्यूटर उनकी पहचान नहीं करते हैं। जहाज के निवासी प्रोग्रामर-आर्कियोलॉजिस्ट के रूप में, आपका काम टाइम-हैंडलिंग कोड को पैच करना है ताकि यह समय की पृथ्वी इकाइयों को पहचान सके।

स्वाभाविक रूप से, चूंकि आप केवल एक और कुछ Ksecs के लिए जुकाम से बाहर हैं, आप अपने कोड को यथासंभव कम करना चाहते हैं ताकि इसे जल्दी से लिखा जा सके। सौभाग्य से, एक इंटरस्टेलर ट्रेडिंग संस्कृति के रूप में, क्यूंग हो की आविष्कार की गई प्रत्येक प्रोग्रामिंग भाषा तक पहुंच है।

इनपुट

इनपुट एक एकल स्ट्रिंग होगा जिसमें एक या एक से अधिक स्थान-पृथक घटक होंगे । एक घटक एक पूर्णांक संख्या> 0 और ≤ 255 है, तो एक स्थान के रूप में परिभाषित किया गया है, और फिर से एक second, minute, hour, day, week, month, year, decade, या century, संभवतः बहुवचन (साथ एक अतिरिक्त s, या centuriesपिछले मामले के लिए)।

यहां कुछ मान्य उदाहरण इनपुट दिए गए हैं:

10 days 12 hours
1 year
184 centuries 1 second
9 weeks 6 days 2 hours 1 minute 20 seconds

आप इनपुट के बारे में निम्नलिखित मान सकते हैं:

• इकाइयों का बहुवचन हमेशा प्रासंगिक संख्या से सहमत होगा।

• यदि इनपुट में कई घटक हैं , तो वे हमेशा लंबाई के अवरोही क्रम में रहेंगे।

इस चुनौती के प्रयोजनों के लिए विभिन्न इनपुट इकाइयों का क्या अर्थ है:

unit     relative    absolute
---------------------------------------
second   1 second    1 second
minute   60 seconds  60 seconds
hour     60 minutes  3600 seconds
day      24 hours    86400 seconds
week     7 days      604800 seconds
month    30 days     2592000 seconds
year     365 days    31536000 seconds
decade   10 years    315360000 seconds
century  10 decades  3153600000 seconds

उत्पादन

यहाँ Qeng Ho इकाइयाँ हैं जिनका आपके कोड को समर्थन करना है:

unit    relative      absolute
----------------------------------------
second  1 second      1 second
Ksec    1000 seconds  1000 seconds
Msec    1000 Ksecs    1000000 seconds
Gsec    1000 Msecs    1000000000 seconds

अपने कोड का आउटपुट निर्धारित करने के लिए निम्न एल्गोरिथम का उपयोग करें:

• सबसे पहले, इनपुट का प्रतिनिधित्व करने वाले कुल समय को जोड़ दें।

• सबसे बड़ी Qeng हो इकाई का पता लगाएं जो छोटा है या इनपुट के रूप में उतना ही समय है - अनिवार्य रूप से, सबसे बड़ी इकाई को खोजें जो कम से कम है।

• इस इकाई में इनपुट में दिए गए समय की कुल राशि को रूपांतरित करें, और परिणाम को तीन दशमलव स्थानों तक गोल कर दें।

आपके पास निम्नलिखित में से किस विधि का उपयोग करने की आपकी पसंद हो सकती है: ऊपर की ओर, नीचे की ओर, गोल से शून्य की ओर, या round या -∞ की ओर गोल। यदि गोल परिणाम समाप्त होता है 0, तो आप या तो अनुगामी शून्य को हटा सकते हैं या जितने चाहें रख सकते हैं (या इनपुट के आधार पर दोनों करते हैं)।

गोल परिणाम वास्तव में है 1.000, तो आप विलक्षण रूप का उपयोग करना चाहिए ( second, Ksec, Msec, Gsec); अन्यथा, बहुवचन रूप का उपयोग करें ( seconds, Ksecs, Msecs, Gsecs)।

कुछ धार-मामलों में, आप उदाहरण के लिए, Ksec की इकाई का उपयोग कर सकते हैं, लेकिन 1000.000 Ksecs का एक गोल परिणाम प्राप्त कर सकते हैं। इस स्थिति में, आप 1000.000 Ksecsइसके बजाय बस आउटपुट कर सकते हैं 1 Msec।

आप हमेशा मान सकते हैं कि इनपुट इकाइयों (शताब्दी, दशक, वर्ष, आदि) के अवरोही क्रम में है; इसके अलावा, किसी भी इकाई के बाद आने वाला घटक हमेशा छोटा होगा (अर्थात, 1 decade 20 yearsअमान्य इनपुट है)।

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

नोट: एक *अंतर के साथ चिह्नित परिणाम ( ) गोलाई अंतर के कारण एक नगण्य राशि से भिन्न हो सकते हैं।

input                                         output
-------------------------------------------------------------
1 hour                                        3.600 Ksecs
1 day                                         86.400 Ksecs
2 weeks                                       1.210 Msecs
1 year                                        31.536 Msecs
32 years                                      1.009 Gsecs   *
1 second                                      1.000 second
1 century 6 decades                           5.046 Gsecs   *
255 centuries                                 804.168 Gsecs
2 weeks 6 days 1 hour 19 minutes 4 seconds    1.733 Msecs
1 week 3 days 3 hours 7 minutes               875.220 Ksecs
1 week 4 days 13 hours 46 minutes 40 seconds  1.000 Msec
2 months 2 hours                              5.191 Msecs   *
16 minutes 39 seconds                         999.000 seconds

नियम

• यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है।

---

^{1: केवल अगर आपको हार्ड स्कफ़ी पसंद है, तो अवश्य। किस मामले में मैं पहले एक आग को पढ़ने की सलाह देता हूं , जो कि (मेरी राय में) और भी शानदार है।}

^{2: ठीक है, तकनीकी रूप से "ओल्ड अर्थ" का उल्लेख कई बार ए डीपनेस इन द स्काई में किया गया है , लेकिन ...}

Comments

टेस्ट केस 9 गलत लगता है (मेरा उत्तर देखें)

— edc65

यह जहाज पृथ्वी का समय नहीं जानता है, लेकिन सभी पृथ्वी प्रोग्रामिंग भाषाओं की पूरी समझ है । बहुत तार्किक है। </ कटाक्ष>

— ताली बजाएं

डांग, मेरे पास बिल्ट-इन यूनिट सपोर्ट का उपयोग करते हुए वास्तव में एक छोटा मैथमेटिका समाधान था, लेकिन यह 2 months 2 hours"2 * 2" घंटे के रूप में व्याख्या करता है।

— २०१२ आर्कम्पियन

हम्म, मुझे लगता है कि ये कारक अप्रचलित समय से निपटने वाले कार्यों की तरह अजीब दिखते हैं जो इन भाषाओं में बहुत अधिक उपयोग नहीं करते हैं।

— रैंडम 832

@DarrelHoffman उनकी तिथि प्रणाली 1 जनवरी, 1970 पर आधारित है। सॉफ्टवेयर पुरातत्वविद् एक पेशा है - जो सदियों पुराने कार्यक्रमों को खोदने और डिबग करने के लिए है। दूसरी बार, Qeng हो ने उस उदाहरण से गिना जो एक मानव ने पहली बार ओल्ड अर्थ के चंद्रमा पर पैर रखा था। लेकिन अगर आप इसे और अधिक बारीकी से देखते हैं ... शुरुआती उदाहरण वास्तव में पंद्रह मिलियन सेकंड के बाद था, मानव जाति के पहले कंप्यूटर ऑपरेटिंग सिस्टम में से 0-सेकंड।

Answer 1

APL (Dyalog APL) , 157 156 154 151 154 141 142 बाइट्स

{∊(3⍕N)' '((B/S⊃' KMG')'sec','ond'/⍨~B←T≥1E3),'s'/⍨1≠N←T÷1E3*S←⌊1E3⍟T←+/×/↑⍎¨'\d+ .a?i?'⎕S'&'⊢⍵⊣c←10×d←10×⊃y m w←365 30 7×da←24×h←×⍨mi←60×s←1}

13 बाइट्स बंद करने के लिए ngn करने के लिए धन्यवाद।

⎕IO←0कई एपीएल में डिफ़ॉल्ट होना चाहिए ।

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

Comments

यदि आप 1E3 को एक नाम (जैसे z) असाइन करते हैं, तो पहले उदाहरण में आपने दो वर्णों को बर्बाद किया है, दूसरे उदाहरण में आप पहले से ही एक को सहेज चुके हैं, और तीसरे उदाहरण से आगे आप दो वर्णों को बचा रहे हैं। क्या तुम नहीं?

— lstefano

@lstefano नहीं, पहले 4 का खर्च आएगा ⌊1E3⍟→ ⌊(z←1E3)⍟और फिर अगले में से प्रत्येक पर 2 बचाएं 1E3→ z।

— आदम

हाँ, बिल्कुल सही। और यह देखते हुए कि उनमें से केवल 3 हैं, कोई लाभ नहीं। शोर के लिए क्षमा करें।

— lstefano

Answer 2

जावास्क्रिप्ट (ईएस 6) 255

f=s=>(s=s.replace(/(\d+) (..)/g,(_,n,u)=>t+={se:1,mi:60,ho:3600,da:86400,we:604800,mo:2592e3,ye:31536e3,de:31536e4,ce:31536e5}[u]*n,t=0),[a,b]=t>=1e9?[t/1e9,' Gsec']:t>=1e6?[t/1e6,' Msec']:t>999?[t/1e3,' Ksec']:[t,' second'],a.toFixed(3)+b+(a-1?'s':''))  

// test

console.log=x=>O.innerHTML+=x+'\n'

;[
 ['1 hour','3.600 Ksecs']
,['1 day','86.400 Ksecs']
,['2 weeks','1.210 Msecs']
,['1 year','31.536 Msecs']
,['32 years','1.009 Gsecs'] 
,['1 second','1.000 second']
,['1 century 6 decades','5.046 Gsecs']
,['255 centuries','804.168 Gsecs']
,['2 weeks 6 days 1 hour 19 minutes 4 seconds','1.733 Msecs']
,['1 week 3 days 3 hours 7 minutes','875.220 Ksecs']
,['1 week 4 days 13 hours 46 minutes 40 seconds', '1.000 Msec']
,['2 months 2 hours', '5.191 Msecs']
,['16 minutes 39 seconds', '999 seconds']
].forEach(t=>console.log(t[0]+' '+f(t[0])+' (Check:'+t[1]+')'))

<pre id=O></pre>

Answer 3

पायथन, 366 363 बाइट्स

d={};l=1;q=str.replace;i=q(raw_input(),"ie","y")
for u,t in zip('second minute hour day week month year decade century'.split(),(1,60,60,24,7,30./7,73./6,10,10)):l=t*l;d[u]=d[u+"s"]=l
while" "in i:
 i=q(q(i," ","*",1)," ","+",1)
q=eval(i,d);f={};l=1
for u in('second','Ksec','Msec','Gsec'):
 l*=1e3
 if q<l:q=q*1e3/l;print"%.3f %s%s"%(q,u,("s","")[q<1.001]);break

Comments

आपके पास q=eval(i,d);f={};l=1लाइन में अनावश्यक इंडेंटेशन है , जो कोड को तोड़ता है। इसके अलावा, आप का उपयोग करके 2 बाइट्स बचा सकता है 10.और 73.बजाय 10.0और 73.0। इसके अलावा, अंतरिक्ष के बाद की कोई जरूरत नहीं है print।

— अगस्त

Answer 4

SpecBAS - 476 471 बाइट्स

क्योंकि कुछ भी नहीं कहा जाता है "हमारी तकनीकी श्रेष्ठता से पहले cower" लाइन नंबर और गोटो बयानों से बेहतर है :-)

1 INPUT e$: DIM t$(SPLIT e$,NOT " "): DIM m=31536e5,31536e4,31536e3,2592e3,604800,86400,3600,60,1
2 LET q=0,n$=" cedeyemowedahomise"
3 FOR i=1 TO ARSIZE t$() STEP 2: LET t=VAL t$(i),u$=t$(i+1)( TO 2),p=POS(u$,n$)/2: INC q,t*m(p): NEXT i
4 IF q>=1e9 THEN LET r=q/1e9,r$=" G": GO TO 8
5 IF q>=1e6 THEN LET r=q/1e6,r$=" M": GO TO 8
6 IF q>999 THEN LET r=q/1e3,r$=" K": GO TO 8
7 IF q<1e3 THEN LET r=q,r$=" "
8 PRINT USING$("&.*0###",r);r$;"sec"+("ond" AND q<1e3)+("s" AND r>1)

Answer 5

C # (LinqPad में फ़ंक्शन के रूप में), 460 बाइट्स

void Main(){var x=Console.ReadLine().Split(' ');long s=0,v,i=0;for(;i<x.Length;){v=long.Parse(x[i++]);var w=x[i++].Substring(0,2);s+=w=="ce"?v*3153600000:w=="de"?v*315360000:w=="ye"?v*31536000:w=="mo"?v*2592000:w=="we"?v*604800:w=="da"?v*86400:w=="ho"?v*3600:w=="mi"?v*60:v;}decimal k=1000,m=k*k,g=m*k,r=0;var o="sec";r=s/g>=1?s/g:s/m>=1?s/m:s/k>=1?s/k:s;o=s/g>=1?"G"+o:s/m>=1?"M"+o:s/k>=1?"K"+o:o+"ond";Console.WriteLine(Math.Round(r,3)+" "+o+(r==1?"":"s"));}

ungolfed:

void Main()
{
    var x=Console.ReadLine().Split(' ');
    long s=0,v,i=0;
    for(;i<x.Length;)
    {
        v=long.Parse(x[i++]);
        var w=x[i++].Substring(0,2);
        s+=w=="ce"?v*3153600000:w=="de"?v*315360000:w=="ye"?v*31536000:w=="mo"?v*2592000:w=="we"?v*604800:w=="da"?v*86400:w=="ho"?v*3600:w=="mi"?v*60:v;
    }
    decimal k=1000,m=k*k,g=m*k,r=0;
    var o="sec";
    r=s/g>=1?s/g:s/m>=1?s/m:s/k>=1?s/k:s;
    o=s/g>=1?"G"+o:s/m>=1?"M"+o:s/k>=1?"K"+o:o+"ond";
    Console.WriteLine(Math.Round(r,3)+" "+o+(r==1?"":"s"));
}

Answer 6

गणितज्ञ 296 281 बाइट्स

h: इनपुट स्ट्रिंग को मात्रा परिमाण और इकाइयों की सूची में तोड़ने के बाद, Capitalizeऔर Pluralizeइनपुट इकाइयों को गणितज्ञ के रूप में परिवर्तित करें Quantity, जिसमें से कुल सेकंड की संख्या प्राप्त होती है।

dसेकंड को उपयुक्त इकाइयों में परिवर्तित करता है। sयदि समय 1 यूनिट (किसी भी प्रकार) से मेल खाता है, तो अंतिम हटा दिया जाता है।

कोड में मामूली समायोजन के साथ, इस दृष्टिकोण को प्राकृतिक भाषा इनपुट को किसी भी माप प्रणाली, पारंपरिक या नहीं में परिवर्तित करने के लिए काम करना चाहिए।

h=Tr[UnitConvert[Quantity@@{ToExpression@#,Capitalize@Pluralize@#2},"Seconds"]&@@@Partition[StringSplit@#,2]][[1]]&;
d=ToString[N@#/(c=10^{9,6,3,0})[[p=Position[l=NumberDecompose[#,c],x_/;x>0][[1,1]]]]]<>StringDrop[{" Gsecs"," Msecs"," Ksecs"," seconds"}[[p]],-Boole[Tr[l]==1]]&
z=d@h@#&;

---

तालिका के रूप में रखें:

z1[n_]:={n,z@n}

Grid[z1 /@ {"1 hour", "2 day", "2 weeks", "1 year", "32 years", 
   "1 second", "1 century 6 decades", "255 centuries", 
   "2 weeks 6 days 1 hour 7 minutes", 
   "1 week 3 days 3 hours 46 minutes 40 seconds", 
   "1 week 4 days 13 hours 46 minutes 40 seconds", "2 months 2 hours",
    "16 minutes 39 seconds"}, Alignment -> Right]

Answer 7

हास्केल, 565 555 बाइट्स

import Data.List
import Numeric
import Data.Bool
i=isPrefixOf
s x=showFFloat(Just 3)x""
r=read
f=fromIntegral
b=bool"s"""
c=b.(=="1.000")
h(c:u:l)
 |i"s"u=(r c)+h l
 |i"mi"u=(r c*60)+h l
 |i"h"u=(r c*3600)+h l
 |i"da"u=(r c*86400)+h l
 |i"w"u=(r c*604800)+h l
 |i"mo"u=(r c*2592000)+h l
 |i"y"u=(r c*31536000)+h l
 |i"de"u=(r c*315360000)+h l
 |True=(r c*3153600000)+h l
h _=0
q i
 |v<-s((f i)/10^9),i>=10^9=v++" Gsec"++c v
 |v<-s((f i)/10^6),i>=10^6=v++" Msec"++c v
 |v<-s((f i)/1000),i>=1000=v++" ksec"++c v
 |True=show i++" second"++b(i==1)
t=q.h.words

मुझे यकीन है कि मुझे यहाँ बहुत सारे गोल्फिंग अवसर याद आ रहे हैं ... एक गोल्फर होने की कीमत जो मुझे लगता है।

मेरा उत्तर एक फ़ंक्शन है जो पृथ्वी समय को इनपुट पैरामीटर के रूप में युक्त करता है और क्यूंग हो समय को वापस करता है।

पुनश्च: मैं बेवकूफी के बारे में 3 अंकों की सटीकता के बारे में भूल गया ... जो बाइट को गिनता है।

PPS: बेहतर रूप से चुने गए शीर्ष-स्तरीय अभिव्यक्ति 10 बाइट्स से मुंडा हुआ है ... और इसे अब बूट करने के लिए सटीक होना चाहिए।

Answer 8

मतलाब 315 बाइट्स

K='cedeyemowedahomiseconds';Q=' KMGT';for j=1:9;y(j)=double(~isempty(strfind(S,K(2*j-1:2*j))));end
y(y==1)=sscanf(S,repmat('%d %*s ',1,9));y=86400*sum(datenum([sum(y(1:3)*10.^[2;1;0]),y(4),y(5:6)*[7;1],y(7:9)]));z=floor(log10(y)/3);y=num2str(y/10^(3*z)+1e-4);[y(1:4),' ',Q(z+1),K(17:23-(y(1:4)=='1.00'))]

परीक्षा:

S = '2 centuries 1 decade 2 years 3 months 3 weeks 4 days 1 hour 44 minutes 58 seconds';

आउटपुट:

ans =
6.69 Gseconds