Minimum Skaler Ürün

Bu kod golf sorununun ilham kaynağı Google'ın kod sıkışması yarışmasından kaynaklanmaktadır . Sorunun arkasındaki dayanak, değişen uzunluklarda iki vektörün girdisi göz önüne alındığında, mümkün olan minimum skaleri bulmaktır. Aşağıdaki formül kullanılarak bir skaler bulunabilir:

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

Ancak sorun, giriş durumundaki sayıların sırasına bağlı olarak skaler için birden fazla değerin bulunabilmesidir (aşağıda görülmektedir). Amacınız, giriş senaryosu sayılarını denkleme takarak ve bunun için çözerek olası minimum skaler tamsayı çözümünü belirlemektir. Girişteki her sayıyı yalnızca bir kez kullanabilirsiniz ve tüm sayıları kullanmanız gerekir.

Aşağıdaki vektörlerle bir örnek vereyim.

Giriş

3
1 3 -5
-2 4 1

Çıktı

-25

Satırdaki ilk tam sayı, her vektördeki n sayısını, n sayısını temsil eder. Bu durumda, her vektörde üç sayı vardır.

N sayısı her test durumuna göre değişebilir, ancak her zaman iki vektör olacaktır.

Örnek girişte, minimum skaler ürün -25 olacaktır.

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

kurallar

• Her tamsayıyı her iki vektörde de yalnızca bir kez kullanabilirsiniz.
• Vektörlerdeki tüm tam sayıları kullanmalısınız.
• Çıktınız yalnızca son ürünü içermelidir
• Yukarıda listelenen tüm özellikleri takip eden en az kod içeren çözümü herhangi bir dilde seçeceğim!

İpucu: Kodunuzu kısaltmadıkça bu sorunu zorlamanız gerekmez. Minimum yayılma skalerini bulmak için spesifik bir yöntem vardır :).

Jöle, 6 bayt

ṢṚ×Ṣ}S

Çevrimiçi deneyin!

Kaba kuvvet kullanmak eşit derecede kısadır:

Œ!×S€Ṃ

Nasıl çalışır

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

Ciddi , 6 bayt

,SR,S*

Çevrimiçi deneyin!

Açıklama:

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

APL, 15 bayt

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

Bu, sol ve sağdaki dizileri kabul eden ve bir tamsayı döndüren ikili bir işlevdir. Benim Julia ile aynı yaklaşımı kullanan cevap sıralı Dizilerin nokta ürünün, bir azalan ve bir artan:.

Burada deneyin

MATL , 6 bayt

Kod:

SiSP*s

İlk MATL cevabım :)

Açıklama:

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

Çevrimiçi deneyin!

Mathematica, 30 17 bayt

Murphy tarafından -13 bayt

Sort@#.-Sort@-#2&

İşlev, girdi vektör1 (liste), vektör2 (liste). Birkaç revizyon:

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 bayt

Sanırım hileyi anladım.

s*VSQ_SE

Burada çevrimiçi deneyin .

Julia, 32 25 bayt

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

Bu, iki diziyi kabul eden ve bir tamsayı döndüren anonim bir işlevdir. Bunu çağırmak için bir değişkene atayın ve yapın f(x)(y).

Girişleri için x ve y , biz sadece nokta ürünü hesaplamak x ters olarak sıralanmış y kriteri. Biz almak x sonra, sıralama, tüm değerleri negating tekrar olumsuzlaştırılmasıyla ters sıralı düzende.

Dennis sayesinde 7 bayt kurtardı!

Javascript ES6, 69 bayt

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

Vay be, bu çok uzun.

Perl 6, 33 30 bayt

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

CJam, 11 Bayt

q~$\$W%.*:+

Çevrimiçi deneyin!

Python, 139 bayt

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 bayt

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

ungolfed:

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

İlk başta ben std::greater<int>()sıralama için kullanılan bama sadece toplamı düzeni tersine çevirmek daha kolaydır.

Haskell, 59 bayt

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

DÖNÜŞ , 29 bayt

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

Try it here.

␆␃␄␇Bunları yazdırılamaz eşleriyle değiştirin .

Yığın2'de sonuç bırakan anonim lambda. Kullanımı:

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

açıklama

[                                 ]  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 bayt

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

Diğerleriyle aynı prensibi kullanır.

açıklama

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