Quanto dovrebbe funzionare il mio forno a microonde?

33

Ho fame. Facciamo un microonde in qualcosa. Dato un input numerico compreso tra 1 e 4 cifre, emettere il numero di secondi che il microonde dovrebbe funzionare.

Dettagli

Il trucco sta nel capire se l'utente sta inserendo secondi o una combinazione di secondi e minuti. Quelli e le decine dovrebbero essere interpretati come secondi e le centinaia e migliaia di luoghi dovrebbero essere minuti. Ad esempio, il valore 1234dovrebbe essere interpretato come 12 minuti, 34 secondi e 9876dovrebbe essere 98 minuti, 76 secondi. La digitazione 130e 90dovrebbe comportare entrambi un tempo di cottura di 90 secondi.

Ecco alcuni altri ingressi e uscite:

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

Regole

Questo è code-golf , quindi vince il programma più breve in byte. Non sono ammesse scappatoie standard. La voce vincente deve restituire la risposta corretta quando viene fornito un input intero compreso tra 1 e 9999.

code-golf  number 
— Andrew Brēza
fonte
@WheatWizard, sono felice di modificare la domanda. Hai un suggerimento su cosa dovrei dire nella sezione Dettagli? Forse potrei rendere più chiara questa frase: "I luoghi e le decine dovrebbero essere interpretati come secondi e le centinaia e migliaia di luoghi dovrebbero essere minuti".
— Andrew Brēza,
@WheatWizard Ho appena aggiunto più dettagli, fammi sapere se pensi che dovrei aggiungere altro.
— Andrew Brēza,
Funziona con un input di 9876?
— Andrew Brēza,
1
Strano, stavo per sandbox questa sfida esatta haha
— FlipTack
A cosa servirebbe l'output 190?
— OldBunny2800,

Risposte:

9

Japt , 6 byte

ìL ì60

Provalo online! ìLconverte in base-100 e ì60torna alla base 60, risultando in floor(n/100)*60 + n%100. Funziona anche con le ore ( 10000 -> 3600il numero di secondi in un'ora).

— ETHproductions
fonte
1
Esattamente quello che avevo :)
— Shaggy,
7

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

D: 35 byte

C: 28 byte

La prima volta che ho una risposta così breve!

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

D può avere un'ottimizzazione speciale grazie al sistema di template golfy:

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

C ha un'ottimizzazione speciale con l'int implicito:

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

Codice da testare

In C (includere 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 ++ ( devi includere 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';
    }
}

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

Provalo 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 (devo importare std.stdio) (esattamente, non ho idea di come usare le matrici in 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]));
}

TIO Link

