En golf, el scratch estándar de un curso se calcula utilizando esta fórmula:

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

Su tarea es calcular el scratch estándar de un campo de golf, dadas estas 4 entradas.

Debe tomar la entrada en cualquier forma estándar en el formato

[num_of_3_pars, num_of_4_pars, num_of_5_pars], difficulty rating

pero si guarda bytes, muchos pueden tomar la entrada de una manera diferente.

Debe generar el resultado final mediante cualquier método aceptado en meta, como regresar de una función.

¡El código más corto gana porque este es el código golf !

Scratch, 145 bytes

<sup>-2 gracias a boboquack
- ??? porque escribirlo en Oto es más corto que el inglés</sup>

(Porque Scratch es el scratch estándar).

Aquí hay una muestra de ejecución:

.

Jalea , 6 bytes

JḊ~æ.N

Pruébalo en línea!

Cómo funciona

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.

Java (OpenJDK 8) , 24 bytes

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

Pruébalo en línea!

Haskell , 22 bytes

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

Pruébalo en línea! Uso: (3#2)5 7rendimientos 35.

Este formato de entrada no tan agradable es un byte más corto que la solución directa:

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

Formato de entrada sin puntos y agradable: (23 bytes)

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

Pruébalo en línea! Vincularse fy llamar con f [3,2,5] 7.

Mathematica, 13 14 bytes

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

Gracias a @GregMartin. Tome la entrada como una lista de longitud 4.

Python 3 , 28 bytes

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

Pruébalo en línea!

Javascript, 24 bytes

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

Perl6, 16 caracteres

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

(Sí, eso es un sub.)

Ejecución de muestra:

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

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

Pruébalo en línea!

Julia 0.5 , 15 bytes

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

Pruébalo en línea!

C #, 24 bytes

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

Código de máquina x86-64, 14 bytes

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

Una función que sigue la convención de llamada System V AMD64 (ubicua en sistemas Gnu / Linux) que toma cuatro parámetros enteros:

• EDI = num_of_3_par_holes
• ESI = num_of_4_par_holes
• EDX = num_of_5_par_holes
• ECX = dificultad_valoración

Devuelve un solo valor, el scratch estándar, en el EAXregistro.

Mnemónicos de ensamblaje sin golf:

; 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 simple traducción de la fórmula. Lo interesante es que este es esencialmente el mismo código que escribirías al optimizar la velocidad también. Esto realmente muestra el poder de la x86 LEAinstrucción, que está diseñado para l oad un correo EFECTIVA un ddress, pero puede hacer la suma y la escala (multiplicación por las bajas potencias de 2) en una sola instrucción, por lo que es un poderoso multi-propósito caballo de batalla de la aritmética .

Jalea , 10 7 bytes

3r5×⁸S_

Pruébalo en línea!

-3 bytes gracias a Erik The Outgolfer!

¡Cómo funciona!

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)

Octava , 14 bytes

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

Pruébalo en línea!

Aproximadamente el doble de tiempo que la respuesta MATL . Inicialmente literalmente lo porté a MATL, pero resultó que iY*es más largo que solo *s. Tenga en cuenta que la entrada a, que contiene los agujeros en orden y luego la dificultad, debe ser un vector de columna.

Julia , 21 bytes

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

Pruébalo en línea!

Neim , 7 bytes

'π𝐂𝕋𝐬S𝕊

Explicación:

'π         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

Programa alternativo: 3𝐈ᛖ𝕋𝐬S𝕊

En lugar de presionar 345y luego obtener los caracteres, crea la matriz [1 2 3]usando 3𝐈, luego agrega 2 a cada elemento con ᛖ.

Pruébalo en línea!

C (gcc) , 30 bytes

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

Pruébalo en línea!

Swift 3 , 25 19 bytes

Me di cuenta de que no necesitas el var f=, porque puedes llamarlo como una lambda Python:

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

¡Pruébalo en línea!

Uso:, {$0*3+$1*4+$2*5-$3}(a,b,c,d) donde a,b,c,destán los parámetros.

brainfuck , 39 bytes

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

Pruébalo en línea!

Toma entradas e imprime salidas como caracteres ASCII; por ejemplo, el valor 99 se representaría como c.

Explicación:

,                                       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

Gallina , 38 bytes

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

dc, 14 caracteres

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

Los números deben pasarse en líneas separadas.

Ejecución de muestra:

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

Pruébalo en línea!

Brachylog , 18 16 bytes

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

Pruébalo en línea!

-2 gracias a Fatalize .

,,, 12 bytes

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

Explicación

Tome la entrada 4, 3, 2, 1 por ejemplo.

↻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

Cubix , 36 bytes

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

Pruébalo en línea!

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

Míralo correr

Un programa bastante lineal que gira sobre sí mismo varias veces. Pasos básicos:

• I3*r;U; obtenga la primera entrada, multiplique por 3 y limpie la pila
• I4*/r\ obtenga la siguiente entrada y multiplique por 4. Gire el resultado hacia abajo.
• Iw5*Ur;w<;r;;W obtener la siguiente entrada, multiplicar por 5 y limpiar la pila
• I-r;w; obtener la última entrada, restar del resultado del par 5 y limpiar la pila
• /+p+O\@ agregar al resultado par 4, llevar el resultado par3 a la parte superior agregar, generar y detener

HP-15C (RPN), 14 bytes

Códigos hexadecimales de instrucciones:

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

Versión legible:

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 } −

Los cuatro números se cargan en la pila en orden antes de ejecutar el programa.

Excel VBA, 20 bytes

Anonymous VBE función de ventana inmediata que toma la entrada de la gama [A3:A6]de los cuales [A3:A5]representan el número de 3, 4y 5hoyos par, respectivamente, y [A6]representa la dificultad. Salidas a la ventana inmediata de VBE

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

Lo anterior es una versión condensada de la llamada.

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

Donde "=3*A3+4*A4+5*A5-A6"se da para ser la fórmula de una celda anónima, como lo indica el [...]contenedor, y ?es la versión obsoleta de la Printllamada con un Debug.contexto implícito

Versión más divertida, 34 bytes

Función de ventana inmediata anónima VBE con las mismas condiciones de E / S que las anteriores.

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

Lo anterior es una versión condensada de la llamada.

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

Donde "=SUMPRODUCT(A3:A5,ROW(A3:A5))"se da como la fórmula de una celda anónima, como lo indica el [...]contenedor, y ?es la versión obsoleta de la Printllamada con un Debug.contexto implícito . En esta versión, el rango [A3:A5]y los números de fila de ese rango ( ROWS(A3:A5)) se pasan como matrices

Versión Excel, 18 bytes

Por supuesto, las versiones anteriores se prestan así a versiones sobresalientes de

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

y

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

R , 25 23 bytes

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

Pruébalo en línea!

Befunge , 15 bytes

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

Pruébalo en línea!

Japt , 12 bytes

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

Pruébalo

Braingolf , 14 bytes

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

Pruébalo en línea!

05AB1E , 7 bytes

3LÌ*O²-

Pruébalo en línea!