12

Nel golf, lo scratch standard di un campo viene calcolato usando questa formula:

(3*num_of_3_par_holes + 4*num_of_4_par_holes + 5*num_of_5_par_holes) - difficulty_rating

Il tuo compito è calcolare lo scratch standard di un campo da golf, dati questi 4 input.

Si dovrebbe prendere input in qualsiasi modulo standard nel formato

[num_of_3_pars, num_of_4_pars, num_of_5_pars], difficulty rating

ma se salva byte, molti prendono l'input in un modo diverso.

Dovresti produrre il risultato finale con qualsiasi metodo accettato su meta, come il ritorno da una funzione.

Il codice più corto vince perché questo è code-golf !

code-golf math number

Tutti gli input saranno numeri interi e almeno 1? (Inoltre, l'output sarà sempre positivo?)

— Maniglia della porta

Possiamo prendere gli input invertiti?

— totalmente umano il

13

Per quanto banale, alcuni casi di test sarebbero belli.

— Dennis,

9

Interessante, un codice golf sul golf.

— sergiol,

28

Scratch, 145 byte

^{-2 grazie a boboquack

- ??? perché scriverlo in Oto è più breve dell'inglese}

(Perché Scratch è lo scratch standard.)

Ecco un esempio:

a = 18, b = 13, c = 41, d = 23; risposta = 124 .

— Alloro
fonte

18

Gelatina , 6 byte

JḊ~æ.N

Provalo online!

Come funziona

JḊ~æ.N  Main link. Argument: [a, b, c, d]

J       Indices; yield [1, 2, 3, 4].
 Ḋ      Dequeue; yield [2, 3, 4].
  ~     Bitwise NOT; yield [-3, -4, -5].
     N  Negate; yield [-a, -b, -c, -d].
   æ.   Dot product; yield
        (-3)(-a) + (-4)(-b) + (-5)(-c) + (-d) = 3a + 4b + 5c - d.

— Dennis
fonte

10

Java (OpenJDK 8) , 24 byte

(a,b,c,d)->a*3+b*4+c*5-d

Provalo online!

— Olivier Grégoire
fonte

7

Sì, più corto di Python \ o /

— Olivier Grégoire il

6

Haskell , 22 byte

(a#b)c d=3*a+4*b+5*c-d

Provalo online! Utilizzo: (3#2)5 7rese 35.

Questo formato di input non così bello è più corto di un byte rispetto alla soluzione semplice:

f a b c d=3*a+4*b+5*c-d

Formato di input privo di punti e gradevole: (23 byte)

(-).sum.zipWith(*)[3..]

Provalo online! Associa fe chiama con f [3,2,5] 7.

— Laikoni
fonte

5

Mathematica, 13 14 byte

{3,4,5,-1}.#&

Grazie a @GregMartin. Prendi input come un elenco di lunghezza 4.

— Keyu Gan
fonte

Grazie a "ma se salva i byte, molti prendono l'input in un modo diverso", penso che dovresti prendere l'input come un elenco di lunghezza 4 e abbreviare la seconda soluzione a {3,4,5,-1}.#&(13 byte).

— Greg Martin,

Hai ragione ..

— Keyu Gan il

4

Python 3 , 28 byte

lambda a,b,c,d:3*a+4*b+5*c-d

Provalo online!

— notjagan
fonte

4

Javascript, 24 byte

(a,b,c,d)=>3*a+4*b+5*c-d

— SuperStormer
fonte

4

Perl6, 16 caratteri

3* *+4* *+5* *-*

(Sì, questo è un sub.)

Esecuzione di esempio:

> say 3* *+4* *+5* *-*
{ ... }

> say (3* *+4* *+5* *-*)(4, 3, 2, 1)
33

Provalo online!

— uomo al lavoro
fonte

4

Julia 0,5 , 15 byte

!v=v⋅[3:5;-1]

Provalo online!

— Dennis
fonte

Sono ⋅tre byte o sto contando male? Sarebbe .*un miglioramento? modifica: non importa, mancata la parte di somma.

— Julian Wolf,

Sì, tre byte. .*esegue solo la moltiplicazione degli elementi; non prende la somma dei prodotti.

— Dennis,

3

C #, 24 byte

(a,b,c,d)=>a*3+b*4+c*5-d

— TheLethalCoder
fonte

3

x86-64 Codice macchina, 14 byte

8D 3C 7F 8D 14 92 8D 04 B7 01 D0 29 C8 C3

Una funzione che segue la convenzione di chiamata System V AMD64 (onnipresente sui sistemi Gnu / Linux) che accetta quattro parametri interi:

EDI = num_of_3_par_holes
ESI = num_of_4_par_holes
EDX = num_of_5_par_holes
ECX = difficoltà_valutazione

Restituisce un singolo valore, lo scratch standard, nel EAXregistro.

Mnemonici di assemblaggio non golfati:

; int ComputeStandardScratch(int num_of_3_par_holes,
;                            int num_of_4_par_holes,
;                            int num_of_5_par_holes,
;                            int difficulty_rating);
lea   edi, [rdi+rdi*2]    ; EDI = num_of_3_par_holes * 3
lea   edx, [rdx+rdx*4]    ; EDX = num_of_5_par_holes * 5
lea   eax, [rdi+rsi*4]    ; EAX = EDI + (num_of_4_par_holes * 4)
add   eax, edx            ; EAX += EDX
sub   eax, ecx            ; EAX -= difficulty_rating
ret                       ; return, leaving result in EAX

Solo una semplice traduzione della formula. La cosa interessante è che questo è essenzialmente lo stesso codice che scriveresti anche quando ottimizzi per la velocità . Questo mostra davvero la potenza del del x86 LEAistruzione, che è progettato per l oad un e ffective un ddress, ma può fare addizioni e scalatura (moltiplicazione per basse potenze di 2) in una singola istruzione, rendendolo un potente multiuso cavallo di battaglia aritmetica .

— Cody Grey
fonte

3

Gelatina , 10 7 byte

3r5×⁸S_

Provalo online!

-3 byte grazie a Erik The Outgolfer!

Come funziona!

3r5×⁸S_  Main link: a, the pars as a list and b, the difficulty rating

     S   The sum of
3r5        [3, 4, 5]
   ×       each element times
    ⁸      the left argument (a)
      _  Subtract the right argument (b)

— caird coinheringaahing
fonte

Il modo standard di creare liste è omettere, []ma puoi usarlo 3r5×⁸S_per giocare di più ( 3r5-> [3, 4, 5], ⁸= argomento sinistro per differenziarlo da S, ×è commutativo).

— Erik the Outgolfer,

3

Ottava , 14 byte

@(a)[3:5 -1]*a

Provalo online!

Circa il doppio della risposta MATL . Inizialmente ho letteralmente portato questo su MATL, ma si è scoperto che iY*è più lungo del semplice *s. Si noti che l'input a, contenente i fori in ordine e quindi la difficoltà, dovrebbe essere un vettore di colonna.

— Sanchises
fonte

Come domanda dice che si può prendere l'input in qualsiasi formato, se si salva byte, questo funziona per 14: @(a)[3:5 -1]*a. L'input è un vettore colonna di[3 holes; 4 holes; 5holes; difficulty]

— Tom Carpenter

@TomCarpenter Oh, ho pensato che la lista + numero parte fosse obbligatoria. È un po 'stranamente espresso: "Dovresti ... ma potresti". Immagino che modificherò la mia risposta allora.

— Sanchises,

2

Julia , 21 byte

f(a,b,c,d)=3a+4b+5c-d

Provalo online!

— Julian Wolf
fonte

2

Neim , 7 byte

'π𝐂𝕋𝐬S𝕊

Spiegazione:

'π         Push 345
           The character ' pushes the next character's index in the codepage plus 100.
           The characters ", + and * do that same thing except add a different number.
           This means that in Neim, all 3 digit numbers can be expressed with 2 characters.
           This commit was pushed 8 days before the answer was posted.
  𝐂        Get the characters
   𝕋       Vectorised multiply with the input
    𝐬       Sum the resulting list
     S𝕊    Subtract the input

Programma alternativo: 3𝐈ᛖ𝕋𝐬S𝕊

Invece di spingere 345e quindi ottenere i caratteri, crea l'array [1 2 3]usando 3𝐈, quindi aggiunge 2 a ciascun elemento con ᛖ.

Provalo online!

— Okx
fonte

This commit was pushed 8 days before the answer was posted.bene, in realtà non hai bisogno di questo.

— Erik the Outgolfer,

@EriktheOutgolfer Certo che no. Ma non ho nemmeno bisogno della spiegazione. Vorresti che lo rimuovessi?

— Okx,

Fondamentalmente non devi preoccuparti di non competere poiché il meta consenso è cambiato.

— Erik the Outgolfer,

@EriktheOutgolfer Mi preoccupo di non competere perché il meta consenso è soggettivo e poco chiaro. Ma in questo caso, non c'è motivo di lamentarsi della sua presenza. Stai impiegando più tempo di quanto altrimenti non avresti pubblicato quel commento.

— Okx,

Per qualche motivo, la maggior parte dei caratteri Neim nei blocchi di codice inline sembrano? scatole.

— CalcolatriceFeline

2

C (gcc) , 30 byte

e;f(a,b,c,d){e=3*a+4*b+5*c-d;}

Provalo online!

— Giacomo Garabello
fonte

2

Non c'è bisogno di una variabile aggiuntiva. Basta assegnare a a.

— Dennis,

2

Swift 3 , 25 19 byte

Mi sono reso conto che non ti serve il var f=, perché puoi chiamarlo come un Python lambda:

{$0*3+$1*4+$2*5-$3}

Provalo online!

Utilizzo:, {$0*3+$1*4+$2*5-$3}(a,b,c,d) dove a,b,c,dsono i parametri.

— Mr. Xcoder
fonte

2

Brainfuck , 39 byte

,[->+++<],[->++++<],[->+++++<],[->-<]>.

Provalo online!

Accetta input e stampa output come caratteri ASCII; ad esempio, il valore 99 sarebbe rappresentato come c.

Spiegazione:

,                                       Take the first input in Cell 0
 [      ]                               While the data being pointed to (Cell 0) is nonzero
  ->+++<                                Decrement Cell 0 and add 3 to Cell 1
                                        Now 4 times the first input is in Cell 1
         ,                              Take the second input in Cell 0
          [->++++<]                     Add 4 times the second input to Cell 1
                   ,[->+++++<]          Take the third input in Cell 0 and add five times its value to Cell 1
                              ,         Take the fourth input in Cell 0
                               [    ]   While the data being pointed to (Cell 0) is nonzero
                                ->-<    Decrement Cells 0 and 1
                                     >. Print the value in Cell 1

— musicman523
fonte

2

Gallina , 38 byte

Definition f a b c d := 3*a+4*b+5*c-d.

— biv
fonte

2

dc, 14 caratteri

?3*?4*+?5*+?-p

I numeri devono essere passati su righe separate.

Esecuzione di esempio:

bash-4.4$ dc -e '?3*?4*+?5*+?-p' <<< '4
> 3
> 2
> 1'
33

Provalo online!

— uomo al lavoro
fonte

2

Brachylog , 18 16 byte

∧5⟦₁↺b;?z×ᵐġ₃+ᵐ-

Provalo online!

-2 grazie a Fatalize .

— Erik l'Outgolfer
fonte

∧5⟦₁↺b;?z×ᵐġ₃+ᵐ-

— costa

@Fatalize Sarebbe stato di 3 byte in meno se non ci fosse un bug con il numero intero e l'input iniziali.

— Erik the Outgolfer,

2

,,, 12 byte

↻5×↻4×↻3×↻-#

Spiegazione

Prendi ad esempio gli ingressi 4, 3, 2, 1.

↻5×↻4×↻3×↻-#

              implicit input                  [4, 3, 2, 1]
↻             rotate the stack clockwise      [1, 4, 3, 2]
 5            push 5                          [1, 4, 3, 2, 5]
  ×           pop 2 and 5 and push 2 * 5      [1, 4, 3, 10]
   ↻          rotate the stack clockwise      [10, 1, 4, 3]
    4         push 4                          [10, 1, 4, 3, 4]
     ×        pop 3 and 4 and push 3 * 4      [10, 1, 4, 12]
      ↻       rotate the stack clockwise      [12, 10, 1, 4]
       3      push 3                          [12, 10, 1, 4, 3]
        ×     pop 4 and 3 and push 4 * 3      [12, 10, 1, 12]
         ↻    rotate the stack clockwise      [12, 12, 10, 1]
          -   pop 10 and 1 and push 10 - 1    [12, 12, 9]
           #  pop 12, 12, 9 and push the sum  [33]
              implicit output

— totallyhuman
fonte

2

Cubix , 36 byte

w;r5*U4I;I3*r;UW;;r;<\r/;r-I/+p+O@;w

Provalo online!

      w ; r
      5 * U
      4 I ;
I 3 * r ; U W ; ; r ; <
\ r / ; r - I / + p + O
@ ; w . . . . . . . . .
      . . .
      . . .
      . . .

Guardalo correre

Un programma abbastanza lineare che si riavvolge su se stesso alcune volte. Passaggi di base:

I3*r;U; ottieni il primo input, moltiplica per 3 e ripulisci lo stack
I4*/r\ ottieni il prossimo input e moltiplica per 4. Ruota il risultato verso il basso.
Iw5*Ur;w<;r;;W ottenere il prossimo input, moltiplicare per 5 e ripulire lo stack
I-r;w; ottenere l'ultimo input, sottrarre dal risultato del par 5 e ripulire lo stack
/+p+O\@ aggiungi al risultato par 4, porta il risultato par3 in alto aggiungi, emetti e ferma

— MickyT
fonte

2

HP-15C (RPN), 14 byte

Codici esadecimali dell'istruzione:

41 C4 F5 FC C5 F4 FC FA C5 F3 FC FA 31 FB

Versione leggibile:

001 {       44  1 } STO 1
002 {          33 } R⬇
003 {           5 } 5
004 {          20 } ×
005 {          34 } x↔y
006 {           4 } 4
007 {          20 } ×
008 {          40 } +
009 {          34 } x↔y
010 {           3 } 3
011 {          20 } ×
012 {          40 } +
013 {       45  1 } RCL 1
014 {          30 } −

I quattro numeri vengono caricati nello stack in ordine prima di eseguire il programma.

— Ryan
fonte

Bella prima risposta. Benvenuti in PPCG!

— musicman523

2

Excel VBA, 20 byte

Anonimo VBE funzione finestra immediata che riceve l'input dalla gamma [A3:A6]dei quali [A3:A5]rappresentano il numero di 3, 4e 5buche par, rispettivamente, e [A6]rappresenta la difficoltà. Emette nella finestra immediata di VBE

?[3*A3+4*A4+5*A5-A6]

Quanto sopra è una versione ridotta della chiamata

Debug.Print Application.Evaluate("=3*A3+4*A4+5*A5-A6")

Dove "=3*A3+4*A4+5*A5-A6"viene data la formula di una cella anonima, come indicato dal [...]wrapper, ed ?è la versione deprecata della Printchiamata con un implicito Debug.dal contesto

Versione più divertente, 34 byte

Funzione finestra immediata VBE immediata con le stesse condizioni I / O di cui sopra.

?[SUMPRODUCT(A3:A5,ROW(A3:A5))-A6]

Quanto sopra è una versione ridotta della chiamata

Debug.Print Application.Evaluate("=SUMPRODUCT(A3:A5,ROW(A3:A5))")

Dove "=SUMPRODUCT(A3:A5,ROW(A3:A5))"viene data la formula di una cella anonima, come indicato dal [...]wrapper, ed ?è la versione deprecata della Printchiamata con un implicito Debug.dal contesto. In questa versione, l'intervallo di [A3:A5]e i numeri di riga di tale intervallo ( ROWS(A3:A5)) vengono passati come matrici

Versione Excel, 18 byte

Naturalmente, le versioni precedenti si prestano così a eccellere nelle versioni di

=3*A3+4*A4+5*A5-A6

e

=SUMPRODUCT(A3:A5,ROW(A3:A5))-A6

— Taylor Scott
fonte

2

R , 25 23 byte

cat(c(3:5,-1)%*%scan())

Provalo online!

— Giuseppe
fonte

1

sum(scan()*3:5)-scan()è leggermente più piccolo

— MickyT

grazie. Di solito non provo scanquando ci sono più ingressi come questo, ma whaddya lo so!

— Giuseppe,

1

Befunge , 15 byte

&3*&4*+&5*+&-.@

Provalo online!

— OVS
fonte

1

Japt , 12 byte

*3+V*4+W*5-X

Provalo

— ispido
fonte

1

Braingolf , 14 byte

3*>4*>5*>>++,-

Provalo online!

— Skidsdev
fonte

1

05AB1E , 7 byte

3LÌ*O²-

Provalo online!

— Erik l'Outgolfer
fonte

È possibile sostituire 3Lcon ācome il primo input sarà comunque un elenco di lunghezza 3.

— Kalsowerus,

Qual è lo scratch standard?

Scratch, 145 byte

Gelatina , 6 byte

Come funziona

Java (OpenJDK 8) , 24 byte

Haskell , 22 byte

Mathematica, 13 14 byte

Python 3 , 28 byte

Javascript, 24 byte

Perl6, 16 caratteri

Julia 0,5 , 15 byte

C #, 24 byte

x86-64 Codice macchina, 14 byte

Gelatina , 10 7 byte

Come funziona!

Ottava , 14 byte

Julia , 21 byte

Neim , 7 byte

C (gcc) , 30 byte

Swift 3 , 25 19 byte

Brainfuck , 39 byte

Spiegazione:

Gallina , 38 byte

dc, 14 caratteri

Brachylog , 18 16 byte

,,, 12 byte

Spiegazione

Cubix , 36 byte

HP-15C (RPN), 14 byte

Excel VBA, 20 byte

Versione più divertente, 34 byte

Versione Excel, 18 byte

R , 25 23 byte

Befunge , 15 byte

Japt , 12 byte

Braingolf , 14 byte

05AB1E , 7 byte