Sie sind an einen Stuhl gekettet. Unter Ihnen befindet sich ein riesiger Vulkan. Eine 12-Stunden-Uhr neben Ihnen tickt bedrohlich, und Sie sehen, dass Drähte von hinten bis zu einer Kette führen, die Sie in den Erdmittelpunkt fallen lässt. Auf die Uhr geklebt ist ein Hinweis:

Jeder Uhrzeiger hat eine Elektrode. Wenn sich beide Uhrzeiger in derselben Position befinden, fließt der Strom und Sie sterben. Das heißt, es sei denn, Sie können mir den genauen Zeitpunkt, zu dem dies eintreten wird, auf die nächste Minute genau mitteilen.

Sie haben einen Computer, der jede Programmiersprache kennt. Sie müssen das kürzeste Programm erstellen (dies ist Code-Golf und Standardschlupflöcher sind verboten), das Sie können, und dem bösen Wissenschaftler mitteilen, wie spät es sein wird. Ihr Programm sollte Eingaben (in jeder Methode) enthalten, die aus Stunde und Minute bestehen. Es sollte die nächste Stunde und Minute (bei jeder Methode) zurückgeben, in der dies auftritt.

Laut der OEIS-Seite sind die elf Überlappungszeiten:

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.

Das nächste Mal wäre 12:00:00. Die Sekunden und ihre Bruchteile werden für diese Herausforderung nicht benötigt. Einfach auf die nächste Minute runden.

Testfälle:

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)

Das Programm kann eine Funktion oder ein vollständiges Programm sein. Es ist mir egal, ob Sie 0:00oder wählen 12:00, und beide sind akzeptabel. Viel Glück!

JavaScript (Node.js) , 54 47 Byte (auf den nächsten gerundet)

-7 Bytes. Danke @ user202729

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

Probieren Sie es online aus!

JavaScript (Node.js) , 40 33 44 Bytes (Runden in Richtung 0)

-3 Bytes dank @Arnauld

-4 Bytes dank @Kevin Cruijssen

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

Erläuterung

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

Randnotiz: Ich bin mir ziemlich sicher, dass dies von jemandem mit mehr Kenntnissen in Mathematik Golf gespielt werden kann. Ich weiß kaum, wie man summiert und multipliziert

Probieren Sie es online aus!

J , 31 Bytes

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

Probieren Sie es online aus!

Die Möglichkeit, eine Zahl in J zu runden, besteht darin 0.5, das Wort hinzuzufügen und zu übernehmen ( <.). Nimmt zu viele Bytes ...

Erläuterung

12 60&#. (Mixed Base Conversion) konvertiert von einem Array von [Stunde, Minute] in die seit 0:00 verstrichene Minute.

Beachten Sie, dass sich die beiden Zeiger ab 12:00 Uhr alle 12/11 Stunden (dh 720/11 Minuten) einmal überlappen.

Runden Sie den gegebenen Wert daher einfach auf das nächste Vielfache von 720/11 auf (anders als sich selbst). Dies kann dadurch erreicht werden, *dass bis 11/720 (J hat ein rationales Zahlenliteral 11r720), das Wort ergreift <., inkrementiert>: und dann mit 720/11 multiplizieren.

Beachten Sie, dass "Multiplizieren mit 11/720" und "Multiplizieren mit 720/11" zwei umgekehrte Aktionen sowie "Konvertieren von [Stunde, Minute] in die Anzahl der verstrichenen Minuten" und umgekehrt sind. Glücklicherweise hat J &.(under) eingebaut , was nach dem Anwenden einer Transformation einige Aktionen umkehrt.

Danach einfach die Rundung machen: 0.5 +dann <..

R , 68 Bytes

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

Probieren Sie es online aus!

• -2 Bytes dank Giuseppe
• +7 Bytes wegen fehlender Rundung :(

Ausnutzung der Gleichung:

same_position_minutes = 720/11 * index

wo indexist 0 für die erste überlappende Position (00:00), 1 für die zweite und so weiter ...

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)

Probieren Sie es online aus!

Erhöhen Sie die Zeit um eine Minute. Überprüft den Winkel. Wenn nicht nahe genug, Schleifen, bis eine Lösung gefunden wird.

Python 3 , 80 78 Bytes

Dies ist meine erste Einreichung, daher ist konstruktive Kritik willkommen :)

-2 Bytes dank @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))

Probieren Sie es online aus! (78) Probieren Sie es online aus! (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

Fest. Mal sehen, ob ich später Golf spielen kann (wahrscheinlich durch Portieren einer anderen Antwort).

Probieren Sie es online aus.

Erläuterung:

MACHEN

Apl (Dyalog Unicode) , 28 Bytes

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

Probieren Sie es online aus!

Erläuterung

((⍳11),⍪0,+\∊5/⊂5 6)ist eine Matrix von Zeiten, in denen sich die Zeiger überlappen (gedruckt am Ende des tio-Links)
(⍸⌷1⊖⊣)⎕, das Intervall findet, in dem sich die Eingabe in der Matrix befindet, und die Indizes darunter umlaufen.

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

Probieren Sie es online aus!

Ich denke, es besteht alle Testfälle. Obwohl der Fall h = 11 irgendwie hässlich ist

Erläuterung:

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

Gelee , 25 Bytes

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

Probieren Sie es online aus!

Eine monadische Verknüpfung, die die Zeit als Zwei-Ganzzahl-Liste verwendet und eine Zwei-Ganzzahl-Liste zurückgibt, die dem nächsten Mal entspricht, wenn sich die Hände berühren.

Perl 6 , 43 Bytes

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

Probieren Sie es online aus!

Ein anonymes Was auch immer-Lambda, das zwei Ganzzahlen benötigt, die Stunden und Minuten darstellen, und die Stunden und Minuten in umgekehrter Reihenfolge zurückgibt. Im Moment ist es nicht konsistent, wenn Sie eine ausgerichtete Zeit eingeben, ob es die nächste ausgerichtete Zeit ausgibt oder auf derselben bleibt. Ich warte auf OP, um auf diese Angelegenheit zu antworten, aber im Moment behandle ich sie als undefiniert.

Erläuterung

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