Debe tomar dos listas de enteros positivos como entrada, llamemos a estos n y m .

Puede suponer que:

• Todos los enteros en n son parte de m
• Todos los enteros en m son únicos
• Las listas no están vacías.

Reto: Devuelve los índices de dónde encuentras los valores en n , en m .

Eso puede ser confuso, pero creo que los casos de prueba aclararán la tarea. Los ejemplos están indexados en 1, puede elegir indexados en 0 si lo desea (especifique).

n = 5 3 4 1
m = 6 8 4 1 2 5 3 100
output: 6 7 3 4    // 5 is in the 6th position of m 
                   // 3 is in the 7th position of m
                   // 4 is in the 3rd position of m
                   // 1 is in the 4th position of m

n = 5 3 4 9 7 5 7
m = 3 4 5 7 9
output: 3 1 2 5 4 3 4

n = 1 2 3 4 5 6
m = 1 2 3 4 5 6
output: 1 2 3 4 5 6

n = 16 27 18 12 6 26 11 24 26 20 2 8 7 12 5 22 22 2 17 4
m = 15 18 11 16 14 20 37 38 6 36 8 32 21 2 31 22 33 4 1 35 3 25 9 30 26 39 5 23 29 10 13 12 7 19 24 17 34 27 40 28
output: 4 38 2 32 9 25 3 35 25 6 14 11 33 32 27 16 16 14 36 18

n = 54
m = 54
output: 1

Los ganadores serán las soluciones más cortas en cada idioma.

_{¡ Por cierto, esta es una muy buena meta-publicación!}

V , 26 bytes

jòdf kÄ/-
DÓÓ
ÒC1@"Gòdk

Pruébalo en línea!

Esta es una solución muy extraña y hacky, porque V tiene poco o ningún concepto de números. La entrada viene en este formato:

6 8 4 1 2 5 3 100 
5 3 4 1 

Con un espacio final en cada línea.

Hexdump:

00000000: 6af2 6466 206b c42f 122d 0a44 d3d3 0ad2  j.df k./.-.D....
00000010: 0143 311b 4022 47f2 646b                 .C1.@"G.dk

Explicación:

j                   " Move down one line (to N) (1)
 ò                  " Recursively:
  df                "   (d)elete until you (f)ind a space. This will be saved into
                    "   register '-' (2)
     k              "   Move up one line (to M)
      Ä             "   Duplicate line M (3)
       /<C-r>-      "   Move the cursor forward until the next occurence of register '-' 
                    "   (the number we deleted from N)
                    "   (4)
D                   "   Delete every character *after* the cursor (5)
 ÓÓ                 "   Remove everything on this line except for whitespace
Ò<C-a>              "   Replace every character on this line with `<C-a>`, which is the 
                    "   command for incrementing a number (6)
      C             "   Delete this line into register '"', and enter insert mode
       1<esc>       "   Enter a '1' and return to normal mode
             @"     "   Run register '"' as V code (7)
               G    "   Go to the last line (1)
                ò   " End recursion
                 dk " Delete the last two lines (m and n)

Si esto no lo aclara, aquí hay ejemplos del búfer durante las distintas etapas por las que pasa el ciclo:

Etapa 1 ( |es el cursor)

6 8 4 1 2 5 3 100
|5 3 4 1

Etapa 2:

6 8 4 1 2 5 3 100
|3 4 1

Etapa 3:

|6 8 4 1 2 5 3 100
6 8 4 1 2 5 3 100
3 4 1

Etapa 4:

6 8 4 1 2 |5 3 100
6 8 4 1 2 5 3 100
3 4 1

Etapa 5:

6 8 4 1 2 |
6 8 4 1 2 5 3 100
3 4 1

Etapa 6:

|<C-a><C-a><C-a><C-a><C-a>
6 8 4 1 2 5 3 100
3 4 1

Etapa 7:

|6
6 8 4 1 2 5 3 100
3 4 1

De vuelta a la etapa 1:

6
6 8 4 1 2 5 3 100
|3 4 1

Python 2 , 25 bytes

lambda a,b:map(a.index,b)

Pruébalo en línea!

Tenga en cuenta que esto usa indexación 0.

APL (Dyalog) , 1 byte

⍳

Pruébalo en línea!

Nota: la ⍳función no toma escalares como argumento izquierdo, por lo que para darle un argumento izquierdo como 54, debes convertirlo en una matriz usando ,así (,54).

Mathematica, 25 bytes

#&@@@PositionIndex@#/@#2&

Toma dos entradas my n, y devuelve los índices basados ​​en 1 de nin m.

Retina , 32 31 30 bytes

1 byte guardado gracias a Kritixi Lithos y 1 byte gracias a Martin Ender

(\d+)(?=.*¶(\d+ )*\1 )
$#2
G1`

Utiliza indexación 0. La entrada tiene un espacio final en cada línea.

Pruébalo en línea!

Explicación

(\d+)(?=.*¶(\d+ )*\1 )
$#2

Aquí reemplazamos cada número en la primera línea por el número de números antes del mismo número en la segunda línea.

G1`

