Imitar un pedido

24

Dadas dos listas de números, una fuente y un patrón , reordene la fuente para que coincida con el orden relativo del patrón. Cualquiera de las dos entradas de la fuente reordenada debe compararse de la misma manera que las entradas en esas mismas posiciones del patrón.

Por ejemplo, la entrada

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

debería producir el resultado

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

Comparando la primera y la última posición, el resultado tiene 11<13, que coincide 7<12en el patrón.

Entrada: Dos listas de enteros no vacías de igual longitud. Cada lista no tendrá repeticiones. Depende de usted si la fuente o el patrón se dan primero.

Salida: una lista que reorganiza los números de origen para que tengan el mismo orden relativo que los números de patrón.

Tabla de clasificación:

Mostrar fragmento de código

code-golf sorting permutations xnor
fuente
¿Debe ser una función / programa, o es suficiente una expresión / fragmento?
Adám
@NBZ A menos que el desafío lo anule, el valor predeterminado es que solo se permiten funciones y programas . Sin embargo, se permiten funciones sin nombre .
Martin Ender

Respuestas:

10

CJam, 12 10 bytes

{_$f#\$f=}

Esta es una función anónima, que toma s pla pila y deja el resultado en la pila. Demostración en línea

Gracias a Martin Büttner por 2 bytes.

Disección

{         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
fuente
{_$@$er}es dos bytes más corto.
Dennis
@ Dennis, eso es lo suficientemente diferente como para ser una respuesta separada
Peter Taylor, el
Si crees que sí, lo publicaré como respuesta.
Dennis
10

J, 9 bytes

/:^:2~/:~

Este es un verbo diádico que toma p y s como argumentos izquierdo y derecho. Pruébelo en línea con J.js .

Prueba de funcionamiento

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

Como funciona esto

Digamos que definimos asignadas las entradas izquierda y derecha del ejemplo a través de

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

Luego:

  • El tren /:^:2~/:~es un gancho de los verbos /:^:2~y /:~, por lo tanto, llama

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

    ejecuta

    p /:^:2~ /:~ s

  • El adverbio ~en /:~es reflexivo , ya que /:se usa monádicamente. Por lo tanto, llamando

    /:~ s

    ejecuta

    s /: s

  • El adverbio ~en /:^:2~es pasivo , ya que el verbo /:^:2se usa de forma diádica. Por lo tanto, llamando

    p /:^:2~ y

    ejecuta

    y /:^:2 p

  • El adverbio ^:es poder . Por lo tanto, llamando

    y /:^:2 p

    ejecuta

    y /: y /: p

Poniendo todo junto, llamando

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

ejecuta

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

Cómo que las obras

Dyadic /:se gradúa usando , es decir, x /:ydevuelve los elementos de x , ordenados según los valores correspondientes de y.

  • s /: ssimplemente ordena los elementos del s .

  • (s /: s) /: pordena los elementos (ordenados) de s de acuerdo con los valores correspondientes de p .

  • La calificación dos veces esencialmente calcula los ordinales de su argumento correcto.

    Por lo tanto, (s /: s) /: (s /: s) /: pordena los elementos (ordenados) de s , imitando el orden de los elementos de p .

Dennis
fuente
9

Mathematica, 32 27 bytes

Sort@#~Permute~Ordering@#2&

Ejemplo de uso:

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} *)

Intento previo:

