Dato un elenco di indici e zero o più elenchi di numeri interi, genera gli elenchi di numeri interi, ordinati in ordine crescente, con la priorità chiave dal primo input.

Esempio

Lascia che siano i tasti immessi [1, 0, 2] e quelli immessi siano [[5, 3, 4], [6, 2, 1], [5, 2, 1]]. Tali elenchi devono essere ordinati in base al secondo elemento, quindi al primo elemento, quindi al terzo elemento, in ordine crescente:

1. Innanzitutto, ordiniamo in base ai valori all'indice 1 :[[6, 2, 1], [5, 2, 1], [5, 3, 4]]
2. Successivamente, interrompiamo qualsiasi legame dal primo ordinamento utilizzando i valori all'indice 0 :[[5, 2, 1], [6, 2, 1], [5, 3, 4]]
3. Infine, rompiamo tutti i legami rimanenti con i valori vlindici 2 (questo in realtà non cambia nulla, perché non sono rimasti legami).

Dettagli

• L'ordinamento è stabile: se due elementi si equivalgono rispetto alle chiavi di ordinamento indicate, devono rimanere nello stesso ordine relativo nell'output. Ad esempio, se Ae Bsono uguali sotto le chiavi di ordinamento fornite e l'input era [..., A, ..., B, ...], Adeve essere posizionato prima Bnell'output.
• Una chiave di ordinamento non farà mai riferimento a un elemento inesistente in uno degli elenchi di input.
• Nessuna chiave di ordinamento verrà ripetuta. Pertanto, [1, 2, 1]non è un elenco valido di chiavi di ordinamento.
• Tutti gli elementi a cui non fanno riferimento le chiavi di ordinamento non incidono sull'ordinamento. Solo l'ordine relativo iniziale e i valori degli elementi a cui fanno riferimento i tasti di ordinamento determinano l'ordine di output.
• È possibile scegliere se le chiavi di ordinamento sono a zero o a un indice.
• Non ci saranno valori negativi nelle chiavi di ordinamento. Se si sceglie di utilizzare l'indicizzazione singola, non ci saranno nemmeno zero nelle chiavi di ordinamento.
• I valori interi non supereranno l'intervallo rappresentabile in modo nativo della tua lingua. Se la lingua scelta è nativamente capace di numeri interi di precisione arbitraria (come Python), allora qualsiasi valore intero può essere presente nell'input, soggetto a vincoli di memoria.

Implementazione di riferimento (Python 2)

#!/usr/bin/env python

keys = input()
lists = input()

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

Provalo online

Casi test

Format: keys lists -> output. Tutte le chiavi di ordinamento sono indicizzate a zero.

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

Gelatina , 4 byte

⁴ị$Þ

Provalo online!

CJam , 13 byte

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

Un blocco senza nome che prevede l'elenco di elenchi e l'elenco di priorità in cima allo stack e li sostituisce con l'elenco ordinato di elenchi.

Provalo online! (Come una suite di test.)

Spiegazione

L'ordinamento con gli interruttori di cravatta può essere implementato ordinando ripetutamente l'intero elenco stabilmente passando dal tasto con la priorità più bassa al tasto con la priorità più alta.

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

Rubino, 35 byte

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

Guardalo su eval.in: https://eval.in/652574

Haskell, 38 byte

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

Esempio di utilizzo: ( sortOn.flip(map.(!!)) ) [2,1] [[9,2,-2,-10,-6], [3,-4,-2]]-> [[3,-4,-2],[9,2,-2,-10,-6]].

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

Mathematica, 22 19 byte

