सूचकांकों की सूची और पूर्णांकों की शून्य या अधिक सूचियों को देखते हुए, पहले इनपुट से प्रमुख प्राथमिकता के साथ, पूर्णांक में क्रमबद्ध किए गए पूर्णांकों की सूचियों को आउटपुट करते हैं।

उदाहरण

कुंजी इनपुट हो [1, 0, 2], और सूची इनपुट हो [[5, 3, 4], [6, 2, 1], [5, 2, 1]]। उन सूचियों को उनके दूसरे तत्व, फिर पहला तत्व, फिर तीसरा तत्व, आरोही क्रम में क्रमबद्ध किया जाना चाहिए:

सबसे पहले, हम सूचकांक में मूल्यों के आधार पर छाँटते हैं 1:[[6, 2, 1], [5, 2, 1], [5, 3, 4]]
अगला, हम सूचकांक में मूल्यों का उपयोग करते हुए पहले प्रकार से किसी भी संबंध को तोड़ते हैं 0:[[5, 2, 1], [6, 2, 1], [5, 3, 4]]
अंत में, हम अनुक्रमणिका पर vlues के साथ किसी भी शेष संबंधों को तोड़ते हैं 2(यह वास्तव में कुछ भी नहीं बदलता है, क्योंकि कोई संबंध शेष नहीं हैं)।

विवरण

सॉर्टिंग स्थिर है: यदि दो तत्व दिए गए सॉर्ट कुंजी के संबंध में बराबर की तुलना करते हैं, तो उन्हें आउटपुट में समान सापेक्ष क्रम में रहना चाहिए। उदाहरण के लिए यदि Aऔर Bदिया तरह कुंजी के तहत बराबर हैं, और इनपुट था [..., A, ..., B, ...], Aपहले रखा जाना चाहिए Bउत्पादन में।
एक प्रकार की कुंजी इनपुट सूची में से एक में कभी भी गैर-मौजूद तत्व का संदर्भ नहीं देगी।
किसी प्रकार की कुंजी नहीं दोहराई जाएगी। इस प्रकार, [1, 2, 1]सॉर्ट कीज़ की एक मान्य सूची नहीं है।
सॉर्ट कीज़ द्वारा संदर्भित कोई भी तत्व सॉर्टिंग ऑर्डर में कारक नहीं हैं। केवल प्रारंभिक सापेक्ष क्रम और सॉर्ट कुंजी द्वारा संदर्भित तत्वों के मूल्य आउटपुट ऑर्डर निर्धारित करते हैं।
आप चुन सकते हैं कि सॉर्ट कुंजियाँ शून्य-अनुक्रमित हैं या एक-अनुक्रमित हैं।
सॉर्ट कुंजी में कोई नकारात्मक मान नहीं होगा। यदि आप एक-इंडेक्सिंग का उपयोग करना चुनते हैं, तो सॉर्ट कुंजी में कोई शून्य नहीं होगा।
पूर्णांक मान आपकी भाषा की मूल-प्रतिनिधित्व योग्य सीमा से अधिक नहीं होंगे। यदि आपकी चुनी हुई भाषा मूल-परिशुद्धता पूर्णांक (जैसे पायथन) की मूल रूप से सक्षम है, तो कोई भी पूर्णांक मान इनपुट में मौजूद हो सकता है, मेमोरी बाधाओं के अधीन हो सकता है।

संदर्भ कार्यान्वयन (पायथन 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]]

— मै जाऊं
स्रोत

परीक्षण के कुछ मामले मोटे तौर पर लंबे लगते हैं।

— 12

@ फ़ेटलाइज़ वे ऐसे मामलों को कवर करने के लिए होते हैं जहाँ सूचियों की लंबाई की तुलना में कुछ प्रकार की कुंजियाँ होती हैं, और ऐसे मामले जहाँ कई प्रकार की कुंजियाँ होती हैं।

— Mego

1

@ जान लीजिए कि हमारे पास कॉपी और पेस्ट क्यों है। यदि आवश्यक हो, तो प्रारूप का उपयोग करने के लिए रेटिना का उपयोग करें जिसे आप उपयोग कर सकते हैं।

