Você está acorrentado a uma cadeira. Debaixo de você há um enorme vulcão. Um relógio de 12 horas ao seu lado marca sinistramente, e você vê que ele tem fios que vão da parte de trás até uma corrente, o que o leva ao centro da terra. Gravada no relógio está uma nota:

Cada ponteiro do relógio possui um eletrodo. Quando os dois ponteiros do relógio estão na mesma posição, a energia flui e você morre. Ou seja, a menos que você possa me dizer a hora exata em que isso ocorrerá, no minuto mais próximo.

Você tem um computador que conhece todas as linguagens de programação. Você precisa criar o programa mais curto (isto é, código-golfe e brechas padrão são proibidas) que puder e informar ao cientista do mal que horas serão. Seu programa deve receber entrada (em qualquer método), consistindo de hora e minuto. Ele deve retornar a próxima hora e minuto (em qualquer método) que isso ocorra.

De acordo com a página OEIS , os onze tempos de sobreposição são:

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.

A próxima vez seria 12:00:00. Os segundos e suas partes fracionárias não são necessários para este desafio. Basta arredondar para o minuto mais próximo.

Casos de teste:

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)

O programa pode ser uma função ou programa completo. Eu não me importo se você escolher 0:00ou 12:00, e ambos são aceitáveis. Boa sorte!

JavaScript (Node.js) , 54 47 bytes (arredondado para o mais próximo)

-7 bytes. Obrigado @ user202729

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

Experimente online!

JavaScript (Node.js) , 40 33 44 bytes (arredonda para 0)

-3 bytes graças a @Arnauld

-4 bytes graças a @Kevin Cruijssen

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

Explicação

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 lateral: Tenho certeza de que isso pode ser um problema no golfe por alguém com mais conhecimento em matemática. Eu mal sei somar e multiplicar

Experimente online!

J , 31 bytes

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

Experimente online!

A maneira de arredondar um número em J é adicionar 0.5e usar a palavra ( <.). Leva muitos bytes ...

Explicação

12 60&#. (conversão de base mista) converte de uma matriz de [hora, minuto] para o minuto passado desde 0:00.

Observe que, a partir das 0:00, a cada 12/11 horas (ou seja, 720/11 minutos), os dois ponteiros se sobrepõem uma vez.

Portanto, dado o valor minuto, basta arredondá-lo para o múltiplo mais próximo de 720/11 (diferente dele mesmo). Isso pode ser alcançado por *11/720 (J tem um número racional literal 11r720), use a palavra <., aumente >:e multiplique por 720/11.

Observe que "multiplicar por 11/720" e "multiplicar por 720/11" são 2 ações reversas, além de "converter de [hora, minuto] para o número de minutos passados" e vice-versa. Felizmente, J incorporou &.(abaixo), o que reverte alguma ação após aplicar uma transformação.

Depois disso basta fazer o arredondamento: 0.5 +então <..

R , 68 bytes

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

Experimente online!

• -2 bytes graças a Giuseppe
• +7 bytes devido a falta de arredondamento :(

Explorando a equação:

same_position_minutes = 720/11 * index

onde indexé 0 para a primeira posição sobreposta (00:00), 1 para a segunda e assim por diante ...

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)

Experimente online!

Aumente o tempo em um minuto. Verifica o ângulo. Se não estiver perto o suficiente, faça um loop até encontrar uma solução.

Python 3 , 80 bytes

Esta é a minha primeira submissão, portanto críticas construtivas são bem-vindas :)

-2 bytes graças 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))

Experimente online! (78) Experimente online! (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

Fixo. Vou ver se consigo jogar depois (provavelmente portando outra resposta) ..

Experimente online.

Explicação:

FAÇAM

Apl (Dyalog Unicode) , 28 bytes

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

Experimente online!

Explicação

((⍳11),⍪0,+\∊5/⊂5 6)é uma matriz de vezes em que os ponteiros se sobrepõem (impressos no final do link do tio)
(⍸⌷1⊖⊣)⎕encontram o intervalo em que a entrada está na matriz e indexa abaixo dela.

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

Experimente online!

Eu acho que passa em todos os casos de teste. Embora o caso h = 11 seja meio feio

Explicação:

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

Gelatina , 25 bytes

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

Experimente online!

Um link monádico que leva o tempo como uma lista de dois inteiros e retorna uma lista de dois inteiros correspondente à próxima vez que os ponteiros tocarem.

Perl 6 , 43 bytes

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

Experimente online!

Um anônimo Qualquer que seja o lambda que use dois números inteiros representando horas e minutos e retorne as horas e os minutos na ordem inversa. No momento, não é consistente quando você insere um horário alinhado, seja o próximo horário alinhado ou se permanece no mesmo. Estou esperando que o OP responda sobre esse assunto, mas agora estou tratando-o como indefinido.

Explicação

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