最小スカラー積

このコードゴルフの問題のインスピレーションは、Googleのコードジャムコンペティションにあります。問題の背後にある前提は、長さが異なる2つのベクトルの入力が与えられると、可能な最小のスカラーを見つけることです。スカラーは、次の式を使用して見つけることができます。

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

ただし、問題は、入力ケースの数字の順序に応じて、スカラーの複数の値を見つけることができることです（以下を参照）。あなたの目標は、入力ケース番号を方程式にプラグインしてそれを解くことにより、可能な最小のスカラー整数解を決定することです。入力ですべての数字を使用できるのは1回だけであり、すべての数字を使用する必要があります。

次のベクターを使用して例を提供させてください。

入力

3
1 3 -5
-2 4 1

出力

-25

行の最初の整数は、各ベクトルの数値の数nを表します。この場合、各ベクトルに3つの数値があります。

数値nはテストケースごとに異なる場合がありますが、常に2つのベクトルがあります。

入力例では、最小のスカラー積は-25です。

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

ルール

• 両方のベクトルで各整数を一度だけ使用できます。
• ベクトル内のすべての整数を使用する必要があります。
• 出力には最終製品のみを含める必要があります
• どの言語でも、上記のすべての仕様に従う最小のコードでソリューションを選択します！

ヒント：コードを短くしない限り、この問題を総当たりする必要はありません。最小スパンスカラーの検出には、特定の方法が含まれます:)。

ゼリー、6バイト

ṢṚ×Ṣ}S

オンラインでお試しください！

総当たり攻撃も同様に短いです：

Œ!×S€Ṃ

使い方

ṢṚ×Ṣ}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.

真剣に、6バイト

,SR,S*

オンラインでお試しください！

説明：

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

APL、15バイト

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

これは、左右の配列を受け入れ、整数を返す2項関数です。私のジュリアの答えと同じアプローチを使用します：ソートされた配列のドット積、降順と昇順。

ここで試してみてください

MATL、6バイト

コード：

SiSP*s

私の最初のMATLの答え:)

説明：

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

オンラインでお試しください！

Mathematica、30 17バイト

マーフィーによる-13バイト

Sort@#.-Sort@-#2&

関数、入力はvector1（list）、vector2（list）いくつかのリビジョン：

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バイト

私はトリックを見つけたと思う。

s*VSQ_SE

こちらからオンラインでお試しください。

ジュリア、32 25バイト

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

これは、2つの配列を受け入れて整数を返す匿名関数です。それを呼び出すには、変数に割り当ててdoしますf(x)(y)。

入力xとyについて、逆の順序で並べ替えられたxのドット積を計算し、yを並べ替えます。すべての値を否定し、ソートしてから再び否定することにより、xを逆のソート順に取得します。

デニスのおかげで7バイト節約できました！

Javascript ES6、69バイト

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

うわー、これは長すぎます。

Perl 6の、33の 30バイト

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

CJam、11バイト

q~$\$W%.*:+

オンラインでお試しください！

Python、139バイト

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バイト

#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;}

なし：

#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;
}

最初std::greater<int>()はソートに使用しましたbが、合計の順序を逆にするだけの方が簡単です。

Haskell、59バイト

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

RETURN、29バイト

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

Try it here.

any ␆␃␄␇を対応する印刷できないものに置き換えます。

stack2に結果を残す匿名ラムダ。使用法：

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

説明

[                                 ]  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バイト

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

他と同じ原理を使用します。

説明

+/@(*|.)&(/:~)  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