Étant donné un entier compris entre 0 et 141 (inclus), répertoriez toutes les heures de 24 heures dont les unités d'heure, de minute et de seconde s'ajoutent à cet entier.

Règles d'addition

Les nombres sont ajoutés par leurs unités de temps, pas par des chiffres simples.

Par exemple, prenez 17:43:59

17 + 43 + 59 = 119

N'oubliez pas qu'il s'agit d'un exemple de chiffres ajoutés. En réalité, vous saisiriez 119 et 17:43:59 serait l'un des résultats. La sortie doit être donnée en HH: MM: SS ou H: MM: SS.

Gardez également à l'esprit que le nombre le plus élevé possible est 141, soit 23:59:59. C'est le golf de code, donc le montant le plus bas gagne. Les essais et erreurs sont autorisés, mais il peut y avoir une meilleure façon de procéder.

Modifier: veuillez spécifier où se trouve la valeur d'entrée dans votre code.

Gelée , 16 30 29 20 octets

Maintenant avec le format de sortie correct! Un grand merci à Dennis pour son aide dans le débogage de cette réponse. Suggestions de golf bienvenues. Essayez-le en ligne!

Modifier: +14 octets en utilisant le format de sortie correct. -1 octet pour supprimer un espace supplémentaire. -3 de passer de 24,60,60à “ð<<‘. -6 octets de passer +100DḊ€€à d⁵.

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

Explication

“ð<<‘Œ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 octets économisés grâce à @hvd

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

Essayez-le en ligne .

Perl 6 , 62 56 octets

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

Vérifie simplement toutes les combinaisons possibles dans le produit croisé de toutes les heures, minutes et secondes.

Python 3 , 91 octets

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

Il existe des solutions plus courtes utilisant exec(Python 2) ou la récursivité (Python 3), mais les deux nécessitent une quantité de mémoire déraisonnable.

Essayez-le en ligne!

PowerShell , 87 77 octets

10 octets enregistrés grâce à John L. Bevan

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

Essayez-le en ligne! (cela va expirer, c'est très lent)

Explication

Assez simple, en commençant par le courant [datetime], ajoutez 1 seconde 86 399 fois, formatez-le en chaîne, puis ne gardez que ceux où la somme s'additionne.

Haskell, 77 octets

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

Haskell, 90 octets

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]

Renvoie une liste de chaînes HH: MM: SS, par exemple f 140-> ["22:59:59","23:58:59","23:59:58"].

Il s'agit de trois boucles simples à travers les heures, les minutes et les secondes. Conservez et formatez toutes les valeurs où la somme est le numéro d'entrée x.

Pyth - 30 octets

Prend toutes les heures possibles puis filtre.

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

Suite de tests .

Julia 0,5 , 69 octets

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

Essayez-le en ligne!

Lot, 168 octets

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

Affiche des heures à un chiffre.

Mathematica, 79 octets

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

Octave, 83 , 87 octets

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

Essayez-le en ligne!

QBIC , 82 72 octets

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

Cela frappe un endroit malheureux dans QBasic, avec le moulage au nombre, le découpage et l'ajout d'un 0 au besoin est vraiment coûteux.

Exemple de sortie:

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

Explication J'ai écrit un roman à ce sujet:

:           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 octets (version désagréable)

Étant donné que les règles ne disent rien sur l'achèvement dans un certain temps (ou pas du tout), et rien sur aucun doublon, voici une solution horrible:

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

Raquette 39 octets

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

Non golfé:

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

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

Essayez-le en ligne!

Explication

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 octets

Prend une chaîne vide supplémentaire en entrée, que je présume ne compte pas pour la taille. Octet mis à jour (y compris l'historique) pour ajouter deux octets pour l'initialisation de la chaîne.

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

Moins golfé

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
}

Tester

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 octets

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

Vue étendue:

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

Parcourez toutes les heures possibles en bouclant 86399 à 1,

• convertir l'entier en temps en divisant par 3600 pour obtenir le premier chiffre
• le 2ème chiffre en prenant le mod entier 3600 puis en divisant par 60
• et le dernier chiffre est le mod entier 60

Soustrayez les 3 nombres de la valeur d'entrée pour renvoyer une valeur de falsey si les trois nombres s'additionnent à la valeur d'entrée. Si la valeur est falsey, sortez-la.

bash, 78 octets (à l'aide d'un utilitaire BSD) ou 79 octets (non BSD également)

C'est un peu plus long que @DigitalTrauma et la belle solution bash de 71 octets de @ hvd, mais j'ai un peu aimé l'idée ici d'utiliser des nombres en base 60; Je suis curieux de savoir si quelqu'un peut jouer au golf un peu plus.

Avec l'utilitaire jot standard BSD:

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

Avec l'utilitaire seq plus universellement disponible:

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

L'idée est de générer les nombres de 0 à 83699 et d'utiliser dc pour les convertir en base 60. Les "chiffres" dans la sortie base-60 de dc sont des nombres à 2 chiffres de 00 à 59, avec des espaces séparant les "chiffres", donc cela répertorie toutes les heures souhaitées de 00 00 00 à 23 59 59 dans presque le format requis.

Si vous effectuez littéralement cela, cependant, les nombres inférieurs à 60 ^ 2 ne sont pas des nombres à 3 chiffres dans la base 60, donc le 00 ou 00 00 initial est manquant. Pour cette raison, je génère en fait les nombres de 60 ^ 3 à 60 ^ 3 + 83699; cela garantit que tous les nombres générés ont exactement 4 chiffres en base 60. C'est OK tant que je jette finalement le premier chiffre supplémentaire (01) qui n'est pas nécessaire.

Donc, une fois que les temps souhaités sont générés, je prends simplement chaque quadruple de 01 00 00 00 à 01 23 59 59, j'ajoute les trois derniers nombres et je soustrais l'argument $ 1. Si c'est 0, je prends alors tout dans le quadruple à partir du 3ème caractère (jetant le "01"), utilise tr pour convertir les espaces en deux-points et imprime le résultat.

PowerShell , 91 97 octets (y compris l'entrée)

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

ou

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

Développé et commenté

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: dépassé par la version de @ Briantist: /codegolf//a/105163/6776