ผลิตภัณฑ์เกลาขั้นต่ำ

แรงบันดาลใจสำหรับปัญหารหัสกอล์ฟแห่งนี้อยู่ห่างจากการแข่งขันรหัสแยมของ Google หลักฐานที่อยู่เบื้องหลังปัญหาคือให้อินพุตของเวกเตอร์ที่มีความยาวต่างกันสองตัวเพื่อหาสเกลาร์ขั้นต่ำที่เป็นไปได้ สเกลาร์สามารถพบได้โดยใช้สูตรต่อไปนี้:

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

อย่างไรก็ตามปัญหาคือสามารถหาค่าสเกลาร์ได้หลายค่าขึ้นอยู่กับลำดับของตัวเลขในกรณีอินพุต (ดูด้านล่าง) เป้าหมายของคุณคือการกำหนดวิธีการแก้ปัญหาจำนวนเต็มสเกลาร์ขั้นต่ำที่เป็นไปได้โดยเสียบหมายเลขกรณีการป้อนเข้าในสมการและการแก้ปัญหา คุณสามารถใช้ทุกหมายเลขในอินพุตได้เพียงครั้งเดียวและต้องใช้ตัวเลขทั้งหมด

อนุญาตให้ฉันยกตัวอย่างกับเวกเตอร์ต่อไปนี้

อินพุต

3
1 3 -5
-2 4 1

เอาท์พุต

-25

จำนวนเต็มแรกในบรรทัดแสดงจำนวนตัวเลข, n ในแต่ละเวกเตอร์ ในกรณีนี้เรามีตัวเลขสามตัวในแต่ละเวกเตอร์

จำนวน n อาจแตกต่างกันไปในแต่ละกรณีทดสอบ แต่จะมีสองเวกเตอร์

ในอินพุตตัวอย่างผลิตภัณฑ์สเกลาร์ขั้นต่ำจะเป็น -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 ไบต์

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

นี่คือฟังก์ชัน dyadic ที่ยอมรับอาร์เรย์ทางซ้ายและขวาและส่งกลับจำนวนเต็ม มันใช้วิธีการเดียวกันกับคำตอบ Julia ของฉัน: ผลคูณดอทของอาเรย์เรียงลำดับหนึ่งรายการจากมากไปน้อยและหนึ่งจากน้อยไปมาก

ลองที่นี่

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 ไบต์โดย murphy

Sort@#.-Sort@-#2&

ฟังก์ชั่นอินพุตเป็น vector1 (รายการ), vector2 (รายการ) การแก้ไขหลายประการ:

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

ลองมันออนไลน์ได้ที่นี่

Julia, 32 25 ไบต์

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

นี่คือฟังก์ชันที่ไม่ระบุชื่อที่ยอมรับสองอาร์เรย์และส่งกลับจำนวนเต็ม 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;}

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

ตอนแรกฉันใช้std::greater<int>()เรียงลำดับbแต่การกลับคำสั่งในการรวมนั้นง่ายกว่า

Haskell, 59 ไบต์

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

ผลตอบแทน 29 ไบต์

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

Try it here.

แทนที่ใด ๆ ␆␃␄␇ด้วยคู่ที่ไม่สามารถพิมพ์ได้ของพวกเขา

แลมบ์ดานิรนามที่ส่งผลให้เกิด 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