Sort[#][[Ordering@Ordering@#2]]&
Campeonato 2012
fuente
@DavidCarraher Fixed!
2012 Arcampion
1
¡Descubrí esta misma solución 4 minutos después de ti! Puede guardar un par de bytes:o = Ordering; (Sort@#)[[o@o@#2]] &
DavidC
Nueva solución encantadora a través de Permute! Uso muy útil de permutaciones.
DavidC
7

J, 17 bytes

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

Esto se evalúa como un verbo diádico (que significa binario). Se puede evocar de la siguiente manera:

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

Explicación

Puede que esta no sea la solución J más corta posible, pero es un enfoque novedoso.

                   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
fuente
6

Pyth, 10 bytes

@LSvzxLSQQ

Pruébelo en línea: demostración

Explicación

@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
fuente
XQSQSvzes tres bytes más corto.
Dennis
@Dennis Dang. ¿Por qué no pensé en esto? ¿Quieres publicarlo?
Jakube
1
Si lo considera lo suficientemente diferente de su enfoque, seguro.
Dennis
6

Pyth, 7 bytes

XQSQSvz

Este es un programa completo que espera representaciones de cadena de s y p en dos líneas. Pruébalo en línea.

Cómo funciona

           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
fuente
5

Pitón 2, 51

lambda s,p,a=sorted:[a(s)[a(p).index(x)]for x in p]
Feersum
fuente
Estoy confundido: ¿por qué hay tres parámetros?
Peter Taylor
@PeterTaylor El tercer parámetro tiene un valor predeterminado, por lo que se puede
invocar
@PeterTaylor Agregar una línea separada a=sortedtendría el mismo efecto.
xnor
Aaaaaah! Estaba confundiendo, y pensé que el cuerpo comenzó en el =.
Peter Taylor
5

Mathematica 56 43 30 29 bytes

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

Ordering@#2Devuelve el orden de los números en el patrón. Ordering@Ordering@#2da las posiciones que deben ocupar los elementos ordenados en la fuente.

Sort[#][[o@o@#2]]& devuelve la fuente en las posiciones requeridas, es decir, aquellas que tienen el mismo orden relativo que la lista de patrones.

Pruebas

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
fuente
5

CJam, 8 bytes

{_$@$er}

Esta es una función anónima que espera s y p (más arriba) en la pila y empuja los s reordenados a cambio. Pruébelo en línea en el intérprete de CJam .

Cómo funciona

_      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
fuente
4

J, 13 bytes

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

Todavía tengo problemas para comprender la composición verbal de J, así que me siento como algunos de ellos @y []podría ser innecesario. Si algún usuario J más experimentado pudiera decirme si esto se puede comprimir, sería genial. :)

El verbo se puede usar de la siguiente manera:

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

Explicación

/:@/:@[{/:~@] 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
fuente
Puede usar dyadic /:para deshacerse de {y @, por 11 bytes:/:~@]/:/:@[
Dennis
@Dennis Gracias, mientras tanto, Zgarb ha encontrado otra solución de 11 bytes que solo necesita dos /:, pero todavía no he podido actualizar la respuesta ( ({~/:)&/:{[).
Martin Ender
4

APL, 17 12 bytes

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

Gracias a @Dennis, esto ahora es muy elegante.

Aquí hay una buena solución de 14 bytes que no utiliza doble indexación:

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

Desafortunadamente, no podemos indexar matrices desde trenes en APL.

lirtosiast
fuente
4

Pitón 2, 48

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

Una gran cantidad de funciones. Esto utiliza el enfoque de traducción de elementos de muchas otras respuestas usando un diccionario.

La entrada destacada *lespera los patrones y la fuente en ese orden, y los convierte en una lista l.

La asignación sortedclasifica ambas listas y dict(zip(_))convierte un par de listas en un diccionario con claves de la primera lista que coinciden con los valores de la segunda, en orden ascendente. Por lo tanto, el resultado es que el ielemento más grande del patrón coincide con eli elemento más grande de la fuente.

Finalmente, transformamos el patrón ( l[0]) a través de este diccionario mapeando su .getmétodo.

xnor
fuente
3

Bash + coreutils, 55

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

La entrada se toma como dos nombres de archivo, para la fuente y el patrón respectivamente:

$ ./imitord.sh source.txt pattern.txt 
11  
-5  
4   
-6  
9   
0   
13  
$
Trauma digital
fuente
3

R, 38 bytes

function(s,p)sort(s)[match(p,sort(p))]
flodel
fuente
Este es un buen enfoque. No hubiera pensado usarlo match.
Alex A.
3

Ruby, 51 bytes

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

Haskell, 65 bytes

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

Ejemplo de uso: [-5,9,4,13,11,-6,0] # [7,-4,1,-8,4,-3,12]-> [11,-5,4,-6,9,0,13].

Cómo funciona:

           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
nimi
fuente
2

R, 37 bytes

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

TeaScript, 15 bytes

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

Esto toma la entrada como una matriz. El intérprete está actualmente fuera de servicio porque estoy colocando el nuevo y elegante intérprete

Explicación

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
fuente
O no estoy entendiendo mal la explicación, o esto no funciona ... Lo codifiqué en Pip de acuerdo con lo que creo que hace, y obtuve 13 9 -6 4 11 -5 0la entrada de muestra. ??
DLosc
2

Jelly , 6 bytes, desafío de postdates de idioma

Œ¿œ?Ṣ}

Pruébalo en línea!

Esto toma el patrón, seguido de la fuente, como dos argumentos separados.

Explicación

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

fuente
1

Haskell, 56 bytes

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

Define una función binaria %. Cada entrada pse transforma en la entrada de scon el mismo orden estadístico, es decir, rango relativo en su lista. La estadística de orden de xin pse encuentra contando los elementos más pequeños ( sort p!!xproduce una molestia Maybe). El resultado se indexa en sort s.

Una zip/lookupsolución tiene la misma longitud, excepto que da Justnúmeros.

import Data.List
p%s=[lookup x$zip(sort p)(sort s)|x<-p]
xnor
fuente