Listen Sie bei einer Ganzzahl zwischen 0 und 141 (einschließlich) alle 24-Stunden-Zeiten auf, deren Einheiten für Stunde, Minute und Sekunde zu dieser Ganzzahl addiert werden.

Regeln der Hinzufügung

Zahlen werden nach ihrer Zeiteinheit und nicht nach einzelnen Ziffern addiert.

Nehmen Sie zum Beispiel 17:43:59

17 + 43 + 59 = 119

Denken Sie daran, dass dies ein Beispiel für das Hinzufügen von Ziffern ist . In Wirklichkeit würden Sie 119 eingeben und 17:43:59 wäre eines der Ergebnisse. Die Ausgabe sollte als HH: MM: SS oder H: MM: SS erfolgen.

Denken Sie auch daran, dass die höchstmögliche Zahl 141 ist, nämlich 23:59:59. Dies ist Codegolf, also gewinnt der niedrigste Betrag. Versuch und Irrtum sind erlaubt, aber es könnte einen besseren Weg geben, dies zu tun.

Bearbeiten: Bitte geben Sie an, wo in Ihrem Code der Eingabewert ist.

Jelly , 16 30 29 20 Bytes

Jetzt mit dem richtigen Ausgabeformat! Vielen Dank an Dennis für seine Hilfe beim Debuggen dieser Antwort. Golfvorschläge sind willkommen. Probieren Sie es online!

Edit: +14 Bytes von der Verwendung des richtigen Ausgabeformats. -1 Byte für das Entfernen eines zusätzlichen Leerzeichens. -3 vom Wechsel von 24,60,60zu “ð<<‘. -6 Bytes vom Ändern +100DḊ€€auf d⁵.

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

Erläuterung

“ð<<‘Œ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 Bytes gespart dank @hvd

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

Probieren Sie es online aus .

Perl 6 , 62 56 Bytes

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

Überprüft einfach alle möglichen Kombinationen im Kreuzprodukt aller Stunden, Minuten und Sekunden.

Python 3 , 91 Bytes

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

Es gibt kürzere Lösungen mit exec(Python 2) oder Rekursion (Python 3), aber beide erfordern eine unzumutbare Menge an Speicher.

Probieren Sie es online!

PowerShell , 87.77 Byte

Dank John L. Bevan 10 Byte gespeichert

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

Probieren Sie es online! (dies wird Zeitüberschreitung, es ist sehr langsam)

Erläuterung

Ziemlich einfach, beginnend mit der aktuellen [datetime], addiere 1 Sekunde 86.399 mal, formatiere als Zeichenkette und behalte dann nur die, bei denen die Summe summiert.

Haskell, 77 Bytes

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

Haskell, 90 Bytes

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]

Gibt eine Liste von HH: MM: SS-Zeichenfolgen zurück, z . B. f 140-> ["22:59:59","23:58:59","23:59:58"].

Es sind drei einfache Schleifen durch die Stunden, Minuten und Sekunden. Behalten und formatieren Sie alle Werte, bei denen die Summe die eingegebene Zahl ist x.

Pyth - 30 Bytes

Nimmt alle möglichen Zeiten auf und filtert dann.

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

Test Suite .

Julia 0,5 , 69 Bytes

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

Probieren Sie es online!

Batch, 168 Bytes

@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%

Gibt einstellige Stunden aus.

Mathematica, 79 Bytes

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

Oktave, 83 , 87 Bytes

@(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)]')}

Probieren Sie es online!

QBIC , 82 72 Bytes

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

Dies ist eine unglückliche Angelegenheit in QBasic, da das Aufzählen, Zuschneiden und Voranstellen 0bei Bedarf sehr kostspielig ist.

Beispielausgabe:

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

Erklärung Ich habe einen Roman darüber geschrieben:

:           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 Bytes (böse Version)

Da die Regeln nichts über das Abschließen in einer bestimmten Zeit (oder überhaupt) und nichts über das Fehlen von Duplikaten aussagen, ist hier eine schreckliche Lösung:

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

Schläger 39 Bytes

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

Ungolfed:

(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 Bytes

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

Probieren Sie es online!

Erläuterung

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 Bytes

Nimmt eine zusätzliche leere Zeichenkette als Eingabe, was ich vermute, zählt nicht für die Größe. Bytecount (einschließlich Verlauf) aktualisiert, um zwei Bytes für die Initialisierung der Zeichenfolge hinzuzufügen.

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

Weniger golfen

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
}

Prüfung

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 Bytes

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

Erweiterte Ansicht:

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

Durchlaufen Sie alle möglichen Zeiten, indem Sie 86399 auf 1 schleifen.

• Wandle die ganze Zahl in die Zeit um, indem du durch 3600 dividierst, um die erste Ziffer zu erhalten
• die 2. Stelle, indem Sie die Ganzzahl mod 3600 nehmen und dann durch 60 teilen
• und die letzte Ziffer ist die Ganzzahl mod 60

Subtrahieren Sie alle 3 Zahlen vom Eingabewert, um einen falschen Wert zurückzugeben, wenn sich die drei Zahlen zum Eingabewert addieren. Wenn der Wert falsch ist, geben Sie den Wert aus.

Bash, 78 Bytes (mit einem BSD-Dienstprogramm) oder 79 Bytes (auch Nicht-BSD)

Dies ist ein bisschen länger als die nette 71-Byte-Bash-Lösung von @DigitalTrauma und @ hvd, aber mir gefiel die Idee, hier Zahlen in Basis 60 zu verwenden. Ich bin gespannt, ob jemand noch ein bisschen mehr Golf spielen kann.

Mit dem BSD-Standard-Jot-Utility:

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

Mit dem universelleren Dienstprogramm seq:

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

Die Idee ist, die Zahlen von 0 bis 83699 zu generieren und sie mit dc in die Basis 60 umzuwandeln. Die "Ziffern" in der Ausgabe der Basis 60 von dc sind zweistellige Zahlen von 00 bis 59, wobei die "Ziffern" durch Leerzeichen voneinander getrennt sind Dies listet alle gewünschten Zeiten von 00 00 00 bis 23 59 59 in fast dem benötigten Format auf.

Wenn Sie dies jedoch buchstäblich ausführen, sind Zahlen unter 60 ^ 2 keine dreistelligen Zahlen in der Basis 60, sodass die ersten 00 oder 00 00 fehlen. Aus diesem Grund generiere ich die Zahlen von 60 ^ 3 bis 60 ^ 3 + 83699; Dies stellt sicher, dass alle generierten Zahlen in Basis 60 genau 4 Stellen lang sind. Dies ist in Ordnung, solange ich die zusätzliche erste Stelle (01), die nicht benötigt wird, wegwerfe.

Sobald die gewünschten Zeiten generiert sind, nehme ich einfach jedes Vierfache von 01 00 00 00 bis 01 23 59 59, addiere die letzten drei Zahlen und subtrahiere das Argument $ 1. Wenn das 0 ist, nehme ich ab dem 3. Zeichen alles im Vierfachen (wirf die "01" weg), konvertiere mit tr Leerzeichen in Doppelpunkte und drucke das Ergebnis.

PowerShell , 91 bis 97 Byte (einschließlich Eingabe)

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,$_}}}

oder

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

Erweitert und kommentiert

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, $_
        }
    }
}

NB: Von der @ Briantist-Version übertroffen: /codegolf//a/105163/6776