Il reste combien de temps?

Récemment, je faisais de la pizza en utilisant une minuterie de 5 minutes sur mon téléphone. Quand quelqu'un est entré et m'a demandé combien de temps il me restait, j'ai d'abord été confus quant à la façon de répondre à la question. Vous voyez, si la minuterie à l'heure actuelle était à 3 h 47, au moment où j'avais lu à haute voix «Trois minutes et quarante-sept secondes», l'heure aurait changé. Par conséquent, je dois trouver une heure que la minuterie atteindrait juste au moment où je termine la lecture.

C'est votre défi: automatiser ce processus. Étant donné une heure dans n'importe quel format approprié (":" délimité ou en tant qu'argument minute et deuxième), affichez l'heure la plus ancienne à partir de cet instant actuel, ce qui prendrait un temps égal à lire comme il faudrait pour que le chronomètre obtienne à. Nous supposons que chaque syllabe prend 1 seconde pour être lue.

Règles supplémentaires

• Vous devez compter «minutes» et «secondes» comme deux syllabes chacune, ainsi qu'un «et» entre elles.
• La pizza ne prendra jamais plus de 59:59 pour cuisiner.
• «11 minutes et 0 seconde» n'est pas 10 syllabes: vous devez simplifier en «11 minutes» (soit 5 syllabes). Il en va de même pour les minutes: «0 minutes et 7 secondes» ne compte également que pour 4 syllabes.
• Votre programme peut donner la sortie dans n'importe quel format: un tableau de [minutes, seconds], ou même comme <minutes> minutes and <seconds> seconds(texte normal écrit).
• Des échappatoires standard s'appliquent.
• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.

Cas de test

Toutes les entrées en tant que (minutes, seconds)

(4, 47) = (4, 38) (Four MiNutes And ThirTy Eight SeConds - 9 syllables/seconds)
(1, 1) = (0, 56) (FifTy-Six SeConds - 5 syllables/seconds)
(59, 57) = (59, 46) (FifTy Nine Minutes And Forty Six SeConds - 11 syllables/seconds)
(0, 10) = null/error/0 (no positive answer)

Référence du nombre de syllabes

Pour référence, voici le nombre de syllabes dans chaque nombre jusqu'à 59.

0,0 (does not need to be counted)
1,1
2,1
3,1
4,1
5,1
6,1
7,2
8,1
9,1
10,1
11,3
12,1
13,2
14,2
15,2
16,2
17,3
18,2
19,2
20,2
21,3
22,3
23,3
24,3
25,3
26,3
27,4
28,3
29,3
30,2
31,3
32,3
33,3
34,3
35,3
36,3
37,4
38,3
39,3
40,2
41,3
42,3
43,3
44,3
45,3
46,3
47,4
48,3
49,3
50,2
51,3
52,3
53,3
54,3
55,3
56,3
57,4
58,3
59,3

JavaScript (ES6),  112 106  105 octets

Une version plus courte basée sur une suggestion de @EmbodimentofIgnorance
6 octets supplémentaires enregistrés par @DaniilTutubalin

(minutes)(seconds)[minutes, seconds]$0$

m=>d=F=s=>m|s?(g=n=>n&&(n%10!=7)-7+(n-11?n<13?2:n<21|n%10<1:0))(m)+g(s)^~d?F(s?s-1:m--&&59,d=-~d):[m,s]:0

Essayez-le en ligne!

JavaScript (ES6),  126  119 octets

(minutes)(seconds)[minutes, seconds]$0$

m=>d=F=s=>m|s?(g=n=>n&&2+(30774612>>2*n%(n>12?20:26)&3)+(n>12)+(n>19))(m)+g(s)+!!(m*s)^d?F(s?s-1:m--&&59,d=-~d):[m,s]:0

Essayez-le en ligne!

Commenté

m =>                  // m = minutes
d =                   // d = delta in seconds between the initial time and the current time,
                      //     initialized to a non-numeric value (zero-ish)
F = s =>              // F is a recursive function taking s = seconds
  m | s ? (           // if either m or s is not 0:
    g = n =>          //   g is a helper function taking an integer n in [0..59]
      n &&            //     return 0 if n = 0
      2 + (           //     otherwise, start with 2 for either 'mi-nutes' or 'se-conds'
        30774612 >>   //     add the base number of syllables (0 to 3) corresponding to n
        2 * n %       //     using a bitmask of 13 entries x 2-bit:
                      //       12 11 10  9  8  7  6  5  4  3  2  1  0
                      //       01 11 01 01 01 10 01 01 01 01 01 01 00
        (n > 12 ? 20  //     using n MOD 10 if n is greater than 12
                : 26) //     or just n otherwise
        & 3           //     isolate the two least significant bits
      ) +             //   
      (n > 12) +      //     add 1 syllable for '-teen' or '-ty' if n is greater than 12
      (n > 19)        //     add 1 more syllable for 'x-ty' if n is greater than 19
  )(m) +              //   invoke g for the minutes
  g(s) +              //   invoke g for the seconds
  !!(m * s)           //   add 1 syllable for 'and' if both m and s are non-zero
  ^ d ?               //   if the result is not equal to the delta:
    F(                //     otherwise, do a recursive call:
      s ? s - 1       //       decrement s if it's not 0,
        : m-- && 59,  //       or decrement m and restart with s = 59
      d = -~d         //       increment the delta
    )                 //     end of recursive call
  :                   //   else:
    [m, s]            //     success: return [m, s]
:                     // else:
  0                   //   failure: return 0

Python 3 , 287 285 octets

m=int(input())
s=int(input())
y=lambda w:3+(w[-1]=='7')-(w[-1]=='0')-(w[0]in'01')*(1+(w[0]=='0'))+(w=='11')-(w=='12')
z=lambda m,s:(2+y(f'{m:02d}'))*(m!=0)+(2+y(f'{s:02d}'))*(s!=0)+(m!=0!=s)
q=lambda t: (m-(t+60-s-1)//60,(s-t)%60)
print([q(t) for t in range(s+60*m) if z(*q(t))==t][0])

Essayez-le en ligne!

Ce n'est pas une solution très intelligente - c'est surtout très simple. Prend m: s m et s comme entrées séparées (n'a pas besoin d'être complétée) et sorties (m, s). Lance une erreur s'il n'y a pas de sortie valide.

Le programme repose fortement sur la conversion implicite de booléens en 0 et 1. La première ligne prend en entrée. La deuxième ligne définit une fonction lambda y qui donne les syllabes dans un nombre - elle suppose une base de 3 syllabes, puis ajoute 1 si elle se termine par 7, soustrait 1 si elle se termine par 0 et soustrait 1 si elle est dans les 10 et 2 s'il est à un seul chiffre. Douze et onze sont ajustés manuellement à la fin. La troisième ligne est un lambda pour les syllabes dans toute l'expression. Enfin, la quatrième ligne donne le temps après t secondes. La cinquième ligne est la sortie - elle construit un tableau de toutes les fois qui satisfont le problème et sort la première.

EDIT 1: Merci à Matthew Anderson dans les commentaires, 2 octets ont été rasés en prenant les entrées séparément.

C # (Visual C # Interactive Compiler) , 141 octets

a=>b=>((a=Enumerable.Range(1,b+=a*60).Last(i=>new[]{i/60,i%60}.Sum(x=>x<1?0:(x%10==7?4:3)+(x==11?3:x<13?1:x<21|x%10<1?2:3))-1==b-i))/60,a%60)

Essayez-le en ligne!

Gelée , 46 octets

ḅḶbɗ60Ṛµ“÷ṢḣxE⁻Ṇ⁹ƬƝwɼỤṡl’ḃ4+2;0⁸ịS+ṬS$’)=JTị⁸Ḣ

Essayez-le en ligne!

Un lien monadique prenant comme argument le temps comme [minutes, seconds]et renvoyant le temps approprié pour dire comme [minutes, seconds]ou [seconds]si moins d'une minute.

CJam , 102 octets

60:X;q~\X*+:W_{;(__X%\X/{_196656821516111872\_A%K+e<_{(2*m>3&3.5+}{\;}?@}2*+i+\X*+_W=!2$0<-}g;_X%\X/S@

Essayez-le en ligne!

Juste une vieille table de recherche binaire de nombre magique ennuyeux, rien à voir ici.