No golfe, o risco padrão de um curso é calculado usando esta fórmula:

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

Sua tarefa é calcular o risco padrão de um campo de golfe, considerando essas 4 entradas.

Você deve receber entrada de qualquer forma padrão no formato

[num_of_3_pars, num_of_4_pars, num_of_5_pars], difficulty rating

mas se ele salvar bytes, você recebe a entrada de uma maneira diferente.

Você deve produzir o resultado final por qualquer método aceito na meta, como retornar de uma função.

O código mais curto vence porque esse é o código-golfe !

Zero, 145 bytes

<sup>-2 graças a boboquack
- ??? porque escrevê-lo em Oto é mais curto que o inglês</sup>

(Porque o zero é o risco padrão.)

Aqui está uma amostra de execução:

.

Gelatina , 6 bytes

JḊ~æ.N

Experimente online!

Como 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

Experimente online!

Haskell , 22 bytes

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

Experimente online! Uso: (3#2)5 7rendimentos 35.

Esse formato de entrada não tão agradável é um byte menor que a solução direta:

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

Formato de entrada sem ponto e agradável: (23 bytes)

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

Experimente online! Se ligam a fe call com f [3,2,5] 7.

Mathematica, 13 14 bytes

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

Graças a @GregMartin. Tome a entrada como uma lista de tamanho 4.

Python 3 , 28 bytes

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

Experimente online!

Javascript, 24 bytes

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

Perl6, 16 caracteres

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

(Sim, isso é um sub.)

Exemplo de execução:

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

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

Experimente online!

Julia 0,5 , 15 bytes

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

Experimente online!

C #, 24 bytes

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

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

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

Uma função que segue a convenção de chamada do System V AMD64 (onipresente nos sistemas Gnu / Linux) que utiliza quatro parâmetros inteiros:

• EDI = num_of_3_par_holes
• ESI = num_of_4_par_holes
• EDX = num_of_5_par_holes
• ECX = dificuldade_rating

Ele retorna um único valor, o rascunho padrão, no EAXregistro.

Mnemônicos de montagem não destruídos:

; 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

Apenas uma tradução simples da fórmula. O interessante é que este é essencialmente o mesmo código que você escreveria ao otimizar a velocidade também. Isso realmente mostra o poder da do x86 LEAinstrução, que é projetado para l OAD um e FICAZ um ddress, mas pode fazer disso e escamação (multiplicação por baixas potências de 2) em uma única instrução, tornando-se um poderoso multi-purpose laborioso aritmética .

Geléia , 10 7 bytes

3r5×⁸S_

Experimente online!

-3 bytes graças a Erik The Outgolfer!

Como 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)

Oitava , 14 bytes

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

Experimente online!

Cerca do dobro do tempo que a resposta MATL . Inicialmente, eu literalmente portado isso para MATL, mas acabou que iY*é mais do que apenas *s. Observe que a entrada a, contendo os furos em ordem e depois a dificuldade, deve ser um vetor de coluna.

Julia , 21 bytes

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

Experimente online!

Neim , 7 bytes

'π𝐂𝕋𝐬S𝕊

Explicação:

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

Em vez de pressionar 345e obter os caracteres, cria a matriz [1 2 3]usando 3𝐈e adiciona 2 a cada elemento com ᛖ.

Experimente online!

C (gcc) , 30 bytes

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

Experimente online!

Swift 3 , 25 19 bytes

Percebi que você não precisa do var f=, porque você pode chamá-lo como um lambda Python:

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

Teste online!

Uso:, {$0*3+$1*4+$2*5-$3}(a,b,c,d) onde a,b,c,destão os parâmetros.

brainfuck , 39 bytes

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

Experimente online!

Recebe e imprime a saída como caracteres ASCII; por exemplo, o valor 99 seria representado como c.

Explicação:

,                                       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

Os números precisam ser passados ​​em linhas separadas.

Exemplo de execução:

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

Experimente online!

Braquilog , 18 16 bytes

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

Experimente online!

-2 graças a Fatalize .

,,, 12 bytes

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

Explicação

Veja as entradas 4, 3, 2, 1, por exemplo.

↻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

Experimente online!

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

Assista

Um programa bastante linear que volta a si próprio algumas vezes. Etapas básicas:

• I3*r;U; obtenha a primeira entrada, multiplique por 3 e limpe a pilha
• I4*/r\ obtenha a próxima entrada e multiplique por 4. Gire o resultado para baixo.
• Iw5*Ur;w<;r;;W obtenha a próxima entrada, multiplique por 5 e limpe a pilha
• I-r;w; obter a última entrada, subtrair do resultado do par 5 e limpar a pilha
• /+p+O\@ adicionar ao resultado do par 4, trazer o resultado do par3 para o topo adicionar, produzir e parar

HP-15C (RPN), 14 bytes

Códigos hexadecimais da instrução:

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

Versão legível:

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

Os quatro números são carregados na pilha em ordem antes de executar o programa.

Excel VBA, 20 bytes

Anonymous VBE funo de janela de imediato que recebe a entrada a partir do intervalo [A3:A6]dos quais [A3:A5]representam o número de 3, 4e 5buracos par, respectivamente, e [A6]representa a dificuldade. Saídas para a janela imediata do VBE

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

A descrição acima é uma versão condensada da chamada

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

Onde "=3*A3+4*A4+5*A5-A6"é atribuída a fórmula de uma célula anônima, conforme indicado pelo [...]wrapper, e ?é a versão descontinuada da Printchamada com um implícito Debug.por contexto

Versão mais divertida, 34 bytes

Função de janela imediata VBE anônima com as mesmas condições de E / S acima.

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

A descrição acima é uma versão condensada da chamada

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

Onde "=SUMPRODUCT(A3:A5,ROW(A3:A5))"é atribuída a fórmula de uma célula anônima, conforme indicado pelo [...]wrapper, e ?é a versão reprovada da Printchamada com um implícito Debug.por contexto. Nesta versão, o intervalo [A3:A5]e os números de linha desse intervalo ( ROWS(A3:A5)) são passados ​​como matrizes

Versão Excel, 18 bytes

Obviamente, as versões acima se prestam assim a versões do Excel

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

e

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

R , 25 23 bytes

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

Experimente online!

Anterior , 15 bytes

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

Experimente online!

Japonês , 12 bytes

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

Teste-o

Braingolf , 14 bytes

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

Experimente online!

05AB1E , 7 bytes

3LÌ*O²-

Experimente online!