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

пример

Пусть будет ввод ключей [1, 0, 2], а ввод списков будет [[5, 3, 4], [6, 2, 1], [5, 2, 1]]. Эти списки должны быть отсортированы по их второму элементу, затем первому элементу, затем третьему элементу в порядке возрастания:

1. Сначала мы сортируем значения по индексу 1:[[6, 2, 1], [5, 2, 1], [5, 3, 4]]
2. Далее мы разрываем любые связи из первой сортировки, используя значения в индексе 0:[[5, 2, 1], [6, 2, 1], [5, 3, 4]]
3. Наконец, мы разрываем все оставшиеся связи с индексами в индексах 2(это на самом деле ничего не меняет, потому что связей не осталось).

Детали

• Сортировка стабильна: если два элемента сравниваются равными по отношению к заданным ключам сортировки, они должны оставаться в одном и том же относительном порядке в выходных данных. Например, если Aи Bпри заданных ключах сортировки равны, а вход был [..., A, ..., B, ...], Aдолжен быть помещен перед Bв выводе.
• Ключ сортировки никогда не будет ссылаться на несуществующий элемент в одном из списков ввода.
• Ключ сортировки не будет повторяться. Таким образом, [1, 2, 1]неверный список ключей сортировки.
• Любые элементы, на которые не ссылаются ключи сортировки, не учитываются в порядке сортировки. Только начальный относительный порядок и значения элементов, на которые ссылаются ключи сортировки, определяют порядок вывода.
• Вы можете выбрать, будут ли ключи сортировки с нулевой или одной индексацией.
• В ключах сортировки не будет отрицательных значений. Если вы решите использовать одноиндексирование, в ключах сортировки также не будет нулей.
• Целочисленные значения не будут превышать естественного представления вашего языка. Если выбранный вами язык обладает способностью к целым числам произвольной точности (например, Python), тогда любое целочисленное значение может присутствовать во входных данных с учетом ограничений памяти.

Реализация ссылок (Python 2)

#!/usr/bin/env python

keys = input()
lists = input()

print sorted(lists, key=lambda l:[l[x] for x in keys])

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

Тестовые случаи

Формат: keys lists -> output. Все ключи сортировки имеют нулевую индексацию.

