Dato un numero intero compreso tra 0 e 141 (incluso), elenca tutte le ore di 24 ore le cui ore, minuti e seconde si aggiungono a quel numero intero.

Regole di aggiunta

I numeri vengono aggiunti dalle loro unità di tempo, non da singole cifre.

Ad esempio, prendi 17:43:59

43 + 17 + 59 = 119

Ricorda, questo è un esempio di cifre aggiunte.In realtà, dovresti inserire 119 e 17:43:59 sarebbe uno dei risultati. L'output deve essere indicato come HH: MM: SS o H: MM: SS.

Tieni anche presente che il numero più alto possibile è 141, ovvero 23:59:59. Questo è il golf del codice, quindi vince l'importo più basso. Sono consentiti tentativi ed errori, ma potrebbe esserci un modo migliore per farlo.

Modifica: specifica dove si trova il tuo codice nel valore di input.

Gelatina , 16 30 29 20 byte

Ora con il formato di output corretto! Mille grazie a Dennis per il suo aiuto nel debug di questa risposta. Suggerimenti di golf benvenuti. Provalo online!

Modifica: +14 byte dall'uso del formato di output corretto. -1 byte dalla rimozione di uno spazio aggiuntivo. -3 dal passaggio da 24,60,60a “ð<<‘. -6 byte dal passaggio +100DḊ€€a d⁵.

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

Spiegazione

“ð<<‘Œ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 byte salvati grazie a @hvd

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

Provalo online .

Perl 6 , 62 56 byte

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

Controlla solo tutte le possibili combinazioni nel prodotto incrociato di tutte le ore, minuti e secondi.

Python 3 , 91 byte

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

Esistono soluzioni più brevi con exec(Python 2) o ricorsione (Python 3), ma entrambe richiedono una quantità irragionevole di memoria.

Provalo online!

PowerShell , 87 77 byte

Risparmiato 10 byte grazie a John L. Bevan

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

Provalo online! (questo andrà in timeout, è molto lento)

Spiegazione

Abbastanza semplice, a partire dalla corrente [datetime], aggiungi 1 secondo 86.399 volte, formatta come una stringa, quindi mantieni solo quelli in cui la somma si somma.

Haskell, 77 byte

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

Haskell, 90 byte

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]

Restituisce un elenco di stringhe HH: MM: SS, ad es. f 140->["22:59:59","23:58:59","23:59:58"] .

Sono tre semplici cicli attraverso le ore, i minuti e i secondi. Conservare e formattare tutti i valori in cui la somma è il numero di input x.

Pyth - 30 byte

Prende tutti i tempi possibili, quindi filtra.

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

Test Suite .

Julia 0,5 , 69 byte

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

Provalo online!

Lotto, 168 byte

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

Emette ore a una cifra.

Mathematica, 79 byte

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

Ottava, 83 , 87 byte

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

Provalo online!

QBIC , 82 72 byte

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

Questo colpisce un punto sfortunato in QBasic, con il cast al numero, tagliare e anteporre 0quando necessario è davvero costoso.

Uscita campione:

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

Spiegazione Ho scritto un romanzo al riguardo:

:           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 byte (versione brutta)

Dal momento che le regole non dicono nulla sul completamento in un determinato momento (o affatto) e niente su nessun duplicato, ecco una soluzione orribile:

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

Racchetta 39 byte

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

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

Provalo online!

Spiegazione

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 byte

Accetta una stringa vuota aggiuntiva come input, che presumo non conta per le dimensioni. Bytecount aggiornato (incluso storico) per aggiungere due byte per l'inizializzazione della stringa.

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

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

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 byte

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

Vista estesa:

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

Ripeti tutti i tempi possibili eseguendo il ciclo 86399 su 1,

• converte il numero intero in tempo dividendo per 3600 per ottenere la prima cifra
• la seconda cifra prendendo il numero intero mod 3600 e poi dividendolo per 60
• e l'ultima cifra è la mod intera 60

Sottrarre tutti e 3 i numeri dal valore di input per restituire un valore di falso se i tre numeri si sommano al valore di input. Se il valore è falso, emettere il valore.

bash, 78 byte (usando un'utilità BSD) o 79 byte (anche non BSD)

Questo è un po 'più lungo di @DigitalTrauma e della bella soluzione bash a 71 byte di @ hvd, ma mi è piaciuta l'idea di usare i numeri nella base 60; Sono curioso di sapere se qualcuno può giocare a golf un po 'di più.

Con l'utilità jot standard BSD:

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

Con l'utilità seq più universalmente disponibile:

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

L'idea è di generare i numeri da 0 a 83699 e utilizzare dc per convertirli in base 60. Le "cifre" nell'output di base-60 di cc sono numeri a 2 cifre da 00 a 59, con spazi che separano le "cifre", quindi questo elenca tutti i tempi desiderati da 00 00 00 a 23 59 59 in quasi il formato necessario.

Se lo esegui letteralmente, tuttavia, i numeri inferiori a 60 ^ 2 non sono numeri a 3 cifre nella base 60, quindi mancano gli 00 o 00 00 iniziali. Per questo motivo, sto effettivamente generando i numeri da 60 ^ 3 a 60 ^ 3 + 83699; questo assicura che tutti i numeri generati siano esattamente lunghi 4 cifre nella base 60. Questo va bene finché alla fine butto via la prima cifra extra (01) che non è necessaria.

Quindi, una volta generati i tempi desiderati, prendo solo ogni quadrupla da 01 00 00 00 a 01 23 59 59, aggiungo gli ultimi tre numeri e sottraggo l'argomento $ 1. Se è 0, prendo tutto nel quadruplo dal 3 ° carattere in poi (buttando via lo "01"), uso tr per convertire gli spazi in due punti e stampo il risultato.

PowerShell , 91 97 byte (incluso input)

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

o

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

Ampliato e commentato

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: superato dalla versione di @ Briantist: /codegolf//a/105163/6776