— mbomb007 14

क्या हम मान सकते हैं कि सभी पंक्तियों की लंबाई समान होगी यदि हमारी भाषा (यानी मैट्रिक्स) में प्राकृतिक डेटा प्रकार है?

— लुइस मेंडू

@LuisMendo No. आप दांतेदार सरणियों का समर्थन करने में सक्षम होना चाहिए।

— मेगो

6

जेली , 4 बाइट्स

⁴ị$Þ

इसे ऑनलाइन आज़माएं!

— लिन
स्रोत

1

क्या आपको पता है कि कैसे काम करता है?

— जामबुलफर

@JamEngulfer: यह उत्तर में निर्दिष्ट किया जाना चाहिए था, लेकिन: Þ"निर्दिष्ट सॉर्ट कुंजी के साथ क्रमबद्ध है", ⁴ịसरणी को फिर से व्यवस्थित करने के लिए दूसरी कमांड-लाइन तर्क का उपयोग करता है (एक सॉर्ट कुंजी का निर्माण करता है जो प्रश्न की तरह काम करता है), और $ओवरराइड करता है वरीयता ताकि कार्यक्रम सही ढंग से पार्स हो।

5

सीजेएम , 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

रूबी, 35 बाइट्स

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

इसे eval.in पर देखें: https://eval.in/652574

— जॉर्डन
स्रोत

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:।

— nimi
स्रोत

4

गणितज्ञ, 22 19 बाइट्स

SortBy[Extract/@#]&

1-आधारित सूचकांकों का उपयोग करता है। यह अनाम फ़ंक्शन घुला हुआ है , इसलिए कॉलिंग सम्मेलन है:

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

मैथेमैटिका SortByउन कार्यों की एक सूची ले सकती है जिन मामलों में व्यक्तिगत कार्यों को क्रमिक टाई-ब्रेकर के रूप में उपयोग किया जाता है, इसलिए बस यही चाहिए। हमें केवल उन कार्यों की एक सूची बनानी होगी जो संबंधित सूची तत्व को वापस करते हैं। इसके साथ किया जा सकता है Extract। Extractसामान्य रूप से एक बाइनरी फ़ंक्शन है Extract[list, index]जो एक सूची तत्व देता है। हालाँकि, यदि इसका उपयोग नहीं किया जाता है, तो Extract[index]एक फ़ंक्शन देता है जो तत्व को उस पर दी indexगई सूची से पुनर्प्राप्त करता है। दूसरे शब्दों में, के indexपैरामीटर पर Extractअंकुश लगाया जा सकता है। हम Extractदिए गए सूचकांकों की सूची पर मैपिंग करके इसका उपयोग करते हैं, जो हमारे द्वारा आवश्यक कार्यों की सूची बनाता है।

— मार्टिन एंडर
स्रोत

नहीं Extract/@#होना चाहिए Extract/@(#+1)? इनपुट का सूचकांक 0. पर शुरू होता है

— जुंगहवां मिन सेप्ट

2

@ जेएचएम "आप चुन सकते हैं कि क्या सॉर्ट कुंजी शून्य-अनुक्रमित या एक-अनुक्रमित है।"

— मार्टिन एंडर

मुझे सही साबित होना है।

— जंगवान मिन सिप

(अप्रत्याशित रूप से) सुरुचिपूर्ण! लेकिन यह देखते हुए कि आप 1-इंडेक्सिंग कर रहे हैं, आपके उदाहरण में नहीं [{1, 0, 2}]होना चाहिए [{2, 1, 3}]? दरअसल, वर्तमान में यह पहले तत्व, फिर सिर, फिर दूसरा तत्व द्वारा क्रमबद्ध हो रहा है।

— ग्रेग मार्टिन

@GregMartin क्षमा करें, कॉपी / पेस्ट विफल।

— मार्टिन एंडर

3

पायथन, 50 बाइट्स

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

यह संदर्भ कार्यान्वयन का एक तुच्छ रूप से तैयार किया गया संस्करण है। lसूची पैरामीटर है, और kसॉर्ट कुंजी पैरामीटर है। lकोई भी पुनरावृत्त हो सकता है, इसलिए जब तक कि इसके तत्व पूर्णांक (जैसे सूचियां, टुपल्स या इंट-कीड डिकट्स) द्वारा ग्राह्य हो जाते हैं। kकिसी भी चलने योग्य हो सकता है।

— मै जाऊं
स्रोत

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

जे, 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

जावास्क्रिप्ट (ईएस 6), 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

अजगर, 5 4 बाइट्स

@LDF

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

@ बाइट्सन को एक बाइट के लिए धन्यवाद।

स्पष्टीकरण:

@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

@ मैलेटसेन धन्यवाद। मैंने सोचा कि यह केवल एक नियमित टोकन विधि से ही संभव है।

— जकुबे सिप

1

चीनी के लिए नियम बहुत ही अडिग और असंगत हैं, सबसे अच्छा दुर्भाग्य से सिर्फ एक विशेष चीज काम करती है।

— माल्टीसेन

2

जावास्क्रिप्ट (ईएस 6) 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;
            }
        }
}

