给定一个$n$维向量$v$与真正的条目，找到最接近的置换$p$的$(1,2,...,n)$相对于所述$l_1$ -distance。

细节

• 如果是更方便，你可以使用置换$(0,1,...,n-1)$代替。如果存在多个最接近的排列，则可以输出任何一个或全部替换。
• 两个向量u ，v之间的$l_1$距离定义为d （u ，v ）= ∑ i | u i − v i | 。$u,v$ $$d(u,v) = \sum_i \vert u_i-v_i\vert.$$
• 如果需要，可以假定输入仅由整数组成。

例子

[0.5  1] -> [1 2], [2 1]
c*[1 1 ... 1] -> any permutation
[1 4 2 6 2] -> [1 4 3 5 2], [1 4 2 5 3]
[1 3 5 4 1] -> [2 3 5 4 1], [1 3 5 4 2]
[7 7 3 2 5 6 4 2] -> [8 7 3 2 5 6 4 1], [8 7 3 1 5 6 4 2], [7 8 3 2 5 6 4 1], [7 8 3 1 5 6 4 2]
[-2 4 5 7 -1 9 3] -> [1 4 5 6 2 7 3], [2 4 5 6 1 7 3], [1 4 5 7 2 6 3], [2 4 5 7 1 6 3]
[0 4 2 10 -1 10 5] -> [1 4 2 6 3 7 5], [1 4 3 6 2 7 5], [2 4 3 6 1 7 5], [3 4 2 6 1 7 5], [1 4 2 7 3 6 5], [1 4 3 7 2 6 5], [2 4 3 7 1 6 5], [3 4 2 7 1 6 5]

八度脚本用于生成更多示例。

Python 2，60个字节

def f(l):z=zip(l,range(len(l)));print map(sorted(z).index,z)

在线尝试！

使用零索引。

具有简单思想的快速算法。如果我们不是需要置换的输入列表，使之尽可能接近$(1,2,...,n)$有可能，我们就应该排序，如下证明。因为我们不是置换$(1,2,...,n)$，我们选择置换该公司订购的相同的方式输入列表，就像在我的挑战模仿排序（除输入可能有重复）。（编辑：Miles指出了这个更加相同的挑战，Dennis的回答与此相同。）

声明：列表的排列$l$，其距离最小化$(1,2,...,n)$是$l$排序。

证明：考虑一些其他置换$l'$的$l$。我们将证明它不能比$l$排序更好。

挑两个指数$i,j$该$l'$具有外的顺序，即，其中$i<j$但 $l'_i > l'_j$。我们发现，他们交换不能增加的距离$(1,2,...,n)$。我们注意到，互换改变这两个要素的贡献如下：

$$|l'_i - i | + |l'_j - j | \to |l'_i - j | + |l'_j - i|.$$

这是显示这不能增加的一种好方法。考虑两个人走在数轴上，一个从去$l'_i$对$i$和其他来自$l'_j$到$j$。他们行走的总距离是左侧的表达式。由于$i<j$但$l'_i > l'_j$，他们切换谁在数行，这意味着它们必须在他们的散步在某些点交叉更高，称之为$p$。但是当他们达到$p$，然后他们可以交换目的地并步行相同的总距离。然后，对于他们来说，从一开始就走到他们交换的目的地，而不是使用$p$作为航路点，这总会在右侧，这并不坏。

所以，在分选两个异序元素$l'$使得其距离$(1,2,...,n)$更小或相同。重复此过程将最终对$l$排序。因此，$l$分拣至少不如$l'$对于任何选择$l'$，这意味着它是最佳的或并列最佳。

需要注意的是唯一的财产$(1,2,...,n)$，我们使用的是它的排序，所以相同的算法将努力置换任何给定的名单的距离尽量减少任何固定列表。

在代码中，的唯一目的z=zip(l,range(len(l)))是使输入元素与众不同，即避免联系，同时在不相等元素之间保持相同的比较。如果我们保证输入没有重复，我们可以删除它而只lambda l:map(sorted(l).index,l)。

05AB1E，7个字节

āœΣαO}н

在线尝试！

说明

ā              # get the numbers 1 to len(input) + 1
 œ             # Permutations of this
  Σ  }         # Sort by ...
   α           # Absolute difference
    O          # Sum these
      н        # And get the first one 
               # implicitly print

Perl 6，44个字节

{permutations(+$_).min((*[]Z-$_)>>.abs.sum)}

在线尝试！

返回索引为0的第一个最小排列的匿名代码块。

说明：

{                                          }   # Anonymous code block
 permutations(+$_)                             # From the permutations with the same length
                  .min(                   )    # Find the minimum by
                                      .sum       # The sum of
                                >>.abs           # The absolute values of
                       (*[]Z-$_)                 # The zip subtraction with the input

我想我也许也可以摆脱.sum绝对值列表的排序，但我不确定这确实是正确的，尽管它可以通过当前的测试用例。

果冻，8字节

LŒ!ạS¥ÐṂ

在线尝试！

果冻，5 个字节

Œ¿œ?J

单子链接接受一个数字列表，该列表产生一个整数列表。

在线尝试！或查看测试套件。

