Vous devez prendre deux listes d'entiers positifs en entrée, appelons-les n et m .

Vous pouvez supposer que:

• Tous les entiers de n font partie de m
• Tous les entiers de m sont uniques
• Les listes ne sont pas vides

Défi: Renvoyez les indices où vous trouvez les valeurs en n , en m .

Cela peut prêter à confusion, mais je pense que les cas de test rendront la tâche assez claire. Les exemples sont indexés 1, vous pouvez choisir l'index 0 si vous le souhaitez (veuillez préciser).

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

Les gagnants seront les solutions les plus courtes dans chaque langue.

_{C'est un très joli méta-post au fait!}

V , 26 octets

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

Essayez-le en ligne!

C'est une solution très étrange et hacky, car V a peu ou pas de concept de nombres. L'entrée vient dans ce format:

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

Avec un espace de fin sur chaque ligne.

Hexdump:

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

Explication:

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 cela ne le rend pas plus clair, voici des exemples de tampon lors des différentes étapes de la boucle:

Étape 1 ( |est le curseur)

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

Étape 2:

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

Étape 3:

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

Étape 4:

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

Étape 5:

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

Étape 6:

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

Étape 7:

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

Retour à l'étape 1:

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

Python 2 , 25 octets

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

Essayez-le en ligne!

Notez que cela utilise l'indexation 0.

APL (Dyalog) , 1 octet

⍳

Essayez-le en ligne!

Remarque: la ⍳fonction ne prend pas les scalaires comme argument de gauche, donc pour lui donner un argument de gauche comme 54, vous devez en faire un tableau en utilisant ,comme ça (,54).

Mathematica, 25 octets

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

Prend deux entrées met net renvoie les indices basés sur 1 de nin m.

Rétine , 32 31 30 octets

1 octet enregistré grâce à Kritixi Lithos et 1 octet grâce à Martin Ender

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

Utilise l'indexation 0. L'entrée a un espace de fin sur chaque ligne.

Essayez-le en ligne!

Explication

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

Ici, nous remplaçons chaque numéro sur la première ligne par le nombre de chiffres avant le même numéro sur la deuxième ligne.

G1`

Ensuite, nous supprimons la deuxième ligne, ne laissant que la nouvelle première ligne comme sortie.

Java , 104 81 octets

1 octet grâce à 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;}

Essayez-le en ligne!

C #, 32 octets

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

Il s'agit du code en tant qu'expression lambda, il doit donc être valide.

La solution est avec un index basé sur 0. Je pense qu'il est assez simple de savoir comment cela fonctionne - il prend simplement les éléments de n et sélectionne les indices des éléments en m.

Octave, 25 octets

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

Essayez-le en ligne!

Haskell , 32 octets

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

Essayez-le en ligne! Un index.

Autres tentatives:

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

Il s'agit d'un opérateur intégré qui kutilise une indexation basée sur zéro.

?

Exemple:

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

05AB1E , 5 octets

v²yk,

Essayez-le en ligne!

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

Gelée , 3 octets

iЀ

Essayez-le en ligne!

Spécifications

• Entrée: deux arguments, le premier étant m et le second étant n .
• Sortie: un tableau

JavaScript (ES6), 28 octets

Prend les tableaux dans la syntaxe de curry (n)(m). 0 indexé.

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 octets

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

Essayez-le

Étendu:

-> \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 indexé

Japt , 4 octets

m!bV

Testez-le en ligne!

Explication

Il n'y a pas grand-chose à expliquer ici, mais cela montre une fonctionnalité intéressante de Japt. Normalement, vous passeriez une fonction à m, comme ceci:

mX{VbX}

C'est fondamentalement U.map(X => V.indexOf(X))(le Uest implicite). Cependant, lorsque vous effectuez simplement une opération entre deux valeurs ( bici, sur Vet X), vous pouvez simplement donner à l'opérateur et l'autre valeur et Japt en fera une fonction. Cela signifie mX{X+2}peut être joué au golf pourm+2 .

Cependant, cela ne fonctionne pas lorsque les valeurs sont dans le mauvais ordre ( mbVserait l'abréviation de mX{XbV}). Pour contourner ce problème, vous pouvez ajouter un point d'exclamation à l'opérateur, qui indique à Japt de permuter les opérandes. Cela coûte un octet supplémentaire, mais c'est encore quelques octets de moins que l'alternative. Et maintenant, vous en savez un peu plus sur Japt.

MATL , 2 octets

&m

Cela utilise l'indexation 1. Essayez-le en ligne!

Explication

La méta-fonction &indique que la fonction suivante utilisera une spécification d'entrée / sortie secondaire (spécifique à la fonction). Pour la fonction m( ismember), &spécifie que sa deuxième sortie sera produite. Il contient l'index de (la première occurrence de) chaque entrée de la première entrée dans la deuxième entrée.

Haskell, 34 octets

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

Exemple d'utilisation: [5,3,4,9,7,5,7] # [3,4,5,7,9]->[3,1,2,5,4,3,4]

L'intégré elemIndexest en Data.Listet donc plus long que la version ci-dessus. La boucle externe passe à travers net la boucle interne à travers des paires de (i,e)où iest l'indice de ein m. Gardez ioù eest égal à l'élément actuel de n.

R, 20 5 octets

1 indexé; matchest la fonction intégrée qui trouve les indices dans la deuxième entrée des éléments du premier, c'est-à-dire, match(n,m)donne la réponse souhaitée

match

merci à @flodel d'avoir souligné que le retour d'une fonction est parfaitement acceptable comme réponse!

Essayez-le en ligne!

Pyth , 4 octets

xLQE

Essayez-le en ligne!

Notez que cela utilise l'indexation 0.

J , 2 octets

i.

Ce n'est pas un programme complet, mais une fonction intégrée.

Utilisez-le comme tel:

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

Essayez-le en ligne!

Notez que cela utilise l'indexation 0.

CJam , 4 octets

{f#}

Bloc anonyme qui attend des arguments sur la pile et laisse le résultat sur la pile.

Utilise l'indexation 0.

Essayez-le en ligne!

Haskell, 43 octets

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 octets

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

0 indexé.

Perl 5, 38 34 octets

4 octets économisés grâce à Dada

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

1 indexé. Prend les listes m et n comme une seule liste, comme f(@m,@n). Il x0s'agit simplement d'empêcher la sortie de commencer par 1,2,3,4,5, etc.

PHP, 56 octets

Versions en ligne

0 Indexation

sortie en tant que chaîne

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

PHP, 65 octets

Sortie sous forme de tableau

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

PHP, 78 octets

solution avec array_map

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

pour les tableaux non uniques remplacer par 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

Essayez-le en ligne .

Réponse précédente:

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

Essayez-le en ligne .

Java 7, 80 octets

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

0 indexé

Explication:

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

Code de test:

Essayez-le ici.

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

Sortie:

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