Przeliczenie dziesiętnej pory dnia

15

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
Mwr247
źródło
Hmm ... 60 to prawie 64. Zastanawiam się, jaki byłby czas, gdyby były 64 sekundy na minutę i 64 minuty na godzinę (i 16 lub 32 godziny na dzień).
1
Czy mamy do czynienia z sekundami przestępnymi? więc 23:59:60 to 1 sekunda od końca 86401 drugiego dnia?
Sparr,
1
@Sparr Nie musisz się martwić o sekundy przestępne. To jest przyszłość, w której zdecydowaliśmy, że to głupie, że sekundę uważa się za wartość bezwzględną, wiążąc ją również ze względną prędkością obrotu ziemi;)
Mwr247,
1
@MichaelT Byłby to świat marzeń dla programistów = P
Mwr247,
1
@ Mwr247 tak. DNS TTL ma (miał?) Pole, w nktórym njest 2 ^ n sekund. Tak więc wartość „6” miała TTL około 1 minuty. Wartość „12” miała TTL około 1 godziny. „15” trwało około 8 godzin i tak dalej. Pozwoliło to jednemu bajtowi zdefiniować limit czasu i dać ci wystarczającą kontrolę na krótki lub długi czas.

Odpowiedzi:

6

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

Optymalizator
źródło
Heh, mamy podobne pomysły
aditsu zrezygnowało, ponieważ SE to EVIL
@aditsu Oh !. Nie widziałem twojego przed aktualizacją mojego, a potem spieszyło ci się dojazdy.
Optymalizator
Wiesz co ... możesz użyć mojego kodu 86400q':/:d_,({60bd\/}{~*mo60bAfmd2/':*}?:, usuwam swoją odpowiedź. moJest tak, że 0.058159 konwertuje 01:23:45
aditsu rzucić bo SE jest zły
3

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.

Kade
źródło
2

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
nderscore
źródło
24:00:00produkuje, 1ale odwrotność nie jest prawdą
rink.attendant. 6
@ rink.attendant.6 naprawiono
nderscore
2

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.

Serdalis
źródło
2

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"
Alex A.
źródło
2

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.);
    }
}
Andrea Biondo
źródło
Bardzo wyraźne użycie scanf i% f
jakiś użytkownik
Nie! Miałem na myśli „sprytny”.
jakiś użytkownik
2

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

Richard Donovan
źródło
Witamy na stronie! Zredagowałem twój post, aby kod był wyświetlany jako kod. Jeśli chodzi o link online, najlepszy, jaki znam, to TIO . Dałbym ci link, ale nie mam doświadczenia z J, więc nie wiem, jak to zrobić. Ponadto wydaje się, że ma to 91 bajtów, jeśli dodasz pierwszą i ostatnią linię. Czy to jest poprawne?
James
Dzięki za pomoc! Program [a = ... do końca.] Ma 77. Tytuł ma 10. Terminator to 1, co daje 88. Z trzema liniowymi przesunięciami, co daje 91! Popracuję nad tym: o)
Richard Donovan,
Teraz do 85-bajtowej jedno-liniowej!
Richard Donovan,
1

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}
SuperJedi224
źródło
1

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);
Downgoat
źródło
Niestety funkcje związane z czasem (takie jak „Data” i „toTimeString”) nie są dozwolone w tym wyzwaniu. W przeciwnym razie jest to o wiele bardziej zwięzły sposób =)
Mwr247,
@ Mwr247 oh nie widziałem tego, naprawię to wtedy
Downgoat
1

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
jakiś użytkownik
źródło
1

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.

Tytus
źródło
1

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.

Denis Ibaev
źródło
0

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)
Wernisch
źródło