怎么样？

Œ¿œ?J - Link: list of numbers, X
Œ¿    - Index of X in a lexicographically sorted list of
         all permutations of X's items
    J - range of length of X
  œ?  - Permutation at the index given on the left of the
         items given on the right

NB L（的长度）将代替，J因为œ?给定一个整数n，在右边将隐式地使该范围[1..n]适用，但是J明确的。

红宝石，63 60字节

->v{[*1..v.size].permutation.max_by{|p|eval [p,0]*'*%p+'%v}}

在线尝试！

这里有一个数学技巧也可能对其他答案有帮助-我们不是使差异的绝对值之和最小化，而是使乘积之和最大化。为什么行得通？

最小化 (x-y) squared不等于最小化的总和|x-y|，但是它总是会给出一个有效的答案，它只是优先考虑减小大差异而不是小差异，而实际的挑战在两者之间并不重要。

但是(x-y)*(x-y)= x*x+y*y-2*x*y。由于平方项对于任何排列总会出现在总和中的某个位置，因此它们不会影响结果，因此我们可以简化为-2*x*y。的2因素了，所以我们可以简化为-x*y。然后，如果我们将最小化更改为最大化，则可以简化为x*y。

从直觉上讲，这类似于观察到如果您尝试使用一组水平墙和一组垂直墙来最大化平方英尺，则最好不要将大小彼此接近的墙配对以创建尽可能靠近正方形。 3*3 + 4*4 = 25，而3*4 + 4*3 = 24。

编辑：通过生成和评估格式字符串而不是使用zip和sum，节省了三个字节。

盖亚（Gaia），13个字节

e:l┅f⟪D†Σ⟫∫ₔ(

在线尝试！

e:		| eval and dup input
l┅f		| push permutations of [1..length(input)]
⟪   ⟫∫ₔ		| iterate over the permutations, sorting with minimum first
 D†Σ		| the sum of the absolute difference of the paired elements
       (	| and select the first (minimum)

JavaScript（ES6），61个字节

基于xnor的见解。

a=>[...a].map(g=n=>g[n]=a.sort((a,b)=>a-b).indexOf(n,g[n])+1)

在线尝试！

已评论

a =>                    // a[] = input array
  [...a]                // create a copy of a[] (unsorted)
  .map(g = n =>         // let g be in a object; for each value n in the copy of a[]:
    g[n] =              //   update g[n]:
      a.sort(           //     sort a[] ...
        (a, b) => a - b //       ... in ascending order
      ).indexOf(        //     and find the position
        n,              //       of n in this sorted array,
        g[n]            //       starting at g[n] (interpreted as 0 if undefined)
      ) + 1             //     add 1
  )                     // end of map()

JavaScript（ES6）， 130  128字节

还有 一定要  绝对是一个更直接的方式...

0索引。

a=>(m=g=(k,p=[])=>1/a[k]?(h=i=>i>k||g(k+1,b=[...p],b.splice(i,0,k),h(-~i)))``:p.map((v,i)=>k+=(v-=a[i])*v)|k>m||(R=p,m=k))(0)&&R

在线尝试！（具有1个索引的输出）

怎么样？

辅助功能 $g$ 计算的所有排列 $(0,...,n-1)$，在哪里 $n$ 是输入数组的隐式长度 $a[\;]$。

对于每个排列 $p$，我们计算：

我们最终返回导致最小的排列 $k$。

Wolfram语言（Mathematica），14个字节

#@*#&@Ordering

在线尝试！

基于xnor的见解。

Python 2中，149个 126 112字节

-23个字节，感谢Xcoder先生

-14个字节感谢xnor

from itertools import*
f=lambda a:min(permutations(range(len(a))),key=lambda x:sum(abs(a-b)for a,b in zip(x,a)))

在线尝试！

使用（0 ... n-1）的排列。

没有任何排列组合

Python 3，238字节

def p(a,r,l):
 if r==[]:l+=[a];return
 for i in range(len(r)):
  p(a+[r[i]],r[:i]+r[i+1:],l)
def m(l):
 s=(float("inf"),0);q=[];p([],list(range(len(l))),q)
 for t in q:D=sum(abs(e-f)for e,f in zip(l,t));s=(D,t)if D<s[0]else s
 return s[1]

在线尝试！

Wolfram语言（Mathematica），57个字节

f@n_:=MinimalBy[Permutations@Range@Length@n,Tr@Abs[n-#]&]

在线尝试！

Japt -g，12 个字节

Êõ á ñÈíaU x

尝试一下

对于0索引，请替换为前2个字节，m,以将数组映射到其索引。

Êõ á ñÈíaU x     :Implicit input of array U
Ê                :Length
 õ               :Range [0,Ê]
   á             :Permutations
     ñÈ          :Sort by
       í U       :  Interleave with U
        a        :  Reduce each pair by absolute difference
           x     :  Reduce resulting array by addition
                 :Implicit output of first sub-array

J，²⁵ 8字节

#\/:@/:]

在线尝试！

更短的答案基于xnor的绝妙想法。

原始答案

J，25个字节

(0{]/:1#.|@-"1)i.@!@#A.#\

在线尝试！