Vous êtes enchaîné à une chaise. Sous vous se trouve un énorme volcan. Une horloge de 12 heures à côté de vous coche de façon inquiétante, et vous voyez qu'elle a des fils menant de l'arrière à une chaîne, qui vous déposera au centre de la terre. Enregistré sur l'horloge est une note:

Chaque aiguille d'horloge a une électrode. Lorsque les deux aiguilles de l'horloge sont dans la même position, la puissance circule et vous mourez. Autrement dit, sauf si vous pouvez me dire l'heure exacte à laquelle cela se produira, à la minute près.

Vous avez un ordinateur qui connaît tous les langages de programmation. Vous devez créer le programme le plus court (c'est le golf de code , et les failles standard sont interdites) que vous pouvez, et dire au mauvais scientifique quelle heure sera. Votre programme doit prendre en compte (dans n'importe quelle méthode), composé de l'heure et des minutes. Il doit renvoyer l'heure et la minute suivantes (dans n'importe quelle méthode) où cela se produit.

Selon la page OEIS , les onze temps de chevauchement sont les suivants:

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 prochaine fois serait 12:00:00. Les secondes et leurs parties fractionnaires ne sont pas nécessaires pour ce défi. Arrondissez simplement à la minute la plus proche.

Cas de 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)

Le programme peut être une fonction ou un programme complet. Je m'en fiche si vous choisissez 0:00ou 12:00, et les deux sont acceptables. Bonne chance!

JavaScript (Node.js) , 54 47 octets (arrondi au plus proche)

-7 octets. Merci @ user202729

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

Essayez-le en ligne!

JavaScript (Node.js) , 40 33 44 octets (arrondi vers 0)

-3 octets grâce à @Arnauld

-4 octets grâce à @Kevin Cruijssen

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

Explication

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

Note latérale: Je suis presque sûr que cela peut être le golf par quelqu'un avec plus de connaissances en mathématiques. Je sais à peine résumer et multiplier

Essayez-le en ligne!

J , 31 octets

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

Essayez-le en ligne!

La façon d'arrondir un nombre dans J est d'ajouter 0.5et de prendre la parole ( <.). Prend trop d'octets ...

Explication

12 60&#. (conversion de base mixte) convertit d'un tableau de [heure, minute] en minute écoulée depuis 0:00.

Notez qu'à partir de 0h00, toutes les 12/11 heures (soit 720/11 minutes), les deux mains se chevauchent une fois.

Par conséquent, étant donné la valeur des minutes, arrondissez-la au multiple de 720/11 le plus proche (différent de lui-même). Cela peut être réalisé par *11/720 (J a un littéral rationnel 11r720), prenez la parole <., incrémentez >:, puis multipliez-le par 720/11.

Notez que "multiplier par 11/720" et "multiplier par 720/11" sont deux actions inverses, ainsi que "convertir de [heure, minute] en nombre de minutes passées" et vice versa. Heureusement, J a intégré &.(sous), qui inverse une action après avoir appliqué une transformation.

Après cela, il suffit d'arrondir: 0.5 +alors <..

R , 68 octets

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

Essayez-le en ligne!

• -2 octets grâce à Giuseppe
• +7 octets en raison de l'arrondissement manquant :(

Exploiter l'équation:

same_position_minutes = 720/11 * index

où indexest 0 pour la première position qui se chevauchent (00:00), 1 pour la 2e et ainsi de suite ...

R , 88 octets

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)

Essayez-le en ligne!

Augmentez le temps d'une minute. Vérifie l'angle. S'il n'est pas assez proche, boucle jusqu'à ce qu'une solution soit trouvée.

Python 3 , 80 78 octets

Ceci est ma première soumission, donc les critiques constructives sont les bienvenues :)

-2 octets grâce à @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))

Essayez-le en ligne! (78) Essayez-le en ligne! (80)

Java 8, 89 82 octets

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

Fixé. Va voir si je peux jouer au golf plus tard (probablement en portant une autre réponse) ..

Essayez-le en ligne.

Explication:

FAIRE

Apl (Dyalog Unicode) , 28 octets

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

Essayez-le en ligne!

Explication

((⍳11),⍪0,+\∊5/⊂5 6)est une matrice de temps où les aiguilles se chevauchent (imprimées à la fin du lien tio)
(⍸⌷1⊖⊣)⎕trouve l'intervalle dans lequel l'entrée est dans la matrice et les index en dessous s'enroulant autour.

C # (.NET Core) , 70 octets

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

Essayez-le en ligne!

Je pense qu'il passe tous les cas de test. Bien que le cas h = 11 soit un peu moche

Explication:

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

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>

Gelée , 25 octets

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

Essayez-le en ligne!

Un lien monadique qui prend le temps comme une liste à deux entiers et renvoie une liste à deux entiers correspondant à la prochaine fois que les mains doivent toucher.

Perl 6 , 43 octets

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

Essayez-le en ligne!

Un lambda anonyme quel qu'il soit qui prend deux entiers représentant les heures et les minutes et renvoie les heures et les minutes dans l'ordre inverse. À l'heure actuelle, il n'est pas cohérent lorsque vous saisissez une heure alignée, qu'elle émette la prochaine heure alignée ou reste la même. J'attends que OP réponde à ce sujet, mais pour l'instant je le traite comme indéfini.

Explication

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