Đưa ra một danh sách các chỉ số và không hoặc nhiều danh sách số nguyên, xuất ra danh sách các số nguyên, được sắp xếp theo thứ tự tăng dần, với mức độ ưu tiên chính từ đầu vào đầu tiên.

Thí dụ

Đặt các phím nhập là [1, 0, 2]và đầu vào danh sách [[5, 3, 4], [6, 2, 1], [5, 2, 1]]. Các danh sách đó cần được sắp xếp theo phần tử thứ hai của chúng, rồi phần tử đầu tiên, rồi phần tử thứ ba, theo thứ tự tăng dần:

1. Đầu tiên, chúng tôi sắp xếp theo các giá trị tại chỉ mục 1:[[6, 2, 1], [5, 2, 1], [5, 3, 4]]
2. Tiếp theo, chúng tôi phá vỡ mọi mối quan hệ từ loại đầu tiên bằng cách sử dụng các giá trị tại chỉ mục 0:[[5, 2, 1], [6, 2, 1], [5, 3, 4]]
3. Cuối cùng, chúng tôi phá vỡ mọi mối quan hệ còn lại với các vlues tại chỉ mục 2(điều này thực sự không thay đổi bất cứ điều gì, vì không còn mối quan hệ nào nữa).

Chi tiết

• Sắp xếp ổn định: nếu hai phần tử so sánh bằng với các khóa sắp xếp đã cho, chúng phải giữ cùng thứ tự tương đối trong đầu ra. Ví dụ, nếu Avà Bbằng nhau dưới các khóa sắp xếp đã cho, và đầu vào là [..., A, ..., B, ...], Aphải được đặt trước Btrong đầu ra.
• Khóa sắp xếp sẽ không bao giờ tham chiếu phần tử không tồn tại trong một trong các danh sách đầu vào.
• Không có phím sắp xếp sẽ được lặp lại. Vì vậy, [1, 2, 1]không phải là một danh sách hợp lệ của các khóa sắp xếp.
• Bất kỳ yếu tố nào không được tham chiếu bởi các phím sắp xếp không tham gia vào thứ tự sắp xếp. Chỉ thứ tự tương đối ban đầu và các giá trị của các phần tử được tham chiếu bởi các khóa sắp xếp xác định thứ tự đầu ra.
• Bạn có thể chọn các khóa sắp xếp là không có chỉ mục hoặc chỉ mục một.
• Sẽ không có giá trị âm trong các phím sắp xếp. Nếu bạn chọn sử dụng lập chỉ mục một, sẽ không có số 0 trong các phím sắp xếp.
• Giá trị số nguyên sẽ không vượt quá phạm vi có thể biểu thị bằng ngôn ngữ của bạn. Nếu ngôn ngữ được chọn của bạn có khả năng tự nhiên là các số nguyên chính xác tùy ý (như Python), thì bất kỳ giá trị số nguyên nào cũng có thể xuất hiện trong đầu vào, tùy thuộc vào các ràng buộc bộ nhớ.

Tham chiếu thực hiện (Python 2)

#!/usr/bin/env python

keys = input()
lists = input()

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

Dùng thử trực tuyến

Các trường hợp thử nghiệm

Định dạng : keys lists -> output. Tất cả các khóa sắp xếp là không có chỉ mục.

[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]]

Thạch , 4 byte

⁴ị$Þ

Hãy thử trực tuyến!

CJam , 13 byte

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

Một khối không tên dự kiến ​​danh sách danh sách và danh sách ưu tiên trên đầu ngăn xếp và thay thế chúng bằng danh sách danh sách được sắp xếp.

Hãy thử trực tuyến! (Là một bộ thử nghiệm.)

Giải trình

Sắp xếp với bộ ngắt kết nối có thể được thực hiện bằng cách liên tục sắp xếp toàn bộ danh sách một cách ổn định từ khóa ưu tiên thấp nhất đến khóa ưu tiên cao nhất.

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

Ruby, 35 byte

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

Xem nó trên eval.in: https://eval.in/652574

Haskell, 38 byte

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

Ví dụ sử dụng: ( sortOn.flip(map.(!!)) ) [2,1] [[9,2,-2,-10,-6], [3,-4,-2]]-> [[3,-4,-2],[9,2,-2,-10,-6]].

Không có điểm : f k v=sortOn(\x->map(\y->x!!y)k)v.

Toán học, 22 19 byte

