考虑两个分别为整数和且的整数和的排序数组。例如，。ÿ 米Ñ 米< Ñ X = （1 ，4 ）ÿ = （2 ，10 ，11 $X$$Y$$m$$n$$m < n$$X = (1,4)$$Y = (2,10,11)$

我们说一个匹配配对的每个元素的一些方法使用的元素以这样一种方式，没有两个元素都具有相同的元素配对 。匹配的成本只是对中差异的绝对值之和。Y X $X$$Y$$X$$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$

作为另一个示例，取，。我们可以将成对花费。对成本。ÿ = （2 ，10 ，11 ，18 ）（7 ，2 ），（11 ，10 ），（14 ，11 ）9 （7 ，10 ），（11 ，11 ），（14 ，18 ）$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]]

Brachylog，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，这意味着首次成功将必然是针对具有最小绝对差的配对。

果冻，15 14 12 11字节

Œ!ż€IASƊÞḢṁ

在线尝试！

• -1字节感谢乔纳森·艾伦
• -1字节感谢Xcoder先生
• -2个字节，感谢匿名编辑器

蛮力。取输入作为然后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字节

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

TIO没有Data.Lists，因此没有链接。

基本上与@dylnan的答案相同。

编辑：-1字节感谢@BMO。

JavaScript（ES7），121个字节

采用currying语法的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

在线尝试！

J，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

Pyth，18个字节

t#h.msaMbm.T,dvz.p

在这里尝试！

八度，66字节

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

匿名函数，采用行向量X，Y作为输入并输出2行矩阵，其中各列是一对匹配的。

在线尝试！

Pyth，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

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]

果冻（10？）12 字节

^{如果仅需要Y的元素，则为10个字节（请参阅注释）-尽管尚不确定规范是否允许（可能不应该这样做，因为其他答案已经实现了此细节）。
这可以通过删除尾随⁸ż来实现。}

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

双向链接，左侧接受X，右侧接受Y。
（œ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)

JavaScript（ES7），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

期望两个参数分别为X，Y。 在线尝试！

似乎类似于@Arnauld的解决方案

说明

依靠给定X，Y进行排序的事实，存在最小成本匹配的解决方案，如果所有对都保留X元素的顺序排列，则排列中的所有Y元素也保留其顺序。

(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