Сортировка по нескольким ключам

20

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

пример

Пусть будет ввод ключей [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]]
code-golf number array-manipulation sorting Mego
источник
Некоторые из тестовых случаев кажутся неприятно длинными.
Роковая
@Fatalize Они предназначены для охвата случаев, когда ключей сортировки мало по сравнению с длинами списков, и случаев, когда ключей сортировки много.
Мего
1
@Fatalize Вот почему у нас есть скопировать и вставить. При необходимости используйте Retina, чтобы изменить формат на то, что вы можете использовать.
mbomb007
Можем ли мы предположить, что все строки будут иметь одинаковую длину, если это естественный тип данных в нашем языке (то есть матрица)?
Луис Мендо
@ LuisMendo Нет. Вы должны быть в состоянии поддерживать зубчатые массивы.
Мего

Ответы:

6

Желе , 4 байта

⁴ị$Þ

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

Линн
источник
1
У вас есть разбивка, как это работает?
JamEngulfer
@JamEngulfer: Он должен был быть указан в ответе, но: Þ«сортировать по указанному ключу сортировки», ⁴ịиспользует второй аргумент командной строки для изменения порядка массива (создает ключ сортировки, который работает как вопрос) и $переопределяет приоритет, так что программа анализирует правильно.
5

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
Мартин Эндер
источник
4

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.

Ними
источник
4

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

Мартин Эндер
источник
Не должно Extract/@#быть Extract/@(#+1)? Индекс ввода начинается с 0.
JungHwan Мин.
2
@JHM «Вы можете выбрать, будут ли ключи сортировки с нулевой или одной индексацией».
Мартин Эндер
Я стою исправлено.
JungHwan Мин
(Неудивительно) элегантно! Но учитывая, что вы 1-индексируете, разве не должно [{1, 0, 2}]быть [{2, 1, 3}]в вашем примере? Действительно, в настоящее время сортировка выполняется по первому элементу, затем по заголовку, затем по второму элементу.
Грег Мартин
@GregMartin извините, копирование / вставка не удалась.
Мартин Эндер,
3

Python, 50 байт

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

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

Mego
источник
3

Брахилог , 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
Fatalize
источник
3

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
}
Питер Тейлор
источник
3

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
миль
источник
2

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)
Нил
источник
2

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

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

Jakube
источник
Я думаю, что вы можете сохранить, заменив QEнаF
Maltysen
@ Maltysen Спасибо. Я думал, что это возможно только с помощью обычного однократного метода.
Якуб
1
правила для сахара очень сложные и непоследовательные, к сожалению, лучше всего просто попробовать, если какая-то вещь работает.
Maltysen
2

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`|`)
})
Развернуть фрагмент

edc65
источник
2

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;
            }
        }
}
Titus
источник
Ваше целое if($r>0){$s=$i[$b+1];$i[$b+1]=$i[$b];$i[$b]=$s;}может быть записано как $r>0&&$i[$b+1]^=$i[$b]^=$i[$b+1]^=$i[$b];, экономя вам 7 байтов. При этом используется подкачка XOR со злоупотреблением оценкой короткого замыкания для эмуляции if(){ ... }. Обмен выполняется только тогда и только тогда, когда $r>0 . Это использует тот же прием, который (иногда) используется с базами данных. Часто вы увидите mysqli_connect( ... ) or die('Cannot connect');.
Исмаэль Мигель
@IsmaelMiguel XOR swap не работает для массивов. И это сэкономит 10 байтов, потому что я мог бы сделать это пост-условие $bцикла. ;)
Тит
Я протестировал обмен XOR, и он работал (я не тестировал с остальным кодом). Я написал 2 тестовых случая: sandbox.onlinephpfunctions.com/code/… (вы код) и sandbox.onlinephpfunctions.com/code/… (XOR swap). Согласно text-compare.com , результат идентичен.
Исмаэль Мигель
@IsmaelMiguel Для проверки функции Вы должны выполнить ее: вставьте m($i,$k);перед тем, как var_dumpи Ваша версия будет выдавать мусор.
Тит
: / Я даже не заметил, что я не выполнял функцию ...: / Но это была классная идея!
Исмаэль Мигель
1

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
rnso
источник
1

Perl 6  23 20  19 байтов

->\a,\b{b.sort:{.[|a]}}
{$^a;$^b.sort:{.[|$a]}}
{$^b.sort: *.[|$^a]}
{$^b.sort: *[|$^a]}
Брэд Гилберт b2gills
источник
1

Ракетка 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))
rnso
источник
1

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));
Йорг Хюльсерманн
источник
Вы можете попробовать использовать <?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=$_GET[a],c);echo json_encode($a);. $_GETэто суперглобальный: это означает, что он уже глобален везде. Удалите global$k;, переместите назначение внутри функции, и все готово. Кроме того, так как это использует $_GET, вы должны использовать <?. При этом вы экономите 10 байтов. Это будет (надеюсь) работать.
Исмаэль Мигель
@IsmaelMiguel Я чувствую себя идиотом, которого я не видел, чтобы использовать глобал только внутри функции.
Йорг Хюльсерманн
PHP- sortфункции используют быструю сортировку; это не стабильно. Кроме того, вы можете сохранить два байта с -вместо <=>и два с анонимным обратным вызовом для usort.
Тит
@Titus Анонимная функция не может использоваться из-за c($x,$y,$i)конца тела функции.
Исмаэль Мигель
@ JörgHülsermann Не волнуйтесь, мы все делаем глупые ошибки.
Исмаэль Мигель
0

Clojure, 29 байт

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

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

NikoNyrh
источник