न्यूनतम स्केलर उत्पाद

Question

न्यूनतम स्केलर उत्पाद

इस कोड गोल्फ समस्या की प्रेरणा 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

नियम

• आप केवल एक बार दोनों वैक्टर में प्रत्येक पूर्णांक का उपयोग कर सकते हैं।
• आपको वैक्टर में सभी पूर्णांक का उपयोग करना चाहिए।
• आपके आउटपुट में केवल अंतिम उत्पाद शामिल होना चाहिए
• मैं कम से कम मात्रा में कोड के साथ समाधान का चयन करूंगा, जो किसी भी भाषा में उपरोक्त सभी विशिष्टताओं का अनुसरण करता है!

संकेत: आपको इस समस्या पर बल देने की आवश्यकता नहीं है, जब तक कि यह आपके कोड को छोटा न बना दे। न्यूनतम फैले हुए स्केलर को खोजने के लिए एक विशिष्ट विधि शामिल है :)।

Comments

मैं वास्तव में किसी के लिए खराब नहीं होना चाहता, इसलिए इसे तब तक न खोलें जब तक कि आपको पहले से ही इसका जवाब न पता हो। यह बहुत अच्छी तरह से ज्ञात है यह मज़ेदार है। en.m.wikipedia.org/wiki/Rearrangement_inequality

— गर्व हैशकेल

Answer 1

जेली, 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.

Answer 2

गंभीरता से , 6 बाइट्स

,SR,S*

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

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

Answer 3

एपीएल, 15 बाइट्स

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

यह एक डाइएडिक फ़ंक्शन है जो बाईं और दाईं ओर सरणियों को स्वीकार करता है और पूर्णांक देता है। यह मेरे जूलिया उत्तर के समान दृष्टिकोण का उपयोग करता है : सॉर्ट किए गए सरणियों का डॉट उत्पाद, एक अवरोही और एक आरोही।

इसे यहाँ आज़माएँ

Answer 4

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

इसे ऑनलाइन आज़माएं!

Comments

मुझे यह देखकर खुशी हुई! :-)

— लुइस मेंडो

Answer 5

गणितज्ञ, 30 17 बाइट्स

-13 बाइट्स मर्फी द्वारा

Sort@#.-Sort@-#2&

फंक्शन, इनपुट वेक्टर 1 (सूची), वेक्टर 2 (सूची) कई संशोधन हैं:

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*)

Comments

चतुर समाधान!

— baseman101

Sort@#.Reverse@Sort@#2&

— एलेफाल्फा

Sort@#.Sort[#2,#>#2&]&

— मर्फी

Sort@#.-Sort@-#2&

— मर्फी

या आपके समाधान के लिए 1,Sort@#.SortBy[#2,-#&]

— कैलक्यूलेटरफल

Answer 6

अजगर - 14 8 बाइट्स

मुझे लगता है कि मैंने चाल को समझ लिया है।

s*VSQ_SE

इसे यहाँ ऑनलाइन आज़माएँ ।

Answer 7

जूलिया, 32 25 बाइट्स

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

यह एक अनाम फ़ंक्शन है जो दो सरणियों को स्वीकार करता है और एक पूर्णांक देता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें और करें f(x)(y)।

के लिए आदानों एक्स और वाई , हम बस की गणना की डॉट उत्पाद एक्स रिवर्स क्रम में सॉर्ट साथ y अनुसार क्रमबद्ध। हम सभी मानों को छांटकर, फिर से नकारते हुए, क्रमबद्ध क्रम में x प्राप्त करते हैं।

डेनिस के लिए धन्यवाद 7 बाइट्स सहेजे गए!

Answer 8

जावास्क्रिप्ट ईएस 6, 69 बाइट्स

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

वाह, यह बहुत लंबा रास्ता है।

Comments

मुझे लगता है कि पुन: उपयोग करने की कोशिश कर रहा है कि आप 3 बाइट्स खर्च कर रहे हैं।

— नील

मैंने और अधिक गोल्फिंग की। बेहतर?

— मामा फन रोल

आप संभवतः बाइट को बचा सकते |iहैं&&i

— ETHproductions

Thx @ETHproductions

— मामा फन रोल

हां, यही मैं सोच रहा था।

— नील

Answer 9

पर्ल 6, 33 30 बाइट्स

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

Comments

क्यों नहीं{sum @^a.sort Z*[R,] @^b.sort}((1,3,-5),(-2,4,1)).say

— एलेक्स-डैनियल जकिमेंको-ए।

Answer 10

सीजेएम, 11 बाइट्स

q~$\$W%.*:+

इसे ऑनलाइन आज़माएं!

Answer 11

पायथन, 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

Comments

आप बाइट्स के बगल में रिक्त स्थान हटाकर कुछ बाइट्स बचा सकते हैं, उदाहरण के लिए (2 बाइट्स सहेजे गए) b = sorted(b)में बदल जाता है b=sorted(b)। आप उदाहरण के लिए एक अर्धविराम के साथ उन्हें अलग करके एक ही पंक्ति में कई कथन रख सकते हैं, उदाहरण के लिएa=list(reversed(sorted(a)));b=sorted(b);res=0

— charredgrass

@charredgrass मैं यहाँ नया हूँ। हर संभव बाइट को बचाने के लिए क्या आवश्यक है? मैं इसे पठनीय बनाने की कोशिश कर रहा था।

— बागी

PPCG में आपका स्वागत है! यह सवाल एक कोड-गोल्फ प्रतियोगिता है जहां लक्ष्य संभव सबसे कम बाइट्स में चुनौती को पूरा करने के लिए कोड लिखना है, जिसका मतलब आमतौर पर कम पठनीय कोड होता है।

— चार्रेग्रास

@charredgrass मिल गया!

— 4

बहुत कम lambda a,b,s=sorted:sum(x*y for x,y in zip(s(a)[::-1],s(b))):। हमें फ़ंक्शन सबमिशन की आवश्यकता नहीं है, नाम दिया जाए (इसलिए एक अनाम लैम्ब्डा वैध है), और nपैरामीटर अनावश्यक है (कई अन्य सबमिशन इसे पूरी तरह से छोड़ देते हैं)।

— मेगो

Answer 12

सी ++, 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लेकिन सिर्फ संक्षेप में आदेश को उलट देना आसान है।

Answer 13

हास्केल, 59 बाइट्स

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

Answer 14

RETURN , 29 बाइट्स

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

Try it here.

कोई भी बदलें ␆␃␄␇उनके अप्रतिस्पर्धी समकक्षों के साथ को ।

अनाम लैम्ब्डा जो स्टैक 2 पर परिणाम देता है। उपयोग:

""{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

Answer 15

जे, 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