সূচকগুলির একটি তালিকা এবং শূন্য বা আরও পূর্ণসংখ্যার তালিকাগুলি দেওয়া, প্রথম ইনপুট থেকে মূল অগ্রাধিকার সহ আরোহণের ক্রমে সাজানো পূর্ণসংখ্যার তালিকা আউটপুট।

উদাহরণ

কীগুলি ইনপুট হতে দিন [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]]
পরিশেষে, আমরা সূচকে ভ্লুগুলির সাথে কোনও অবশিষ্ট সম্পর্ক ভাঙ্গি 2(এটি আসলে কোনও পরিবর্তন করে না, কারণ কোনও সম্পর্ক নেই) are

বিস্তারিত

বাছাই স্থিতিশীল: যদি দুটি উপাদান প্রদত্ত বাছাইয়ের কীগুলির সাথে সম্মানের সাথে সমান তুলনা করে, তবে অবশ্যই আউটপুটে একই আপেক্ষিক ক্রমে থাকতে হবে। উদাহরণস্বরূপ, যদি 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]]

— ঐ মেগো
সূত্র

কিছু পরীক্ষার কেস অযৌক্তিকভাবে দীর্ঘ বলে মনে হয়।

— 5

@ ফ্যাটালাইজ করে তাদের বোঝানো হয়েছে যে তালিকাগুলির দৈর্ঘ্যের তুলনায় কয়েকটি সাজানোর কী রয়েছে এবং যেখানে অনেকগুলি সাজানোর কী রয়েছে এমন কেসগুলি কভার করা।

— মেগো

1

@ ফ্যাটালাইজ করুন এজন্য আমাদের কপি এবং পেস্ট রয়েছে। যদি প্রয়োজন হয়, আপনি ব্যবহার করতে পারেন এমন কিছুতে ফর্ম্যাটটি পরিবর্তন করতে রেটিনা ব্যবহার করুন।

— mbomb007

আমরা কি ধরে নিতে পারি যে যদি আমাদের ভাষায় প্রাকৃতিক ডেটা টাইপ হয় (তবে একটি ম্যাট্রিক্স) তবে সমস্ত সারিটির দৈর্ঘ্য একই হবে?

— লুইস মেন্ডো

@ লুইসমেন্ডো নং। আপনি নিশ্চয় জেগড অ্যারে সমর্থন করতে সক্ষম হবেন।

— মেগো

6

জেলি , 4 বাইট

⁴ị$Þ

এটি অনলাইন চেষ্টা করুন!

— লিন
সূত্র

1

কীভাবে এটি কাজ করে তার একটি ব্রেকডাউন পেয়েছেন?

— জামেঙ্গুলফার

@ জামেঞ্জুলার: এটি উত্তরে উল্লেখ করা উচিত ছিল, তবে: Þ"নির্দিষ্ট ধরণের কী দিয়ে বাছাই করা", ⁴ịঅ্যারেটিকে পুনরায় অর্ডার করতে দ্বিতীয় কমান্ড-লাইন যুক্তি ব্যবহার করে (প্রশ্নটির অনুরূপ কাজ করে এমন একটি সাজানোর কী তৈরি করে), এবং $ওভাররাইডগুলি অগ্রাধিকার যাতে প্রোগ্রামটি সঠিকভাবে বিশ্লেষণ করে।

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

অ pointfree: 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)?

— ইনপুটটির সূচকটি

2

@ জেএইচএম "আপনি বাছাই করতে কীগুলি শূন্য-সূচকযুক্ত বা এক-সূচকযুক্ত চয়ন করতে পারেন" "

— মার্টিন এন্ডার

আমি সংশোধন করেছি.

— জংহওয়ান মিন

(অনিচ্ছাকৃতভাবে) মার্জিত! কিন্তু দেওয়া যে আপনার 1-ইন্ডেক্স হন, করা উচিত নয় [{1, 0, 2}]হতে [{2, 1, 3}]আপনার উদাহরণে? প্রকৃতপক্ষে, বর্তমানে এটি প্রথম উপাদান অনুসারে বাছাই করা বলে মনে হচ্ছে, তারপরে মাথা, পরে দ্বিতীয় উপাদান।

— গ্রেগ মার্টিন

@ গ্রেগমার্টিন দুঃখিত, অনুলিপি / অনুলিপি করুন

— মার্টিন এন্ডার

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ইনপুট হিসাবে একটি additionnal সম্পৃক্ত সাথে ব্যবহার করা যাবে: আমরা প্রত্যেকের জন্য ব্যবহার করে তালিকা অর্ডার [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

সিজেএম (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 বাইট

]/:{&>

কীগুলি শূন্য-সূচকযুক্ত। এলএইচএস হ'ল কীগুলির তালিকা এবং আরএইচএস মানগুলির একটি অ্যারে। যেহেতু জে রগড অ্যারেগুলি সমর্থন করে না, তাই প্রতিটি অ্যারে অবশ্যই বাক্সে করা উচিত।

ব্যবহার

   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)

ইসমাস্ক্রিপ্ট মানটি গ্যারান্টি দেয় না যে অন্তর্নিহিত সাজানটি স্থিতিশীল, সুতরাং নিম্নলিখিত -৮-বাইট কোডটি অনুমান করে না:

(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

— মাল্টেসেন

@ মাল্টেসেন ধন্যবাদ আমি ভেবেছিলাম এটি কেবল একটি নিয়মিত এক-টোকেন পদ্ধতি দ্বারা সম্ভব।

— জাকুবে

1

চিনির নিয়মগুলি খুব অ্যাডহক এবং অসামঞ্জস্যপূর্ণ, দুর্ভাগ্যক্রমে কোনও বিশেষ জিনিস যদি কাজ করে তবে চেষ্টা করা ভাল।

— মাল্টেসেন

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

পিএইচপি, 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;}}}

