Wprowadzenie

Czas jest zagmatwany. Sześćdziesiąt sekund do minuty, sześćdziesiąt minut do godziny, dwadzieścia cztery godziny do dnia (nie wspominając już o tym nieznośnym am / pm!).

W dzisiejszych czasach nie ma miejsca na taką głupotę, dlatego postanowiliśmy przyjąć jedyną sensowną alternatywę: dni dziesiętne! To znaczy, każdy dzień jest uważany za 1 całość, a cokolwiek krótszego jest zapisywane jako ułamek dziesiętny tego dnia. Na przykład: „12:00:00” można zapisać jako „0,5”, a „01:23:45” jako „0,058159”.

Ponieważ przyzwyczajenie się do nowego systemu zajmie trochę czasu, Twoim zadaniem jest napisanie programu, który może konwertować między nimi w obu kierunkach.

Wyzwanie

Napisz program w wybranym języku, który, biorąc pod uwagę współczesny czas w formacie ISO-8601 „gg: mm: ss”, zwróci równoważną jednostkę ułamka dziesiętnego. Podobnie, biorąc pod uwagę ułamek dziesiętny, program powinien zwrócić czas w nowoczesnym formacie początkowo określonym.

Możesz przyjąć następujące założenia:

• Współczesny czas wejścia i wyjścia może wynosić od „00:00:00” do „24:00:00”
• Wejście i wyjście czasu dziesiętnego może zawierać się w przedziale od „0” do „1” i powinno być możliwe przyjęcie / wyprowadzenie do co najmniej 5 miejsc po przecinku (takich jak „0.12345”). Dopuszczalna jest większa precyzja
• Program powinien wiedzieć, który kierunek konwersji wykonać na podstawie danych wejściowych
• Nie można używać funkcji / bibliotek związanych z czasem

Zwycięzca zostanie określony na podstawie najkrótszego kodu spełniającego kryteria. Zostaną one wybrane w co najmniej 7 jednostkach dziesiętnych lub, jeśli / kiedy liczba zgłoszeń będzie wystarczająca.

Przykłady

Oto (n celowo) źle napisany fragment kodu JavaScript, który można wykorzystać jako przykład:

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

CJam, 58 56 42 bajtów

Jestem pewien, że jest za długi i można w niego dużo grać w golfa. Ale tutaj jest na początek:

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

Wypróbuj online tutaj

Python 2, 159 150 141 + 2 = 143 bajtów

Proste rozwiązanie, może być prawdopodobnie znacznie krótsze. Będzie nad tym pracować.

Dodano dwa bajty, aby uwzględnić dane wejściowe, które muszą być ujęte w „s”. Ponadto Sp3000 wskazał problem z interpretacją ósemkowych przez eval () i pokazał sposób na skrócenie formatowania, użycie map () i usunięcie jednego wydruku.

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

Sprawdź to na ideone tutaj.

JavaScript ( ES6 ), 116 110 bajtów

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))

Skomentowano:

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

Python 3: 143 bajtów

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)

Taki sam bajt jest liczony jak rozwiązanie Pythona 2, ale wygląda na to, że przyjęliśmy inne podejście do matematyki.

Julia, 152 143 142 bajty

Cóż, zaktualizowałem swoje podejście, by być mniej „Julianem”, jak mówią, ze względu na grę w golfa. Aby uzyskać lepsze (choć mniej zwięzłe) podejście, zobacz historię zmian.

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]))

Tworzy to nienazwaną funkcję, która akceptuje ciąg lub 64-bitową liczbę zmiennoprzecinkową i zwraca odpowiednio 64-bitową liczbę zmiennoprzecinkową lub ciąg. Aby to nazwać, nadaj mu nazwę, np f=x->....

Niegolfowane + wyjaśnienie:

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

Przykłady:

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

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

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

C, 137 bajtów

Pełny program C. Pobiera dane wejściowe na standardowe wejście i wyjścia na standardowe wyjście.

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.);}

Nie golfił i skomentował:

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.);
    }
}

J, 85 bajtów

Wyniki:

T '12: 00: 00 '
0,5

T 0,5
12 0 0

T '12: 34: 56 '
0,524259

T 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.'

Razem 85

JavaScript, 194 192 190 188 bajtów

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}

JavaScript ES6, 98 130 bajtów

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);

C 156 156 bajtów

Myślałem, że będzie to łatwe dla C. Ale nadal było dość duże. :(

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);}

Program testowy:

#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;
}

Wynik:

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

PHP, 70 69 bajtów

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

pobiera dane z argumentu wiersza poleceń, wypisuje na STDOUT:

Jeśli dane wejściowe zawierają dwukropek, przelicz na czas uniksowy i podziel przez (sekundy na dzień), w
przeciwnym razie pomnóż wartość liczbową przez (sekundy na dzień) i sformatuj czas unix na hh:mm:ss.

Perl, 109 108 101 + 6 ( -plaF:flaga) = 107 bajtów

$_=$#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

Za pomocą:

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

Wypróbuj na Ideone.

Excel, 178 bajtów

=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)