¿Cuál es el rasguño estándar?

12

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 !


fuente
¿Todas las entradas serán enteras y al menos 1? (Además, ¿la salida siempre será positiva?)
Pomo de la puerta
¿Podemos tomar entradas invertidas?
totalmente humano
13
Tan trivial como es esto, algunos casos de prueba serían buenos.
Dennis
99
Interesante, un código de golf sobre golf.
sergiol

Respuestas:

28

Scratch, 145 bytes

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

(Porque Scratch es el scratch estándar).

adi () - temi (a) kuati (thadi adi () - temi (b) kuati (thadi adi () - temi (c) kuati (thadi adi () - temi (d) kuati (thadi ma (((c) - ((a) + (d))) + ((4) * (((a) (b)) + (traducción c: ask () y wait set (a) a (answer ask () y wait set ( b) a (responder ask () y esperar set (c) a (responder ask () y esperar set (d) a (responder say (((c) - ((a) + (d))) + ((4 ) * (((a) + (b)) + (c

Aquí hay una muestra de ejecución:

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

Laurel
fuente
18

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.
Dennis
fuente
6

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.

Laikoni
fuente
5

Mathematica, 13 14 bytes

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

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

Keyu Gan
fuente
Gracias a "pero si ahorra bytes, muchos pueden tomar la entrada de una manera diferente", creo que debería tomar la entrada como una lista de longitud 4 y acortar la segunda solución a {3,4,5,-1}.#&(13 bytes).
Greg Martin
Tienes razón ..
Keyu Gan
4

Javascript, 24 bytes

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

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!

hombre trabajando
fuente
4

Julia 0.5 , 15 bytes

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

Pruébalo en línea!

Dennis
fuente
¿Son tres bytes o estoy contando mal? Sería .*una mejora? editar: No importa, se perdió la parte de resumen.
Julian Wolf
Si, tres bytes. .*solo realiza la multiplicación por elementos; No toma la suma de los productos.
Dennis
3

C #, 24 bytes

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

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 .

Cody Gray
fuente
3

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)
caird coinheringaahing
fuente
La forma estándar de hacer listas es omitir, []pero puede usarlo 3r5×⁸S_para jugar más golf ( 3r5-> [3, 4, 5], = el argumento izquierdo para diferenciarlo del S, ×es conmutativo).
Erik the Outgolfer
3

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.

Sanchises
fuente
Como cuestión dice que puede tomar la entrada en cualquier formato si salva bytes, esto funciona para 14: @(a)[3:5 -1]*a. La entrada es un vector de columna de[3 holes; 4 holes; 5holes; difficulty]
Tom Carpenter
@TomCarpenter Oh, pensé que la parte de la lista + número era obligatoria. Es un poco extraño: "Deberías ... pero puedes". Supongo que enmendaré mi respuesta entonces.
Sanchises
2

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!

Okx
fuente
This commit was pushed 8 days before the answer was posted.bueno, en realidad no necesitas esto.
Erik the Outgolfer
@EriktheOutgolfer Claro que no. Pero tampoco necesito la explicación. ¿Quieres que elimine eso?
Okx
Básicamente, no tiene que preocuparse por no competir ya que el meta consenso ha cambiado.
Erik the Outgolfer
@EriktheOutgolfer Me preocupa no competir porque el meta consenso es subjetivo y poco claro. Pero en este caso, no hay razón para quejarse de que esté allí. Estás gastando más tiempo del que de otra manera no hubieras publicado ese comentario.
Okx
Por alguna razón, la mayoría de los caracteres Neim en bloques de código en línea se parecen? cajas
CalculatorFeline
2

C (gcc) , 30 bytes

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

Pruébalo en línea!

Giacomo Garabello
fuente
2
No hay necesidad de una variable extra. Solo asigna a a.
Dennis
2

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.

Sr. Xcoder
fuente
2

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
musicman523
fuente
2

Gallina , 38 bytes

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

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!

hombre trabajando
fuente
2

Brachylog , 18 16 bytes

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

Pruébalo en línea!

-2 gracias a Fatalize .

Erik el Outgolfer
fuente
∧5⟦₁↺b;?z×ᵐġ₃+ᵐ-son 2 bytes menos
Fatalize
@Fatalize Hubiera sido 3 bytes menos si no hubiera un error con el entero principal y la entrada.
Erik the Outgolfer
2

,,, 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
totalmente humano
fuente
2

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
MickyT
fuente
2

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.

Ryan
fuente
Buena primera respuesta. Bienvenido a PPCG!
musicman523
2

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

R , 25 23 bytes

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

Pruébalo en línea!

Giuseppe
fuente
1
sum(scan()*3:5)-scan()es ligeramente más pequeño
MickyT
gracias. Por lo general, no lo intento scancuando hay múltiples entradas como esta, ¡pero qué sé!
Giuseppe
1

05AB1E , 7 bytes

3LÌ*O²-

Pruébalo en línea!

Erik el Outgolfer
fuente
Puede reemplazar 3Lcon ācomo la primera entrada será una lista de longitud 3 de todos modos.
kalsowerus