Somme de 24 heures

21

É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.

Noah L
la source
3
Bienvenue sur Programmation Puzzles & Code Golf! Si par branché, vous entendez faire partie du code source, cela est généralement interdit. En général, c'est une bonne idée de s'en tenir à ces valeurs par défaut. Doit-on afficher les résultats sous forme de chaînes? Si oui, quels formats sont autorisés?
Dennis
Le nombre d'entrée est-il garanti positif? Y aura-t-il au moins une solution?
xnor
J'ai un peu édité la question pour clarifier / répondre à certaines choses. Si votre intention était différente de mes modifications, n'hésitez pas à la modifier pour qu'elle corresponde à cela.
Geobits
1
Je ne l'ai fait que parce que c'est la façon habituelle de voir les temps donnés (dans le monde réel). Personne ne dit jamais qu'il est 13: 4: 7, mais 5:10:30 est presque toujours acceptable. Je n'ai aucun problème avec son changement.
Geobits
3
"Veuillez spécifier où se trouve la valeur d'entrée dans votre code." - La convention sur PPCG pour la saisie de données utilise des arguments, ainsi que quelques autres options. Voir Default pour Code Golf: méthodes d'entrée / sortie sur Meta.
user2428118

Réponses:

8

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.
Sherlock9
la source
8

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 .

Traumatisme numérique
la source
1
printfest coûteux ici. En vous trapprochant du bon format et en le réparant pour que ça ((t-$1))marche, vous pouvez le ramener à 71:for t in {0..23}+{00..59}+{00..59};{((${t//+0/+}-$1))||echo ${t//+/:};}
DVD
@hvd Bon golf - merci!
Digital Trauma
6

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.

Sean
la source
4

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!

Dennis
la source
4

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.

briantiste
la source
FYI: Vous pouvez remplacer 10000000par 1e7lpour économiser 4 octets ... ou même 1e7pour un octet supplémentaire (je pense; j'ai dû inclure le Lpour le bénéfice du paramètre; mais soupçonnez que votre approche évite ce besoin.
JohnLBevan
1
@JohnLBevan merci! J'ai lutté 1e7pendant au moins 30 minutes et c'est le Lsuffixe qui m'a manqué; Je l'ai oublié et je ne pouvais pas trouver un moyen de le faire atteindre un entier plus court que la constante. Qui a décidé qu'un [timespan]interprète un [int]comme des ticks et un [double]as days de toute façon ?? Le iexbit est assez brillant, bien que cela rende tout cela excessivement plus lent.
briantist
1
Pas de soucis; J'ai eu de l'aide sur celui-là aussi;): stackoverflow.com/q/41408902/361842
JohnLBevan
1
@JohnLBevan Je viens littéralement de voir cette question avant le commentaire où vous l'avez liée! Agréable.
briantist
1
L' iexastuce a également été adaptée à partir d'une astuce ici: codegolf.stackexchange.com/a/746/6776
JohnLBevan
3

Haskell, 77 octets

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

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.

nimi
la source
2

Pyth - 30 octets

Prend toutes les heures possibles puis filtre.

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

Suite de tests .

Maltysen
la source
2

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.

Neil
la source
2

Mathematica, 79 octets

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

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!

rahnema1
la source
1

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 :-)
steenbergh
la source
QBIC semble intéressant. L'avez-vous créé juste pour # code-golf !? :)
wasatchwizard
@wasatchwizard Yup :-)
steenbergh
1

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}}
JohnLBevan
la source
1
Je ne trouve pas le meta post pertinent, mais je suis sûr qu'une soumission doit s'arrêter pour être valide, sauf indication contraire par le défi
Sefa
Merci @Sefa ... si c'est le cas, je ne peux pas trouver un bon moyen de faire fonctionner ma version méchante avec moins de caractères que la version propre de Briantist ... Tenté de supprimer cette réponse, mais je suis un peu fier de la façon dont c'est mauvais;)
JohnLBevan
0

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
rnso
la source
0

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
Luis Mendo
la source
0

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:",""))(""))

user2428118
la source
Si vous devez initialiser une chaîne pour la vider, l'initialisation doit être comptée
edc65
@ edc65 Fait. ···
user2428118
0

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>

edc65
la source
0

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.

Grax32
la source
0

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.

Mitchell Spector
la source
0

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

JohnLBevan
la source