Sei incatenato a una sedia. Sotto di te c'è un enorme vulcano. Un orologio di 12 ore accanto a te ticchetta minacciosamente e vedi che ha fili che conducono dal retro fino a una catena, che ti lascerà cadere al centro della terra. Legato all'orologio è una nota:

Ogni lancetta dell'orologio ha un elettrodo. Quando entrambe le lancette dell'orologio sono nella stessa posizione, la potenza scorre e tu muori. Cioè, a meno che tu non possa dirmi l'ora esatta in cui ciò accadrà, al minuto più vicino.

Hai un computer che conosce ogni linguaggio di programmazione. Devi creare il programma più breve (questo è code-golf e sono vietate le scappatoie standard ), e dire allo scienziato malvagio che ore saranno. Il tuo programma dovrebbe ricevere input (in qualsiasi metodo), costituito da ora e minuti. Dovrebbe restituire l'ora e il minuto successivi (in qualsiasi metodo) che ciò si verifichi.

Secondo la pagina OEIS , gli undici tempi di sovrapposizione sono:

00:00:00 plus 0/11 s, 01:05:27 plus 3/11 s,
02:10:54 plus 6/11 s, 03:16:21 plus 9/11 s,
04:21:49 plus 1/11 s, 05:27:16 plus 4/11 s,
06:32:43 plus 7/11 s, 07:38:10 plus 10/11 s,
08:43:38 plus 2/11 s, 09:49:05 plus 5/11 s,
10:54:32 plus 8/11 s.

La prossima volta sarebbero le 12:00:00. I secondi e le loro parti frazionarie non sono necessari per questa sfida. Basta arrotondare al minuto più vicino.

Casi test:

0:00 (Or 12:00) > 1:05
1:00 > 1:05
11:56 > 12:00 (Or 0:00)
6:45 > 7:38
5:00 > 5:27
6:30 > 6:33 (round up)

Il programma può essere una funzione o un programma completo. Non mi importa se scegli 0:00o 12:00, ed entrambi sono accettabili. In bocca al lupo!

JavaScript (Node.js) , 54 47 byte (arrotondato al più vicino)

-7 byte. Grazie @ user202729

a=>b=>[(a+=b>5.46*a)+a/11|0,a%12*65.46%60+.5|0]

Provalo online!

JavaScript (Node.js) , 40 33 44 byte (arrotonda verso 0)

-3 byte grazie a @Arnauld

-4 byte grazie a @Kevin Cruijssen

a=>b=>[(a+=b>5.46*a)+a/11|0,a%12*65.46%60|0]

Spiegazione

a=>b=>[(a+=b>5.46*a)+a/11|0,a%12*65.46%60|0]    Full Code
a                                               Hours
   b                                            Minutes
    =>[                    ,               ]    return array with
       (a+=        )                            add to the current hour
           b>5.46*a                             1 if the minute's clock hand has 
                                                passed the hour's clock hand. Here we use
                                                equation 60*a/11 which is the same as 5.46*a
                    +a/11                       and add 1 when hour is 11
                         |0                     floor the result

                            a%12*65.46%60|0     Here we do equation ((720/11)*a) (mod 60)
                            a%12                In case of hour 12 we take 0
                                *65.46          multiply hour by 720/11 which can be shortened to
                                                65.46 to save 1 byte.
                                      %60       mod 60
                                         |0     floor the result

Nota a margine: sono abbastanza sicuro che questo possa essere golfato da qualcuno con maggiori conoscenze in matematica. So a malapena come sommare e moltiplicare

Provalo online!

J , 31 byte

