Sản phẩm vô hướng tối thiểu

Cảm hứng cho vấn đề golf mã này là từ cuộc thi kẹt mã của Google . Tiền đề đằng sau vấn đề này, được đưa vào đầu vào của hai vectơ có độ dài khác nhau, tìm vô hướng tối thiểu có thể. Một vô hướng có thể được tìm thấy bằng cách sử dụng công thức sau đây:

x1 * y1 + x2 * y2 + ... + xn * yn

Tuy nhiên, vấn đề là có thể tìm thấy nhiều giá trị cho vô hướng tùy thuộc vào thứ tự của các chữ số trong trường hợp đầu vào (xem bên dưới). Mục tiêu của bạn là xác định giải pháp số nguyên vô hướng tối thiểu có thể bằng cách cắm các số trường hợp đầu vào vào phương trình và giải cho nó. Bạn chỉ có thể sử dụng mỗi số trong đầu vào một lần và phải sử dụng tất cả các số.

Cho phép tôi cung cấp một ví dụ với các vectơ sau.

Đầu vào

3
1 3 -5
-2 4 1

Đầu ra

-25

Số nguyên đầu tiên trên dòng biểu thị số lượng số, n, trong mỗi vectơ. Trong trường hợp này, chúng ta có ba số trong mỗi vector.

Số n có thể thay đổi theo từng trường hợp thử nghiệm, nhưng sẽ luôn có hai vectơ.

Trong ví dụ đầu vào, sản phẩm vô hướng tối thiểu sẽ là -25.

(-5 * 4) + (1 * 1) + (3 * -2) = 25

Quy tắc

• Bạn chỉ có thể sử dụng mỗi số nguyên trong cả hai vectơ một lần.
• Bạn phải sử dụng tất cả các số nguyên trong các vectơ.
• Đầu ra của bạn chỉ phải bao gồm sản phẩm cuối cùng
• Tôi sẽ chọn giải pháp có số lượng mã ít nhất, tuân theo tất cả các thông số kỹ thuật được liệt kê ở trên, bằng bất kỳ ngôn ngữ nào!

Gợi ý: Bạn không cần phải xử lý vấn đề này, trừ khi nó làm cho mã của bạn ngắn hơn. Có một phương pháp cụ thể liên quan đến việc tìm vô hướng kéo dài tối thiểu :).

Thạch, 6 byte

ṢṚ×Ṣ}S

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

Sử dụng vũ lực cũng ngắn không kém:

Œ!×S€Ṃ

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

ṢṚ×Ṣ}S  Main link. Arguments: u (vector), v (vector)

Ṣ       Sort the components of u.
 Ṛ      Reverse.
   Ṣ}   Sort the components of v.
  ×     Multiply the results, element by element.
     S  Compute the sum of the products.

Nghiêm túc , 6 byte

,SR,S*

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

Giải trình:

,SR,S*
,SR     input first vector, sort, reverse
   ,S   input second vector, sort
     *  dot product

APL, 15 byte

{+/⍺[⍒⍺]×⍵[⍋⍵]}

Đây là một hàm dyadic chấp nhận các mảng ở bên trái và bên phải và trả về một số nguyên. Nó sử dụng cách tiếp cận giống như câu trả lời Julia của tôi : chấm sản phẩm của các mảng được sắp xếp, một giảm dần và một tăng dần.

Hãy thử nó ở đây

MATL , 6 byte

Mã số:

SiSP*s

Câu trả lời MATL đầu tiên của tôi :)

Giải trình:

S       # Sort the first array
 iS     # Take the second array and sort it
   P    # Flip the array
    *   # Multiply both arrays with each other
     s  # Sum of the result

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

Toán học, 30 17 byte

-13 byte bởi tiếng vang

Sort@#.-Sort@-#2&

Hàm, đầu vào là vector1 (danh sách), vector2 (danh sách) Một số sửa đổi:

Plus@@(Sort@#*Reverse@Sort@#2)&(*me*)
Total[Sort@#*Reverse@Sort@#2]& 
Sort@#.Reverse@Sort@#2&        (*alephalpha*)
Sort@#.Sort[#2,#>#2&]&         (*murphy*)
Sort@#.SortBy[#2,-#&]          (*me*)
Sort@#.-Sort@-#2&              (*murphy*)

Pyth - 14 8 byte

Tôi nghĩ rằng tôi đã tìm ra mánh khóe.

s*VSQ_SE

Hãy thử trực tuyến tại đây .

Julia, 32 25 byte

x->y->-sort(-x)⋅sort(y)

Đây là một hàm ẩn danh chấp nhận hai mảng và trả về một số nguyên. Để gọi nó, gán nó cho một biến và làm f(x)(y).

Đối với đầu vào x và y , chúng ta chỉ cần tính sản phẩm chấm của x được sắp xếp theo thứ tự ngược với y được sắp xếp. Chúng tôi nhận x theo thứ tự sắp xếp ngược bằng cách phủ định tất cả các giá trị, sắp xếp, sau đó phủ định lại.

Đã lưu 7 byte nhờ Dennis!

Javascript ES6, 69 byte

a=>b=>a.sort((x,y)=>x-y).map((x,y)=>i+=b.sort((x,y)=>y-x)[y]*x,i=0)|i

Wow, đây là cách quá dài.

Perl 6, 33 30 byte

{sum @^a.sort Z*@^b.sort.reverse}

CJam, 11 byte

q~$\$W%.*:+

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

Python, 139 byte

def mdp(n, a, b):
    a = list(reversed(sorted(a)))
    b = sorted(b)
    res = sum([a[i] * b[i] for i in range(len(a))])
    return res

C ++, 124 byte

#include<algorithm>
int m(int*a,int*b,int n){std::sort(a,a+n);std::sort(b,b+n);int r=0;while(--n>=0)r+=a[n]**b++;return r;}

vô dụng:

#include<algorithm>
int m(int*a,int*b,int n){
 std::sort(a,a+n);
 std::sort(b,b+n);
 int r=0;
 while(--n>=0)
  r+=a[n]*(*b++);
return r;
}

Lúc đầu tôi sử dụng std::greater<int>()để sắp xếp bnhưng chỉ cần đảo ngược thứ tự trong tổng kết là dễ dàng hơn.

Haskell, 59 byte

import Data.List
v?u=sum$zipWith(*)(sort v)$reverse$sort u

TRẢ LẠI , 29 byte

[{␆␃}\{␆}␄␅[¤¥][×␌]#}␁[¤][+]#]

Try it here.

Thay thế bất kỳ ␆␃␄␇với các đối tác không thể in của họ.

Lambda ẩn danh mà kết quả trên stack2. Sử dụng:

""{1 3 0 5-}""{0 2- 4 1}[{␆␃}\{␆}␄␅[¤¥][×␌]#}␁[¤][+]#]!

Giải trình

[                                 ]  lambda
 {␆␃}                              sort and reverse first stack
       \{␆}                         sort second stack
            ␄␅                     transpose and flatten
               [  ][  ]#             while loop
                ¤¥                     check if 2 items exist in stack
                    ×                  if so, multiply top 2 items
                     ␌                 and push to stack2
                        }␁          switch to stack2
                           [¤][+]#   sum stack2

J, 14 byte

+/@(*|.)&(/:~)

Sử dụng nguyên tắc giống như những người khác.

Giải trình

+/@(*|.)&(/:~)  Input: x on LHS and y on RHS
        &(/:~)  Sort both x and y
     |.         Reverse the sorted y
    *           Multiply the sorted x and reversed sorted y elementwise
+/@             Reduce the products using addition and return