다중 키 정렬

20

인덱스 목록과 0 개 이상의 정수 목록이 제공되면 첫 번째 입력의 키 우선 순위와 함께 오름차순으로 정렬 된 정수 목록을 출력하십시오.

예

키를 입력 [1, 0, 2]하고 목록을 입력하십시오 [[5, 3, 4], [6, 2, 1], [5, 2, 1]]. 이 목록은 두 번째 요소, 첫 번째 요소, 세 번째 요소 순으로 오름차순으로 정렬해야합니다.

  1. 먼저 index의 값을 기준으로 정렬합니다 1.[[6, 2, 1], [5, 2, 1], [5, 3, 4]]
  2. 다음으로 index의 값을 사용하여 첫 번째 정렬과의 관계를 끊습니다 0.[[5, 2, 1], [6, 2, 1], [5, 3, 4]]
  3. 마지막으로 인덱스에서 vlues와의 남은 연결을 끊습니다. 남은 연결 2이 없기 때문에 실제로 아무것도 변경되지 않습니다.

세부

  • 정렬은 안정적입니다. 두 요소가 주어진 정렬 키와 동일하게 비교되는 경우 출력에서 ​​동일한 상대 순서를 유지해야합니다. 예를 들어, A및 B지정된 소트 키 하에서 동일하고, 입력 된 [..., A, ..., B, ...], A이전에 위치해야 B출력한다.
  • 정렬 키는 입력 목록 중 하나에 존재하지 않는 요소를 참조하지 않습니다.
  • 정렬 키가 반복되지 않습니다. 따라서 [1, 2, 1]유효한 정렬 키 목록이 아닙니다.
  • 정렬 키로 참조되지 않은 요소는 정렬 순서를 고려하지 않습니다. 정렬 키로 참조되는 요소의 값과 초기 상대 순서 만 출력 순서를 결정합니다.
  • 정렬 키가 0 색인인지 1 색인인지를 선택할 수 있습니다.
  • 정렬 키에는 음수 값이 없습니다. 1 인덱싱을 사용하도록 선택하면 정렬 키에도 0이 없습니다.
  • 정수 값은 귀하의 언어가 대표 할 수있는 범위를 초과하지 않습니다. 선택한 언어가 기본적으로 파이썬과 같은 임의의 정밀도 정수를 사용할 수있는 경우 메모리 제약 조건에 따라 모든 정수 값이 입력에 존재할 수 있습니다.

참조 구현 (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. 모든 정렬 키는 인덱스가 0입니다.

[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 
— 메고
소스
테스트 사례 중 일부는 명백히 길다.
— Fatalize
@Fatalize 목록의 길이와 비교할 때 정렬 키가 적은 경우와 정렬 키가 많은 경우를 포함합니다.
— Mego
1
@Fatalize 그래서 우리는 복사하여 붙여 넣기가 있습니다. 필요한 경우 Retina를 사용하여 형식을 사용 가능한 것으로 변경하십시오.
— mbomb007
언어의 자연 데이터 유형 (예 : 행렬) 인 경우 모든 행의 길이가 같다고 가정 할 수 있습니까?
— Luis Mendo
@LuisMendo 아니오. 들쭉날쭉 한 배열을 지원할 수 있어야합니다.
— Mego

답변:

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

하스켈, 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]].

비점 유형 : f k v=sortOn(\x->map(\y->x!!y)k)v.

— 니미
소스
4

수학, 22 19 바이트

