12

पर विचार करें दो पूर्णांकों का सरणियों अनुसार क्रमबद्ध और आकार के और क्रमशः के साथ। उदाहरण के लिए , । $X$ $Y$ $m$ $n$ $m < n$ $X = (1,4)$ $Y = (2,10,11)$

हम कहते हैं कि एक मेल प्रत्येक तत्व को तत्व के साथ बाँधने का एक तरीका है, जिसमें दो तत्वों को के एक ही तत्व के साथ जोड़ा जाता है । एक मेल की लागत जोड़े में अंतर के पूर्ण मूल्यों का योग है। $X$ $Y$ $X$ $Y$

उदाहरण के लिए, , हम जोड़े बना सकते हैं जिसकी लागत । यदि हमने जोड़े बनाये होते तो लागत $X = (7,11)$ $Y = (2,10,11)$ $(7,2), (11,10)$ $5+1 = 6$ $(7,10), (11,11)$ । यदि हमने जोड़े बनाए होते तो लागत । $3+0 = 3$ $(7,11), (11,10)$ $4+1 = 5$

एक अन्य उदाहरण के रूप में , । हम लागत के लिए जोड़े । जोड़े $X = (7,11,14)$ $Y = (2,10,11,18)$ $(7,2), (11,10), (14,11)$ $9$ लागत । $(7,10), (11,11), (14,18)$ $7$

कार्य कोड लिखना है, जो पूर्णांक और दो क्रमबद्ध सरणियों को देखते हुए , एक न्यूनतम लागत मिलान की गणना करता है। $X$ $Y$

परीक्षण के मामलों

[1, 4],      [2, 10, 11]     => [[1, 2], [4, 10]]
[7, 11],     [2, 10, 11]     => [[7, 10], [11, 11]]
[7, 11, 14], [2, 10, 11, 18] => [[7, 10], [11, 11], [14, 18]]

code-golf number array-manipulation

— अनुश
स्रोत

क्या X या Y में कभी दोहराव होगा?

@ मेनेनिक नहीं वे नहीं

— Anush

2

स्पष्ट होने के लिए, हम न्यूनतम लागत के साथ मिलान लौटाते हैं, न्यूनतम लागत के साथ नहीं।

— ग्यूसेप

1

क्या हमारे पास और उदाहरण हो सकते हैं?

— डायलन

क्या हम मान सकते हैं कि केवल एक ही मिलान है जिसकी न्यूनतम लागत है?

— डायलन

4

ब्रेकीलॉग , 16 बाइट्स

∧≜I&pᵐz₀.-ᵐȧᵐ+I∧

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

व्याख्या

∧
 ≜I                   Take an integer I = 0, 1, -1, 2, -2, 3, -3, …
   &pᵐ                Permute each sublist
      z₀.             Zip the sublists together. The result of the zip is the output
         -ᵐȧᵐ         Absolute differences of each pair
             +I       The sum of these differences must be I
               ∧

चूंकि हम Iबहुत शुरुआत में एक पूर्णांक के लिए एकजुट होते हैं, इसलिए हम छोटे मूल्यों से Iलेकर बड़े मूल्यों तक की चीजों की कोशिश करते हैं I, जिसका अर्थ है कि पहली बार यह सफल होगा यह आवश्यक रूप से सबसे छोटे अंतर के साथ जोड़ी बनाने के लिए होगा।

— Fatalize
स्रोत

4

जेली , 15 14 12 11 बाइट्स

Œ!ż€IASƊÞḢṁ

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

-1 जोनाथन एलन को धन्यवाद
-1 बाइट मिस्टर एक्सकोडर की बदौलत
एक गुमनाम संपादक के लिए -2 बाइट्स धन्यवाद

पाशविक बल। तब रूप में इनपुट लेता है । $Y$ $X$

Œ!ż€IASƊÞḢṁ
Œ!                 All permutations of Y.
  ż€               Zip each of the permutations with X.

       ƊÞ          Sort by:
    I              Difference of each pair.
     A             Absolute value.
      S            Sum.
         Ḣ         Take the first matching.
          ṁ        Mold the result like X. Keeps only values up to the length 
                   of X which removes unpaired values from Y.

— dylnan
स्रोत

के L}स्थान पर काम करेगा ⁹L¤?

— श्री Xcoder

@ Mr.Xcoder हाँ, धन्यवाद!

— dylnan

ÐṂḢ-> ÞḢएक बाइट को बचाने के लिए।

— जोनाथन एलन

3

हास्केल, 78 77 76 बाइट्स