— टाइटस
स्रोत

आपका पूरा 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>0mysqli_connect( ... ) or die('Cannot connect');

— इस्माइल मिगुएल

@IsmaelMiguel XOR स्वैप सरणियों के लिए काम नहीं करता है। और यह 10 बाइट्स बचाएगा, क्योंकि मैं इसे $bलूप के बाद की स्थिति बना सकता हूं । ;)

— टाइटस

मैंने XOR स्वैप का परीक्षण किया और यह काम किया (मैंने बाकी कोड के साथ परीक्षण नहीं किया)। मैंने 2 परीक्षण मामले लिखे: sandbox.onlinephpfunctions.com/code/… (आप कोड) और sandbox.onlinephpfunctions.com/code/… (XOR स्वैप)। Text-compare.com के अनुसार , आउटपुट समान है।

— इस्माइल मिगुएल

@IsmaelMiguel फ़ंक्शन का परीक्षण करने के लिए आपको इसे निष्पादित करना चाहिए: m($i,$k);इससे पहले डालें var_dumpऔर आपका संस्करण कचरा उत्पन्न करेगा।

— टाइटस

: / मैं भी ध्यान नहीं दिया कि मैं समारोह को अंजाम नहीं दिया ...: / लेकिन यह एक अच्छा विचार था!

— इस्माइल मिगुएल

1

आर 40 बाइट्स

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

स्पष्टीकरण:

सूचियों की सूची को 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]),]}

आउटपुट:

— rnso
स्रोत

1

पर्ल 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 = index list; 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))

— 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

क्लोजर, 29 बाइट्स

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

अच्छी तरह sort-byसे स्थिर है और वैक्टर को क्रमबद्ध करना जानता है, और वैक्टर कार्यों के रूप में काम कर सकता है। ([4 6 9 7] 2)है 9(0-आधारित अनुक्रमण)।

— NikoNyrh
स्रोत

एकाधिक-कुंजी छँटाई

उदाहरण

विवरण

संदर्भ कार्यान्वयन (पायथन 2)

परीक्षण के मामलों

जेली , 4 बाइट्स

सीजेएम , 13 बाइट्स

व्याख्या

रूबी, 35 बाइट्स

हास्केल, 38 बाइट्स

गणितज्ञ, 22 19 बाइट्स

पायथन, 50 बाइट्स

ब्रेकीलॉग , 29 बाइट्स

व्याख्या

CJam (12 बाइट्स)

विच्छेदन

जे, 6 बाइट्स

प्रयोग

व्याख्या

जावास्क्रिप्ट (ईएस 6), 55 बाइट्स

अजगर, 5 4 बाइट्स

स्पष्टीकरण:

जावास्क्रिप्ट (ईएस 6) 46

PHP, 212 170 बाइट्स

आर 40 बाइट्स

पर्ल 6 23 20 19 बाइट्स

रैकेट 218 बाइट्स

PHP, 139 बाइट्स