0.5<.@+>:@<.&.(11r720*12 60&#.)

Provalo online!

Il modo per arrotondare un numero in J è aggiungere 0.5e prendere la parola ( <.). Richiede troppi byte ...

Spiegazione

12 60&#. (conversione di base mista) converte da un array di [ora, minuti] al minuto trascorso dalle 0:00.

Si noti che a partire dalle 0:00, ogni 12/11 ore (ovvero 720/11 minuti), le due mani si sovrappongono una volta.

Pertanto, dato il valore del minuto, basta arrotondarlo al multiplo più vicino di 720/11 (diverso da se stesso). Ciò può essere ottenuto da *11/720 (J ha un numero razionale letterale 11r720), prendi la parola <., incrementa >:, quindi moltiplicalo per 720/11.

Si noti che "moltiplicare per 11/720" e "moltiplicare per 720/11" sono 2 azioni inverse, nonché "convertire da [ora, minuto] al numero di minuti trascorsi" e viceversa. Fortunatamente J ha incorporato &.(sotto), che inverte alcune azioni dopo aver applicato una trasformazione.

Dopo di che basta fare l'arrotondamento: 0.5 +allora <..

R , 68 byte

a=round(1:30*720/11);a[a>sum(scan()*c(60,1))][1]%/%c(60,1)%%c(12,60)

Provalo online!

• -2 byte grazie a Giuseppe
• +7 byte a causa dell'arrotondamento mancante :(

Sfruttando l'equazione:

same_position_minutes = 720/11 * index

dove indexè 0 per la prima posizione sovrapposta (00:00), 1 per la seconda e così via ...

R , 88 byte

i=scan();d=1+60*i[1]+i[2];while(abs(60*(h=d%/%60%%12)-11*(m=d%%60))>5){d=d+1};paste(h,m)

Provalo online!

Aumenta il tempo di un minuto. Controlla l'angolazione. Se non abbastanza vicino, scorre fino a trovare una soluzione.

Python 3 , 80 78 byte

Questa è la mia prima presentazione, quindi le critiche costruttive sono benvenute :)

-2 byte grazie a @Jo King

def f(h,m):n=65.45;r=round(((60*h+m)//n%11+1)*n);print('%i:%02i'%(r//60,r%60))

Provalo online! (78) Provalo online! (80)

Java 8, 89 82 byte

(h,m)->(m=m<(m=(int)(h%12*720d/11%60))?m:(int)(++h%12*720d/11%60))*0+h%12%11+" "+m

Fisso. Vedrò se posso giocare a golf più tardi (probabilmente portando un'altra risposta).

Provalo online.

Spiegazione:

FARE

Apl (Dyalog Unicode) , 28 byte

((⍳11),⍪0,+\∊5/⊂5 6)(⍸⌷1⊖⊣)⎕

Provalo online!

Spiegazione

((⍳11),⍪0,+\∊5/⊂5 6)è una matrice di volte in cui le mani si sovrappongono (stampate alla fine del collegamento tio)
(⍸⌷1⊖⊣)⎕trova l'intervallo in cui l'input è nella matrice e gli indici sottostanti si avvolgono.

C # (.NET Core) , 70 byte

(h,m)=>{h%=12;int n=(5*h+h/2)%60;return (m>n||h>10)?f(h+1,0):h+":"+n;}

Provalo online!

Penso che superi tutti i casi di test. Sebbene il caso h = 11 sia piuttosto brutto

Spiegazione:

(h,m)=>{ // Lambda receiving 2 integers
    h%=12; // Just to get rid of the 0/12 case
    int n=(5*h+h/2)%60; // get the minute at which the hands overlap 
                        //for current hour.
    return 
    (m>n||h>10)? // if current minute > n or h=11
        f(h+1,0) // it will happen next hour
    :
        h+":"+n; // return result
}

JavaScript, 41 byte

p=>q=>(p+=q>=(5.5*p|0),p%=11,[p,5.5*p|0])

f =
p=>q=>(p+=q>=(5.5*p|0),p%=11,[p,5.5*p|0])

<div oninput="o.value = f(+h.value)(+m.value).join(':')">
Input: <input type=number min=0 max=11 id=h style=width:40px value=0 autofocus>:<input type=number min=0 max=59 id=m style=width:40px value=0><br />
Output: <output id=o></output>
</div>

Gelatina , 25 byte

‘2¦ɓ;W}Ṣi¹ịḷø5,6ẋ5ÄĖØ0W¤;

Provalo online!

Un collegamento monadico che prende il tempo come un elenco di due numeri interi e restituisce un elenco di due numeri interi corrispondente alla prossima volta che le mani sono dovute al tocco.

Perl 6 , 43 byte

(* *60+*+33).round(65.45).round.polymod(60)

Provalo online!

Un lambda qualunque sia quello che richiede due numeri interi che rappresentano ore e minuti e restituisce le ore e i minuti in ordine inverso. Al momento non è coerente quando si inserisce un tempo allineato, indipendentemente dal fatto che emetta il successivo orario allineato o rimanga sullo stesso. Sto aspettando che OP risponda a tale questione, ma in questo momento lo sto trattando come indefinito.

Spiegazione

(* *60+*+33)   # Converts the two inputs to number of minutes
            .round(65.45)   # Round to the nearest multiple of 65.45
                         .round  # Round to the nearest integer
                               .polymod(60) # Repeatedly modulo by 60 and return the list of results