— HatsuPointerKun
fonte
Il codice del test D è il piè di pagina di questo TIO: tio.run/… e vedo che hai imparato il sistema di template :). (C'è un foreachin D, ho appena dimenticato come usarlo tristemente)
— Zacharý
C può essere golfato a 28 byte usando C89 implicit-int.
— pizzapants184
Dovresti pubblicare tutti questi come risposte separate.
— MD XF,
6

Pyth - 9 8 byte

Converte l'input in base 100, quindi lo interpreta come un numero base 60.

ijQ*TT60

Test Suite .

— Maltysen
fonte
6

TI-Basic (serie 83), 8 byte

Ans-40int(sub(Ans

Richiede OS versione 1.15 o successiva.

— Misha Lavrov
fonte
6

dc , 10 byte

?9A~r60*+p

Provalo online!

Spiegazione: in cc quando si preme sth. sullo stack va in 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
— seshoumara
fonte
5

Bash bc + sed, 30 28 byte

-2 byte grazie a @seshoumara .

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

Provalo online!

Riceve input dallo stdin. È andato per un approccio più creativo: inserisce *60+prima delle ultime 1 o 2 cifre e antepone 0a all'inizio per tenere conto degli input con solo 1 o 2 cifre. Il risultato viene quindi passato a bc.

— Justin Mariner
fonte
1
Se si rimuove -re si utilizza \?, è possibile perdere 2 byte.
— seshoumara,
2

JavaScript, 21 byte

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

Provalo online!

Salva 4 byte usando il trucco di ovs - a- (a / 100 ^ 0) * 40
— IanF1
1
@ IanF1. Grazie, ma penso che letteralmente ruberebbe la loro idea.
Si hai ragione. Troppo entusiasta, scusa.
— IanF1
3
@ThePirateBay Allora non vivi davvero fino al tuo nome;)
— kamoroso94
2

J , 12 byte

-40*&<.%&100

È la soluzione Python 2 di ovs espressa in J. È composta da un gancio e una forchetta:

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

Provalo online!

— Galen Ivanov
fonte
1
Stesso numero di byte di 60#.0 100#:].
— FrownyFrog,
@FrownyFrog - la tua soluzione sembra più bella, evviva!
— Galen Ivanov,
2

Lotto, 23 byte

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

Labirinto , 19 byte

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

Provalo online!

Spiegazione

?      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 quindi raggiunge un vicolo cieco e inizia a muoversi all'indietro. Quando raggiunge /, tenta una divisione per zero che termina il programma.

— Martin Ender
fonte
2

Gelatina , 5 byte

Come collegamento monadico (grazie per l'heads-up, caird!):

b³ḅ60

Provalo online!

... O come programma completo:

bȷ2ḅ60

Questo può essere portato facilmente su 05AB1E, quindi:

05AB1E , 5 byte

тв60β

Provalo online!

Converte semplicemente il numero intero di input in base 100 e quindi converte il risultato dalla base 60 in numero intero. Quindi, equivale a Input% 100 + 60 * ⌊Input / 100⌋

— Mr. Xcoder
fonte
— caird coinheringaahing
@cairdcoinheringaahing Penso che intendevi questo , ma grazie comunque per l'heads-up
— Mr. Xcoder,
2

Excel VBA, 29 byte

Funzione di finestra immediata VBE anonima che accetta input dalla gamma [A1]e output alla finestra immediata VBE.

?[A1]Mod 1E2+60*[Int(A1/100)]
— Taylor Scott
fonte
2

APL (Dyalog) , 11 10 byte

60⊥0 100⊤⊢

Provalo online!

Come?

0 100⊤- codifica nella base 100, fermandosi al secondo LSB, producendo efficacemente n ÷ 100, n % 100.

60⊥ - decodifica in base 60

— Uriel
fonte
2

PARI / GP , 16 byte

semplice:

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

Purtroppo questo bel metodo è semplicemente troppo lungo da usare:

n->[60,1]*divrem(n,100)
— Charles
fonte
2

Pushy , 10 9 byte

Kevin mi ha superato nella mia lingua ... (usando l'approccio dalla risposta di ovs )

2dH/40*-#

Provalo online!

10 byte

sjvj60*^+#

Provalo 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 byte

Per un byte in più possiamo usare l' Input % 100 + 60 * ⌊Input / 100⌋approccio:

H2d%}/60*+#

Provalo online!

— FlipTack
fonte
1
9 byte creando una porta di pitone 2 risposta @ovs' : 2dH/40*-#. Mai programmato in Pushy prima, ma sembra un linguaggio piuttosto interessante. :)
— Kevin Cruijssen,
1
@KevinCruijssen è un linguaggio piuttosto generico basato sullo stack, immagino che l'unica cosa leggermente diversa che porti sul tavolo sia il doppio stack ... ma grazie e grazie per il golf :)
— FlipTack
1

05AB1E , 9 byte

т÷60*¹т%+

Provalo online!

Spiegazione:

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

Probabilmente c'è qualche trucco con le conversioni di base che può essere ottenuto in 05AB1E, ma non sono riuscito a trovarlo.

1

Retina , 11 byte

.{100}
60$*

Provalo online!

Input e output in unario . La suite di test converte da e in decimale per comodità.

Fare questo tipo di conversione di base per un massimo di due cifre è sorprendentemente semplice da fare all'unario. Abbiniamo solo le corse di 100 se le 1sostituiamo con 60 1s. Tutto ciò che rimane corrisponderebbe alle ultime due cifre nella rappresentazione decimale e rimane invariato.

— Martin Ender
fonte
1

Alice , 19 byte

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

Provalo online!

Spiegazione

Peccato che ho rimosso divmod dalla lingua, immagino ...

/o
\i@/...

Questo è solo il solito framework per programmi lineari con I / O decimali che funzionano esclusivamente in modalità Cardinale (aritmetica).

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

Via Lattea , 10 byte

':Z/v40*-!

utilizzo: ./mw code.mwg -i 9999

Spiegazione:

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
fonte
1

R , 21 byte

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

Provalo online!

— marchio
fonte
1
Ho creato la mia soluzione in R ed era molto meno elegante di così.
— Andrew Brēza,
Puoi tagliare scanpoiché la maggior parte delle risposte presuppone che la variabile sia già definita.
— Andrew Brēza,
Le regole sono così incoerenti al riguardo. Una delle altre sfide è necessario disporre di una funzione o scansione per acquisire il valore.
— Segna il
1

REXX, 25 byte

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

(Solo un'altra traduzione di @ovs)

— idrougge
fonte
0

05AB1E , 7 byte

т‰ć60*+

Provalo online!

Spiegazione

         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
fonte
0

Python simbolico , 66 byte

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

Provalo online!

Spiegazione

Symbolic Python          values

___=-~-~_-_              ___=2
__=___*___               __=2*2=4
__=__*__*___+___*__      __=4*4*2+2*4=32+8=40
_=_-_/(__+__+__/___)*__  _=_-_/(40+40+40/2)*40=_-_/100*40
— OVS
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.