SortBy[Extract/@#]&

1 기반 인덱스를 사용합니다. 이 명명되지 않은 함수는 curried 이므로 호출 규칙은 다음과 같습니다.

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 Min
2
@JHM "정렬 키의 색인이 0인지 색인이 아닌지 선택할 수 있습니다."
— Martin Ender
나는 정정되었다.
— JungHwan Min
(확실히) 우아합니다! 하지만 1 색인 걸 주어,해서는 안 [{1, 0, 2}]될 [{2, 1, 3}]귀하의 예에? 실제로 현재 첫 번째 요소로 정렬 한 다음 머리로 두 번째 요소로 정렬하는 것 같습니다.
— Greg Martin
@GregMartin 죄송합니다. 복사 / 붙여 넣기에 실패했습니다.
— Martin Ender
3

파이썬, 50 바이트

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

이것은 참조 구현의 사소한 골프 버전입니다. llist 매개 변수이며 ksort keys 매개 변수입니다. l요소가 목록, 튜플 또는 int-keyed dict와 같은 정수로 첨자 화 될 수있는 한 반복 가능할 수 있습니다. k반복 가능할 수 있습니다.

— 메고
소스
3

Brachylog , 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
— 치명적
소스
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 바이트

]/:{&>

키는 0으로 색인화됩니다. 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

자바 스크립트 (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

온라인으로 사용해보십시오 : 데모 또는 테스트 스위트

1 바이트 동안 @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

나는 이것이 효과가 있다는 것에 정말로 놀랐다. 정말 이상한 구문입니다.

— 자쿠 베
소스
나는 당신이 다음을 대체 QE함으로써 절약 할 수 있다고 생각합니다F
— Maltysen
@Maltysen 감사합니다. 나는 그것이 일반적인 단일 토큰 방법으로 만 가능하다고 생각했습니다.
— Jakube
1
설탕에 대한 규칙은 매우 임시적이고 일관성이 없으며, 가장 좋은 것은 불행히도 특정 일이 효과가 있는지 시험해 보는 것입니다.
— Maltysen
2

자바 스크립트 (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, 212170 바이트

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;
            }
        }
}
— 디도서
소스
전체 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 및 if 경우 에만 실행 됩니다 . 이것은 데이터베이스에 사용되는 것과 같은 트릭을 사용합니다. 종종을 보게 됩니다. if(){ ... } $r>0mysqli_connect( ... ) or die('Cannot connect');
— 이스마엘 미겔
@IsmaelMiguel XOR 스왑은 배열에서 작동하지 않습니다. 그리고 $b루프 의 사후 조건으로 만들 수 있기 때문에 10 바이트를 절약 할 수 있습니다 . ;)
— 디도
XOR 스왑을 테스트했으며 작동했습니다 (나머지 코드로는 테스트하지 않았습니다). sandbox.onlinephpfunctions.com/code/… (사용자 코드)와 sandbox.onlinephpfunctions.com/code/…(XOR 스왑)의 두 가지 테스트 사례를 작성했습니다 . text-compare.com 에 따르면 출력은 동일합니다.
— Ismael Miguel
@IsmaelMiguel 함수를 테스트하려면 함수를 실행해야합니다. m($i,$k);앞에 삽입 하면 var_dump버전에서 가비지가 생성됩니다.
— Titus
: / 나는 심지어 그 기능을 수행하지 않았다는 것을 알아 차리지 못했다 ... : / 그러나 그것은 멋진 생각이었다!
— Ismael Miguel
1

R 40 바이트

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

설명:

목록의 목록은 R에서 data.frame으로 가장 잘 나타납니다. 

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

라켓 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 = head (첫 번째 요소); 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 바이트

새로운 우주선 연산자를 사용 하고 소트 

<?$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]] 7-2 바이트 이상의 PHP 버전에서

실제 라이브러리에서와 같이 자체 색인을 생성하는 버전 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 바이트를 절약 할 수 있습니다. 그것은 (희망적으로) 작동 할 것입니다.
— Ismael Miguel
@IsmaelMiguel 나는 함수 내에서만 전역을 사용한다는 것을 보지 못한 바보처럼 느낀다.
— Jörg Hülsermann
PHP sort함수는 퀵 정렬을 사용합니다. 그것은 안정적이지 않습니다. 그 외에도 에 대한 익명의 콜백 -대신에 2 바이트를 절약하고 2 바이트를 절약 할 수 있습니다 . <=>usort
— Titus
@Titus 함수 c($x,$y,$i)본문 끝에 익명 함수를 사용할 수 없습니다 .
— Ismael Miguel
@ JörgHülsermann 걱정하지 마십시오. 우리 모두 바보 같은 실수를합니다.
— Ismael Miguel
0

클로저, 29 바이트

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

멋지게 sort-by안정적이며 벡터를 정렬하는 방법을 알고 있으며 벡터는 함수로 작동 할 수 있습니다. ([4 6 9 7] 2)인 9(0 기반 인덱스).

— 니코 니르
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.