Eu estou com fome. Vamos microondas alguma coisa. Dada uma entrada numérica entre 1 e 4 dígitos, produza o número de segundos que o microondas deve funcionar.

Detalhes

O truque é descobrir se o usuário está inserindo segundos ou uma combinação de segundos e minutos. Os locais das dezenas e dezenas devem ser interpretados como segundos e as centenas e milhares de locais devem ser minutos. Por exemplo, o valor 1234deve ser interpretado como 12 minutos, 34 segundos e 9876deve ser 98 minutos, 76 segundos. Digitando 130e 90ambos devem resultar em um tempo de cozedura de 90 segundos.

Aqui estão algumas outras entradas e saídas:

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

Regras

Isso é código-golfe , então o programa mais curto em bytes vence. As brechas padrão não são permitidas. A entrada vencedora deve retornar a resposta correta quando receber uma entrada inteira de 1 a 9999.

Python 2 , 19 bytes

lambda t:t-t/100*40

Experimente online!

Japonês , 6 bytes

ìL ì60

Teste online! ìLconverte em base-100 e ì60volta a base 60, resultando em floor(n/100)*60 + n%100. Também funciona com horas ( 10000 -> 3600, o número de segundos em uma hora).

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

D: 35 bytes

C: 28 bytes

Primeira vez que tenho uma resposta curta!

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

D pode ter uma otimização especial por causa do sistema de modelos de golfe:

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

C tem uma otimização especial com o int implícito:

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

Código a testar

Em C (tem 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;
}

Link TIO

Em C ++ (tem 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';
    }
}

Experimente online!

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

Experimente online!

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

Em D (tem que importar std.stdio) (exatamente, eu não tenho idéia de como usar matrizes em 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]));
} 

Link TIO

Pitão - 9 8 bytes

Converte a entrada na base 100 e a interpreta como um número base 60.

ijQ*TT60

Conjunto de Teste .

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

Ans-40int(sub(Ans

Requer o SO versão 1.15 ou superior.

dc , 10 bytes

?9A~r60*+p

Experimente online!

Explicação: em dc quando você pressiona sth. na pilha vai por cima

?         # 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 graças a @seshoumara .

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

Experimente online!

Recebe entrada de stdin. Adotou uma abordagem mais criativa: insere *60+antes dos últimos 1 ou 2 dígitos e precede 0a ao início para contabilizar entradas com apenas 1 ou 2 dígitos. O resultado é então passado para bc.

C (gcc) , 50 bytes

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

Experimente online!

Perl 5, 15 + 1 (-p) bytes

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

• -l switch não é contado porque para legibilidade dos testes

Experimente online

Java 8, 13 bytes

n->n-n/100*40

Porto da incrível fórmula Python 2 do @ovs .

Experimente aqui.

JavaScript, 21 bytes

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

Experimente online!

J , 12 bytes

-40*&<.%&100

É a solução Python 2 da ovs, expressa em J. Consiste em um gancho e um garfo:

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

Experimente online!

Lote, 23 bytes

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

Haskell , 18 bytes

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

Experimente online!

Porto Anotha.

Solução sem ponto, 21 bytes

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

Labirinto , 19 bytes

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

Experimente online!

Explicação

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

O IP atinge um beco sem saída e começa a retroceder. Quando chega ao /, tenta uma divisão por zero que finaliza o programa.

Gelatina , 5 bytes

Como um link monádico (obrigado pelo alerta, caird!):

b³ḅ60

Experimente online!

... Ou como um programa completo:

bȷ2ḅ60

Isso pode ser portado facilmente para 05AB1E, portanto:

05AB1E , 5 bytes

тв60β

Experimente online!

Simplesmente converte o número inteiro de entrada na base 100 e depois converte o resultado da base 60 em número inteiro. Portanto, é equivalente a % de entrada 100 + 60 * Entrada / 100

Excel VBA, 29 bytes

Função de janela imediata VBE anônima que leva a entrada do intervalo [A1]e sai para a janela imediata VBE.

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

APL (Dyalog) , 11 10 bytes

60⊥0 100⊤⊢

Experimente online!

Quão?

0 100⊤- codifique na base 100, parando no segundo LSB, produzindo efetivamente n ÷ 100, n % 100.

60⊥ - decodificar na base 60

PARI / GP , 16 bytes

Direto:

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

Infelizmente, esse bom método é simplesmente muito longo para usar:

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

Pushy , 10 9 bytes

Kevin me superou no meu próprio idioma ... (usando a abordagem da resposta dos ovs )

2dH/40*-#

Experimente online!

10 bytes

sjvj60*^+#

Experimente 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

Por mais um byte, podemos usar a Input % 100 + 60 * ⌊Input / 100⌋abordagem:

H2d%}/60*+#

Experimente online!

05AB1E , 9 bytes

т÷60*¹т%+

Experimente online!

Explicação:

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

Provavelmente há algum truque com conversões básicas que pode ser alcançado em 05AB1E, mas não consegui encontrá-lo.

bash, 20 bytes

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

Experimente online

Retina , 11 bytes

.{100}
60$*

Experimente online!

Entrada e saída em unário . O conjunto de testes converte de e para decimal por conveniência.

Fazer esse tipo de conversão de base por apenas dois dígitos é surpreendentemente simples de ser realizado. Apenas combinamos séries de 100 se 1as substituímos por 60 1s. Tudo o que sobrar corresponderia aos dois últimos dígitos na representação decimal e permanecerá inalterado.

Alice , 19 bytes

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

Experimente online!

Explicação

Pena que eu removi o divmod do idioma, eu acho ...

/o
\i@/...

Essa é apenas a estrutura usual para programas lineares com E / S decimal operando puramente no modo Cardinal (aritmético).

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

Via Láctea , 10 bytes

':Z/v40*-!

uso: ./mw code.mwg -i 9999

Explicação:

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

Experimente online!

Lisp comum, 34 bytes

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

Experimente online!

Outra porta da fórmula @ovs .

REXX, 25 bytes

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

(Apenas mais traduções de @ovs)

05AB1E , 7 bytes

т‰ć60*+

Experimente online!

Explicação

         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

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

Experimente online!

Explicação

Symbolic Python          values

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