दिन रूपांतरण का समय

Question

परिचय

समय भ्रमित कर रहा है। एक मिनट के लिए साठ सेकंड, एक घंटे से साठ मिनट, एक दिन के चौबीस घंटे (और उस pesky am / pm का उल्लेख नहीं करने के लिए!)।

आजकल इस तरह की मूर्खता के लिए कोई जगह नहीं है, इसलिए हमने एकमात्र समझदार विकल्प अपनाने का फैसला किया है: दशमलव के दिन! यह कहना है, प्रत्येक दिन को 1 पूरी इकाई माना जाता है, और कुछ भी छोटा उस दिन के दशमलव अंश के रूप में लिखा जाता है। इसलिए, उदाहरण के लिए: "12:00:00" को "0.5" के रूप में लिखा जाएगा, और "01:23:45" को "0.058159" के रूप में लिखा जा सकता है।

क्योंकि नई प्रणाली के लिए उपयोग होने में समय लगेगा, आपको एक प्रोग्राम लिखने का काम सौंपा गया है जो दोनों दिशाओं में उनके बीच परिवर्तित हो सकता है।

चुनौती

अपनी पसंद की भाषा में एक कार्यक्रम लिखें, जिसने "hh: mm: ss" के ISO-8601 प्रारूप में एक आधुनिक समय दिया, समकक्ष दशमलव अंश इकाई को लौटाएगा। इसी तरह, दशमलव अंश को देखते हुए, कार्यक्रम को शुरू में निर्दिष्ट आधुनिक प्रारूप में समय लौटाना चाहिए।

आप निम्नलिखित अनुमान लगा सकते हैं:

• आधुनिक समय इनपुट और आउटपुट "00:00:00" से "24:00:00" तक हो सकता है
• दशमलव समय इनपुट और आउटपुट "0" से लेकर "1" तक हो सकता है, और कम से कम 5 दशमलव स्थानों (जैसे "0.12345") को स्वीकार / आउटपुट करने में सक्षम होना चाहिए। अधिक परिशुद्धता स्वीकार्य है
• कार्यक्रम को यह जानने में सक्षम होना चाहिए कि इनपुट के आधार पर किस रूपांतरण दिशा में प्रदर्शन करना है
• आप समय संबंधी कार्यों / पुस्तकालयों का उपयोग नहीं कर सकते

विजेता को सबसे कम कोड द्वारा निर्धारित किया जाएगा जो मानदंडों को पूरा करता है। उनका चयन कम से कम 7 दशमलव दिन इकाइयों में किया जाएगा, या यदि / जब पर्याप्त प्रस्तुतियाँ हो गई हों।

उदाहरण

यहां उदाहरण के रूप में उपयोग किए जाने वाले जावास्क्रिप्ट कोड का खराब (जानबूझकर) लिखा गया टुकड़ा है:

function decimalDay(hms) {
    var x, h, m, s;
    if (typeof hms === 'string' && hms.indexOf(':') > -1) {
        x = hms.split(':');
        return (x[0] * 3600 + x[1] * 60 + x[2] * 1) / 86400;
    }
    h = Math.floor(hms * 24) % 24;
    m = Math.floor(hms * 1440) % 60;
    s = Math.floor(hms * 86400) % 60;
    return (h > 9 ? '' : '0') + h + ':' + (m > 9 ? '' : '0') + m + ':' + (s > 9 ? '' : '0') + s;
}
decimalDay('02:57:46'); // 0.12344907407407407
decimalDay('23:42:12'); // 0.9876388888888888
decimalDay(0.5); // 12:00:00
decimalDay(0.05816); // 01:23:45

Comments

हम्म ... 60 लगभग 64 है। मुझे आश्चर्य है कि अगर एक मिनट में 64 सेकंड और एक घंटे में 64 मिनट (और एक दिन में 16 या 32 घंटे) होंगे तो क्या होगा।

क्या हमें लीप सेकंड संभालना है? इसलिए 23:59:60 86401 दूसरे दिन के अंत से 1 सेकंड है?

— जूल

@ छलांग के बारे में चिंता करने की कोई ज़रूरत नहीं है। यह भविष्य है, जहां हमने तय किया है कि एक सेकंड के लिए मूर्खतापूर्ण माना जाता है, जबकि इसे पृथ्वी के रोटेशन की सापेक्ष गति से बांधते हुए एक निरपेक्ष मूल्य माना जाता है;)

— मौर्य 247

@

— मिचेल्ट

