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

Приклад

Нехай введені клавіші будуть [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.

Математика, 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список поданих нам індексів, що створює список необхідних нам функцій.

Пітон, 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 = quicksort для списку списків; 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 байт

використовувати нового оператора космічного корабля та усортувати

<?$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)

Добре sort-byстабільний і вміє сортувати вектори, а вектори можуть працювати як функції. ([4 6 9 7] 2)є 9(індексація на основі 0).