Biorąc pod uwagę liczbę całkowitą od 0 do 141 (włącznie), wypisz wszystkie 24-godzinne czasy, których godzina, minuta i druga jednostka dodają do tej liczby całkowitej.

Zasady dodawania

Liczby są dodawane według ich jednostek czasu, a nie pojedynczych cyfr.

Na przykład weź 17:43:59

17 + 43 + 59 = 119

Pamiętaj, że to przykład dodawanych cyfr . W rzeczywistości wpisałeś 119, a 17:43:59 byłby jednym z wyników. Dane wyjściowe należy podać jako GG: MM: SS lub G: MM: SS.

Pamiętaj również, że najwyższa możliwa liczba to 141, czyli 23:59:59. To jest kod golfowy, więc wygrywa najmniejsza kwota. Próba i błąd są dozwolone, ale może być lepszy sposób na rozwiązanie tego problemu.

Edycja: Określ, gdzie w kodzie jest wartość wejściowa.

Galaretka , 16 30 29 20 bajtów

Teraz z poprawnym formatem wyjściowym! Ogromne podziękowania dla Dennisa za pomoc w debugowaniu tej odpowiedzi. Sugestie dotyczące gry w golfa mile widziane. Wypróbuj online!

Edycja: +14 bajtów przy użyciu poprawnego formatu wyjściowego. -1 bajt od usunięcia dodatkowej spacji. -3 od zmiany z 24,60,60na “ð<<‘. -6 bajtów od zmiany +100DḊ€€na d⁵.

“ð<<‘Œp’S=¥Ðfd⁵j€”:Y

Wyjaśnienie

“ð<<‘Œp’S=¥Ðfd⁵j€”:Y  Main link. Argument: n

“ð<<‘                 Jelly ord() the string `ð<<` to get [24, 60, 60]. Call this list z.
     Œp               Cartesian product of z's items. 
                        Since each item of z is a literal,
                        Jelly takes the range [1 ... item] for each item.
       ’              Decrements every number in the Cartesian product 
                        to get lowered ranges [0 ... item-1].
        S=¥           Create a dyadic link of `sum is equal to (implicit n)`.
           Ðf         Filter the Cartesian product for items with sum equal to n.
             d⁵       By taking divmod 10 of every number in each item,
                        we get zero padding for single-digit numbers
                        and every double-digit number just turns into a list of its digits.
               j€”:   Join every number with a ':'.
                   Y  Join all of the times with linefeeds for easier reading.

Bash, 71

• 8 bajtów zapisanych dzięki @hvd

