Imitare un ordine

24

Dati due elenchi di numeri, una sorgente e un modello , riordinare la sorgente in modo che corrisponda all'ordinamento relativo del modello. Ogni due voci della fonte riordinata dovrebbero comparare allo stesso modo delle voci nelle stesse posizioni del modello.

Ad esempio, l'input

s = [-5, 9, 4, 13, 11, -6, 0]
p = [7, -4, 1, -8, 4, -3, 12]

dovrebbe produrre il risultato

    [11, -5, 4, -6, 9, 0, 13]

Confrontando la prima e l'ultima posizione, il risultato ha 11<13, che corrisponde 7<12allo schema.

Input: due elenchi di numeri interi non vuoti di uguale lunghezza. Ogni elenco non avrà ripetizioni. Dipende da te se la fonte o il modello sono dati per primi.

Output: un elenco che riorganizza i numeri sorgente per avere lo stesso ordinamento relativo dei numeri di modello.

Classifica:

Mostra snippet di codice

code-golf  sorting  permutations 
— XNOR
fonte
Deve essere una funzione / programma o un'espressione / frammento è sufficiente?
— Adám,
— Martin Ender,

Risposte:

10

CJam, 12 10 byte

{_$f#\$f=}

Questa è una funzione anonima, che accetta s plo stack e lascia il risultato nello stack. Demo online

Grazie a Martin Büttner per 2 byte.

Dissezione

{         e# Define an anonymous function
  _$f#    e# Use a copy of the pattern to map each element to its sort index
  \$      e# Sort the source
  f=      e# Map each sort index to the corresponding source element
}
— Peter Taylor
fonte
{_$@$er}è due byte più breve.
— Dennis,
@Dennis, è abbastanza diverso da essere una risposta separata
— Peter Taylor,
Se la pensi così, la posterò come risposta.
— Dennis,
10

J, 9 byte

/:^:2~/:~

Questo è un verbo diadico che accetta p e s come argomenti sinistro e destro. Provalo in rete con J.js .

Prova

   7 _4 1 _8 4 _3 12 (/:^:2~/:~) _5 9 4 13 11 _6 0
11 _5 4 _6 9 0 13

Come funziona

Supponiamo che abbiamo definito assegnato l'ingresso sinistro e destro dall'esempio via

p =: 7 _4 1 _8 4 _3 12
s =: _5 9 4 13 11 _6 0

Poi:

  • Il treno /:^:2~/:~è un gancio dei verbi /:^:2~e /:~, quindi, chiama

    p (/:^:2~/:~) s

    esegue

    p /:^:2~ /:~ s

  • L'avverbio ~in /:~è riflessivo , poiché /:è usato monadicamente. Quindi, chiamando

    /:~ s

    esegue

    s /: s

  • L'avverbio ~in /:^:2~è passivo , poiché il verbo /:^:2viene usato in modo diaadico. Quindi, chiamando

    p /:^:2~ y

    esegue

    y /:^:2 p

  • L'avverbio ^:è potere . Quindi, chiamando

    y /:^:2 p

    esegue

    y /: y /: p

Mettendo tutto insieme, chiamando

p (/:^:2~/:~) s

esegue

(s /: s) /: (s /: s) /: p

Come che funziona

Dyadic /:viene valutato in base al grado usando , ad esempio, x /:yrestituisce gli elementi di x , ordinati in base ai corrispondenti valori di y.

  • s /: sordina semplicemente gli elementi di s .

  • (s /: s) /: pordina gli elementi (ordinati) di s in base ai corrispondenti valori di p .

  • Classificare due volte essenzialmente calcola gli ordinali della sua giusta argomentazione.

    Quindi, (s /: s) /: (s /: s) /: pordina gli elementi (ordinati) di s , imitando l'ordine degli elementi di p .

— Dennis
fonte
9

Mathematica, 32 27 byte

Sort@#~Permute~Ordering@#2&

Esempio di utilizzo:

Sort@#~Permute~Ordering@#2 &[{-5, 9, 4, 13, 11, -6, 0}, {7, -4, 1, -8, 4, -3, 12}]
(* {11, -5, 4, -6, 9, 0, 13} *)

Tentativo precedente:

Sort[#][[Ordering@Ordering@#2]]&
— 2012rcampion
fonte
@DavidCarraher Fixed!
— 2012campo
1
+1 Ho scoperto questa stessa soluzione 4 minuti dopo di te! È possibile salvare un paio di byte:o = Ordering; (Sort@#)[[o@o@#2]] &
— DavidC
Bella nuova soluzione via Permute! Uso molto utile di permutazioni.
— DavidC,
7

J, 17 byte

(A.^:_1/:~)~A.@/:

Questo valuta un verbo diadico (che significa binario). Può essere evocato come segue:

  _5 9 4 13 11 _6 0 ((A.^:_1/:~)~A.@/:) 7 _4 1 _8 4 _3 12
11 _5 4 _6 9 0 13

Spiegazione

Questa potrebbe non essere la soluzione J più breve possibile, ma è un nuovo approccio.

                   Left input is x, right input is y.
            A.@/:  The index of the permutation P that sorts y. /: gives the
                   permutation itself, and A. gives its index in the sorted
                   list of all its permutations.
       /:~         x sorted in ascending order. We are applying the x-sorting
                   permutation to x itself.
(A.^:_1   )~       The inverse of the permutation P applied to the sorted
                   version of x. Since P maps y to its sorted version, its
                   inverse maps the sorted version to y, and thus sorted x to
                   the correct output.
— Zgarb
fonte
6

Pyth, 10 byte

@LSvzxLSQQ

Provalo online: dimostrazione

Spiegazione

@LSvzxLSQQ implicit: z = first input line as string
                     Q = second input line evaluated
       SQ  sorted(Q)
     xLSQQ find the index for each element of Q in sorted(Q)
  Svz      sorted(evaluated z)
@LSvz      take the element in ^ for each index
— Jakube
fonte
XQSQSvzè di tre byte più breve.
— Dennis,
@Dennis Dang. Perché non l'ho pensato? Vuoi pubblicarlo?
— Jakube,
1
Se lo consideri sufficientemente diverso dal tuo approccio, certo.
— Dennis,
6

Pyth, 7 byte

XQSQSvz

Questo è un programma completo che prevede rappresentazioni di stringhe di s e p su due righe. Provalo online.

Come funziona

           Store the first line of input (rep. of s) in z.
           Evaluate the second line of input and store the result (p) in Q.
  SQ       Sort the elements of p.
    Svz    Evaluate the repr. of s and sort its elements.
XQ         Perform transliteration on p.
           This replaces the lowest element of p with the lowest element of s, etc.
— Dennis
fonte
5

Python 2, 51

lambda s,p,a=sorted:[a(s)[a(p).index(x)]for x in p]
— feersum
fonte
Sono confuso: perché ci sono tre parametri?
— Peter Taylor,
@PeterTaylor Il terzo parametro ha un valore predefinito, quindi può essere chiamato con solo 2.
— feersum
@PeterTaylor L'aggiunta di una riga separata a=sortedavrebbe lo stesso effetto.
— xnor
Aaaaaah! Stavo travisando, e ho pensato che il corpo ha iniziato a =.
— Peter Taylor,
5

Mathematica 56 43 30 29 byte

o=Ordering;Sort[#][[o@o@#2]]&

Ordering@#2restituisce l'ordine dei numeri nel modello. Ordering@Ordering@#2indica le posizioni che gli elementi ordinati nella sorgente dovrebbero occupare.

Sort[#][[o@o@#2]]& restituisce l'origine nelle posizioni richieste, vale a dire quelle che hanno lo stesso ordinamento relativo dell'elenco dei modelli.

analisi

o=Ordering;Sort[#][[o@o@#2]]&[{-5, 9, 4, 13, 11, -6, 0}, {7, -4, 1, -8, 4, -3, 12}]

{11, -5, 4, -6, 9, 0, 13}

— DavidC
fonte
5

CJam, 8 byte

{_$@$er}

Si tratta di una funzione anonima che prevede s e p (più in alto) nello stack e invia in cambio le s riordinate . Provalo online nell'interprete CJam .

Come funziona

_      e# Push a copy of p.
 $     e# Sort it.
  @    e# Rotate s on top of p and the sorted p.
   $   e# Sort s.
    er e# Perform transliteration.
       e# This replaces the lowest element of p with the lowest element of s, etc.
— Dennis
fonte
4

J, 13 byte

/:@/:@[{/:~@]

Ho ancora problemi a avvolgere la testa attorno alla composizione del verbo di J, quindi mi sento come alcuni di questi @e []potrebbe non essere necessario. Se un utente J più esperto potesse farmi sapere se questo può essere compresso, sarebbe fantastico. :)

Il verbo può essere usato come segue:

   7 _4 1 _8 4 _3 12 (/:@/:@[{/:~@]) _5 9 4 13 11 _6 0
11 _5 4 _6 9 0 13

Spiegazione

/:@/:@[{/:~@] NB. Left input is the pattern, right input is the source.
        /:~@] NB. Sort the source.
/:@/:@[       NB. Compute the ordering of the ordering of the pattern.
       {      NB. Use those as indices into the sorted source.
— Martin Ender
fonte
È possibile utilizzare diadico /:per sbarazzarsi di {e un @, per 11 byte:/:~@]/:/:@[
— Dennis
@Dennis Grazie, Zgarb ha trovato nel frattempo un'altra soluzione a 11 byte che ne richiede solo due /:, ma non ho ancora avuto modo di aggiornare la risposta ( ({~/:)&/:{[).
— Martin Ender,
4

APL, 17 12 byte

{⍺[⍋⍺][⍋⍋⍵]}

Grazie a @Dennis, questo è ora molto elegante.

Ecco una bella soluzione a 14 byte che non utilizza la doppia indicizzazione:

{⍺[(⍋⍋⍺)⍳⍋⍋⍵]}

Sfortunatamente, non possiamo indicizzare le matrici all'interno dei treni in APL.

— lirtosiast
fonte
4

Python 2, 48

lambda*l:map(dict(zip(*map(sorted,l))).get,l[0])

Un grande globo di funzioni. Questo utilizza l'approccio di traduzione degli elementi di molte altre risposte usando un dizionario.

L'ingresso stellato *lprevede i motivi e l'origine in quell'ordine e li trasforma in un elenco l.

La mappatura sortedordina entrambi gli elenchi e dict(zip(_))trasforma una coppia di elenchi in un dizionario con le chiavi del primo elenco abbinate ai valori nel secondo, in ordine crescente. Quindi, il risultato è che quel iterzo elemento più grande del pattern è abbinato al iterzo elemento più grande della sorgente.

Infine, trasformiamo il pattern ( l[0]) tramite questo dizionario mappandone il .getmetodo.

— XNOR
fonte
3

Bash + coreutils, 55

nl $2|sort -nk2|paste <(sort -n $1) -|sort -nk2|cut -f1

L'input viene preso come due nomi di file, rispettivamente per sorgente e modello:

$ ./imitord.sh source.txt pattern.txt 
11  
-5  
4   
-6  
9   
0   
13  
$
— Trauma digitale
fonte
3

R, 38 byte

function(s,p)sort(s)[match(p,sort(p))]
— flodel
fonte
Questo è un approccio simpatico. Non avrei pensato di usare match.
— Alex A.
3

Rubino, 51 byte

->s,p{s.map{|x|s.sort[p.sort.index(p[s.index x])]}}
— daniero
fonte
2

Haskell, 65 byte

import Data.List
s#p=[sort s!!i|b<-p,(i,e)<-zip[0..]$sort p,b==e]

Esempio di utilizzo: [-5,9,4,13,11,-6,0] # [7,-4,1,-8,4,-3,12] -> [11,-5,4,-6,9,0,13].

Come funziona:

           b<-p                              -- for every b in p
               ,(i,e)<-zip[0..]$sort p       -- walk through the sorted list of p 
                                             -- paired with it's index ->
                                             -- (index,element) or (i,e)
                                      ,b==e  -- for those cases where b equals e
 sort s!!i                                   -- take the i-th element from the
                                             -- sorted list s
— Nome del modello
fonte
2

R, 37 byte

function(s,p,o=order)s[o(s)][o(o(p))]
— aPaulT
fonte
2

TeaScript, 15 byte

ys¡m™x[yi(l)])

Questo richiede input come un array. L'interprete è attualmente inattivo perché sto mettendo su il nuovo interprete di fantasia

Spiegazione

y      // Second input
 s¡    // Sort it = s()
m™     // Map over it = m(#
  x[      // Num in first input at index...
    yi(l) // Current char's index in y
  ]
)
— Downgoat
fonte
O sto male fraintendendo la spiegazione, o questo non funziona ... L'ho codificato in Pip secondo quello che penso che funzioni, e ho ottenuto 13 9 -6 4 11 -5 0l'input del campione. ??
— DLosc,
2

Gelatina , 6 byte, sfida postdatati in lingua

Œ¿œ?Ṣ}

Provalo online!

Questo prende il modello, seguito dalla fonte, come due argomenti separati.

Spiegazione

Œ¿œ?Ṣ}
Œ¿      Generate an integer that describes the order of {the first input}
  œ?    Use that integer to reorder
    Ṣ}  the sorted version of the second {input}
1

Haskell, 56 byte

import Data.List
p%s=[sort s!!(length$filter(<x)p)|x<-p]

Definisce una funzione binaria %. Ogni voce in pviene trasformata in una voce scon lo stesso ordine statistico, ovvero il rango relativo nel suo elenco. La statistica dell'ordine di xin psi trova contando gli elementi più piccoli di esso ( sort p!!xproduce un fastidioso Maybe). Il risultato è indicizzato insort s .

Una zip/lookupsoluzione ha la stessa lunghezza, tranne per il fatto che fornisce Justnumeri.

import Data.List
p%s=[lookup x$zip(sort p)(sort s)|x<-p]
— XNOR
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.