Учитывая $n$ - мерный вектор $v$ с вещественными элементами, найти ближайший перестановку $p$ из $(1,2,...,n)$ относительно $l_1$ -Расстояние.

Детали

• Если это более удобно, можно использовать перестановки $(0,1,...,n-1)$ вместо этого. Если имеется несколько ближайших перестановок, вы можете вывести любую или поочередно все из них.
• Расстояние $l_1$ между двумя векторами $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]

Octave скрипт для генерации большего количества примеров.

Python 2 , 60 байт

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

Попробуйте онлайн!

Использует нулевую индексацию.

Быстрый алгоритм с простой идеей. Если вместо этого мы должны переставить список ввода , чтобы сделать его как можно ближе к $(1,2,...,n)$ , насколько это возможно, мы должны просто разбирайтесь, как доказано ниже. Поскольку мы вместо перестановки $(1,2,...,n)$ , мы выбираем перестановку , что заказали точно так же , как список ввода, как в моем вызове Подражать упорядоченность ( за исключением ввода может быть повторы). (Изменить: мили указали на этот более идентичный вызов , где Деннис имеет тот же ответ .)

Утверждение: Перестановка из списка $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'$ , что означает, что она является оптимальной или связана для оптимальной.

Note that the only property of $(1,2,...,n)$ that we used is that it's sorted, so the same algorithm would work to permute any given list to minimize its distance to any fixed list.

In the code, the only purpose of z=zip(l,range(len(l))) is to make the input elements distinct, that is to avoid ties, while keeping the same comparisons between unequal elements. If the input we guaranteed to have no repeats, we could remove this and just have 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 Language (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 Language (Mathematica) , 57 байтов

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

Попробуйте онлайн!

Japt -g , 12 байт

Êõ á ñÈíaU x

Попытайся

For 0-indexed, replace the first 2 bytes with m, to map the array to its indices instead.

Êõ á ñÈí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.#\

Попробуйте онлайн!