for t in {0..23}+{00..59}+{00..59};{((${t//+0/+}-$1))||echo ${t//+/:};}

Wypróbuj online .

Perl 6 , 62 56 bajtów

{map *.fmt('%02d',':'),grep $_==*.sum,(^24 X ^60 X ^60)}

Wystarczy sprawdzić wszystkie możliwe kombinacje w iloczynie wszystkich godzin, minut i sekund.

Python 3 , 91 bajtów

def f(n):
 for k in range(86400):t=k//3600,k//60%60,k%60;sum(t)==n!=print('%d:%02d:%02d'%t)

Istnieją krótsze rozwiązania wykorzystujące exec(Python 2) lub rekurencyjny (Python 3), ale oba wymagają nieuzasadnionej ilości pamięci.

Wypróbuj online!

PowerShell , 87 77 bajtów

Zaoszczędzono 10 bajtów dzięki Johnowi L. Bevanowi

$d=date;0..86399|%{$d+=1e7l;"$d".Split()[1]}|?{("{0:H+m+s}"-f$d|iex)-in$args}

Wypróbuj online! (upłynie limit czasu, jest bardzo wolny)

Wyjaśnienie

Całkiem proste, zaczynając od bieżącego [datetime], dodaj 1 sekundę 86.399 razy, sformatuj jako ciąg, a następnie zachowaj tylko te, w których suma się sumuje.

Haskell, 77 bajtów

f x=[tail$(':':).tail.show.(+100)=<<t|t<-mapM(\x->[0..x])[23,59,59],sum t==x]

Haskell, 90 bajtów

p x=['0'|x<10]++show x
i=[0..59]
f x=[p h++':':p m++':':p s|h<-[0..23],m<-i,s<-i,h+m+s==x]

Zwraca listę ciągów GG: MM: SS, np. f 140-> ["22:59:59","23:58:59","23:59:58"].

To trzy proste pętle na godziny, minuty i sekundy. Zachowaj i sformatuj wszystkie wartości, w których suma jest liczbą wejściową x.

Pyth - 30 bajtów

Zajmuje wszystkie możliwe czasy, a następnie filtry.

mj\:%L"%02d"dfqsTQsM*U24*KU60K

Pakiet testowy .

Julia 0,5 , 69 bajtów

!n=[h+m+s==n&&@printf("%d:%02d:%02d
",h,m,s)for s=0:59,m=0:59,h=0:23]

Wypróbuj online!

Partia, 168 bajtów

@for /l %%t in (0,1,86399)do @call:c %1 %%t
@exit/b
:c
@set/ah=%2/3600,m=%2/60%%60,s=%2%%60,n=%1-h-m-s
@set m=0%m%
@set s=0%s%
@if %n%==0 echo %h%:%m:~-2%:%s:~-2%

Wyświetla jednocyfrowe godziny.

Mathematica, 79 bajtów

Cases[Tuples@{(r=Range)@24-1,x=r@60-1,x},t_/;Tr@t==#:>DateString@TimeObject@t]&

Oktawa, 83 , 87 bajtów

@(a){[H,M,S]=ndgrid(0:23,s=0:59,s);printf("%d:%02d:%02d\n",[H(x=H+M+S==a),M(x),S(x)]')}

Wypróbuj online!

QBIC , 82 72 bajty

:[0,23|[0,59|[0,59|~b+c+d=a|?!b$+@:`+right$(@0`+!c$,2)+A+right$(B+!d$,2)

Uderza to w niefortunne miejsce w QBasic, a rzucanie na numer, przycinanie i przygotowywanie w 0razie potrzeby jest naprawdę kosztowne.

Przykładowe dane wyjściowe:

Command line: 119
1:59:59
2:58:59
2:59:58
3:57:59
[... SNIP 270 lines ...]
23:58:38
23:59:37

Wyjaśnienie Napisałem o tym powieść:

:           Get N, call it 'a'
[0,23|      Loop through the hours; this FOR loop is initialised with 2 parameters
            using a comma to separate FROM and TO, and a '|' to delimit the argument list
[0,59|      Same for the minutes
[0,59|      And the seconds
            QBIC automatically creates variables to use as loop-counters: 
            b, c, d (a was already taken by ':')
~b+c+d=a    IF a == b+c+d
|           THEN
 ?          PRINT
  !         CAST
   b        'b'
    $       To String; casting num to str in QBasic adds a space, this is trimmed in QBIC
+@:`        Create string A$, containing ":"
+right$      This is a QBasic function, but since it's all lowercase (and '$' is 
            not a function in QBIC) it remains unaltered in the resulting QBasic.
(@0`+!c$,2) Pad the minutes by prepending a 0, then taking the rightmost 2 characters.
+A          Remember that semicolon in A$? Add it again
+right$     Same for the seconds
(B+!d$,2)   Reusing the 0-string saves 2 bytes :-)

PowerShell , 67 79 bajtów (nieprzyjemna wersja)

Ponieważ zasady nie mówią nic o ukończeniu w określonym czasie (lub wcale), ani nic o duplikatach, oto przerażające rozwiązanie:

for(){if(("{0:H+m+s}"-f($d=date)|iex)-in$args){"{0:H:mm:ss}"-f$d}}

Rakieta 39 bajtów

(for*/sum((h 24)(m 60)(s 60))(+ h m s))

Nie golfowany:

(for*/sum      ; loop for all combinations; return sum of values for each loop
   ((h 24)     ; h from 0 to 23
    (m 60)     ; m from 0 to 59
    (s 60))    ; s from 0 to 59
  (+ h m s))   ; sum of all 3 variables

MATL , 29 bajtów

24:q60:qt&Z*t!si=Y)'%i:'8:)&V

Wypróbuj online!

Wyjaśnienie

24:q     % Push [0 1 ... 23]
60:q     % Push [0 1 ... 59]
t        % Duplicate
&Z*      % Cartesian product of the three arrays. This gives a matrix with each
         % on a different row Cartesian tuple
t!       % Push a transposed copy
s        % Sum of each column
i=       % Logical mask of values that equal the input
Y)       % Select rows based on that mask
'%i:'    % Push this string
8:)      % Index (modularly) with [1 2 ... 8]: gives string '%i:%i:%i'
&V       % Convert to string with that format specification. Implicitly display

JavaScript, 122 120 bajtów

Pobiera jeden dodatkowy pusty ciąg jako dane wejściowe, który, jak zakładam, nie wlicza się do wielkości. Zaktualizowany bytecount (w tym historyczny), aby dodać dwa bajty do inicjalizacji ciągu.

console.log((
//Submission starts at the next line
i=>o=>{for(h=24;h--;)for(m=60;m--;)for(s=60;s--;)if(h+m+s==i)o+=`${h}:0${m}:0${s} `;return o.replace(/0\d{2}/g,d=>+d)}
//End submission
)(prompt("Number:",""))(""))

JavaScript (ES6), 110

v=>eval("o=[];z=x=>':'+`0${x}`.slice(-2);for(m=60;m--;)for(s=60;s--;h>=0&h<24&&o.push(h+z(m)+z(s)))h=v-m-s;o")

Mniej golfa

v=>{
  o=[];
  z=x=>':' + `0${x}`.slice(-2);
  for(m = 60; m--;)
    for(s = 60; s--; )
      h = v - m - s,
      h >= 0 & h < 24 && o.push(h + z(m) + z(s))
  return o
}

Test

F=
v=>eval("o=[];z=x=>':'+`0${x}`.slice(-2);for(m=60;m--;)for(s=60;s--;h>=0&h<24&&o.push(h+z(m)+z(s)))h=v-m-s;o")

function update() {
  O.textContent=F(+I.value).join`\n`
}

update()

<input id='I' value=119 type=number min=0 max=141 oninput='update()'><pre id=O></pre>

JavaScript, 96 bajtów

v=>{for (i=86399;i;[a,b,c]=[i/3600|0,i%3600/60|0,i--%60]){v-a-b-c?0:console.log(a+":"+b+":"+c)}}

Widok rozszerzony:

v => {
    for (i = 86399; i;
        [a, b, c] = [i / 3600 | 0, i % 3600 / 60 | 0, i-- % 60]) {
        v - a - b - c ? 0 : console.log(a + ":" + b + ":" + c)
    }
}

Zapętlaj wszystkie możliwe czasy, zapętlając 86399 na 1,

• przelicz liczbę całkowitą na czas, dzieląc przez 3600, aby uzyskać pierwszą cyfrę
• druga cyfra, przyjmując liczbę całkowitą mod 3600, a następnie dzieląc przez 60
• a ostatnia cyfra to liczba całkowita mod 60

Odejmij wszystkie 3 liczby od wartości wejściowej, aby zwrócić wartość falsey, jeśli trzy liczby sumują się do wartości wejściowej. Jeśli wartością jest falsey, wyślij wartość.

bash, 78 bajtów (przy użyciu narzędzia BSD) lub 79 bajtów (również innych niż BSD)

Jest to trochę dłużej niż dobre 71-bajtowe rozwiązanie bash @DigitalTrauma i @ hvd, ale podobał mi się pomysł użycia liczb w bazie 60; Jestem ciekawy, czy ktoś może trochę bardziej pograć w golfa.

Za pomocą narzędzia jot w standardzie BSD:

jot '-wx=`dc<<<60do3^%d+n`;((`dc<<<$x++'$1'-n`))||tr \  :<<<${x:3}' 86400 0|sh

Dzięki bardziej powszechnie dostępnemu narzędziu Seq:

seq '-fx=`dc<<<60do3^%.f+n`;((`dc<<<$x++'$1'-n`))||tr \  :<<<${x:3}' 0 86399|sh

Chodzi o to, aby wygenerować liczby od 0 do 83699 i użyć dc do przekonwertowania ich na bazę 60. „Cyfry” na wyjściu dc base-60 to 2-cyfrowe liczby od 00 do 59, ze spacjami oddzielającymi „cyfry”, więc wyświetla wszystkie pożądane czasy od 00 00 00 do 23 59 59 w prawie wymaganym formacie.

Jeśli jednak dosłownie to wykonasz, liczby poniżej 60 ^ 2 nie są trzycyfrowymi liczbami w podstawie 60, więc brakuje początkowej 00 lub 00 00. Z tego powodu generuję liczby od 60 ^ 3 do 60 ^ 3 + 83699; zapewnia to, że wszystkie wygenerowane liczby mają dokładnie 4 cyfry długości w bazie 60. Jest to OK, o ile w końcu wyrzucę dodatkową pierwszą cyfrę (01), która nie jest potrzebna.

Tak więc po wygenerowaniu pożądanych czasów po prostu biorę każdy poczwórny od 01 00 00 00 do 01 23 59 59, dodam trzy ostatnie liczby i odejmuję argument $ 1. Jeśli to 0, biorę wszystko czterokrotnie od trzeciej postaci (wyrzucając „01”), używam tr, aby konwertować spacje na dwukropki i wydrukować wynik.

PowerShell , 91 97 bajtów (w tym dane wejściowe)

param($x)1..864e3|%{($d=date($_*1e7l))}|?{("{0:H+m+s}"-f$_|iex)-eq$x}|%{"{0:H:mm:ss}"-f$_}

param($x)0..23|%{$h=$_;0..59|%{$m=$_;0..59|?{$h+$m+$_-eq$x}|%{"{0:0}:{1:00}:{2:00}"-f$h,$m,$_}}}

lub

param($x)0..23|%{$h=$_;0..59|?{($s=$x-$h-$_)-le59-and$s-ge0}|%{"{0:0}:{1:00}:{2:00}"-f$h,$_,$s}} <\ s>

Rozszerzony i skomentowany

param($x)
#loop through the hours
0..23 | %{
    $h=$_
    #loop through the minutes
    0..59 | %{
        $m=$_
        #loop through the seconds
        0..59 | ?{ #filter for those where the sum matches the target
            $h + $m + $_ -eq $x
        } | %{
            #format the result
            "{0:#0}:{1:00}:{2:00}" -f $h, $m, $_
        }
    }
}

Uwaga: wyprzedzona przez wersję @ Briantist: /codegolf//a/105163/6776