@ Mwr247 हां। DNS TTL है (है?) एक क्षेत्र है nजहाँ n2 ^ n सेकंड है। इसलिए '6' के मूल्य में लगभग 1 मिनट का TTL था। '12' के मान में लगभग 1 घंटे का TTL था। '15' लगभग 8 घंटे का समय था। इसने एक बाइट को टाइमआउट को परिभाषित करने और आपको कम या लंबे समय के लिए पर्याप्त नियंत्रण देने की अनुमति दी।

Answer 1

CJam, 58 56 42 बाइट्स

मुझे यकीन है कि यह बहुत लंबा है और इसे बहुत बड़ा किया जा सकता है। लेकिन यहाँ शुरुआत के लिए चला जाता है:

86400q':/:d_,({60bd\/}{~*i60b{s2Ue[}%':*}?

इसे यहाँ ऑनलाइन आज़माएँ

Comments

हे, हमारे पास इसी तरह के विचार हैं

— एडिट्स ने छोड़ दिया क्योंकि एसई EVIL

@aditsu ओह! मेरा अद्यतन करने से पहले तुम्हारा नहीं देखा और फिर हंगामा करने की जल्दी में था।

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

तुम्हें पता है क्या .. मेरे कोड का उपयोग करने के लिए स्वतंत्र महसूस हो 86400q':/:d_,({60bd\/}{~*mo60bAfmd2/':*}?रहा है :, मैं अपना जवाब हटा रहा हूं। ऐसा moइसलिए है कि 0.058159 01:23:45 में परिवर्तित हो जाता है

— aditsu छोड़ दिया क्योंकि SE EVIL

Answer 2

अजगर 2, 159 150 141 + 2 = 143 बाइट्स

सीधा समाधान, शायद बहुत कम हो सकता है। उस पर काम करेंगे।

इनपुट करने के लिए दो बाइट्स को "s" में संलग्न करने की आवश्यकता है। इसके अलावा, Sp3000 ने अष्टक () की व्याख्या करने वाले अष्टक के साथ एक मुद्दा बताया, और प्रारूपण को छोटा करने, मानचित्र का उपयोग करने (और एक प्रिंट को हटाने) का रास्ता दिखाया।

n=input();i=float;d=864e2
if':'in n:a,b,c=map(i,n.split(':'));o=a/24+b/1440+c/d
else:n=i(n);o=(':%02d'*3%(n*24,n*1440%60,n*d%60))[1:]
print o

इसे यहाँ ideone पर देखें।

Answer 3

जावास्क्रिप्ट ( ईएस 6 ), 116 110 बाइट्स

f=x=>x[0]?([h,m,s]=x.split(':'),+s+m*60+h*3600)/86400:[24,60,60].map(y=>('0'+~~(x*=y)%60).slice(-2)).join(':')


// for snippet demo:
i=prompt();
i=i==+i?+i:i; // convert decimal string to number type
alert(f(i))

टिप्पणी की:

f=x=>
    x[0] ? // if x is a string (has a defined property at '0')
        ([h, m, s] = x.split(':'), // split into hours, minutes, seconds
        +s + m*60 + h*3600) // calculate number of seconds
        / 86400 // divide by seconds in a day
    : // else
        [24, 60, 60]. // array of hours, minutes, seconds
        map(y=> // map each with function
            ('0' + // prepend with string zero
                ~~(x *= y) // multiply x by y and floor it
                % 60 // get remainder
            ).slice(-2) // get last 2 digits
        ).join(':') // join resulting array with colons

Comments

24:00:00पैदा करता है, 1लेकिन उलटा सच नहीं है

— rink.attenders.6

@ rink.attenders.6 फिक्स्ड

— nadcore

Answer 4

पायथन 3: 143 बाइट्स

i,k,l,m=input(),60,86400,float
if'.'in i:i=m(i)*l;m=(3*':%02d'%(i/k/k,i/k%k,i%k))[1:]
else:a,b,c=map(m,i.split(':'));m=(a*k*k+b*k+c)/l
print(m)

अजगर 2 समाधान के रूप में एक ही बाइट की गिनती करता है, लेकिन ऐसा लगता है कि हमने गणित के लिए अलग-अलग तरीके अपनाए।

Answer 5

जूलिया, 152 143 142 बाइट्स

खैर, मैंने अपने दृष्टिकोण को "जूलियन" होने के लिए अद्यतन किया, जैसा कि वे कहते हैं, गोल्फिंग के लिए। एक बेहतर (हालांकि कम संक्षिप्त) दृष्टिकोण के लिए, संशोधन इतिहास देखें।

