각각 크기가 이고 인 정수 와 의 정렬 된 두 배열을 고려하십시오 . 예를 들어 , 입니다.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)$

우리는 매칭의 각 요소 쌍이있는 방법이라고 말할 의 원소 의 두 개의 요소 방식으로 동일 요소와 페어링되지 않는 . 매칭 비용은 쌍의 차이의 절대 값의 합입니다.Y X $X$$Y$$X$$Y$

예를 들어 , 쌍을 만들 수 있으며 비용은 입니다. 쌍 만들었다면 비용은 이었을 것 입니다. 쌍 다면 비용은 입니다.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$

다른 예로 , . 의 비용으로 쌍 을 만들 수 있습니다 . 쌍 비용은 입니다.Y = ( 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ƊÞḢṁ

온라인으로 사용해보십시오!

• Jonathan Allan 덕분에 -1 바이트
• Mr. Xcoder 덕분에 -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.

하스켈, 78 77 76 바이트

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

TIO에는 Data.Lists이 없으므로 링크 가 없습니다 .

기본적으로 @dylnan의 답변 과 동일한 알고리즘 입니다.

편집 : @ BMO 덕분에 -1 바이트.

자바 스크립트 (ES7), 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

온라인으로 사용해보십시오!

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를 수용하는 2 차원 링크입니다.
( œ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)

자바 스크립트 (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