Estás encadenado a una silla. Debajo de ti hay un enorme volcán. Un reloj de 12 horas a su lado marca siniestramente, y ve que tiene cables que van desde la parte posterior hasta una cadena, que lo dejará caer en el centro de la tierra. Pegado al reloj hay una nota:

Cada manecilla del reloj tiene un electrodo. Cuando ambas manecillas del reloj están en la misma posición, el poder fluye y mueres. Es decir, a menos que pueda decirme la hora exacta en que esto ocurrirá, al minuto más cercano.

Tienes una computadora que conoce todos los lenguajes de programación. Debe crear el programa más corto (esto es código de golf , y las lagunas estándar están prohibidas) que pueda y decirle al malvado científico qué hora será. Su programa debe recibir información (en cualquier método), que consta de la hora y los minutos. Debería devolver la siguiente hora y minuto (en cualquier método) que esto ocurra.

Según la página OEIS , los once tiempos de superposición son:

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 próxima vez serían las 12:00:00. Los segundos y sus partes fraccionarias no son necesarios para este desafío. Simplemente redondea al minuto más cercano.

Casos de prueba:

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)

El programa puede ser una función o un programa completo. No me importa si eliges 0:00o 12:00, y ambos son aceptables. ¡Buena suerte!

JavaScript (Node.js) , 54 47 bytes (redondear al más cercano)

-7 bytes. Gracias @ user202729

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

Pruébalo en línea!

JavaScript (Node.js) , 40 33 44 bytes (se redondea hacia 0)

-3 bytes gracias a @Arnauld

-4 bytes gracias a @Kevin Cruijssen

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

Explicación

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 al margen: estoy bastante seguro de que alguien que tenga más conocimientos de matemáticas puede jugar golf. Apenas sé cómo sumar y multiplicar

Pruébalo en línea!

J , 31 bytes

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

Pruébalo en línea!

La forma de redondear un número en J es sumar 0.5y tomar la palabra ( <.). Toma demasiados bytes ...

Explicación

12 60&#. (conversión de base mixta) convierte de una matriz de [hora, minuto] al minuto pasado desde las 0:00.

Tenga en cuenta que a partir de las 0:00, cada 12/11 horas (es decir, 720/11 minutos), las dos manos se superponen una vez.

Por lo tanto, dado el valor de los minutos, simplemente redondea al múltiplo más cercano de 720/11 (diferente de sí mismo). Esto se puede lograr mediante *11/720 (J tiene un número racional literal 11r720), toma la palabra <., incrementa>: , luego multiplícalo por 720/11.

Tenga en cuenta que "multiplicar por 11/720" y "multiplicar por 720/11" son 2 acciones inversas, así como "convertir de [hora, minuto] a número de minutos transcurridos" y viceversa. Afortunadamente J tiene incorporado&. (debajo), que revierte alguna acción después de aplicar una transformación.

Después de eso solo haz el redondeo: 0.5 +entonces <..

R , 68 bytes

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

Pruébalo en línea!

• -2 bytes gracias a Giuseppe
• +7 bytes debido al redondeo faltante :(

Explotando la ecuación:

same_position_minutes = 720/11 * index

donde indexes 0 para la primera posición superpuesta (00:00), 1 para la segunda y así sucesivamente ...

R , 88 bytes

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)

Pruébalo en línea!

Aumentar el tiempo en un minuto. Comprueba el ángulo. Si no está lo suficientemente cerca, realiza un bucle hasta encontrar una solución.

Python 3 , 80 78 bytes

Esta es mi primera presentación, así que las críticas constructivas son bienvenidas :)

-2 bytes gracias 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))

Pruébalo en línea! (78) ¡ Pruébalo en línea! (80)

Java 8, 89 82 bytes

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

Fijo. Veré si puedo jugar golf más tarde (probablemente portando otra respuesta).

Pruébalo en línea.

Explicación:

QUE HACER

Apl (Dyalog Unicode) , 28 bytes

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

Pruébalo en línea!

Explicación

((⍳11),⍪0,+\∊5/⊂5 6)es una matriz de veces en que las manos se superponen (impresas al final del enlace tio)
(⍸⌷1⊖⊣)⎕encuentra el intervalo en el que la entrada está en la matriz y los índices debajo de ella se envuelven.

C # (.NET Core) , 70 bytes

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

Pruébalo en línea!

Creo que pasa todos los casos de prueba. Aunque el caso h = 11 es algo feo

Explicación:

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

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>

Jalea , 25 bytes

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

Pruébalo en línea!

Un enlace monádico que toma el tiempo como una lista de dos enteros y devuelve una lista de dos enteros correspondiente a la próxima vez que las manos deben tocarse.

Perl 6 , 43 bytes

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

Pruébalo en línea!

Una lambda anónima Cualquiera que tome dos enteros que representen horas y minutos y devuelva las horas y minutos en orden inverso. En este momento no es coherente cuando ingresa un tiempo alineado, ya sea que salga el siguiente tiempo alineado o permanezca en el mismo. Estoy esperando que OP responda sobre ese asunto, pero en este momento lo estoy tratando como indefinido.

Explicación

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