x->(t=[3600,60,1];d=86400;typeof(x)<:String?dot(int(split(x,":")),t)/d:(x*=d;o="";for i=t q,x=x÷i,x%i;o*=lpad(int(q),2,0)*":"end;o[1:end-1]))

यह एक अनाम फ़ंक्शन बनाता है जो एक स्ट्रिंग या 64-बिट फ़्लोटिंग पॉइंट संख्या को स्वीकार करता है और क्रमशः 64-बिट फ़्लोटिंग पॉइंट नंबर या स्ट्रिंग देता है। इसे कॉल करने के लिए, इसे एक नाम दें, जैसेf=x->... ।

असंगठित + स्पष्टीकरण:

function f(x)
    # Construct a vector of the number of seconds in an hour,
    # minute, and second
    t = [3600, 60, 1]

    # Store the number of seconds in 24 hours
    d = 86400

    # Does the type of x inherit from the type String?
    if typeof(x) <: String
        # Compute the total number of observed seconds as the
        # dot product of the time split into a vector with the
        # number of seconds in an hour, minute, and second
        s = dot(int(split(x, ":")), t)

        # Get the proportion of the day by dividing this by
        # the number of seconds in 24 hours
        s / d
    else
        # Convert x to the number of observed seconds
        x *= d

        # Initialize an output string
        o = ""

        # Loop over the number of seconds in each time unit
        for i in t
            # Set q to be the quotient and x to be the remainder
            # from x divided by i
            q, x = divrem(x, i)

            # Append q to o, padded with zeroes as necessary
            o *= lpad(int(q), 2, 0) * ":"
        end

        # o has a trailing :, so return everything up to that
        o[1:end-1]
    end
end

उदाहरण:

julia> f("23:42:12")
0.9876388888888888

julia> f(0.9876388888888888)
"23:42:12"

julia> f(f("23:42:12"))
"23:42:12"

Answer 6

सी, 137 बाइट्स

पूर्ण सी कार्यक्रम। स्टड पर इनपुट लेता है और स्टडआउट पर आउटपुट देता है।

main(c){float a,b;scanf("%f:%f:%d",&a,&b,&c)<3?c=a*86400,printf("%02d:%02d:%02d",c/3600,c/60%60,c%60):printf("%f",a/24+b/1440+c/86400.);}

असंबद्ध और टिप्पणी:

int main() {
    // b is float to save a . on 1440
    float a,b;
    // c is int to implicitly cast floats
    int c;

    // If the input is hh:mm:ss it gets splitted into a, b, c
    // Three arguments are filled, so ret = 3
    // If the input is a float, it gets stored in a
    // scanf stops at the first semicolon and only fills a, so ret = 1
    int ret = scanf("%f:%f:%d", &a, &b, &c);

    if(ret < 3) {
        // Got a float, convert to time
        // c = number of seconds from 00:00:00
        c = a * 86400;
        printf("%02d:%02d:%02d", c/3600, c/60 % 60, c%60);
    }
    else {
        // a = hh, b = mm, c = ss
        // In one day there are:
        // 24 hours
        // 1440 minutes
        // 86400 seconds
        printf("%f", a/24 + b/1440 + c/86400.);
    }
}

Comments

स्कैनफ और% f का बहुत स्पष्ट उपयोग

— कुछ उपयोगकर्ता

डी 'ओह! मेरा मतलब था "चतुर"।

— कुछ उपयोगकर्ता

Answer 7

जे, 85 बाइट्स

परिणाम:

टी '12: 00: 00'
0.5

टी 0.5
12 0 0

टी '12: 34: 56 '
0.524259

टी 0.524259
12 34 56

T=:3 :'a=.86400 if.1=#y do.>.(24 60 60#:y*a)else.a%~+/3600 60 1*".y#~#:192 24 3 end.'

कुल 85

Comments

साइट पर आपका स्वागत है! मैंने आपकी पोस्ट को एडिट किया ताकि कोड के रूप में कोड प्रदर्शित हो। एक ऑनलाइन लिंक के लिए, सबसे अच्छा मैं जानता हूँ कि TIO है । मैं आपको एक लिंक दूंगा, लेकिन मैं J के साथ अनुभवी नहीं हूं, इसलिए मुझे इसे लागू करने का सही तरीका नहीं पता है। इसके अलावा, यह 91 बाइट्स लगता है जब आप पहली और आखिरी पंक्तियों को शामिल करते हैं। क्या ये सही है?

— जेम्स

आपकी सहायताके लिए धन्यवाद! कार्यक्रम [a = ... to end।] 77 है। शीर्षक 10 है। टर्मिनेटर 1 है, जिससे 88 बनता है। तीन लाइन के साथ फ़ीड्स जो 91 बनाती है! मैं इस पर काम करूँगा: o)

