Sie müssen zwei Listen positiver Ganzzahlen als Eingabe verwenden. Nennen wir diese n und m .

Sie können davon ausgehen, dass:

• Alle ganzen Zahlen in n sind Teil von m
• Alle ganzen Zahlen in m sind eindeutig
• Die Listen sind nicht leer

Herausforderung: Geben Sie die Indizes zurück, in denen Sie die Werte in n und in m finden .

Das mag verwirrend sein, aber ich denke, die Testfälle werden die Aufgabe ziemlich klar machen. Die Beispiele sind 1-indiziert, Sie können 0-indiziert wählen, wenn Sie möchten (bitte angeben).

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

Die Gewinner sind die kürzesten Lösungen in jeder Sprache.

_{Dies ist übrigens ein sehr schöner Meta-Post!}

V , 26 Bytes

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

Probieren Sie es online!

Dies ist eine sehr seltsame und hackige Lösung, da V wenig bis gar kein Konzept von Zahlen hat. Die Eingabe erfolgt in folgendem Format:

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

Mit einem Leerzeichen in jeder Zeile.

Hexdump:

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

Erläuterung:

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)

Wenn dies nicht klarer wird, sind hier Beispiele für den Puffer während der verschiedenen Phasen, die die Schleife durchläuft:

Stufe 1 ( |ist der Cursor)

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

Stufe 2:

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

Stufe 3:

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

Stufe 4:

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

Stufe 5:

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

Stufe 6:

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

Stufe 7:

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

Zurück zu Stufe 1:

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

Python 2 , 25 Bytes

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

Probieren Sie es online!

Beachten Sie, dass dies eine 0-Indizierung verwendet.

APL (Dyalog) , 1 Byte

⍳

Probieren Sie es online!

Hinweis: Die ⍳Funktion akzeptiert keine Skalare als linkes Argument. Um ein linkes Argument zu erhalten 54, müssen Sie es mit ,like so in ein Array umwandeln (,54).

Mathematica, 25 Bytes

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

Nimmt zwei Eingaben mund nund gibt die 1-basierten Indizes von nin zurück m.

Retina , 32 31 30 Bytes

Dank Kritixi Lithos 1 Byte und dank Martin Ender 1 Byte gespart

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

Verwendet die 0-Indizierung. Die Eingabe enthält in jeder Zeile ein Leerzeichen am Ende.

Probieren Sie es online!

Erläuterung

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

Hier ersetzen wir jede Zahl in der ersten Zeile durch die Zahl vor der gleichen Zahl in der zweiten Zeile.

G1`

Dann löschen wir die zweite Zeile und lassen nur die neue erste Zeile als Ausgabe übrig.

Java , 104 81 Bytes

1 Byte dank Geschäftskat.

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

Probieren Sie es online!

C #, 32 Bytes

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

Dies ist der Code als Lambda-Ausdruck, daher sollte er gültig sein.

Die Lösung ist mit einem 0-basierten Index. Ich denke, es ist ziemlich klar, wie es funktioniert - es nimmt einfach die Elemente von n und wählt die Indizes der Elemente in m aus.

Oktave, 25 Bytes

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

Probieren Sie es online!

Haskell , 32 Bytes

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

Probieren Sie es online! Einseitig indiziert.

Andere Versuche:

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

Dies ist ein eingebauter Operator kund verwendet die auf Null basierende Indizierung.

?

Beispiel:

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

05AB1E , 5 Bytes

v²yk,

Probieren Sie es online!

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

Gelee , 3 Bytes

iЀ

Probieren Sie es online!

Technische Daten

• Eingabe: zwei Argumente, wobei das erste m und das zweite n ist .
• Ausgabe: ein Array

JavaScript (ES6), 28 Byte

Übernimmt die Arrays in Currying-Syntax (n)(m). 0-indiziert.

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

Versuch es

Erweitert:

-> \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 indiziert

Japt , 4 Bytes

m!bV

Online testen!

Erläuterung

Es gibt hier nicht viel zu erklären, aber es zeigt eine interessante Eigenschaft von Japt. Normalerweise würden Sie eine Funktion mwie folgt übergeben:

mX{VbX}

Dies ist im Grunde U.map(X => V.indexOf(X))(das Uist implizit). Wenn Sie jedoch nur eine Operation zwischen zwei Werten ausführen ( bhier, auf Vund X), können Sie dem Operator und dem anderen Wert nur einen Wert zuweisen, und Japt erstellt daraus eine Funktion. Das heißt, man mX{X+2}kann Golf spielenm+2 .

Dies funktioniert jedoch nicht, wenn die Werte in der falschen Reihenfolge sind ( mbVwäre eine Abkürzung für mX{XbV}). Um dies zu umgehen, können Sie dem Operator ein Ausrufezeichen voranstellen, das Japt anweist, die Operanden auszutauschen. Dies kostet ein zusätzliches Byte, ist aber immer noch ein paar Bytes kürzer als die Alternative. Und jetzt wissen Sie etwas mehr über Japt.

MATL , 2 Bytes

&m

Dies verwendet die 1-Indizierung. Probieren Sie es online!

Erläuterung

Die Meta-Funktion &gibt an, dass die nächste Funktion eine (funktionsspezifische) sekundäre Standard-Ein- / Ausgangsspezifikation verwendet. Gibt für function m( ismember) an, &dass die zweite Ausgabe erzeugt wird. Dies enthält den Index (das erste Vorkommen von) jedes Eintrags der ersten Eingabe in der zweiten Eingabe.

Haskell, 34 Bytes

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

Anwendungsbeispiel: [5,3,4,9,7,5,7] # [3,4,5,7,9]->[3,1,2,5,4,3,4]

Das eingebaute elemIndexist in Data.Listund daher länger als die obige Version. Die äußere Schleife geht durch nund die innere Schleife durch Paare von (i,e)wo iist der Index von ein m. Halten Sie das , iwo edas aktuelle Element entspricht n.

R 20 5 Bytes

1-indiziert; matchist die eingebaute Funktion, die die Indizes in der zweiten Eingabe der Elemente der ersten findet, dh match(n,m)die gewünschte Antwort gibt

match

Vielen Dank an @flodel für den Hinweis, dass die Rückgabe einer Funktion als Antwort durchaus akzeptabel ist!

Probieren Sie es online!

Pyth , 4 Bytes

xLQE

Probieren Sie es online!

Beachten Sie, dass dies eine 0-Indizierung verwendet.

J , 2 Bytes

i.

Dies ist kein vollständiges Programm, sondern eine eingebaute Funktion.

Verwenden Sie es als solches:

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

Probieren Sie es online!

Beachten Sie, dass dies eine 0-Indizierung verwendet.

CJam , 4 Bytes

{f#}

Anonymer Block, der Argumente auf dem Stapel erwartet und das Ergebnis auf dem Stapel belässt.

Verwendet die 0-Indizierung.

Probieren Sie es online!

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-indiziert.

Perl 5, 38 34 Bytes

Dank Dada 4 Bytes gespart

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

1-indiziert. Nimmt die Listen m und n wie eine einzelne Liste f(@m,@n). Das x0ist nur, um die Ausgabe davon abzuhalten, mit 1,2,3,4,5usw. zu beginnen .

PHP, 56 Bytes

Online-Versionen

0 Indizierung

Ausgabe als String

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

PHP, 65 Bytes

Ausgabe als Array

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

PHP, 78 Bytes

Problemumgehung mit array_map

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

für nicht eindeutige Arrays ersetzen durch 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

Probieren Sie es online aus .

Vorherige Antwort:

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

Probieren Sie es online aus .

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-indiziert

Erläuterung:

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

Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

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