¿Cuánto tiempo debe funcionar mi microondas?

33

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

Andrew Brēza
fuente
@WheatWizard, estoy feliz de editar la pregunta. ¿Tiene alguna sugerencia para lo que debería decir en la sección Detalles? Tal vez podría aclarar esta oración: "Los unos y los diez lugares deberían interpretarse como segundos y los cientos y miles de lugares deberían ser minutos".
Andrew Brēza
@WheatWizard Acabo de agregar más detalles, avíseme si cree que debería agregar más.
Andrew Brēza
¿Funciona con una entrada de 9876?
Andrew Brēza
1
Extraño, estaba a punto de caja de arena este desafío exacta jaja
FlipTack
¿Para qué sería la salida 190?
OldBunny2800

Respuestas:

9

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

ETHproducciones
fuente
1
Exactamente lo que tenía :)
Shaggy
7

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

HatsuPointerKun
fuente
El código de prueba D será el pie de página de este TIO: tio.run/… , y veo que has aprendido el sistema de plantillas :). (Hay una foreachen D, simplemente olvidé cómo usarla tristemente)
Zacharý
C puede jugar golf a 28 bytes usando C89 implicit-int.
pizzapants184
Debe publicar todo esto como respuestas separadas.
MD XF
6

Pyth - 9 8 bytes

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

ijQ*TT60

Test Suite .

Maltysen
fuente
6

TI-Basic (serie 83), 8 bytes

Ans-40int(sub(Ans

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

Misha Lavrov
fuente
6

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
seshoumara
fuente
5

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.

Justin Mariner
fuente
1
Si elimina -ry usa \?, puede perder 2 bytes.
seshoumara
3

Perl 5, 15 + 1 (-p) bytes

/..$/;$_-=40*$`
  • -l interruptor no contado porque para las pruebas de legibilidad

Pruébalo en línea

Nahuel Fouilleul
fuente
2

JavaScript, 21 bytes

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

Pruébalo en línea!


fuente
Ahorre 4 bytes utilizando el truco de ovs - a- (a / 100 ^ 0) * 40
IanF1
1
@ IanF1. Gracias, pero creo que literalmente estaría robando su idea.
Si, tienes razón. Demasiado entusiasta, lo siento.
IanF1
3
@ThePirateBay Realmente no estás a la altura de tu nombre;)
kamoroso94
2

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!

Galen Ivanov
fuente
1
El mismo byte cuenta que 60#.0 100#:].
FrownyFrog
@FrownyFrog: ¡su solución se ve más bonita!
Galen Ivanov
2

Lote, 23 bytes

@cmd/cset/a%1-%1/100*40
Neil
fuente
2

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.

Martin Ender
fuente
2

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⌋

Sr. Xcoder
fuente
Como función, 5 bytes
caird coinheringaahing
@cairdcoinheringaahing Creo que quisiste decir esto , pero gracias por el
aviso de
2

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)]
Taylor Scott
fuente
2

APL (Dyalog) , 11 10 bytes

600 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

Uriel
fuente
2

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)
Charles
fuente
2

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!

FlipTack
fuente
1
9 bytes creando un puerto de Python 2 Respuesta @ovs' : 2dH/40*-#. Nunca programado en Pushy antes, pero parece un lenguaje muy bueno. :)
Kevin Cruijssen
1
@KevinCruijssen es un lenguaje bastante genérico basado en la pila, supongo que la única cosa ligeramente diferente que trae a la mesa es la pila doble ... pero gracias y gracias por el golf :)
FlipTack
1

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.


fuente
1

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.

Martin Ender
fuente
1

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.
Martin Ender
fuente
1

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
ovs
fuente
1

R , 21 bytes

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

Pruébalo en línea!

marca
fuente
1
Creé mi propia solución en R y era mucho menos elegante que esto.
Andrew Brēza
Puede cortar scanya que la mayoría de las respuestas solo asumen que la variable ya está definida.
Andrew Brēza
Las reglas son tan inconsistentes con respecto a eso. Uno de los desafíos más importantes que debe tener una función o escaneo para capturar el valor.
Mark
1

REXX, 25 bytes

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

(Solo otras traducciones de @ovs)

idrougge
fuente
0

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]
Cinari
fuente
0

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
ovs
fuente