import Data.Lists
(argmin(sum.map(abs.uncurry(-))).).(.permutations).map.zip

TIO के पास Data.Listsकोई लिंक नहीं है।

मूल रूप से @ dylnan के उत्तर में देखा गया समान एल्गोरिथ्म ।

संपादित करें: -1 बाईट @ बीएमओ को धन्यवाद।

— nimi
स्रोत

2

जावास्क्रिप्ट (ईएस 7), 121 बाइट्स

सिंटैक्स में 2 सरणियों को ले जाता है (x)(y)।

x=>y=>(m=P=(b,[x,...a],s=0,o=[])=>1/x?b.map((v,i)=>P(b.filter(_=>i--),a,s+(x-v)**2,[[x,v],...o])):m<s||(r=o,m=s))(y,x)&&r

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

— Arnauld
स्रोत

2

जे , 24 बाइट्स

[,.[-[:,@:(0{]#~1>])"1-/

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

स्पष्टीकरण / प्रदर्शन:

एक रंग क्रिया, x f y

-/ अंतर पाता है

 7 11 14 -/ 2 10 11 18
 5 _3 _4 _11
 9  1  0  _7
12  4  3  _4

(0{]#~1>])"1 प्रत्येक पंक्ति के लिए केवल गैर-सकारात्मक मान रखें और पहले एक को लें:

   7 11 14 ([:(0{]#~1>])"1-/) 2 10 11 18
_3 0 _4

[:,@: सूची को समतल करता है (बाएं तर्क के आकार से मेल खाने के लिए)

[-मिनट घटाओ। बाएं तर्क से मतभेद

    7 11 14 ([-[:,@:(0{]#~1>])"1-/) 2 10 11 18
10
11
18

[,. उन्हें बाएँ तर्क में बाँधें:

   7 11 14 ([,.[-[:,@:(0{]#~1>])"1-/) 2 10 11 18
 7 10
11 11
14 18

— गैलेन इवानोव
स्रोत

1

पायथ , 18 बाइट्स

t#h.msaMbm.T,dvz.p

यहाँ यह कोशिश करो!

— मिस्टर एक्सकोडर
स्रोत

1

ऑक्टेव , 66 बाइट्स

@(X,Y)[X;C([~,r]=min(sum(abs(X-(C=perms(Y)(:,1:numel(X)))),2)),:)]

अनाम फ़ंक्शन जो इनपुट के रूप में पंक्ति वैक्टर लेता है X, Yऔर 2-पंक्ति मैट्रिक्स को आउटपुट करता है जहां प्रत्येक कॉलम मिलान की एक जोड़ी है।

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

— लुइस मेंडो
स्रोत

1

पायथ , 16 बाइट्स

hosaMNCM*.pQ.cEl

इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ पर सभी परीक्षण मामलों को सत्यापित करें ।

hosaMNCM*.pQ.cEl   Implicit: Q=evaluated 1st input, E=evaluated 2nd input
               l   Length of 1st input (trailing Q inferred)
            .cE    All combinations of 2nd input of the above length
         .pQ       All permutations of 1st input
        *          Cartesian product
      CM           Transpose each of the above
 o                 Order the above using:
   aMN               Take the absolute difference of each pair
  s                  ... and take their sum
h                  Take the first element of the sorted list, implicit print

— सोक
स्रोत

1

MATL , 16 बाइट्स

yn&Y@yy&1ZP&X<Y)

इनपुट्स Xतो हैं Y।

Xपहली पंक्ति में प्रत्येक जोड़ी (जो है ) के पहले मान और दूसरी पंक्ति में प्रत्येक जोड़ी के दूसरे मूल्यों के साथ मिलान आउटपुट है ।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

y       % Implicit inputs: X, Y. Duplicate from below
        % STACK: [7 11], [2 10 11], [7 11]
n       % Number of elements
        % STACK: [7 11], [2 10 11], 2
&Y@     % Variations without repetition
        % STACK: [7 11], [2 10; 2 11; 10 2; 10 11; 11 2; 11 10]
yy      % Duplicate top two elements
        % STACK: [7 11], [2 10; ...; 11 10], [7 11], [2 10; ...; 11 10]
&1ZP    % Compute cityblock distance between rows of the two input matrices
        % STACK: [7 11], [2 10;...; 11 10], [6 5 12 3 13 5]
&X<     % Argmin (first index of occurrences of the minimum)
        % STACK: [7 11], [2 10; 2 11; 10 2; 10 11; 11 2; 11 10], 4
Y)      % Row indexing. Implicit display
        % STACK: [7 11], 10 11]

— लुइस मेंडो
स्रोत

1

जेली , (10?) 12 बाइट्स

^{10 बाइट्स यदि केवल Y के तत्वों की आवश्यकता है (टिप्पणियां देखें) - सुनिश्चित नहीं है कि क्या यह अभी तक कल्पना द्वारा अनुमति दी गई है (और शायद यह नहीं होना चाहिए क्योंकि अन्य उत्तर पहले से ही इस विवरण को लागू करते हैं)। अनुगामी को हटाकर

इसे प्राप्त किया⁸ż जा सकता है ।}

Lœc@ạS¥Þ⁸Ḣ⁸ż

बाईं ओर X और दाईं ओर X को स्वीकार करने वाला एक डाईडिक लिंक।
( œc⁹L¤ạS¥ÞḢż@और 10 बाइट œc⁹L¤ạS¥ÞḢबाईं ओर Y के साथ और दाईं ओर X के साथ ऐसा ही करते हैं)।

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

कैसे?

Lœc@ạS¥Þ⁸Ḣ⁸ż - Link: sorted list of integers X, sorted list of integers Y
L            - length
   @         - with swapped arguments:
 œc          -   combinations (chosen as if picked left-to-right
             -      e.g. [2,5,7,9] œc 2 -> [[2,5],[2,7],[2,9],[5,7],[5,9],[7,9]] )
        ⁸    - chain's left argument (to be on right of the following...)
       Þ     -   sort by:
      ¥      -     last two links as a dyad:
    ạ        -       absolute difference (vectorises)
     S       -       sum
         Ḣ   - head (since sorted this is just the first minimal choices from Y)
          ⁸  - chain's left argument
           ż - zip with (the chosen Y elements)

— जोनाथन एलन
स्रोत

1

जावास्क्रिप्ट (ईएस 7), 100 बाइट्स

यहाँ नये; किसी भी सुझाव / सुधार की सराहना की जाएगी! पिछले प्रयास में एक NaNमान रखने वाले सरणी को छाँटने के साथ जटिलताओं को अनदेखा किया गया था , इसलिए उम्मीद है कि मैं इस बार कुछ भी याद नहीं करूंगा।

(x,y,q=Infinity)=>y.map((u,j)=>(p=0,s=x.map((t,i)=>(u=y[i+j],p+=(t-u)**2,[t,u])),p)<q&&(q=p,r=s))&&r

क्रमशः एक्स , वाई के रूप में दो तर्क की उम्मीद है। इसे ऑनलाइन आज़माएं!

@ Arnauld के समाधान के समान प्रतीत होता है

व्याख्या

इस तथ्य पर निर्भर करता है कि एक्स , वाई को छांटा गया है, न्यूनतम लागत मैचों का एक समाधान मौजूद है जहां यदि सभी जोड़े एक्स के तत्वों के आदेश को संरक्षित करने के लिए व्यवस्थित किए जाते हैं , तो व्यवस्था में सभी वाई तत्व भी उनके आदेश को संरक्षित करते हैं।

(x, y, q = Infinity) =>
    y.map((u, j) =>                   // iterate over indices of y
        (
            p=0,
            s=x.map((t, i) => (       // map each element of x to...
                    u = y[i+j],       // an element of y offset by j
                    p += (t-u)**2,    // accumulate the square of the difference
                    [t, u]            // new element of s
                )),
            p
        ) < q                         // if accumulated cost less than previous cost...
                                      // (if p is NaN, any comparison will return false and short circuit)
        && (q=p, r=s)                 // save cost, pair values respectively
    ) && r                            // return lowest-cost pairs

— फालतूपन
स्रोत

पूर्णांकों के सरणियों के बीच न्यूनतम लागत मिलान का पता लगाएं

परीक्षण के मामलों

ब्रेकीलॉग , 16 बाइट्स

व्याख्या

जेली , 15 14 12 11 बाइट्स

हास्केल, 78 77 76 बाइट्स

जावास्क्रिप्ट (ईएस 7), 121 बाइट्स

जे , 24 बाइट्स

स्पष्टीकरण / प्रदर्शन:

पायथ , 18 बाइट्स

ऑक्टेव , 66 बाइट्स

पायथ , 16 बाइट्स

MATL , 16 बाइट्स

व्याख्या

जेली , (10?) 12 बाइट्स

कैसे?

जावास्क्रिप्ट (ईएस 7), 100 बाइट्स

व्याख्या