[1, 0, 2] [[5, 3, 4], [6, 2, 1], [5, 2, 1]] -> [[5, 2, 1], [6, 2, 1], [5, 3, 4]]
[1, 2] [[5, 3, 4], [6, 2, 1], [5, 2, 1]] -> [[6, 2, 1], [5, 2, 1], [5, 3, 4]]
[0, 1] [[1, 2], [2, 1]] -> [[1, 2], [2, 1]]
[1, 0] [[1, 2], [2, 1]] -> [[2, 1], [1, 2]]
[0] [[4], [10, 11, -88], [-2, 7]] -> [[-2, 7], [4], [10, 11, -88]]
[2] [[-1, -5, 8, -1, -4, -10, -5, 4, 4, 6, -8, 4, 2], [-7, 6, 2, -8, -7, 7, -3, 3, 0, -6, 1], [-9, 8, -5, -1, -7, -8, -5, -6, 5, -6, 6]] -> [[-9, 8, -5, -1, -7, -8, -5, -6, 5, -6, 6], [-7, 6, 2, -8, -7, 7, -3, 3, 0, -6, 1], [-1, -5, 8, -1, -4, -10, -5, 4, 4, 6, -8, 4, 2]]
[2, 1] [[9, 2, -2, -10, -6], [3, -4, -2]] -> [[3, -4, -2], [9, 2, -2, -10, -6]]
[2, 4, 8] [[5, -3, 4, -6, -1, -2, -2, -4, 5], [-2, -3, 6, -4, -1, -4, -4, -5, 8, 9, 9, -3, 3, -9, -3], [2, 0, 10, -10, -1, 2, -1, 5, -1, 10, -5], [-7, -8, -6, 7, 3, 8, 6, -7, -2, 0, -6, -4, 4, -3, 2, -3]] -> [[-7, -8, -6, 7, 3, 8, 6, -7, -2, 0, -6, -4, 4, -3, 2, -3], [5, -3, 4, -6, -1, -2, -2, -4, 5], [-2, -3, 6, -4, -1, -4, -4, -5, 8, 9, 9, -3, 3, -9, -3], [2, 0, 10, -10, -1, 2, -1, 5, -1, 10, -5]]
[1, 2, 3, 4, 5] [[-7, 3, -8, 3, 5, -1, 6, -6, 9, 8], [-9, -1, -7, -9, -10, -2, -8, -10, -10, -3], [5, 3, -6, -5, -4, -4, -8, 2], [9, -4, 1, -1, -3, -2], [-6, -10, 4, -10, 6, 6, -1, 3, 0, 0], [1, -2, -7, -6, -7, -7, -1, 0, -4, 3, 3], [7, -1, -7, 2, -2, 9, 7, 5, -6, -8], [1, -5, -3, -10, -7, 9, -8, -5, -1], [-9, 4, -1, -1, 2, 4]] -> [[-6, -10, 4, -10, 6, 6, -1, 3, 0, 0], [1, -5, -3, -10, -7, 9, -8, -5, -1], [9, -4, 1, -1, -3, -2], [1, -2, -7, -6, -7, -7, -1, 0, -4, 3, 3], [-9, -1, -7, -9, -10, -2, -8, -10, -10, -3], [7, -1, -7, 2, -2, 9, 7, 5, -6, -8], [-7, 3, -8, 3, 5, -1, 6, -6, 9, 8], [5, 3, -6, -5, -4, -4, -8, 2], [-9, 4, -1, -1, 2, 4]]
[8, 7, 3, 2, 4, 9, 1] [[8, -5, 1, -6, -1, -4, 6, 10, 10, 6, 9, 5], [4, -8, 6, -10, -2, -3, 2, -6, 9, 5, 4, 10, 2, 3], [10, -1, 3, 0, -4, 1, -5, -4, -1, -7, 9, -9, -1, -5, 7, 8, 9, 6, -3], [0, -9, -7, -2, 2, -5, 7, 4, 6, -4, 1, 8, -7, 10], [5, 6, -9, 0, -1, 5, 4, 7, 5, 10, 2, 5, 7, -9]] -> [[10, -1, 3, 0, -4, 1, -5, -4, -1, -7, 9, -9, -1, -5, 7, 8, 9, 6, -3], [5, 6, -9, 0, -1, 5, 4, 7, 5, 10, 2, 5, 7, -9], [0, -9, -7, -2, 2, -5, 7, 4, 6, -4, 1, 8, -7, 10], [4, -8, 6, -10, -2, -3, 2, -6, 9, 5, 4, 10, 2, 3], [8, -5, 1, -6, -1, -4, 6, 10, 10, 6, 9, 5]]

Желе , 4 байта

⁴ị$Þ

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

CJam , 13 байтов

{W%{{X=}$}fX}

Безымянный блок, который ожидает список списков и список приоритетов сверху стека и заменяет их отсортированным списком списков.

Попробуйте онлайн! (Как набор тестов.)

объяснение

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

W%      e# Reverse priority list.
{       e# For each priority X...
  {     e#   Sort the lists by the result of this block...
    X=  e#     Extract the Xth element from the current list.
  }$
}fX

Рубин, 35 байт

->k,a{a.sort_by{|e|e.values_at *k}}

Смотрите это на eval.in: https://eval.in/652574

Haskell, 38 байт

import Data.List
sortOn.flip(map.(!!))

Пример использования: ( sortOn.flip(map.(!!)) ) [2,1] [[9,2,-2,-10,-6], [3,-4,-2]]-> [[3,-4,-2],[9,2,-2,-10,-6]].

