Tengo hambre. Pongamos algo en el microondas. Dada una entrada numérica de entre 1 y 4 dígitos, genera la cantidad de segundos que el microondas debe funcionar.

Detalles

El truco es descubrir si el usuario está ingresando segundos o una combinación de segundos y minutos. Los lugares y las decenas deben interpretarse como segundos y los cientos y miles de lugares deben ser minutos. Por ejemplo, el valor 1234debe interpretarse como 12 minutos, 34 segundos y 9876debe ser 98 minutos, 76 segundos. Escribir 130y 90ambos deberían resultar en un tiempo de cocción de 90 segundos.

Aquí hay algunas otras entradas y salidas:

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

Reglas

Este es el código de golf , por lo que gana el programa más corto en bytes. Las lagunas estándar no están permitidas. La entrada ganadora debe devolver la respuesta correcta cuando se le da una entrada entera del 1 al 9999.

Python 2 , 19 bytes

lambda t:t-t/100*40

Pruébalo en línea!

Japt , 6 bytes

ìL ì60

¡Pruébelo en línea! ìLconvierte a base-100 y ì60vuelve a convertir a base 60, lo que resulta en floor(n/100)*60 + n%100. También funciona con horas ( 10000 -> 3600la cantidad de segundos en una hora).

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

D: 35 bytes

C: 28 bytes

Primera vez que tengo una respuesta tan corta!

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

D puede tener una optimización especial debido al sistema de plantillas de golf:

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

C tiene una optimización especial con el int implícito:

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

Código para probar

En C (tiene que incluir 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;
}

Enlace TIO

En C ++ (tiene que incluir 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';
    }
}

Pruébalo en línea!

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

Pruébalo en línea!

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 (tengo que importar std.stdio) (exactamente, no tengo idea de cómo usar matrices 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]));
} 

Enlace TIO

Pyth - 9 8 bytes

Convierte la entrada a base 100, luego la interpreta como un número base 60.

ijQ*TT60

Test Suite .

TI-Basic (serie 83), 8 bytes

Ans-40int(sub(Ans

Requiere la versión del sistema operativo 1.15 o superior.

dc , 10 bytes

?9A~r60*+p

Pruébalo en línea!

Explicación: en cc cuando presionas algo. en la pila va arriba

?         # 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 gracias a @seshoumara .

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

Pruébalo en línea!

Toma información de stdin. Se *60+buscó un enfoque más creativo: se inserta antes de los últimos 1 o 2 dígitos, y antepone 0al principio para tener en cuenta las entradas con solo 1 o 2 dígitos. El resultado se pasa a bc.

C (gcc) , 50 bytes

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

Pruébalo en línea!

Perl 5, 15 + 1 (-p) bytes

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

• -l interruptor no contado porque para las pruebas de legibilidad

Pruébalo en línea

Java 8, 13 bytes

n->n-n/100*40

La sorprendente fórmula de Python 2 de @ovs .

Pruébalo aquí

JavaScript, 21 bytes

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

Pruébalo en línea!

J , 12 bytes

-40*&<.%&100

Es la solución Python 2 de ovs expresada en J. Consiste en un gancho y un tenedor:

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

Pruébalo en línea!

Lote, 23 bytes

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

Haskell , 18 bytes

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

Pruébalo en línea!

Puerto de Anotha.

Solución sin puntos, 21 bytes

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

Laberinto , 19 bytes

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

Pruébalo en línea!

Explicación

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

La IP luego llega a un callejón sin salida y comienza a retroceder. Cuando llega al /intenta una división por cero que termina el programa.

Jalea , 5 bytes

Como enlace monádico (¡gracias por el aviso, caird!):

b³ḅ60

Pruébalo en línea!

... O como un programa completo:

bȷ2ḅ60

Esto se puede portar fácilmente a 05AB1E, por lo que:

05AB1E , 5 bytes

тв60β

Pruébalo en línea!

Simplemente convierte el entero de entrada a base 100 y luego convierte el resultado de base 60 a entero. Por lo tanto, es equivalente a Input% 100 + 60 * ⌊Input / 100⌋

Excel VBA, 29 bytes

Función de ventana inmediata anónima de VBE que toma entrada del rango [A1]y salidas a la ventana inmediata de VBE.

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

APL (Dyalog) , 11 10 bytes

60⊥0 100⊤⊢

Pruébalo en línea!

¿Cómo?

0 100⊤- codificar en base 100, deteniéndose en el segundo LSB, produciendo efectivamente n ÷ 100, n % 100.

60⊥ - decodificar en base 60

PARI / GP , 16 bytes

Sencillo:

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

Lamentablemente, este buen método es simplemente demasiado largo para usar:

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

Pushy , 10 9 bytes

Kevin me superó en mi propio idioma ... (usando el enfoque de la respuesta de los ovs )

2dH/40*-#

Pruébalo en línea!

10 bytes

sjvj60*^+#

Pruébalo en línea!

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

Para un byte más podemos usar el Input % 100 + 60 * ⌊Input / 100⌋enfoque:

H2d%}/60*+#

Pruébalo en línea!

05AB1E , 9 bytes

т÷60*¹т%+

Pruébalo en línea!

Explicación:

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

Probablemente hay algún truco con las conversiones de base que se puede lograr en 05AB1E, pero no pude encontrarlo.

bash, 20 bytes

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

Pruébalo en línea

Retina , 11 bytes

.{100}
60$*

Pruébalo en línea!

Entrada y salida en unario . El conjunto de pruebas convierte de y a decimal por conveniencia.

Hacer este tipo de conversión de base para solo hasta dos dígitos es sorprendentemente simple de hacer en unario. Simplemente combinamos carreras de 100 1sy las reemplazamos por 60 1s. Cualquier cosa que quede correspondería a los dos últimos dígitos en la representación decimal y permanecerá sin cambios.

Alice , 19 bytes

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

Pruébalo en línea!

Explicación

Lástima que eliminé divmod del lenguaje, supongo ...

/o
\i@/...

Este es solo el marco habitual para programas lineales con E / S decimal que funcionan exclusivamente en modo Cardinal (aritmético).

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

Vía Láctea , 10 bytes

':Z/v40*-!

uso: ./mw code.mwg -i 9999

Explicación:

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

Pruébalo en línea!

Lisp común, 34 bytes

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

Pruébalo en línea!

Otro puerto de la fórmula de @ovs .

REXX, 25 bytes

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

(Solo otras traducciones de @ovs)

05AB1E , 7 bytes

т‰ć60*+

Pruébalo en línea!

Explicación

         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 simbólico , 66 bytes

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

Pruébalo en línea!

Explicación

Symbolic Python          values

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