Ich habe Hunger. Lassen Sie uns etwas Mikrowelle. Geben Sie bei einer Zahleneingabe zwischen 1 und 4 Ziffern die Anzahl der Sekunden aus, die die Mikrowelle laufen soll.

Einzelheiten

Der Trick besteht darin, herauszufinden, ob der Benutzer Sekunden oder eine Kombination aus Sekunden und Minuten eingibt. Die Einsen und die Zehnerstellen sollten als Sekunden interpretiert werden und die Hunderter und Tausenderstellen sollten Minuten sein. Beispielsweise sollte der Wert 1234als 12 Minuten, 34 Sekunden und 987698 Minuten, 76 Sekunden interpretiert werden. Tippen 130und 90beides sollte eine Garzeit von 90 Sekunden ergeben.

Hier sind einige andere Ein- und Ausgänge:

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

Regeln

Das ist Code-Golf , also gewinnt das kürzeste Programm in Bytes. Standardlücken sind nicht erlaubt. Der Gewinner muss die richtige Antwort zurückgeben, wenn er eine Ganzzahleingabe von 1 bis 9999 erhält.

Python 2 , 19 Bytes

lambda t:t-t/100*40

Probieren Sie es online!

Japt , 6 Bytes

ìL ì60

Testen Sie es online! ìLkonvertiert zu Base-100 und ì60konvertiert zurück zu Base 60, was zu führt floor(n/100)*60 + n%100. Funktioniert auch mit Stunden ( 10000 -> 3600die Anzahl der Sekunden in einer Stunde).

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

D: 35 Bytes

C: 28 Bytes

Zum ersten Mal habe ich eine Antwort so kurz!

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

D kann aufgrund des Golf-Template-Systems eine besondere Optimierung erfahren:

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

C hat eine spezielle Optimierung mit dem impliziten int:

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

Code zum Testen

In C (muss enthalten sein 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;
}

TIO Link

In C ++ (muss enthalten sein 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';
    }
}

Probieren Sie es online!

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

Probieren Sie es online!

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

In D (muss importieren std.stdio) (genau, ich habe keine Ahnung, wie man Arrays in D verwendet):

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

TIO Link

Pyth - 9 8 Bytes

Wandelt die Eingabe in eine Zahl zur Basis 100 um und interpretiert diese als Zahl zur Basis 60.

ijQ*TT60

Test Suite .

TI-Basic (Serie 83), 8 Byte