Non-pointfree: f k v=sortOn(\x->map(\y->x!!y)k)v.

Mathematica, 22 19 байтов

SortBy[Extract/@#]&

Использует индексы на основе 1. Эта безымянная функция каррируется , поэтому соглашение о вызовах:

SortBy[Extract/@#]&[{2, 1, 3}][{{5, 3, 4}, {6, 2, 1}, {5, 2, 1}}]

Mathematica SortByможет взять список функций, и в этом случае отдельные функции используются как последовательные прерыватели связей, так что это именно то, что мы хотим. Все, что нам нужно сделать, это создать список функций, которые возвращают соответствующий элемент списка. Это можно сделать с помощью Extract. Extractобычно это двоичная функция, Extract[list, index]которая возвращает элемент списка. Однако, если используется не по назначению, то Extract[index]возвращает функцию, которая извлекает элемент indexиз списка, переданного ему. Другими словами, indexпараметр Extractможет быть карри. Мы используем это, отображая Extractсписок заданных нами индексов, который создает список необходимых нам функций.

Python, 50 байт

lambda l,k:sorted(l,key=lambda x:[x[y]for y in k])

Это тривиальная версия эталонной реализации. lявляется параметром списков и параметром kключей сортировки. lможет быть любым итеративным, при условии, что его элементы подписываются целыми числами (такими как списки, кортежи или подсказки с внутренним ключом). kможет быть любым повторяемым.

Брахилог , 29 байт

tT,?hg:Tz:{:2f}o:ta
heI,?t:Im

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

объяснение

Мы используем тот факт, что o - Orderможно использовать с дополнительным предикатом в качестве входных данных: мы упорядочиваем списки, используя для каждого [Keys, a list]список элементов, a listкоторые находятся в индексе a keyв порядке их появления Keys.

                          Input = [Keys, List of lists]

tT,                       Call the Keys T
   ?hg:T                  Create the list [[T], List of lists]
        z                 Zip [T] with the list of lists
         :{   }o          Order by the output of this predicate
                :ta       Keep only the last element of each sublist in the Output

           :2f            Find all outputs of the predicate below

heI,                      Take a key I
    ?t:Im                 Output is the Ith element of the sublist

CJam (12 байт)

{{1$\f=}$\;}

Демо онлайн . Это анонимный блок (функция), который принимает аргументы в порядке, заданном для тестовых случаев, и оставляет отсортированное значение в стеке. Он полагается на $стабильность встроенной сортировки , но официальный интерпретатор гарантирует это.

рассечение

{          e# Define a block. Stack: orders values-to-sort
  {        e#   Sort by...
    1$\f=  e#     Copy orders from the stack, and map array lookup
  }$
  \;       e#   Pop the orders to leave just sorted-values
}

J, 6 байт

]/:{&>

Ключи с нулевой индексацией. LHS - это список ключей, а RHS - это массив значений. Поскольку J не поддерживает рваные массивы, каждый массив должен быть в штучной упаковке.

использование

   f =: ]/:{&>
   < 1 0 2
┌─────┐
│1 0 2│
└─────┘
   5 3 4 ; 6 2 1 ; 5 2 1
┌─────┬─────┬─────┐
│5 3 4│6 2 1│5 2 1│
└─────┴─────┴─────┘
   (< 1 0 2) f  5 3 4 ; 6 2 1 ; 5 2 1
┌─────┬─────┬─────┐
│5 2 1│6 2 1│5 3 4│
└─────┴─────┴─────┘
   (< 1 2) f  5 3 4 ; 6 2 1 ; 5 2 1
┌─────┬─────┬─────┐
│6 2 1│5 2 1│5 3 4│
└─────┴─────┴─────┘
   (< 0) f 4 ; 10 11 _88 ; _2 7
┌────┬─┬─────────┐
│_2 7│4│10 11 _88│
└────┴─┴─────────┘

объяснение

]/:{&>  Input: keys (LHS), values (RHS)
   {&>  Select from values at each index in keys
]       Get the values
 /:     Sort up the values using the ones selected with the keys

JavaScript (ES6), 55 байт

(k,l)=>k.reduceRight((l,i)=>l.sort((a,b)=>a[i]-b[i]),l)

Стандарт ECMAscript не гарантирует, что базовая сортировка стабильна, поэтому следующий 68-байтовый код не делает такого предположения:

(k,l)=>l.sort(g=(a,b,i=0)=>i<k.length?a[k[i]]-b[k[i]]||g(a,b,i+1):0)

Pyth, 5 4 байта

@LDF

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

Спасибо @Maltysen за один байт.

Объяснение:

@LDFQ   Q (=input) added implicitly. 
  D     sort a list of lists by
@L         the sublists generated by some indices
   FQ   executes ^ with the the input as parameter

Я был очень удивлен, что это сработало. Это действительно странный синтаксис.

JavaScript (ES6) 46

k=>l=>l.sort((a,b)=>k.some(i=>v=a[i]-b[i])&&v)

При каждом сравнении во время сортировки сканируйте ключевые индексы, чтобы найти правильный порядок

Тестовое задание

f=k=>l=>l.sort((a,b)=>k.some(i=>v=a[i]-b[i])&&v)

;`[1, 0, 2] [[5, 3, 4], [6, 2, 1], [5, 2, 1]] -> [[5, 2, 1], [6, 2, 1], [5, 3, 4]]
[1, 2] [[5, 3, 4], [6, 2, 1], [5, 2, 1]] -> [[6, 2, 1], [5, 2, 1], [5, 3, 4]]
[0, 1] [[1, 2], [2, 1]] -> [[1, 2], [2, 1]]
[1, 0] [[1, 2], [2, 1]] -> [[2, 1], [1, 2]]
[0] [[4], [10, 11, -88], [-2, 7]] -> [[-2, 7], [4], [10, 11, -88]]
[2] [[-1, -5, 8, -1, -4, -10, -5, 4, 4, 6, -8, 4, 2], [-7, 6, 2, -8, -7, 7, -3, 3, 0, -6, 1], [-9, 8, -5, -1, -7, -8, -5, -6, 5, -6, 6]] -> [[-9, 8, -5, -1, -7, -8, -5, -6, 5, -6, 6], [-7, 6, 2, -8, -7, 7, -3, 3, 0, -6, 1], [-1, -5, 8, -1, -4, -10, -5, 4, 4, 6, -8, 4, 2]]
[2, 1] [[9, 2, -2, -10, -6], [3, -4, -2]] -> [[3, -4, -2], [9, 2, -2, -10, -6]]
[2, 4, 8] [[5, -3, 4, -6, -1, -2, -2, -4, 5], [-2, -3, 6, -4, -1, -4, -4, -5, 8, 9, 9, -3, 3, -9, -3], [2, 0, 10, -10, -1, 2, -1, 5, -1, 10, -5], [-7, -8, -6, 7, 3, 8, 6, -7, -2, 0, -6, -4, 4, -3, 2, -3]] -> [[-7, -8, -6, 7, 3, 8, 6, -7, -2, 0, -6, -4, 4, -3, 2, -3], [5, -3, 4, -6, -1, -2, -2, -4, 5], [-2, -3, 6, -4, -1, -4, -4, -5, 8, 9, 9, -3, 3, -9, -3], [2, 0, 10, -10, -1, 2, -1, 5, -1, 10, -5]]
[1, 2, 3, 4, 5] [[-7, 3, -8, 3, 5, -1, 6, -6, 9, 8], [-9, -1, -7, -9, -10, -2, -8, -10, -10, -3], [5, 3, -6, -5, -4, -4, -8, 2], [9, -4, 1, -1, -3, -2], [-6, -10, 4, -10, 6, 6, -1, 3, 0, 0], [1, -2, -7, -6, -7, -7, -1, 0, -4, 3, 3], [7, -1, -7, 2, -2, 9, 7, 5, -6, -8], [1, -5, -3, -10, -7, 9, -8, -5, -1], [-9, 4, -1, -1, 2, 4]] -> [[-6, -10, 4, -10, 6, 6, -1, 3, 0, 0], [1, -5, -3, -10, -7, 9, -8, -5, -1], [9, -4, 1, -1, -3, -2], [1, -2, -7, -6, -7, -7, -1, 0, -4, 3, 3], [-9, -1, -7, -9, -10, -2, -8, -10, -10, -3], [7, -1, -7, 2, -2, 9, 7, 5, -6, -8], [-7, 3, -8, 3, 5, -1, 6, -6, 9, 8], [5, 3, -6, -5, -4, -4, -8, 2], [-9, 4, -1, -1, 2, 4]]
[8, 7, 3, 2, 4, 9, 1] [[8, -5, 1, -6, -1, -4, 6, 10, 10, 6, 9, 5], [4, -8, 6, -10, -2, -3, 2, -6, 9, 5, 4, 10, 2, 3], [10, -1, 3, 0, -4, 1, -5, -4, -1, -7, 9, -9, -1, -5, 7, 8, 9, 6, -3], [0, -9, -7, -2, 2, -5, 7, 4, 6, -4, 1, 8, -7, 10], [5, 6, -9, 0, -1, 5, 4, 7, 5, 10, 2, 5, 7, -9]] -> [[10, -1, 3, 0, -4, 1, -5, -4, -1, -7, 9, -9, -1, -5, 7, 8, 9, 6, -3], [5, 6, -9, 0, -1, 5, 4, 7, 5, 10, 2, 5, 7, -9], [0, -9, -7, -2, 2, -5, 7, 4, 6, -4, 1, 8, -7, 10], [4, -8, 6, -10, -2, -3, 2, -6, 9, 5, 4, 10, 2, 3], [8, -5, 1, -6, -1, -4, 6, 10, 10, 6, 9, 5]]`
.split('\n').map(row=>{
  var [keys,list,expected]=row.split(/] -?>? ?\[/)
  keys=eval(keys+']');
  list=eval('['+list+']');
  expected=eval('['+expected);
  var result=f(keys)(list);
  var ok=result.join`|`==expected.join`|`;
  console.log(ok?'OK':'KO',keys+' '+list.join`|`+' -> ' +expected.join`|`,ok?'':result.join`|`)
})

PHP, 212 170 байт

function m(&$i,$k){foreach($i as$a=>$y)for($b=-1;++$b<$a;){for($p=0;$p<count($k)&!$r=$i[$b][$x=$k[$p++]]-$i[$b+1][$x];);if($r>0){$s=$i[$b+1];$i[$b+1]=$i[$b];$i[$b]=$s;}}}

В PHP больше нет встроенной стабильной сортировки ; При выборе более старой версии невозможно выполнить рекурсивный обратный вызов с необходимой спецификацией. Но не берите в голову: использование рекурсивного итератора обратного вызова обойдется в тонны; так что я даже не проверил, может ли это сделать.

Внутренний цикл может быть заменен другим foreach ; это сэкономило бы несколько байтов при обмене. Но без проверки $b<$a(или $b<count($i)) это приведет к бесконечному циклу. И с этой проверкой foreachстоит столько же, сколько выигрывает обмен.

Сначала я сделал сравнение рекурсивно; но итерация экономит тонны байтов:

сломать

// bubble sort
function m(&$i,$k)
{
    foreach($i as$a=>$y)
        for($b=-1;++$b<$a;)
        {
            // comparison:
            for($p=0;$p<count($k)                       // loop through keys
                &
                !$r=$i[$b][$x=$k[$p++]]-$i[$b+1][$x]    // while element equals its successor
            ;);
            // if element is larger than its successor, swap them
            if($r>0)
            {
                $s=$i[$b+1];$i[$b+1]=$i[$b];$i[$b]=$s;
            }
        }
}

R 40 байт

for(i in rev(il)){dd=dd[order(dd[,i]),]}

Объяснение:

Список списков лучше всего представить в виде data.frame в R:

ll2 = list(c(5,3,4), c(5,3,7), c(6,2,1), c(6,1,3), c(5,2,1))
dd = data.frame(do.call(rbind, ll2))
dd
      X1 X2 X3
    1  5  3  4
    2  5  3  7
    3  6  2  1
    4  6  1  3
    5  5  2  1

Если список индексов равен il (индексирование от 1):

il = list(1, 2, 3)

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

for(i in rev(il)){dd = dd[order(dd[,i]),]}

Выход:

dd
  X1 X2 X3
5  5  2  1
1  5  3  4
2  5  3  7
4  6  1  3
3  6  2  1

Perl 6  23 20  19 байтов

->\a,\b{b.sort:{.[|a]}}
{$^a;$^b.sort:{.[|$a]}}
{$^b.sort: *.[|$^a]}

{$^b.sort: *[|$^a]}

Ракетка 218 байт

(λ(il ll)(define qsl(λ(l i)(if(null? l)l(let*((h(first l))(t(rest l))(g(λ(ff)(filter(λ(x)(ff(list-ref x i)
(list-ref h i)))t))))(append(qsl(g <)i)(list h)(qsl(g >=)i))))))(for((i(reverse il)))(set! ll(qsl ll i)))ll)

Ungolfed (il = индексный список; ll = список списков; qsl = быстрая сортировка для списка списков; h = голова (первый элемент); t = хвост (остальные или оставшиеся элементы); g = модифицируемый фильтр fn):

(define qsl
  (λ(l i)
    (if (null? l)
        l
        (let* ((h (first l))
               (t (rest  l))
               (g (λ(ff) (filter (λ(x) (ff (list-ref x i) (list-ref h i))) t))))
          (append (qsl (g <) i)
                  (list h)
                  (qsl (g >=) i)
                  )))))
(define f
  (λ(il ll)
    (for ((i (reverse il)))
      (set! ll (qsl ll i)))
    ll))

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

(f (list 0 1 2) (list (list 5 3 4) (list 5 3 7) (list 6 2 1) (list 6 1 3) (list 5 2 1)))
(f [list 1 2] [list [list 5 3 4] [list 6 2 1] [list 5 2 3]])

Выход:

'((5 2 1) (5 3 4) (5 3 7) (6 1 3) (6 2 1))
'((6 2 1) (5 2 3) (5 3 4))

PHP, 139 байт

используйте новый оператор космического корабля и usort

<?$a=$_GET[a];function c($x,$y,$i=0){$k=$_GET[k];return$x[$k[$i]]-$y[$k[$i]]?:($k[++$i]?c($x,$y,$i):0);}usort($a,c);echo json_encode($a);

Вместо $x[$k[$i]]<=>$y[$k[$i]]вас можно использовать $x[$k[$i]]-$y[$k[$i]]под версией PHP больше 7 - 2 байта

версия с созданием собственного индекса 197 байт, как в реальной библиотеке

<?$m=min(array_map(min,$a=$_GET[a]));foreach($a as$p=>$v){$k="";foreach($s=$_GET[s]as$f){$k.=str_pad($v[$f]-$m,5,0,0);}$k.=str_pad($p,5,0,0);$r[$k]=$v;}ksort($r);echo json_encode(array_values($r));

Clojure, 29 байт

#(sort-by(fn[c](mapv c %))%2)

Nicely sort-byстабильна и умеет сортировать векторы, и векторы могут работать как функции. ([4 6 9 7] 2)есть 9(индексирование на основе 0).