পিএইচপি-তে আর কোনও স্থির বাছাই নেই ; পুরানো সংস্করণ বাছাই করা প্রয়োজনীয় স্পেসিফিকেশন সহ পুনরাবৃত্ত কলব্যাক করার কোনও উপায় নেই। তবে কিছুই নয়: পুনরাবৃত্ত কলব্যাক পুনরুক্তি ব্যবহার করে টন খরচ পড়বে; সুতরাং আমি এটি পরীক্ষা করতে পারি না যে এটি করতে পারে কিনা।

অভ্যন্তরীণ লুপটি অন্যটির সাথে প্রতিস্থাপন করা যেতে পারে 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;
            }
        }
}

— তিতাস
সূত্র

আপনার পুরোটি আপনাকে 7 বাইট সংরক্ষণ করে 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];। এটি অনুকরণ করতে শর্ট সার্কিট মূল্যায়নের অপব্যবহারের সাথে একটি এক্সওআর সোয়াপ ব্যবহার করে । অদলবদল কেবলমাত্র যদি হয় এবং শুধুমাত্র কার্যকর হয় । এটি একই কৌশলটি ব্যবহার করে যা (কখনও কখনও) ডাটাবেসগুলির সাথে ব্যবহৃত হয়। প্রায়শই, আপনি দেখতে পাবেন । if(){ ... } $r>0mysqli_connect( ... ) or die('Cannot connect');

— ইসমাইল মিগুয়েল 15

@ ইসমাইল মিগুয়েল এক্সওআর সোয়াপ অ্যারেগুলির জন্য কাজ করে না। এবং এটি 10 বাইট সংরক্ষণ করতে পারে, কারণ আমি এটিকে $bলুপের পোস্ট-শর্ত করতে পারি । ;)

— তিতাস

আমি এক্সওআর অদলবদল পরীক্ষা করেছি এবং এটি কাজ করেছে (আমি বাকী কোড দিয়ে পরীক্ষা করিনি)। আমি 2 টি পরীক্ষার কেস লিখেছি: স্যান্ডবক্স.অনলাইনপ্পফিউশনস / কোড / … (আপনার কোড) এবং স্যান্ডবক্স.অনলাইনপ্পফুনিউশনস কোড / কোড ( এক্সওআর সোয়াপ)। Text-compare.com অনুসারে আউটপুট অভিন্ন।

— ইসমাইল মিগুয়েল

@ ইসমাইলমিগুয়েল ফাংশনটি পরীক্ষা করার জন্য আপনার এটি সম্পাদন করা উচিত: এর m($i,$k);আগে sertোকান var_dumpএবং আপনার সংস্করণটি আবর্জনা তৈরি করবে।

— টাইটাস

: / আমি এমনকি খেয়ালও করেছিলাম যে আমি ফাংশনটি সম্পাদন করি নি ...: / তবে এটি একটি দুর্দান্ত ধারণা ছিল!

— ইসমাইল মিগুয়েল

1

আর 40 বাইট

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

ব্যাখ্যা:

তালিকার তালিকাটি আর-তে ডেটাফ্রেম হিসাবে সেরা উপস্থাপিত হয়:

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

যদি সূচকের তালিকাটি ইল হয় (সূচীকরণ 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]}

— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র

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)

অবরুদ্ধ

(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

পিএইচপি, 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]]পিএইচপি সংস্করণ অধীনে 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 বাইট সংরক্ষণ করুন। এটি (আশা) কাজ করবে।

— ইসমাইল মিগুয়েল 10

@ ইসমাইল মিগুয়েল আমি এমন এক নির্বোধের মতো বোধ করি যা আমি দেখিনি যে আমি কেবল ফাংশনের অভ্যন্তরে গ্লোবাল ব্যবহার করি।

— জার্গ হালসারম্যান

পিএইচপি sortফাংশন কুইকোর্ট ব্যবহার করে; এটি স্থিতিশীল নয়। তা ছাড়া, আপনি দুটি বাইট -পরিবর্তে <=>দুটি এবং একটি অ্যালিয়োমাস কলব্যাকের সাহায্যে সংরক্ষণ করতে পারেন usort।

— টাইটাস

@ টিটাস একটি বেনাম ফাংশনটি ফাংশনের মূল অংশের কারণে ব্যবহার করা যাবে না c($x,$y,$i)।

— ইসমাইল মিগুয়েল 14 ই

@ জার্গহেলসারমান চিন্তা করবেন না, আমরা সকলেই মূর্খ ভুল করি।

— ইসমাইল মিগুয়েল 14 ই

0

Clojure, 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 বাইট

ব্যাখ্যা

সিজেএম (12 বাইট)

ব্যবচ্ছেদ

জে, 6 বাইট

ব্যবহার

ব্যাখ্যা

জাভাস্ক্রিপ্ট (ES6), 55 বাইট

পাইথ, 5 4 বাইট

ব্যাখ্যা:

জাভাস্ক্রিপ্ট (ES6) 46

পিএইচপি, 212 170 বাইট

আর 40 বাইট

পার্ল 6 23 20 19 বাইট

218 বাইট রেকেট

পিএইচপি, 139 বাইট