J'ai faim. Faisons au micro-ondes quelque chose. Avec une entrée numérique comprise entre 1 et 4 chiffres, indiquez le nombre de secondes pendant lesquelles le micro-ondes devrait fonctionner.

Détails

L'astuce consiste à déterminer si l'utilisateur saisit des secondes ou une combinaison de secondes et de minutes. Les uns et les dizaines doivent être interprétés comme des secondes et les centaines et des milliers doivent être des minutes. Par exemple, la valeur 1234doit être interprétée comme 12 minutes, 34 secondes et 987698 minutes, 76 secondes. En tapant 130, vous 90devriez obtenir un temps de cuisson de 90 secondes.

Voici quelques autres entrées et sorties:

• 1 = 1
• 11 = 11
• 111 = 71
• 1111 = 671
• 9 = 9
• 99 = 99
• 999 = 639
• 9999 = 6039

Règles

C'est le code-golf , donc le programme le plus court en octets gagne. Les failles standard ne sont pas autorisées. L'entrée gagnante doit renvoyer la bonne réponse lorsque toute entrée entière comprise entre 1 et 9999 est donnée.

Python 2 , 19 octets

lambda t:t-t/100*40

Essayez-le en ligne!

Japt , 6 octets

ìL ì60

Testez-le en ligne! ìLconvertit en base 100, et ì60reconvertit en base 60, résultant en floor(n/100)*60 + n%100. Fonctionne également avec les heures ( 10000 -> 3600le nombre de secondes dans une heure).

C, C ++, Java, C #, D: 36 octets

D: 35 octets

C: 28 octets

La première fois que j'ai une réponse aussi courte!

int r(int i){return i/100*60+i%100;}

D peut avoir une optimisation spéciale à cause du système de template golfy:

T r(T)(T i){return i/100*60+i%100;}

C a une optimisation spéciale avec l’int implicite:

r(i){return i/100*60+i%100;}

Code à tester

En C (à inclure stdio.h):

int main() {
    int testArr[] = {1,11,111,1111,9,99,999,9999};
    for(int i=0;i<8; ++i) {
        printf("%d = %d\n",testArr[i],r(testArr[i]));
    }
    return 0;
}

Lien TIO

En C ++ (à inclure iostream):

int main() {
    std::initializer_list<int> testList{
        1,11,111,1111,9,99,999,9999
    };

    for (auto x : testList) {
        std::cout << r(x) << '\n';
    }
}

Essayez-le en ligne!

En Java :

public class MainApp {

    int r(int i){return i/100*60+i%100;}

    public static void main(String[]a) {
        MainApp m = new MainApp();
        int testArr[] = new int[]{
                1,11,111,1111,9,99,999,9999
        };

        for (int v : testArr) {
            System.out.println(v + " = " + m.r(v));
        }
    }
}

Essayez-le en ligne!

En C #

class Program {
    int r(int i){return i/100*60+i%100;}
    static void Main(string[] args) {
        var p = new Program();
        int[] testArr = new int[8]
        {
            1,11,111,1111,9,99,999,9999
        };
        foreach(int a in testArr) {
            Console.WriteLine(a + " = " + p.r(a));
        }
    }
}

En D (à importer std.stdio) (exactement, je ne sais pas comment utiliser les tableaux en D):

void main() {
    int[] arr = [1,11,111,1111,9,9,999,9999];
    for(int i = 0; i < arr.length; i++)
        writeln(arr[i]," = ",r(arr[i]));
} 

Lien TIO

Pyth - 9 8 octets

Convertit l’entrée en base 100, puis interprète cela comme un nombre base 60.

ijQ*TT60

Suite de test .

TI-Basic (série 83), 8 octets

