Man betrachte zwei sortierte Arrays von ganzen Zahlen und der Größe bzw. mit . Zum Beispiel ist , .Y m n m < n X = ( 1 , 4 ) Y = ( 2 , 10 , 11 $X$$Y$$m$$n$$m < n$$X = (1,4)$$Y = (2,10,11)$

Wir sagen, dass eine Übereinstimmung eine Art ist, jedes Element von mit einem Element von so zu paaren , dass keine zwei Elemente von mit demselben Element von gepaart werden . Die Kosten eines Matchings sind nur die Summe der absoluten Werte der Differenzen in den Paaren.Y X $X$$Y$$X$$Y$

Zum Beispiel können wir mit , die Paare die dann gekostet haben . Wenn wir die Paare hätten die Kosten . Wenn wir die Paare hätten, wären die Kosten .Y = ( 2 , 10 , 11 ) ( 7 , 2 ) , ( 11 , 10 ) 5 + 1 = 6 ( 7 , 10 ) , ( 11 , 11 ) 3 + 0 = 3 ( 7 , 11 ) , ( 11 , 10 ) $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$

Als weiteres Beispiel nimm , . Wir können die Paare zu einem Preis von . Die Paare (7,10), (11,11), (14,18) kosten 7 .$X = (7,11,14)$$Y = (2,10,11,18)$$(7,2), (11,10), (14,11)$$9$$(7,10), (11,11), (14,18)$$7$

Die Aufgabe besteht darin, Code zu schreiben, der bei zwei sortierten Arrays von Ganzzahlen und eine minimale Kostenanpassung berechnet.$X$$Y$

Testfälle

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

Brachylog , 16 Bytes

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

Probieren Sie es online!

Erläuterung

∧
 ≜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
               ∧

Da wir uns Izu Beginn zu einer ganzen Zahl vereinigen, probieren wir Dinge von kleinen Werten Ibis zu großen Werten von aus I, was bedeutet, dass das erste Mal, wenn es erfolgreich sein wird, notwendigerweise die Paarung mit kleinsten absoluten Differenzen sein wird.

Jelly , 15 14 12 11 Bytes

Œ!ż€IASƊÞḢṁ

Probieren Sie es online!

• -1 Byte danke an Jonathan Allan
• -1 Byte danke an Herrn Xcoder
• -2 Bytes dank eines anonymen Editors

Rohe Gewalt. Nimmt als Eingabe dann X .$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.

Haskell, 78 77 76 Bytes

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

TIO hat keine Data.Lists, also keine Verbindung.

Grundsätzlich der gleiche Algorithmus wie in @ dylnans Antwort .

Edit: -1 Byte dank @BMO.

JavaScript (ES7), 121 Byte

Übernimmt die 2 Arrays in Currying-Syntax (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

Probieren Sie es online!

J , 24 Bytes

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

Probieren Sie es online!

Erklärung / Demonstration:

Ein dyadisches Verb, x f y

-/ findet die Unterschiede

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

(0{]#~1>])"1 Behalten Sie für jede Zeile nur die nicht positiven Werte bei und nehmen Sie den ersten:

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

[:,@: verflacht die Liste (um der Form des linken Arguments zu entsprechen)

[-subtrahieren Sie die min. Unterschiede zum linken Argument

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

[,. Heften Sie sie an das linke Argument:

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

Pyth , 18 Bytes

t#h.msaMbm.T,dvz.p

Probieren Sie es hier aus!

Oktave , 66 Bytes

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

Anonymous Funktion , die Zeilenvektoren nimmt X, Yals Eingänge und gibt eine 2-Zeilenmatrix , wobei jede Spalte ein Paar der passenden.

Probieren Sie es online!

Pyth , 16 Bytes

hosaMNCM*.pQ.cEl

Versuchen Sie es online hier , oder prüfen Sie alle Testfälle auf einmal hier .

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

MATL , 16 Bytes

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

Eingänge sind Xdann Y.

Die Übereinstimmung wird mit den ersten Werten jedes Paares (dh X) in der ersten Zeile und den zweiten Werten jedes Paares in der zweiten Zeile ausgegeben .

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

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]

Jelly , (10?) 12 Bytes

^{10 Bytes, wenn nur die Elemente von Y benötigt werden (siehe Kommentare) - nicht sicher, ob dies in der Spezifikation zulässig ist (und dies sollte möglicherweise nicht der Fall sein, da andere Antworten dieses Detail bereits implementieren).
Dies kann durch Entfernen des Schleppers erreicht werden⁸ż .}

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

Eine dyadische Verknüpfung, die X links und Y rechts akzeptiert.
( œc⁹L¤ạS¥ÞḢż@und die 10 Bytes œc⁹L¤ạS¥ÞḢmachen dasselbe mit Y auf der linken und X auf der rechten Seite).

Probieren Sie es online!

Wie?

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)

JavaScript (ES7), 100 Byte

Neu hier; Alle Tipps / Korrekturen wäre dankbar! Bei einem früheren Versuch wurden Probleme beim Sortieren eines Arrays übersehen, das einen NaNWert enthält. Hoffentlich habe ich diesmal nichts verpasst.

(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

Erwartet zwei Argumente wie X , Y , respectively. Probieren Sie es online!

Scheint der Lösung von @ Arnauld ähnlich zu sein

Erläuterung

Beruht auf der Tatsache, dass gegebene X , Y sortiert sind, gibt es eine Lösung von Minimalkostenübereinstimmungen, bei denen, wenn alle Paare angeordnet sind, um die Reihenfolge der Elemente von X beizubehalten , alle Y- Elemente in der Anordnung auch ihre Reihenfolge beibehalten.

(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