The Clock Hands of Doom

Question

You are chained to a chair. Underneath you is a huge volcano. A 12-hour clock next to you ticks ominously, and you see that it has wires leading from the back up to a chain, which will drop you into the center of the earth. Taped to the clock is a note:

Each clock hand has an electrode. When both clock hands are in the same position, the power flows and you die. That is, unless you can tell me the exact time that this will occur, to the nearest minute.

You have a computer that knows every programming language. You need to create the shortest (this is code-golf, and standard loopholes are prohibited) program you can, and tell the evil scientist what the time will be. Your program should take input (in any method), consisting of the hour and minute. It should return the next hour and minute (in any method) that this occurs.

According to the OEIS page, the eleven overlap times are:

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.

The next time would be 12:00:00. The seconds and their fractional parts are not needed for this challenge. Simply round to the nearest minute.

Test cases:

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)

The program can be a function, or full program. I do not care if you choose 0:00 or 12:00, and both are acceptable. Good luck!

Answer 1

JavaScript (Node.js), 54 47 bytes (round to the nearest)

-7 bytes. Thanks @user202729

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

Try it online!

---

JavaScript (Node.js), 40 33 44 bytes (rounds towards 0)

-3 bytes thanks to @Arnauld

-4 bytes thanks to @Kevin Cruijssen

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

Explanation

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

Side note: I'm pretty sure this can be golf down by someone with more knowledge at math. I barely know how to sum and multiply

Try it online!

Answer 2

J, 31 bytes

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

Try it online!

The way to round a number in J is to add 0.5 and take the floor (<.). Takes too many bytes...

---

Explanation

12 60&#. (mixed base conversion) converts from an array of [hour, minute] to the minute passed since 0:00.

Note that starting from 0:00, every 12/11 hours (that is, 720/11 minutes), the two hands overlap once.

Therefore, given the minute value, just round it up to the nearest multiple of 720/11 (different from itself). This can be achieved by * it by 11/720 (J has rational number literal 11r720), take the floor <., increment >:, then multiply it by 720/11.

Note that "multiply by 11/720" and "multiply by 720/11" are 2 reverse action, as well as "convert from [hour, minute] to number of minute passed" and vice versa. Fortunately J has built-in &. (under), which reverses some action after applying a transformation.

After that just do the rounding: 0.5 + then <..

Answer 3

R, 68 bytes

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

Try it online!

• -2 bytes thanks to Giuseppe
• +7 bytes due to missing rounding :(

Exploiting the equation :

same_position_minutes = 720/11 * index

where index is 0 for the first overlapping position (00:00), 1 for the 2nd and so on...

Answer 4

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)

Try it online!

Increase time by one minute. Checks the angle. If not close enough, loops until a solution is found.

Answer 5

Python 3, 80 78 bytes

This is my first submission, so constructive criticism is welcome :)

-2 bytes thanks to @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))

Try it online! (78) Try it online! (80)

Answer 6

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

Fixed. Will see if I can golf it later (probably by porting another answer)..

Try it online.

Explanation:

TODO

Answer 7

Apl (Dyalog Unicode), 28 bytes

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

Try it online!

---

Explanation

((⍳11),⍪0,+\∊5/⊂5 6) is a matrix of times where the hands overlap (printed at the end of the tio link)
(⍸⌷1⊖⊣)⎕ finds the interval in which the input is in the matrix and indexes below it wrapping around.

Answer 8

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

Try it online!

I think it passes all test cases. Although the h=11 case is kind of ugly

Explanation:

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

Answer 9

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>

Answer 10

Jelly, 25 bytes

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

Try it online!

A monadic link that takes the time as a two-integer list and returns a two-integer list corresponding to the next time the hands are due to touch.

Answer 11

Perl 6, 43 bytes

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

Try it online!

An anonymous Whatever lambda that takes two integers representing hours and minutes and returns the hours and minutes in reverse order. Right now it isn't consistent when you input an aligned time, whether it outputs the next aligned time or stays on the same one. I'm waiting on OP to respond on that matter, but right now I'm treating it as undefined.

Explanation

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