กำหนดรายการดัชนีและรายการเลขจำนวนเต็มศูนย์หรือมากกว่าให้เอาท์พุทรายการจำนวนเต็มเรียงตามลำดับจากน้อยไปมากโดยให้ความสำคัญกับคีย์จากอินพุตแรก

ตัวอย่าง

ปล่อยให้ปุ่มป้อนเข้า[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. ในที่สุดเราก็แยกความสัมพันธ์ที่เหลือกับ vlues ที่ index 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}

บล็อกที่ไม่มีชื่อซึ่งคาดว่าจะมีรายการของรายการและรายการของลำดับความสำคัญที่ด้านบนของสแต็กและแทนที่ด้วยรายการเรียงลำดับของรายการ

ลองออนไลน์! (เป็นชุดทดสอบ)

คำอธิบาย

การเรียงลำดับด้วยตัวแบ่ง tie สามารถนำมาใช้โดยการเรียงลำดับรายการทั้งหมดซ้ำ ๆ อย่างเสถียรจากคีย์ลำดับความสำคัญต่ำสุดไปยังคีย์ลำดับความสำคัญสูงสุด

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 ไบต์

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

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

Mathematica, 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สามารถ curried เราใช้สิ่งนี้โดยทำแผนที่Extractเหนือรายการดัชนีที่เราได้รับซึ่งสร้างรายการของฟังก์ชันที่เราต้องการ

Python ขนาด 50 ไบต์

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

นี่เป็นเวอร์ชันที่นำมาใช้อ้างอิงได้เล็กน้อย lคือพารามิเตอร์รายการและkเป็นพารามิเตอร์การเรียงลำดับคีย์ lสามารถทำซ้ำได้ใด ๆ ตราบใดที่องค์ประกอบของมันสามารถถูกแทนที่ด้วยจำนวนเต็ม (เช่นรายการ tuples หรือ int-keyed dicts) kสามารถ iterable ใด ๆ

Brachylogขนาด 29 ไบต์

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

ลองออนไลน์!

คำอธิบาย

เราใช้ความจริงที่ว่าo - Orderสามารถนำมาใช้กับกริยา additionnal เป็น input: เราสั่งซื้อรายการโดยใช้สำหรับแต่ละ[Keys, a list]รายการขององค์ประกอบของa listซึ่งเป็นที่ดัชนีเพื่อที่พวกเขาจะปรากฏในa keyKeys

                          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 = head (องค์ประกอบแรก); t = tail (องค์ประกอบที่เหลือหรือส่วนที่เหลือ); 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 Bytes

รุ่นที่มีการสร้างดัชนีของตัวเอง 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)