Au golf, le scratch standard d'un parcours est calculé à l'aide de cette formule:

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

Votre tâche consiste à calculer le scratch standard d'un parcours de golf, compte tenu de ces 4 entrées.

Vous devez prendre la saisie sous n'importe quelle forme standard dans le format

[num_of_3_pars, num_of_4_pars, num_of_5_pars], difficulty rating

mais si cela permet d'économiser des octets, vous êtes nombreux à prendre les entrées d'une manière différente.

Vous devez sortir le résultat final par n'importe quelle méthode acceptée sur les méta, comme le retour d'une fonction.

Le code le plus court gagne parce que c'est du code-golf !

Scratch, 145 octets

<sup>-2 grâce à boboquack
- ??? parce que l'écrire en Oto est plus court qu'en anglais</sup>

(Parce que Scratch est le scratch standard.)

Voici un exemple d'exécution:

.

Gelée , 6 octets

JḊ~æ.N

Essayez-le en ligne!

Comment ça fonctionne

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 octets

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

Essayez-le en ligne!

Haskell , 22 octets

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

Essayez-le en ligne! Utilisation: (3#2)5 7rendements 35.

Ce format d'entrée pas si agréable est un octet plus court que la solution simple:

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

Format d'entrée sans point et agréable: (23 octets)

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

Essayez-le en ligne! Liez à fet appelez avec f [3,2,5] 7.

Mathematica, 13 14 octets

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

Merci à @GregMartin. Prenez l'entrée comme une liste de longueur 4.

Python 3 , 28 octets

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

Essayez-le en ligne!

Javascript, 24 octets

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

Perl6, 16 caractères

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

(Ouais, c'est un sous.)

Exemple d'exécution:

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

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

Essayez-le en ligne!

Julia 0,5 , 15 octets

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

Essayez-le en ligne!

C #, 24 octets

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

Code machine x86-64, 14 octets

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

Une fonction suivant la convention d'appel System V AMD64 (omniprésente sur les systèmes Gnu / Linux) qui prend quatre paramètres entiers:

• EDI = num_of_3_par_holes
• ESI = num_of_4_par_holes
• EDX = num_of_5_par_holes
• ECX = difficulté_évaluation

Il renvoie une seule valeur, le scratch standard, dans le EAXregistre.

Mnémoniques d'assemblage non golfés:

; 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

Juste une simple traduction de la formule. Ce qui est intéressant, c'est qu'il s'agit essentiellement du même code que celui que vous écririez lors de l'optimisation de la vitesse . Cela montre vraiment la puissance de l'x86 LEAinstruction, qui est conçu pour l OAD un e EFFICACES un DRESSE, mais peut faire plus et mise à l' échelle (multiplication par de faibles puissances de 2) en une seule instruction, ce qui en fait un puissant multi-usages bête de somme arithmétique .

Gelée , 10 7 octets

3r5×⁸S_

Essayez-le en ligne!

-3 octets grâce à Erik The Outgolfer!

Comment ça fonctionne!

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)

Octave , 14 octets

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

Essayez-le en ligne!

Environ deux fois plus longtemps que la réponse MATL . Au départ, j'ai littéralement porté cela sur MATL, mais il s'est avéré que c'était iY*plus long que juste *s. Notez que l'entrée a, contenant les trous dans l'ordre puis la difficulté, doit être un vecteur de colonne.

Julia , 21 octets

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

Essayez-le en ligne!

Neim , 7 octets

'π𝐂𝕋𝐬S𝕊

Explication:

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

Programme alternatif: 3𝐈ᛖ𝕋𝐬S𝕊

Au lieu de pousser 345puis d'obtenir les caractères, crée le tableau en [1 2 3]utilisant 3𝐈, puis ajoute 2 à chaque élément avec ᛖ.

Essayez-le en ligne!

C (gcc) , 30 octets

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

Essayez-le en ligne!

Swift 3 , 25 19 octets

J'ai réalisé que vous n'en avez pas besoin var f=, car vous pouvez l'appeler comme un lambda Python:

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

Testez-le en ligne!

Utilisation:, {$0*3+$1*4+$2*5-$3}(a,b,c,d) où a,b,c,dsont les paramètres.

brainfuck , 39 octets

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

Essayez-le en ligne!

Prend l'entrée et imprime la sortie sous forme de caractères ASCII; par exemple, la valeur 99 serait représentée comme c.

Explication:

,                                       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 octets

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

dc, 14 caractères

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

Les numéros doivent être transmis sur des lignes distinctes.

Exemple d'exécution:

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

Essayez-le en ligne!

Brachylog , 18 16 octets

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

Essayez-le en ligne!

-2 grâce à Fatalize .

,,,, 12 octets

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

Explication

Prenez l'entrée 4, 3, 2, 1 par exemple.

↻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 octets

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

Essayez-le en ligne!

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

Regardez-le courir

Un programme assez linéaire qui revient sur lui-même plusieurs fois. Étapes de base:

• I3*r;U; obtenir la première entrée, multiplier par 3 et nettoyer la pile
• I4*/r\ obtenir la prochaine entrée et multiplier par 4. Faire pivoter le résultat vers le bas.
• Iw5*Ur;w<;r;;W obtenir la prochaine entrée, multiplier par 5 et nettoyer la pile
• I-r;w; obtenir la dernière entrée, soustraire du résultat du par 5 et nettoyer la pile
• /+p+O\@ ajouter au résultat du par 4, amener le résultat du par3 en haut ajouter, sortir et arrêter

HP-15C (RPN), 14 octets

Codes hexadécimaux d'instruction:

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

Version lisible:

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

Les quatre numéros sont chargés dans la pile dans l'ordre avant d'exécuter le programme.

Excel VBA, 20 octets

Anonyme VBE La fonction de fenêtre immédiate qui accepte une entrée de la gamme [A3:A6]qui [A3:A5]représentent le nombre de 3, 4et 5trous par, respectivement , et [A6]représente la difficulté. Sorties vers la fenêtre immédiate VBE

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

Ce qui précède est une version condensée de l'appel

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

Où "=3*A3+4*A4+5*A5-A6"est donnée pour être la formule d'une cellule anonyme, comme indiqué par l' [...]encapsuleur, et ?est la version obsolète de l' Printappel avec un Debug.contexte implicite

Version plus amusante, 34 octets

Fonction de fenêtre immédiate VBE anonyme avec les mêmes conditions d'E / S que ci-dessus.

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

Ce qui précède est une version condensée de l'appel

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

Où "=SUMPRODUCT(A3:A5,ROW(A3:A5))"est donné la formule d'une cellule anonyme, comme indiqué par l' [...]encapsuleur, et ?est la version obsolète de l' Printappel avec un Debug.contexte implicite . Dans cette version, la plage de [A3:A5]et les numéros de ligne de cette plage ( ROWS(A3:A5)) sont passés sous forme de tableaux

Version Excel, 18 octets

Bien sûr, les versions ci-dessus se prêtent ainsi à exceller les versions de

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

et

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

R , 25 23 octets

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

Essayez-le en ligne!

Befunge , 15 octets

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

Essayez-le en ligne!

Japt , 12 octets

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

Essaye-le

Braingolf , 14 octets

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

Essayez-le en ligne!

05AB1E , 7 octets

3LÌ*O²-

Essayez-le en ligne!