— रिचर्ड डोनोवन

अब एक 85 बाइट वन-लाइनर के नीचे!

— रिचर्ड डोनोवन

Answer 8

जावास्क्रिप्ट, 194 192 190 188 बाइट्स

function(z){if(isNaN(z)){x=z.split(':');return x[0]/24+x[1]/1440+x[2]/86400}h=(z*24)|0;h%=24;m=(z*1440)|0;m%=60;s=(z*86400)|0;s%=60;return""+(h>9?'':0)+h+':'+(m>9?'':0)+m+':'+(s>9?'':0)+s}

Answer 9

जावास्क्रिप्ट ईएस 6, 98 130 बाइट्स

s=>s==+s?'246060'.replace(/../g,l=>':'+('0'+~~(s*=+l)%60).slice(-2)).slice(1):s.split`:`.reduce((a,b)=>+b+(+a)*60)*1/864e2;f(0.5);

Comments

दुर्भाग्य से, इस चुनौती में समय से संबंधित कार्य (जैसे "दिनांक" और "टाइमस्ट्रीमिंग") की अनुमति नहीं है। अन्यथा, इसे करने का एक बहुत अधिक संक्षिप्त तरीका है =)

— Mwr247

@ Mwr247 ओह ने यह नहीं देखा कि, मैं इसे ठीक कर

— दूंगा

Answer 10

सी, 156 152 बाइट्स

मैंने सोचा कि यह सी के लिए आसान होने जा रहा है, लेकिन अभी भी काफी बड़ा है। :(

n,m=60;d(char*s){strchr(s,58)?printf("%f",(float)(atoi(s)*m*m+atoi(s+3)*m+atoi(s+6))/m/m/24):printf("%02d:%02d:%02d",(n=atof(s)*m*m*24)/m/m,n/m%m,n%m);}

परीक्षण कार्यक्रम:

#include <stdio.h>
#include <stdlib.h>

int n,m=60;
d(char*s)
{
    strchr(s,':') ? 
        printf("%f",(float)(atoi(s)*m*m+atoi(s+3)*m+atoi(s+6))/m/m/24):
        printf("%02d:%02d:%02d",(n=atof(s)*m*m*24)/m/m,n/m%m,n%m);
}

int main()
{
    d("01:23:45");
    printf("\n");
    d("02:57:46");
    printf("\n");
    d("23:42:12");
    printf("\n");
    d("12:00:00");
    printf("\n");
    d("0.5");
    printf("\n");
    d("0.05816");
    printf("\n");
    d("0");
    printf("\n");
    d("1");
    printf("\n");
    return 0;
}

आउटपुट:

0.058160
0.123449
0.987639
0.500000
12:00:00
01:23:45
00:00:00
24:00:00

Answer 11

PHP, 70 69 बाइट्स

<?=strpos($t=$argv[1],58)?strtotime($t)/86400:date("H:i:s",$t*86400);

कमांड लाइन तर्क से इनपुट लेता है, STDOUT पर प्रिंट करता है:

यदि इनपुट में एक बृहदान्त्र होता है, तो यूनिक्स समय में परिवर्तित करें और प्रति सेकंड (सेकंड) से विभाजित करें,
और (प्रति दिन सेकंड) के साथ संख्यात्मक मान को गुणा करें और यूनिक्स समय को प्रारूपित करें hh:mm:ss।

Answer 12

पर्ल, 109 108 101 + 6 ( -plaF:ध्वज) = 107 बाइट्स

$_=$#F?($F[0]*60+$F[1]+$F[2]/60)/1440:sprintf"%02d:%02d:%02d",$h=$_*24,$m=($h-int$h)*60,($m-int$m)*60

का उपयोग करते हुए:

perl -plaF: -e '$_=$#F?($F[0]*60+$F[1]+$F[2]/60)/1440:sprintf"%02d:%02d:%02d",$h=$_*24,$m=($h-int$h)*60,($m-int$m)*60' <<< 01:23:45

Ideone पर इसे आज़माएं।

Answer 13

एक्सेल, 178 बाइट्स

=IF(LEFT(A1,2)="0.",TEXT(FLOOR(A1*24,1),"00")&":"&TEXT(MOD(FLOOR(A1*1440,1),60),"00")&":"&TEXT(MOD(FLOOR(A1*86400,1),60),"00"),((LEFT(A1,2)*60+MID(A1,4,2))*60+RIGHT(A1,2))/86400)