Ans-40int(sub(Ans

Nécessite la version 1.15 ou supérieure du système d'exploitation.

dc , 10 octets

?9A~r60*+p

Essayez-le en ligne!

Explication: en courant continu lorsque vous appuyez sur qc. sur la pile, il va sur le dessus

?         # read and push the input number on the stack
9A        # push 100: 9 * 10^1 + A[10] * 10^0 :D
~         # divide 2nd nr. by the top nr., push quotient, then remainder
r60*      # swap top 2 nr., then multiply the top by 60
+p        # add top 2 nr., then print result

Bash bc + sed, 30 ans 28 octets

-2 octets grâce à @seshoumara .

bc<<<0`sed 's/..\?$/*60+&/'`

Essayez-le en ligne!

Prend les commentaires de stdin. Nous sommes allés vers une approche plus créative: insère *60+avant les 1 ou 2 derniers chiffres et ajoute 0le début de page au début de manière à prendre en compte les entrées comportant 1 ou 2 chiffres seulement. Le résultat est ensuite transmis à bc.

C (gcc) , 50 octets

t;f(){scanf("%d",&t);printf("%d",t%100+t/100*60);}

Essayez-le en ligne!

Perl 5, 15 + 1 (-p) octets

/..$/;$_-=40*$`

• -l commutateur non compté car pour la lisibilité des tests

Essayez-le en ligne

Java 8, 13 octets

n->n-n/100*40

La formule étonnante Python 2 du port de @ovs .

Essayez ici.

JavaScript, 21 octets

a=>(a/100^0)*60+a%100

Essayez-le en ligne!

J , 12 octets

-40*&<.%&100

C'est la solution Python 2 de ovs exprimée en J. Elle consiste en un crochet et une fourchette:

┌─┬───────────────────────┐
│-│┌──┬────────┬─────────┐│
│ ││40│┌─┬─┬──┐│┌─┬─┬───┐││
│ ││  ││*│&│<.│││%│&│100│││
│ ││  │└─┴─┴──┘│└─┴─┴───┘││
│ │└──┴────────┴─────────┘│
└─┴───────────────────────┘

       %&100  - divides the number by 100
   *&<.       - finds the floor of the left argument and multiplies it to the left arg.
 40           - 
-             - subtracts the result of the above fork from the input 

Essayez-le en ligne!

Lot, 23 octets

@cmd/cset/a%1-%1/100*40

Haskell , 18 octets

f t=t-t`div`100*40

Essayez-le en ligne!

Port d'Anotha.

Solution sans point, 21 octets

(-)<*>(*40).(`div`40)

Labyrinthe , 19 octets

?:_100%}#00/_60*{+!

Essayez-le en ligne!

Explication

?      Read input.
:      Duplicate.
_100%  Mod 100.
}      Move off to auxiliary stack.
#00/   Divide by 100, using the stack depth to get a 1, instead of _1.
_60*   Multiply by 60.
{+     Retrieve the earlier result and add it.
!      Print.

L’IP se heurte alors à une impasse et commence à reculer. Quand il atteint le /il tente une division par zéro qui termine le programme.

Gelée , 5 octets

En tant que lien monadique (merci pour le heads-up, caird!):

b³ḅ60

Essayez-le en ligne!

... ou en programme complet:

bȷ2ḅ60

Cela peut être facilement porté sur 05AB1E, donc:

05AB1E , 5 octets

тв60β

Essayez-le en ligne!

Convertit simplement le nombre entier en entrée en base 100 , puis convertit le résultat de la base 60 en nombre entier. Par conséquent, cela équivaut à Input% 100 + 60 * «Input / 100».

Excel VBA, 29 octets

Fonction de fenêtre immédiate VBE anonyme qui prend les entrées de la plage [A1]et les envoie à la fenêtre immédiate VBE.

?[A1]Mod 1E2+60*[Int(A1/100)]

APL (Dyalog) , 11 à 10 octets

60⊥0 100⊤⊢

Essayez-le en ligne!

Comment?

0 100⊤- encoder en base 100, en s’arrêtant au deuxième LSB, produisant effectivement n ÷ 100, n % 100.

60⊥ - décoder en base 60

PARI / GP , 16 octets

Simple:

n->n\100*60+n%100

Malheureusement, cette méthode est trop longue à utiliser:

n->[60,1]*divrem(n,100)

Pushy , 10 9 octets

Kevin m'a gommé dans ma propre langue ... (en utilisant l'approche de la réponse des ovs )

2dH/40*-#

Essayez-le en ligne!

10 octets

sjvj60*^+#

Essayez-le en ligne!

s             \ Split input into digits
 jvj          \ Join the first two and the last two
    60*       \ Multiply the first by 60
       ^+     \ Add the values
         #    \ Print

11 octets

Pour un octet de plus, nous pouvons utiliser l' Input % 100 + 60 * ⌊Input / 100⌋approche:

H2d%}/60*+#

Essayez-le en ligne!

05AB1E , 9 octets

т÷60*¹т%+

Essayez-le en ligne!

Explication:

т÷60*¹т%+

т         // Push number 100
 ÷        // Integer division with the input
  60      // Push number 60
    *     // Multiply with the previous result
     ¹    // Push input
      т   // Push 100 again
       %  // Modulo
        + // Add the first and the second result

Il y a probablement un truc avec des conversions de base qui peut être réalisé dans 05AB1E, mais je ne l'ai pas trouvé.

bash, 20 octets

echo $[$1-$1/100*40]

Essayez-le en ligne

Rétine , 11 octets

.{100}
60$*

Essayez-le en ligne!

Entrée et sortie en unaire . La suite de tests est convertie de et en décimal pour plus de commodité.

Faire ce genre de conversion de base pour seulement deux chiffres est étonnamment simple à faire en unaire. Nous assortissons simplement des séries de 100 1s et les remplaçons par 60 1s. Tout ce qui reste correspondrait aux deux derniers chiffres de la représentation décimale et resterait inchangé.

Alice , 19 octets

/o
\i@/.'d%~'d:'<*+

Essayez-le en ligne!

Explication

Dommage que j'ai enlevé divmod de la langue, je suppose ...

/o
\i@/...

Ce n'est que le cadre habituel pour les programmes linéaires avec E / S décimales fonctionnant uniquement en mode Cardinal (arithmétique).

.     Duplicate input.
'd%   Mod 100.
~     Swap with other copy.
'd:   Divide by 100.
'<*   Multiply by 60.
+     Add.

Voie lactée , 10 octets

':Z/v40*-!

usage: ./mw code.mwg -i 9999

Explication:

code       explanation                          stack

'          push input to stack                  [input]
 :         duplicate ToS                        [input, input]
  Z        push 100                             [input, input, 100]
   /v      integer division (divide and floor)  [input, ⌊input/100⌋]
     40    push 40                              [input, ⌊input/100⌋, 40]
       *   multiply                             [input, ⌊input/100⌋*40]
        -  subtract                             [input - ⌊input/100⌋*40]
         ! print

R , 21 octets

x=scan();x-x%/%100*40

Essayez-le en ligne!

Common Lisp, 34 octets

(lambda(n)(- n(*(floor n 100)40)))

Essayez-le en ligne!

Un autre port de la formule @ovs .

REXX, 25 octets

arg t
say t%100*60+t//100

(Juste une autre traduction de @ovs)

05AB1E , 7 octets

т‰ć60*+

Essayez-le en ligne!

Explication

         command                              current stack
т‰ć60*+  full program. push input implicitly  [1234]
т        push 100                             [1234] [100]
 ‰       push divmod                          [12, 34]
  ć      push head extracted (n[1:], n[0])    [34] [12]
   60*   multiply by 60                       [34] [720]
      +  add and display implicitly           [754]

Python symbolique , 66 octets

___=-~-~_-_
__=___*___
__=__*__*___+___*__
_=_-_/(__+__+__/___)*__

Essayez-le en ligne!

Explication

Symbolic Python          values

___=-~-~_-_              ___=2
__=___*___               __=2*2=4
__=__*__*___+___*__      __=4*4*2+2*4=32+8=40
_=_-_/(__+__+__/___)*__  _=_-_/(40+40+40/2)*40=_-_/100*40