Bir indeks listesi ve sıfır veya daha fazla tamsayı listesi verildiğinde, ilk girişin anahtar önceliği ile birlikte artan sırada sıralanan tamsayıların listesini çıkarın.

Misal

Girilen tuşlar [1, 0, 2]ve girilen listeler olsun [[5, 3, 4], [6, 2, 1], [5, 2, 1]]. Bu listelerin artan öğelerine göre ikinci öğelerine, ardından ilk öğeye, ardından üçüncü öğeye göre sıralanması gerekir:

1. İlk olarak, index'teki değerlere göre sıralarız 1:[[6, 2, 1], [5, 2, 1], [5, 3, 4]]
2. Ardından, dizindeki değerleri kullanarak ilk sıralamadaki bağları koparırız 0:[[5, 2, 1], [6, 2, 1], [5, 3, 4]]
3. Son olarak, indeksteki vlularla kalan bağları koparırız 2(bu aslında hiçbir şeyi değiştirmez, çünkü kalan bağ yoktur).

ayrıntılar

• Sıralama sabittir: eğer iki öğe verilen sıralama tuşlarına göre eşitse, çıktıda aynı göreli sırada kalmaları gerekir. Örneğin, Ave Bbelirli bir sıralama anahtarları altında eşittir ve giriş olarak [..., A, ..., B, ...],A önce yerleştirilmelidir Bçıktı.
• Sıralama anahtarı, giriş listelerinden birinde hiçbir zaman var olmayan bir öğeye başvurmaz.
• Hiçbir sıralama anahtarı tekrarlanmayacaktır. Böylece,[1, 2, 1] sıralama anahtarlarının geçerli bir listesi değildir.
• Sıralama anahtarları tarafından başvurulan öğeler, sıralama düzenini dikkate almaz. Çıktı sırasını yalnızca ilk göreli sıra ve sıralama tuşları tarafından başvurulan öğelerin değerleri belirler.
• Sıralama anahtarlarının sıfır veya tek dizinli olup olmadığını seçebilirsiniz.
• Sıralama tuşlarında negatif değer olmayacaktır. Tek endekslemeyi kullanmayı seçerseniz, sıralama tuşlarında da sıfır olmaz.
• Tam sayı değerleri, dilinizin yerel olarak temsil edilebilir aralığını aşmayacaktır. Seçtiğiniz dil yerel olarak rasgele kesinlikli tamsayıları (Python gibi) yapabiliyorsa, bellek sınırlamalarına tabi olarak girişte herhangi bir tamsayı değeri bulunabilir.

Referans Uygulaması (Python 2)

#!/usr/bin/env python

keys = input()
lists = input()

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

Çevrimiçi deneyin

Test Durumları

Biçim: keys lists -> output. Tüm sıralama anahtarları sıfır dizinlidir.

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

Jöle , 4 bayt

⁴ị$Þ

Çevrimiçi deneyin!

CJam , 13 bayt

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

Listelerin listesini ve yığının üstündeki öncelikler listesini bekleyen ve bunları sıralı listeler listesiyle değiştiren adsız bir blok.

Çevrimiçi deneyin! (Test paketi olarak.)

açıklama

Bağlantı kesicilerle sıralama, en düşük öncelikli anahtardan en yüksek öncelikli anahtara giderek tüm listeyi sürekli olarak sıralayarak yürütülebilir.

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

Yakut, 35 bayt

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

Eval.in'de bakınız: https://eval.in/652574

Haskell, 38 bayt

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

Kullanım örneği: ( sortOn.flip(map.(!!)) ) [2,1] [[9,2,-2,-10,-6], [3,-4,-2]]->[[3,-4,-2],[9,2,-2,-10,-6]] .

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

Mathematica, 22 19 bayt