Luego, eliminamos la segunda línea, dejando solo la nueva primera línea como salida.

Java , 104 81 bytes

1 byte gracias a Business cat.

void f(int[]a,int[]b){for(int i=0,j=0;i<b.length;)j=a[j++]==b[i]?0*(b[i++]=j):j;}

Pruébalo en línea!

C #, 32 bytes

(n,m)=>n.Select(i=>m.IndexOf(i))

Este es el código como una expresión lambda, por lo que debería ser válido.

La solución es con un índice basado en 0. Creo que es bastante sencillo cómo funciona: simplemente toma los elementos de n y selecciona los índices de los elementos en m.

Octava, 25 bytes

@(n,m)([x,~]=find(n==m'))

Pruébalo en línea!

Haskell , 32 bytes

a%b=[length$fst$span(/=x)b|x<-a]

Pruébalo en línea! Un índice.

Otros intentos

q(h:t)x|x==h=0|1>0=1+q t x;map.q
f b=map$length.fst.($b).span.(/=)
a%b=[until((==x).(b!!))(+1)0|x<-a]
a%b=[until(\y->x==b!!y)(+1)0|x<-a]
import Data.List;map.flip elemIndex

k, 1

Este es un operador incorporado ky utiliza indexación basada en cero.

?

Ejemplo:

k)6 8 4 1 2 5 3 100 ? 5 3 4 1
5 6 2 3

05AB1E , 5 bytes

v²yk,

Pruébalo en línea!

v     # For each value in n (call it y)
 ²    # Push m
  y   # Push y
   k, # Print the 0-indexed index of y in m

Jalea , 3 bytes

iЀ

Pruébalo en línea!

Especificaciones

• Entrada: dos argumentos, el primero es m y el segundo es n .
• Salida: una matriz

JavaScript (ES6), 28 bytes

Toma las matrices en sintaxis curry (n)(m). 0 indexado.

let f =

n=>m=>n.map(v=>m.indexOf(v))

console.log(JSON.stringify(f([5,3,4,1])([6,8,4,1,2,5,3,100])))
console.log(JSON.stringify(f([5,3,4,9,7,5,7])([3,4,5,7,9])))
console.log(JSON.stringify(f([1,2,3,4,5,6])([1,2,3,4,5,6])))
console.log(JSON.stringify(f([16,27,18,12,6,26,11,24,26,20,2,8,7,12,5,22,22,2,17,4])([15,18,11,16,14,20,37,38,6,36,8,32,21,2,31,22,33,4,1,35,3,25,9,30,26,39,5,23,29,10,13,12,7,19,24,17,34,27,40,28])))
console.log(JSON.stringify(f([54])([54])))

Perl 6 , 31 bytes

->\n,\m{n.map:{m.first($_,:k)}}

Intentalo

Expandido:

-> \n, \m {  # pointy block lambda

  n.map: {            # map over the values in ｢n｣
    m.first( $_, :k ) # return the key ｢:k｣ of the first occurrence
  }
}

0 indexado

Japt , 4 bytes

m!bV

¡Pruébelo en línea!

Explicación

No hay mucho que explicar aquí, pero muestra una característica interesante de Japt. Normalmente, pasaría una función a m, así:

mX{VbX}

Esto es básicamente U.map(X => V.indexOf(X))(el Ues implícito). Sin embargo, cuando solo está realizando una operación entre dos valores ( baquí, encendido Vy X), puede dar al operador y el otro valor y Japt hará una función a partir de él. Esto significa que mX{X+2}se puede jugar golf m+2.

Sin embargo, esto no funciona cuando los valores están en el orden incorrecto ( mbVsería la abreviatura de mX{XbV}). Para evitar esto, puede anteponer un signo de exclamación al operador, que le dice a Japt que cambie los operandos. Esto cuesta un byte adicional, pero sigue siendo un par de bytes más corto que la alternativa. Y ahora sabes un poco más sobre Japt.

MATL , 2 bytes

&m

Esto usa 1-indexación. Pruébalo en línea!

Explicación

La metafunción &indica que la siguiente función utilizará una especificación de entrada / salida secundaria (específica de la función). Para la función m( ismember), &especifica que se producirá su segunda salida. Contiene el índice de (la primera aparición de) cada entrada de la primera entrada en la segunda entrada.

Haskell, 34 bytes

n#m=[i|a<-n,(i,e)<-zip[1..]m,e==a]

Ejemplo de uso: [5,3,4,9,7,5,7] # [3,4,5,7,9]->[3,1,2,5,4,3,4]

El incorporado elemIndexestá dentro Data.Listy, por lo tanto, es más largo que la versión anterior. El bucle externo atraviesa ny el bucle interno atraviesa pares de (i,e)donde iestá el índice de ein m. Mantener idonde ees igual al elemento actual de n.

R, 20 5 bytes

1 indexado; matches la función incorporada que encuentra los índices en la segunda entrada de los elementos de la primera, es decir, match(n,m)da la respuesta deseada

match

¡Gracias a @flodel por señalar que devolver una función es perfectamente aceptable como respuesta!

Pruébalo en línea!

Pyth , 4 bytes

xLQE

Pruébalo en línea!

Tenga en cuenta que esto usa indexación 0.

J , 2 bytes

i.

Este no es un programa completo, sino una función incorporada.

Úselo como tal:

echo 6 8 4 1 2 5 3 100 i. 5 3 4 1

Pruébalo en línea!

Tenga en cuenta que esto usa indexación 0.

CJam , 4 bytes

{f#}

Bloque anónimo que espera argumentos en la pila y deja el resultado en la pila.

Utiliza indexación 0.

Pruébalo en línea!

Haskell, 43 bytes

a*b=[[fst x|x<-zip[0..]b,y==snd x]!!0|y<-a]

a*b=                                         -- define function * with 2 args
    [                                |y<-a]  -- for each elt in first arg
               zip[0..]b                     -- match elts in second arg w/ idxs
                                             -- [a,b,c] -> [[0,a],[1,b],[2,c]]
     [fst x|x<-                  ]           -- take first element in each pair
                        ,y==snd x            -- if the index matches
                                  !!0        -- first element (always only 1)

Clojure, 25 bytes

#(map(zipmap %2(range))%)

0 indexado.

Perl 5, 38 34 bytes

4 bytes guardados gracias a Dada

sub{map$x{$_}//($x{$_}=++$x)x0,@_}

1 indexado. Toma las listas de m y n como una única lista, como f(@m,@n). Esto x0es solo para evitar que la salida comience 1,2,3,4,5, etc.

PHP, 56 bytes

Versiones en linea

0 indexación

salida como cadena

<?foreach($_GET[0]as$v)echo" ".array_flip($_GET[1])[$v];

PHP, 65 bytes

Salida como matriz

<?foreach($_GET[0]as$v)$r[]=array_flip($_GET[1])[$v];print_r($r);

PHP, 78 bytes

solución alternativa con array_map

<?print_r(array_map(function($v){return array_flip($_GET[1])[$v];},$_GET[0]));

para matrices no únicas, reemplace con array_flip($_GET[1])[$v] array_search($v,$_GET[1])

Bash + coreutils, 51

for n in $1
do grep -wn $n <<<"$2"
done|cut -d: -f1

Pruébalo en línea .

Respuesta anterior:

s()(sort -$1k2)
nl|s|join -j2 - <(nl<<<"$1"|s)|s n|cut -d\  -f3

Pruébalo en línea .

Java 7, 80 bytes

void c(int[]a,java.util.List b){for(int i=0;i<a.length;a[i]=b.indexOf(a[i++]));}

0 indexado

Explicación:

void c(int[]a,java.util.List b){  // Method with integer-array and List parameters
  for(int i=0;i<a.length;         //  Loop over the integer-array
    a[i]=b.indexOf(a[i++])        //   And change every value to the index of the List
  );                              //  End of loop (no body)
}                                 // End of method

Código de prueba:

Pruébalo aquí

import java.util.Arrays;
class M{
  static void c(int[]a,java.util.List b){for(int i=0;i<a.length;a[i]=b.indexOf(a[i++]));}

  public static void main(String[] a){
    int[] x = new int[]{ 5, 3, 4, 1 };
    c(x, Arrays.asList(6, 8, 4, 1, 2, 5, 3, 100));
    System.out.println(Arrays.toString(x));

    x = new int[]{ 5, 3, 4, 9, 7, 5, 7 };
    c(x, Arrays.asList(3, 4, 5, 7, 9));
    System.out.println(Arrays.toString(x));

    x = new int[]{ 1, 2, 3, 4, 5, 6 };
    c(x, Arrays.asList(1, 2, 3, 4, 5, 6));
    System.out.println(Arrays.toString(x));


    x = new int[]{ 16, 27, 18, 12, 6, 26, 11, 24, 26, 20, 2, 8, 7, 12, 5, 22, 22, 2, 17, 4 };
    c(x, Arrays.asList(15, 18, 11, 16, 14, 20, 37, 38, 6, 36, 8, 32, 21, 2, 31, 22, 33, 4, 1, 35, 3, 25, 9, 30, 26, 39, 5, 23, 29, 10, 13, 12, 7, 19, 24, 17, 34, 27, 40, 28));
    System.out.println(Arrays.toString(x));


    x = new int[]{ 54 };
    c(x, Arrays.asList(54));
    System.out.println(Arrays.toString(x));
  }
}

Salida:

[5, 6, 2, 3]
[2, 0, 1, 4, 3, 2, 3]
[0, 1, 2, 3, 4, 5]
[3, 37, 1, 31, 8, 24, 2, 34, 24, 5, 13, 10, 32, 31, 26, 15, 15, 13, 35, 17]
[0]