Trong golf, độ xước chuẩn của khóa học được tính bằng công thức này:

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

Nhiệm vụ của bạn là tính toán vết xước tiêu chuẩn của một sân gôn, với 4 đầu vào này.

Bạn nên lấy đầu vào ở bất kỳ dạng chuẩn nào ở định dạng

[num_of_3_pars, num_of_4_pars, num_of_5_pars], difficulty rating

nhưng nếu nó tiết kiệm byte, nhiều bạn sẽ nhập dữ liệu theo một cách khác.

Bạn nên xuất kết quả cuối cùng bằng bất kỳ phương thức được chấp nhận nào trên meta, chẳng hạn như trả về từ một hàm.

Mã ngắn nhất thắng vì đây là mã golf !

Cào, 145 byte

<sup>-2 nhờ boboquack
- ??? bởi vì viết nó bằng Oto ngắn hơn tiếng Anh</sup>

(Vì Scratch là vết xước tiêu chuẩn.)

Đây là một mẫu chạy:

.

Thạch , 6 byte

JḊ~æ.N

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

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

Hãy thử trực tuyến!

Haskell , 22 byte

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

Hãy thử trực tuyến! Cách sử dụng: (3#2)5 7sản lượng 35.

Định dạng đầu vào không đẹp này ngắn hơn một byte so với giải pháp chuyển tiếp thẳng:

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

Định dạng đầu vào đẹp và miễn phí: (23 byte)

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

Hãy thử trực tuyến! Ràng buộc fvà gọi với f [3,2,5] 7.

Toán học, 13 14 byte

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

Cảm ơn @GregMartin. Lấy đầu vào là một danh sách dài 4.

Python 3 , 28 byte

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

Hãy thử trực tuyến!

Javascript, 24 byte

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

Perl6, 16 ký tự

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

(Yepp, đó là một phụ.)

Chạy mẫu:

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

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

Hãy thử trực tuyến!

Julia 0,5 , 15 byte

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

Hãy thử trực tuyến!

C #, 24 byte

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

Mã máy x86-64, 14 byte

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

Một hàm tuân theo quy ước gọi AMD V của Hệ thống V (có mặt khắp nơi trên các hệ thống Gnu / Linux) có bốn tham số nguyên:

• EDI = num_of_3_par_holes
• ESI = num_of_4_par_holes
• EDX = num_of_5_par_holes
• ECX = Khó khăn

Nó trả về một giá trị duy nhất, vết xước tiêu chuẩn, trong EAX ghi.

Ma thuật lắp ráp bất khả xâm phạm:

; 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

Chỉ là một bản dịch đơn giản của công thức. Điều thú vị là về cơ bản đây cũng chính là mã mà bạn sẽ viết khi tối ưu hóa tốc độ . Điều này thực sự cho thấy sức mạnh của của x86 LEAhướng dẫn, được thiết kế để l OAD một e ffective một ddress, nhưng có thể làm bổ sung và mở rộng quy mô (nhân bởi quyền hạn thấp của 2) trong một chỉ dẫn duy nhất, làm cho nó mạnh mẽ đa năng số học Workhorse .

Thạch , 10 7 byte

3r5×⁸S_

Hãy thử trực tuyến!

-3 byte nhờ Erik The Outgolfer!

Làm thế nào nó hoạt động!

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 byte

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

Hãy thử trực tuyến!

Khoảng gấp đôi câu trả lời MATL . Tôi ban đầu đã chuyển cái này sang MATL, nhưng hóa ra iY*nó dài hơn chỉ *s. Lưu ý rằng đầu vào a, chứa các lỗ theo thứ tự và sau đó là độ khó, phải là một vectơ cột.

Julia , 21 byte

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

Hãy thử trực tuyến!

Neim , 7 byte

'π𝐂𝕋𝐬S𝕊

Giải trình:

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

Chương trình thay thế: 3𝐈ᛖ𝕋𝐬S𝕊

Thay vì đẩy 345và sau đó lấy các ký tự, tạo mảng [1 2 3]bằng cách sử dụng 3𝐈, sau đó thêm 2 vào mỗi phần tử vớiᛖ .

Hãy thử trực tuyến!

C (gcc) , 30 byte

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

Hãy thử trực tuyến!

Swift 3 , 25 19 byte

Tôi nhận ra rằng bạn không cần var f=, bởi vì bạn có thể gọi nó như lambda Python:

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

Kiểm tra nó trực tuyến!

Cách sử dụng : {$0*3+$1*4+$2*5-$3}(a,b,c,d) , đâu a,b,c,dlà thông số.

Brainfuck , 39 byte

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

Hãy thử trực tuyến!

Lấy đầu vào và in đầu ra dưới dạng ký tự ASCII; ví dụ: giá trị 99 sẽ được biểu diễn dưới dạng c.

Giải trình:

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

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

dc, 14 ký tự

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

Các số cần phải được truyền vào các dòng riêng biệt.

Chạy mẫu:

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

Hãy thử trực tuyến!

Brachylog , 18 16 byte

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

Hãy thử trực tuyến!

-2 nhờ Fatalize .

,,, 12 byte

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

Giải trình

Lấy đầu vào 4, 3, 2, 1 chẳng hạn.

↻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

Khối , 36 byte

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

Hãy thử trực tuyến!

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

Xem nó chạy

Một chương trình khá tuyến tính cuộn lại xung quanh chính nó một vài lần. Các bước cơ bản:

• I3*r;U; nhận đầu vào đầu tiên, nhân 3 và dọn sạch ngăn xếp
• I4*/r\ nhận đầu vào tiếp theo và nhân với 4. Xoay kết quả xuống.
• Iw5*Ur;w<;r;;W nhận đầu vào tiếp theo, nhân với 5 và dọn sạch ngăn xếp
• I-r;w; nhận đầu vào cuối cùng, trừ đi kết quả par 5 và dọn sạch ngăn xếp
• /+p+O\@ thêm vào kết quả par 4, đưa kết quả par3 lên top add, output và tạm dừng

HP-15C (RPN), 14 byte

Mã hex hướng dẫn:

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

Phiên bản dễ đọc:

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

Bốn số được tải vào ngăn xếp theo thứ tự trước khi chạy chương trình.

VBA Excel, 20 byte

Anonymous VBE chức năng cửa sổ ngay lập tức mà có đầu vào từ dãy [A3:A6]trong đó [A3:A5]đại diện cho số của 3, 4và 5lỗ mệnh, tương ứng và [A6]đại diện cho sự khó khăn. Đầu ra cho cửa sổ VBE ngay lập tức

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

Trên đây là phiên bản thu gọn của cuộc gọi

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

Trường hợp "=3*A3+4*A4+5*A5-A6"được cho là công thức của một ô ẩn danh, như được chỉ định bởi [...]trình bao bọc và ?là phiên bản không dùng nữa của Printcuộc gọi với ẩnDebug. theo ngữ cảnh

Phiên bản thú vị hơn, 34 byte

Chức năng cửa sổ ngay lập tức VBE ẩn danh với các điều kiện I / O giống như trên.

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

Trên đây là phiên bản thu gọn của cuộc gọi

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

Trường hợp "=SUMPRODUCT(A3:A5,ROW(A3:A5))"được đưa ra là công thức của một ô ẩn danh, như được chỉ định bởi [...]trình bao bọc và ?là phiên bản không dùng nữa của Printcuộc gọi với ẩn Debug.theo ngữ cảnh. Trong phiên bản này, phạm vi [A3:A5]và số hàng của phạm vi đó (ROWS(A3:A5) ) được truyền dưới dạng mảng

Phiên bản Excel, 18 byte

Tất nhiên, các phiên bản trên cho vay chính nó cho các phiên bản excel của

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

và

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

R , 25 23 byte

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

Hãy thử trực tuyến!

Befunge , 15 byte

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

Hãy thử trực tuyến!

Japt , 12 byte

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

Kiểm tra nó

Braingolf , 14 byte

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

Hãy thử trực tuyến!

05AB1E , 7 byte

3LÌ*O²-

Hãy thử trực tuyến!