Ans-40int(sub(Ans

Benötigt OS Version 1.15 oder höher.

Gleichstrom , 10 Bytes

?9A~r60*+p

Probieren Sie es online!

Erklärung: in dc, wenn du etw drückst. auf dem Stapel geht es oben drauf

?         # 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 28 Bytes

-2 Bytes dank @seshoumara .

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

Probieren Sie es online!

Übernimmt die Eingabe von stdin. Ging zu einem kreativeren Ansatz über: *60+Fügt vor den letzten 1 oder 2 Ziffern ein und stellt ein 0vor den Anfang, um Eingaben mit nur 1 oder 2 Ziffern zu berücksichtigen. Das Ergebnis wird dann an übergeben bc.

C (gcc) , 50 Bytes

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

Probieren Sie es online!

Perl 5, 15 + 1 (-p) Bytes

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

• -l Schalter nicht gezählt, da für Tests Lesbarkeit

Probieren Sie es online aus

Java 8, 13 Bytes

n->n-n/100*40

Port von @ovs 'erstaunlicher Python 2-Formel .

Probieren Sie es hier aus.

JavaScript, 21 Bytes

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

Probieren Sie es online!

J , 12 Bytes

-40*&<.%&100

Es ist die Python 2-Lösung von ovs, ausgedrückt in J. Sie besteht aus einem Haken und einer Gabel:

┌─┬───────────────────────┐
│-│┌──┬────────┬─────────┐│
│ ││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 

Probieren Sie es online!

Batch, 23 Bytes

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

Haskell , 18 Bytes

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

Probieren Sie es online!

Anotha Hafen.

Punktfreie Lösung, 21 Bytes

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

Labyrinth , 19 Bytes

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

Probieren Sie es online!

Erläuterung

?      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.

Die IP stößt dann auf eine Sackgasse und beginnt sich rückwärts zu bewegen. Wenn es das erreicht /, versucht es eine Division durch Null, die das Programm beendet.

Gelee , 5 Bytes

Als monadischer Link (danke für das Heads-up, caird!):

b³ḅ60

Probieren Sie es online!

... oder als volles Programm:

bȷ2ḅ60

Dies kann einfach auf 05AB1E portiert werden, also:

05AB1E , 5 Bytes

тв60β

Probieren Sie es online!

Konvertiert einfach die eingegebene Ganzzahl in die Basis 100 und konvertiert dann das Ergebnis von der Basis 60 in eine Ganzzahl. Daher entspricht dies Eingabe% 100 + 60 * ⌊Eingang / 100⌋

Excel VBA, 29 Bytes

Anonyme VBE-Direktfensterfunktion, die Eingaben aus dem Bereich [A1]und Ausgaben in das VBE-Direktfenster übernimmt .

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

APL (Dyalog) , 11 10 Bytes

60⊥0 100⊤⊢

Probieren Sie es online!

Wie?

0 100⊤- in der Basis 100 codieren, an dem zweiten LSB anhalten und effektiv produzieren n ÷ 100, n % 100.

60⊥ - in der Basis 60 dekodieren

PARI / GP , 16 Bytes

Einfach:

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

Leider ist diese schöne Methode einfach zu lang:

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

Aufdringlich , 10 9 Bytes

Kevin hat mich in meiner eigenen Sprache übervorteilt ... (mit dem Ansatz von ovs 'Antwort)

2dH/40*-#

Probieren Sie es online!

10 Bytes

sjvj60*^+#

Probieren Sie es online!

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 Bytes

Für ein Byte mehr können wir den Input % 100 + 60 * ⌊Input / 100⌋Ansatz verwenden:

H2d%}/60*+#

Probieren Sie es online!

05AB1E , 9 Bytes

т÷60*¹т%+

Probieren Sie es online!

Erläuterung:

т÷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

Wahrscheinlich gibt es einen Trick mit Basisumwandlungen, der in 05AB1E erzielt werden kann, aber ich konnte ihn nicht finden.

Bash, 20 Bytes

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

Probieren Sie es online aus

Retina , 11 Bytes

.{100}
60$*

Probieren Sie es online!

Ein- und Ausgabe in unary . Die Testsuite konvertiert aus praktischen Gründen von und nach Dezimalstellen.

Diese Art der Basiskonvertierung für nur zwei Ziffern ist überraschend einfach in unary durchzuführen. Wir gleichen nur Läufe von 100 1s ab und ersetzen sie durch 60 1s. Alles, was übrig bleibt, entspricht den letzten beiden Stellen in der Dezimaldarstellung und bleibt unverändert.

Alice , 19 Bytes

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

Probieren Sie es online!

Erläuterung

Schade, dass ich Divmod aus der Sprache entfernt habe, denke ich ...

/o
\i@/...

Dies ist nur der übliche Rahmen für lineare Programme mit dezimaler E / A, die nur im Kardinalmodus (arithmetisch) ausgeführt werden.

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

Milchstraße , 10 Bytes

':Z/v40*-!

Verwendung: ./mw code.mwg -i 9999

Erläuterung:

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 Bytes

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

Probieren Sie es online!

Common Lisp, 34 Bytes

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

Probieren Sie es online!

Ein weiterer Port der @ovs-Formel .

REXX, 25 Bytes

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

(Nur eine andere Übersetzung von @ovs)

05AB1E , 7 Bytes

т‰ć60*+

Probieren Sie es online!

Erläuterung

         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]

Symbolische Python , 66 Bytes

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

Probieren Sie es online!

Erläuterung

Symbolic Python          values

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