Подражать заказ

24

Учитывая два списка чисел, источник и образец , измените порядок источника, чтобы соответствовать относительному порядку образца. Любые две записи переупорядоченного источника должны сравниваться так же, как записи в тех же позициях шаблона.

Например, вход

s = [-5, 9, 4, 13, 11, -6, 0]
p = [7, -4, 1, -8, 4, -3, 12]

должен дать результат

    [11, -5, 4, -6, 9, 0, 13]

Сравнивая первую и последнюю позиции, получился результат 11<13, который совпадает 7<12с шаблоном.

Входные данные: два непустых списка целых чисел одинаковой длины. Каждый список не будет повторяться. Вам решать, будет ли указан источник или шаблон первым.

Вывод: список, который переставляет исходные номера, чтобы иметь тот же относительный порядок, что и номера шаблонов.

Leaderboard:

Показать фрагмент кода

code-golf sorting permutations XNOR
источник
Должна ли это быть функция / программа или достаточно выражения / фрагмента?
Адам
@NBZ Если задача не переопределяет ее, по умолчанию разрешены только функции и программы . Хотя функции без имени разрешены .
Мартин Эндер

Ответы:

10

CJam, 12 10 байтов

{_$f#\$f=}

Это анонимная функция, которая берет s pстек и оставляет результат в стеке. Онлайн демо

С благодарностью Мартину Бюттнеру за 2 байта.

рассечение

{         e# Define an anonymous function
  _$f#    e# Use a copy of the pattern to map each element to its sort index
  \$      e# Sort the source
  f=      e# Map each sort index to the corresponding source element
}
Питер Тейлор
источник
{_$@$er}на два байта короче.
Деннис
@ Денис, это достаточно отличается, чтобы быть отдельным ответом
Питер Тейлор
Если вы так думаете, я выложу это как ответ.
Деннис
10

J, 9 байт

/:^:2~/:~

Это двоичный глагол, который принимает p и s в качестве левого и правого аргументов. Попробуйте его в Интернете с J.js .

Тестовый забег

   7 _4 1 _8 4 _3 12 (/:^:2~/:~) _5 9 4 13 11 _6 0
11 _5 4 _6 9 0 13

Как это работает

Скажем, мы определили назначенный левый и правый вход из примера через

p =: 7 _4 1 _8 4 _3 12
s =: _5 9 4 13 11 _6 0

Затем:

  • Поезд /:^:2~/:~- это крюк глаголов /:^:2~и /:~, так называемый

    p (/:^:2~/:~) s

    исполняет

    p /:^:2~ /:~ s

  • Наречие ~в /:~является рефлексивным , поскольку /:используется монадически. Таким образом, призывая

    /:~ s

    исполняет

    s /: s

  • Наречие ~в /:^:2~является пассивным , так как глагол /:^:2используется двоично. Таким образом, призывая

    p /:^:2~ y

    исполняет

    y /:^:2 p

  • Наречие ^:это сила . Таким образом, призывая

    y /:^:2 p

    исполняет

    y /: y /: p

Собираем все вместе, звоним

p (/:^:2~/:~) s

исполняет

(s /: s) /: (s /: s) /: p

Как это работает

Диадические /:является оценка с использованием , то есть, x /:yвозвращает элементы х , сортируются в соответствии с соответствующими значениями y.

  • s /: sпросто сортирует элементы s .

  • (s /: s) /: pсортирует (отсортированные) элементы s по соответствующим значениям p .

  • Повышение в два раза по существу вычисляет ординалы его правильного аргумента.

    Таким образом, (s /: s) /: (s /: s) /: pсортирует (отсортированные) элементы s , имитируя порядок элементов p .

Деннис
источник
9

Mathematica, 32 27 байт

Sort@#~Permute~Ordering@#2&

Пример использования:

Sort@#~Permute~Ordering@#2 &[{-5, 9, 4, 13, 11, -6, 0}, {7, -4, 1, -8, 4, -3, 12}]
(* {11, -5, 4, -6, 9, 0, 13} *)

Предыдущая попытка:

Sort[#][[Ordering@Ordering@#2]]&
2012rcampion
источник
@DavidCarraher Исправлено!
2012rcampion
1
+1 Я нашел то же самое решение через 4 минуты после вас! Вы можете сохранить пару байтов:o = Ordering; (Sort@#)[[o@o@#2]] &
DavidC
Прекрасное новое решение через Permute! Очень полезное использование перестановок.
DavidC
7

J, 17 байт

(A.^:_1/:~)~A.@/:

Это приводит к двоичному (то есть двоичному) глаголу. Это может быть вызвано следующим образом:

  _5 9 4 13 11 _6 0 ((A.^:_1/:~)~A.@/:) 7 _4 1 _8 4 _3 12
11 _5 4 _6 9 0 13

объяснение

Возможно, это не самое короткое J-решение, но это новый подход.

                   Left input is x, right input is y.
            A.@/:  The index of the permutation P that sorts y. /: gives the
                   permutation itself, and A. gives its index in the sorted
                   list of all its permutations.
       /:~         x sorted in ascending order. We are applying the x-sorting
                   permutation to x itself.
(A.^:_1   )~       The inverse of the permutation P applied to the sorted
                   version of x. Since P maps y to its sorted version, its
                   inverse maps the sorted version to y, and thus sorted x to
                   the correct output.
Zgarb
источник
6

Pyth, 10 байт

@LSvzxLSQQ

Попробуйте онлайн: демонстрация

объяснение

@LSvzxLSQQ implicit: z = first input line as string
                     Q = second input line evaluated
       SQ  sorted(Q)
     xLSQQ find the index for each element of Q in sorted(Q)
  Svz      sorted(evaluated z)
@LSvz      take the element in ^ for each index
Jakube
источник
XQSQSvzна три байта короче.
Деннис
@ Денис Данг. Почему я не подумал об этом? Вы хотите опубликовать это?
Якуб
1
Если вы считаете, что это достаточно отличается от вашего подхода, конечно.
Деннис
6

Pyth, 7 байт

XQSQSvz

Это полная программа, которая ожидает строковые представления s и p в две строки. Попробуйте онлайн.

Как это работает

           Store the first line of input (rep. of s) in z.
           Evaluate the second line of input and store the result (p) in Q.
  SQ       Sort the elements of p.
    Svz    Evaluate the repr. of s and sort its elements.
XQ         Perform transliteration on p.
           This replaces the lowest element of p with the lowest element of s, etc.
Деннис
источник
5

Python 2, 51

lambda s,p,a=sorted:[a(s)[a(p).index(x)]for x in p]
feersum
источник
Я в замешательстве: почему есть три параметра?
Питер Тейлор
@PeterTaylor Третий параметр имеет значение по умолчанию, поэтому его можно вызывать только с 2.
feersum
@PeterTaylor Добавление отдельной строки a=sortedбудет иметь тот же эффект.
xnor
Aaaaaah! Я неправильно разбирался и думал, что тело началось с =.
Питер Тейлор
5

Mathematica 56 43 30 29 байт

o=Ordering;Sort[#][[o@o@#2]]&

Ordering@#2 возвращает порядок чисел в шаблоне. Ordering@Ordering@#2дает позиции, которые должны занимать отсортированные элементы в источнике.

Sort[#][[o@o@#2]]& возвращает источник в требуемых позициях, а именно те, которые имеют тот же относительный порядок, что и список шаблонов.

тестирование

o=Ordering;Sort[#][[o@o@#2]]&[{-5, 9, 4, 13, 11, -6, 0}, {7, -4, 1, -8, 4, -3, 12}]

{11, -5, 4, -6, 9, 0, 13}

DavidC
источник
5

CJam, 8 байт

{_$@$er}

Это анонимная функция, которая ожидает s и p (самый верхний) в стеке и выталкивает переупорядоченные s в ответ. Попробуйте онлайн в интерпретаторе CJam .

Как это работает

_      e# Push a copy of p.
 $     e# Sort it.
  @    e# Rotate s on top of p and the sorted p.
   $   e# Sort s.
    er e# Perform transliteration.
       e# This replaces the lowest element of p with the lowest element of s, etc.
Деннис
источник
4

J, 13 байт

/:@/:@[{/:~@]

У меня все еще проблемы с тем, чтобы обернуть голову вокруг композиции глагола J, поэтому я чувствую, что некоторые из них @и []могут быть ненужными. Если бы более опытный пользователь J мог сообщить мне, можно ли это сжать, это было бы здорово. :)

Глагол можно использовать следующим образом:

   7 _4 1 _8 4 _3 12 (/:@/:@[{/:~@]) _5 9 4 13 11 _6 0
11 _5 4 _6 9 0 13

объяснение

/:@/:@[{/:~@] NB. Left input is the pattern, right input is the source.
        /:~@] NB. Sort the source.
/:@/:@[       NB. Compute the ordering of the ordering of the pattern.
       {      NB. Use those as indices into the sorted source.
Мартин Эндер
источник
Вы можете использовать Dyadic, /:чтобы избавиться от {и @, для 11 байтов:/:~@]/:/:@[
Деннис
@Dennis Спасибо, Zgarb нашел еще одно 11-байтовое решение, которому нужно всего два /:, но я еще не успел обновить ответ ( ({~/:)&/:{[).
Мартин Эндер
4

APL, 17 12 байт

{⍺[⍋⍺][⍋⍋⍵]}

Благодаря @Dennis, теперь это очень элегантно.

Вот хорошее 14-байтовое решение, которое не использует двойную индексацию:

{⍺[(⍋⍋⍺)⍳⍋⍋⍵]}

К сожалению, мы не можем индексировать массивы из поездов в APL.

lirtosiast
источник
4

Python 2, 48

lambda*l:map(dict(zip(*map(sorted,l))).get,l[0])

Большой шар функций. При этом используется подход перевода элементов многих других ответов с использованием словаря.

Помеченный вход *lожидает шаблоны и источник в указанном порядке и превращает их в списокl .

Сопоставление sortedсортирует оба списка и dict(zip(_))превращает пару списков в словарь с ключами из первого списка, совпадающими со значениями во втором, в порядке возрастания. Таким образом, результатом является то, что этот iсамый большой элемент шаблона сопоставляется с самым iбольшим элементом источника.

Наконец, мы преобразовываем pattern ( l[0]) через этот словарь, отображая его .getметод.

XNOR
источник
3

Bash + coreutils, 55

nl $2|sort -nk2|paste <(sort -n $1) -|sort -nk2|cut -f1

Ввод принимается как два имени файла, для источника и шаблона соответственно:

$ ./imitord.sh source.txt pattern.txt 
11  
-5  
4   
-6  
9   
0   
13  
$
Цифровая травма
источник
3

R, 38 байт

function(s,p)sort(s)[match(p,sort(p))]
flodel
источник
Это хороший подход. Не думал бы использовать match.
Алекс А.
3

Рубин, 51 байт

->s,p{s.map{|x|s.sort[p.sort.index(p[s.index x])]}}
daniero
источник
2

Haskell, 65 байт

import Data.List
s#p=[sort s!!i|b<-p,(i,e)<-zip[0..]$sort p,b==e]

Пример использования: [-5,9,4,13,11,-6,0] # [7,-4,1,-8,4,-3,12]-> [11,-5,4,-6,9,0,13].

Как это работает:

           b<-p                              -- for every b in p
               ,(i,e)<-zip[0..]$sort p       -- walk through the sorted list of p 
                                             -- paired with it's index ->
                                             -- (index,element) or (i,e)
                                      ,b==e  -- for those cases where b equals e
 sort s!!i                                   -- take the i-th element from the
                                             -- sorted list s
Ними
источник
2

R, 37 байт

function(s,p,o=order)s[o(s)][o(o(p))]
aPaulT
источник
2

TeaScript, 15 байт

ys¡m™x[yi(l)])

Это принимает входные данные в виде массива. Переводчик в настоящее время не работает, потому что я выставляю необычного нового переводчика

объяснение

y      // Second input
 s¡    // Sort it = s()
m™     // Map over it = m(#
  x[      // Num in first input at index...
    yi(l) // Current char's index in y
  ]
)
Downgoat
источник
Либо я плохо понимаю объяснение, либо это не сработает ... Я закодировал его в Пипе в соответствии с тем, что я думаю, и получил 13 9 -6 4 11 -5 0для примера ввода. ??
DLosc
2

Желе , 6 байтов, языковые проблемы

Œ¿œ?Ṣ}

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

Это берет образец, сопровождаемый источником, как два отдельных аргумента.

объяснение

Œ¿œ?Ṣ}
Œ¿      Generate an integer that describes the order of {the first input}
  œ?    Use that integer to reorder
    Ṣ}  the sorted version of the second {input}

источник
1

Haskell, 56 байт

import Data.List
p%s=[sort s!!(length$filter(<x)p)|x<-p]

Определяет двоичную функцию %. Каждая запись в pпреобразуется в запись sс той же статистикой порядка, т.е. относительным рангом в своем списке. Статистику порядка в xin pможно найти, посчитав элементы меньше, чем она ( sort p!!xвызывает раздражение Maybe). Результат индексируется в sort s.

zip/lookupРешение имеет ту же длину, за исключением того, что дает Justномера.

import Data.List
p%s=[lookup x$zip(sort p)(sort s)|x<-p]
XNOR
источник