SortBy[Extract/@#]&

1 tabanlı indeksler kullanır. Bu adlandırılmamış işlev curried , bu nedenle çağrı kuralı:

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

Mathematica'nın SortByişlevlerin bir listesini alabilir, bu durumda bireysel işlevler ardışık bağlantı kesiciler olarak kullanılır, bu yüzden istediğimiz şey budur. Tek yapmamız gereken, karşılık gelen liste elemanını döndüren fonksiyonların bir listesini oluşturmaktır. Bu ile yapılabilir Extract. Extractnormalde bir Extract[list, index]liste öğesi döndüren ikili bir fonksiyondur . Ancak alışılmadık şekilde kullanılırsa Extract[index], öğeyi indexkendisine iletilen listeden alan bir işlev döndürür . Başka bir deyişle, indexparametresi Extractkörüklenebilir. Bunu Extract, ihtiyacımız olan fonksiyonların listesini oluşturan, bize verilen endekslerin listesini eşleştirerek kullanırız .

Python, 50 bayt

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

Bu, referans uygulamasının önemsiz golfçü bir versiyonudur. llist parametresidir ve ksort keys parametresidir. löğeleri tamsayılara (listeler, tuples veya int-keyed dicts gibi) abone olduğu sürece herhangi bir yinelenebilir olabilir. kherhangi bir yinelenebilir olabilir.

Brachylog , 29 bayt

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

Çevrimiçi deneyin!

açıklama

o - OrderEk bir yüklemle kullanılabilecek olguyu girdi olarak kullanırız: listeleri dizinde bulunan [Keys, a list]öğelerin her listesi için göründükleri sırayla kullanarak sıralarız .a lista 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 bayt)

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

Çevrimiçi demo . Bu, değişkenleri test senaryoları için verilen sırayla alan ve sıralanan değeri yığına bırakan anonim bir bloktur (işlev). Yerleşik türün $kararlı olmasına dayanır , ancak resmi tercüman bunu garanti eder.

teşrih

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

]/:{&>

Anahtarlar sıfır indekslidir. LHS, anahtarların listesidir ve RHS, bir değerler dizisidir. J düzensiz dizileri desteklemediğinden, her dizi kutulanmış olmalıdır.

kullanım

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

açıklama

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

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

ECMAscript standardı, temeldeki sıralamanın kararlı olduğunu garanti etmez, bu nedenle aşağıdaki 68 baytlık kod bu varsayımı yapmaz:

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

@LDF

Çevrimiçi deneyin: Gösteri veya Test Paketi

@Maltysen'e bir bayt için teşekkürler.

Açıklama:

@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

Bunun işe yaradığına gerçekten şaşırdım. Gerçekten tuhaf bir sözdizimi.

JavaScript (ES6) 46

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

Sıralama sırasında her karşılaştırmada, doğru siparişi bulmak için anahtar endeksleri tarayın

Ölçek

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 bayt

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'nin artık yerleşik bir türü yoktur ; daha eski bir sürüm seçerken, gerekli özelliklere sahip bir özyinelemeli geri arama yapmanın bir yolu yoktur. Ama boşver: özyinelemeli geri arama yineleyicisini kullanma tonlarca mal olacak; bu yüzden bunu yapabileceğini bile kontrol etmedim.

İç halka bir başkasıyla değiştirilebilir foreach; Bu, takasta bazı baytlar kurtarabilir. Ancak $b<$a(veya $b<count($i)) için bir kontrol yapılmazsa , bu sonsuz bir döngüye neden olur. Ve bu kontrolle,foreach takas ücreti de kazanıyor.

İlk olarak karşılaştırmayı tekrar tekrar yaptım; ancak yineleme tonlarca bayt tasarrufu sağlar:

Yıkmak

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

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

Açıklama:

Liste listesi en iyi R'de bir veri çerçevesi olarak temsil edilir:

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

Dizin listesi il ise (dizinleme 1'den başlar):

il = list(1, 2, 3)

Sıralama aşağıdaki kod ile yapılabilir:

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

Çıktı:

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 bayt

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

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

Raket 218 bayt

(λ(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 = dizin listesi; ll = liste listesi; qsl = liste listesi için hızlı sıralama; h = kafa (ilk öğe); t = kuyruk (kalan veya kalan öğeler); g = değiştirilebilir filtre 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))

Test yapmak:

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

Çıktı:

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

yeni uzay gemisi operatörünü kullan ve 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);

Bunun yerine $x[$k[$i]]<=>$y[$k[$i]]kullanabilirsiniz$x[$k[$i]]-$y[$k[$i]] bir PHP Sürümü altında 7 - 2 Bayt daha büyük

sürümü ile kendi dizin oluşturmak 197 bayt gibi gerçek bir kütüphane

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

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

Güzelce sort-bykararlıdır ve vektörlerin nasıl sıralanacağını bilir ve vektörler fonksiyon olarak çalışabilir. ([4 6 9 7] 2)olduğu 9(0-esaslı indeks).