SortBy[Extract/@#]&

Utilizza indici basati su 1. Questa funzione senza nome è curry , quindi la convenzione di chiamata è:

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

Mathematica SortBypuò prendere un elenco di funzioni, nel qual caso le singole funzioni vengono utilizzate come successive interruzioni, quindi è proprio quello che vogliamo. Tutto quello che dobbiamo fare è creare un elenco di funzioni che restituiscono l'elemento elenco corrispondente. Questo può essere fatto con Extract. Extractè normalmente una funzione binaria Extract[list, index]che restituisce un elemento list. Tuttavia, se utilizzato in modo non comune, Extract[index]restituisce una funzione che recupera l'elemento indexda un elenco passato ad esso. In altre parole, il indexparametro di Extractpuò essere curry. ExtractNe facciamo uso mappando l'elenco degli indici che ci vengono forniti, che crea l'elenco delle funzioni di cui abbiamo bisogno.

Python, 50 byte

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

Questa è una versione banale dell'implementazione di riferimento. lè il parametro lists ed kè il parametro sort keys. lpuò essere qualsiasi iterabile, purché i suoi elementi siano sottoscrivibili da numeri interi (come elenchi, tuple o dadi int-keyed). kpuò essere qualsiasi iterabile.

Brachylog , 29 byte

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

Provalo online!

Spiegazione

Usiamo il fatto che o - Orderpuò essere usato con un predicato addizionale come input: ordiniamo le liste usando per ognuna [Keys, a list]la lista degli elementi di a listcui sono indicizzati a keynell'ordine in cui appaiono 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=}$\;}

Demo online . Si tratta di un blocco (funzione) anonimo che accetta gli argomenti nell'ordine indicato per i casi di test e lascia il valore ordinato nello stack. Si basa sul fatto che l'ordinamento incorporato $sia stabile, ma l'interprete ufficiale lo garantisce.

Dissezione

{          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

]/:{&>

Le chiavi sono indicizzate a zero. LHS è l'elenco di chiavi e RHS è un array di valori. Poiché J non supporta array sfilacciati, ogni array deve essere inscatolato.

uso

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

Spiegazione

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

Lo standard ECMAscript non garantisce che l'ordinamento sottostante sia stabile, quindi il seguente codice a 68 byte non assume tale presupposto:

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

@LDF

Provalo online: Dimostrazione o Test Suite

Grazie a @Maltysen per un byte.

Spiegazione:

@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

Sono stato davvero sorpreso che funzionasse. È una sintassi davvero strana.

JavaScript (ES6) 46

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

Ad ogni confronto durante l'ordinamento, scansiona gli indici chiave per trovare il giusto ordine

Test

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 non ha più un ordinamento stabile integrato ; scegliendo una versione precedente non è possibile eseguire un callback ricorsivo con le specifiche richieste. Ma non importa: l'uso dell'iteratore di callback ricorsivo costerebbe tonnellate; quindi non ho nemmeno verificato se potesse farlo.

Il circuito interno potrebbe essere sostituito con un altro foreach; che salverebbe alcuni byte sullo scambio. Ma senza un controllo per $b<$a(o $b<count($i)), ciò comporterà un ciclo infinito. E con quel controllo, i foreachcosti tanto quanto lo scambio vince.

Per prima cosa ho fatto il confronto in modo ricorsivo; ma l'iterazione consente di risparmiare tonnellate di byte:

abbattersi

// 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]),]}

Spiegazione:

L'elenco delle liste è rappresentato al meglio come data.frame in 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

Se l'elenco degli indici è il (l'indicizzazione è da 1):

il = list(1, 2, 3)

L'ordinamento può essere eseguito con il seguente codice:

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

Produzione:

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

Racchetta 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 = lista indice; ll = lista di liste; qsl = quicksort per lista di liste; h = head (primo elemento); t = tail (resto o elementi rimanenti); g = filtro modificabile 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:

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

Produzione:

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

usa il nuovo operatore navicella spaziale e 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);

Invece di $x[$k[$i]]<=>$y[$k[$i]]te puoi usare $x[$k[$i]]-$y[$k[$i]]in una versione PHP maggiore di 7 - 2 byte

versione con creare un proprio indice 197 byte come in una vera libreria

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

Ben sort-byè stabile e sa come ordinare i vettori e i vettori possono operare come funzioni. ([4 6 9 7] 2)è 9(indicizzazione basata su 0).