SortBy[Extract/@#]&

Sử dụng các chỉ số dựa trên 1. Chức năng giấu tên này được cà ri , vì vậy quy ước gọi là:

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

Mathicala SortBycó thể lấy một danh sách các hàm trong trường hợp các hàm riêng lẻ được sử dụng như các bộ ngắt liên tiếp, vì vậy đó chỉ là những gì chúng ta muốn. Tất cả những gì chúng ta cần làm là tạo một danh sách các hàm trả về phần tử danh sách tương ứng. Điều này có thể được thực hiện với Extract. Extractthường là một hàm nhị phân Extract[list, index]trả về một phần tử danh sách. Tuy nhiên, nếu được sử dụng một cách bất thường, thì Extract[index]sẽ trả về một hàm lấy phần tử tại indextừ một danh sách được truyền cho nó. Nói cách khác, indextham số của Extractcó thể được chế biến. Chúng tôi sử dụng điều này bằng cách ánh xạ Extractqua danh sách các chỉ số chúng tôi đưa ra, điều này tạo ra danh sách các chức năng chúng tôi cần.

Python, 50 byte

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

Đây là một phiên bản tầm thường của việc thực hiện tham chiếu. llà tham số danh sách và klà tham số khóa sắp xếp. lcó thể là bất kỳ lần lặp nào, miễn là các phần tử của nó có thể được ghi lại bởi các số nguyên (như danh sách, bộ dữ liệu hoặc các ký tự int-keyed). kcó thể là bất kỳ lặp đi lặp lại.

Brachylog , 29 byte

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

Hãy thử trực tuyến!

Giải trình

Chúng tôi sử dụng thực tế o - Ordercó thể được sử dụng với một vị từ bổ sung làm đầu vào: chúng tôi sắp xếp các danh sách bằng cách sử dụng cho từng [Keys, a list]danh sách các thành phần a listcó trong chỉ mục a keytheo thứ tự xuất hiện 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 byte)

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

Bản demo trực tuyến . Đây là một khối ẩn danh (hàm) lấy các đối số theo thứ tự được đưa ra cho các trường hợp thử nghiệm và để lại giá trị được sắp xếp trên ngăn xếp. Nó dựa vào loại tích hợp sẵn $ổn định, nhưng trình thông dịch chính thức đảm bảo điều đó.

Mổ xẻ

{          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 byte

]/:{&>

Các khóa được lập chỉ mục bằng không. LHS là danh sách các khóa và RHS là một mảng các giá trị. Vì J không hỗ trợ các mảng bị rách, nên mỗi mảng phải được đóng hộp.

Sử dụng

   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│
└────┴─┴─────────┘

Giải trình

]/:{&>  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 byte

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

Tiêu chuẩn ECMAscript không đảm bảo rằng sắp xếp cơ bản là ổn định, do đó, mã 68 byte sau đây không đưa ra giả định đó:

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

Bình thường, 5 4 byte

@LDF

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Cảm ơn @Maltysen cho một byte.

Giải trình:

@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

Tôi thực sự ngạc nhiên khi điều này làm việc. Đó là một cú pháp thực sự kỳ lạ.

JavaScript (ES6) 46

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

Tại mỗi so sánh trong quá trình sắp xếp, quét các chỉ số chính để tìm đúng thứ tự

Kiểm tra

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 byte

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 không có sắp xếp ổn định được xây dựng trong nữa ; chọn một phiên bản cũ hơn không có cách nào để thực hiện một cuộc gọi lại đệ quy với thông số kỹ thuật được yêu cầu. Nhưng đừng bận tâm: sử dụng trình lặp gọi lại đệ quy sẽ tốn hàng tấn; Vì vậy, tôi thậm chí đã kiểm tra nếu điều đó có thể làm điều đó.

Vòng lặp bên trong có thể được thay thế bằng một vòng lặp khác foreach; Điều đó sẽ lưu một số byte trên trao đổi. Nhưng không có kiểm tra $b<$a(hoặc $b<count($i)), điều đó sẽ dẫn đến một vòng lặp vô hạn. Và với kiểm tra đó, foreachChi phí nhiều như trao đổi chiến thắng.

Lần đầu tiên tôi đã làm so sánh đệ quy; nhưng lặp lại tiết kiệm hàng tấn byte:

phá vỡ

// 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 byte

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

Giải trình:

Danh sách các danh sách được thể hiện tốt nhất dưới dạng data.frame trong 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

Nếu danh sách chỉ mục là il (lập chỉ mục là từ 1):

il = list(1, 2, 3)

Sắp xếp có thể được thực hiện với mã sau đây:

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

Đầu ra:

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 byte

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

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

Vợt 218 byte

(λ(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 = index list; ll = list of list;

(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))

Kiểm tra:

(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]])

Đầu ra:

'((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 byte

sử dụng toán tử tàu vũ trụ mới và 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);

Thay vì $x[$k[$i]]<=>$y[$k[$i]] bạn có thể sử dụng$x[$k[$i]]-$y[$k[$i]] theo Phiên bản PHP lớn hơn 7 - 2 byte

phiên bản tạo chỉ mục riêng 197 Byte như trong thư viện thực

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

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

Nicely sort-byổn định và biết cách sắp xếp các vectơ và vectơ có thể hoạt động như các hàm. ([4 6 9 7] 2)là 9(lập chỉ mục dựa trên 0).