Musisz wziąć dwie listy dodatnich liczb całkowitych jako dane wejściowe, nazwijmy je n i m .

Możesz założyć, że:

• Wszystkie liczby całkowite n są częścią m
• Wszystkie liczby całkowite wm są unikalne
• Listy nie są puste

Wyzwanie: Zwróć wskaźniki, w których znajdziesz wartości w n , w m .

Może to być mylące, ale myślę, że przypadki testowe sprawią, że zadanie będzie całkiem jasne. Przykłady są indeksowane 1, możesz wybrać indeksowanie 0, jeśli chcesz (proszę określić).

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

Zwycięzcy będą najkrótszymi rozwiązaniami w każdym języku.

_{To jest bardzo miłe meta-post na drodze!}

V , 26 bajtów

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

Wypróbuj online!

Jest to bardzo dziwne i nieuczciwe rozwiązanie, ponieważ V ma niewiele lub nie ma pojęcia liczb. Dane wejściowe są w tym formacie:

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

Ze spacją na końcu każdej linii.

Hexdump:

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

Wyjaśnienie:

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)

Jeśli to nie wyjaśnia, oto przykłady bufora na różnych etapach, przez które przechodzi pętla:

Etap 1 ( |jest kursorem)

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

Etap 2:

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

Etap 3:

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

Etap 4:

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

Etap 5:

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

Etap 6:

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

Etap 7:

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

Powrót do etapu 1:

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

Python 2 , 25 bajtów

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

Wypróbuj online!

Zauważ, że używa to indeksowania 0.

APL (Dyalog) , 1 bajt

⍳

Wypróbuj online!

Uwaga: ⍳funkcja nie przyjmuje skalarów jako lewego argumentu, więc aby nadać mu lewy argument 54, musisz przekształcić go w tablicę, używając ,podobnie (,54).

Mathematica, 25 bajtów

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

Przyjmuje dwa dane wejściowe mi nzwraca indeksy 1 dla nin m.

Siatkówka , 32 31 30 bajtów

1 bajt zapisany dzięki Kritixi Lithos i 1 bajt dzięki Martinowi Enderowi

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

Wykorzystuje indeksowanie 0. Wejście ma końcowe spacje w każdym wierszu.

Wypróbuj online!

Wyjaśnienie

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

Tutaj zamieniamy każdą liczbę w pierwszym wierszu na liczbę liczb przed tą samą liczbą w drugim wierszu.

G1`

Następnie usuwamy drugi wiersz, pozostawiając tylko nowy pierwszy wiersz jako wynik.

Java , 104 81 bajtów

1 bajt dzięki 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;}

Wypróbuj online!

C #, 32 bajtów

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

Jest to kod jako wyrażenie lambda, więc powinien być poprawny.

Rozwiązanie ma indeks oparty na 0. Myślę, że to całkiem proste, jak to działa - po prostu bierze elementy n i wybiera indeksy elementów wm.

Oktawa, 25 bajtów

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

Wypróbuj online!

Haskell , 32 bajty

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

Wypróbuj online!Jeden indeksowany.

Inne próby:

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

Jest to wbudowany operator ki korzysta z indeksowania zerowego.

?

Przykład:

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

05AB1E , 5 bajtów

v²yk,

Wypróbuj 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

Galaretka , 3 bajty

iЀ

Wypróbuj online!

Okular

• Dane wejściowe: dwa argumenty, pierwszy to m , a drugi to n .
• Wyjście: jedna tablica

JavaScript (ES6), 28 bajtów

Bierze tablice w składni curry (n)(m). 0-indeksowane.

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 bajtów

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

Spróbuj

Rozszerzony:

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

Japt , 4 bajty

m!bV

Przetestuj online!

Wyjaśnienie

Nie ma tu wiele do wyjaśnienia, ale pokazuje ciekawą funkcję Japt. Zwykle przekazujesz funkcję do m:

mX{VbX}

Jest to w zasadzie U.map(X => V.indexOf(X))( Uniejawne). Jednak gdy wykonujesz tylko jedną operację między dwiema wartościami ( btutaj, on Vi X), możesz po prostu podać operatorowi i drugą wartość, a Japt wykona z niej funkcję. Oznacza to, że mX{X+2}można grać w golfa m+2.

Nie działa to jednak, gdy wartości są w niewłaściwej kolejności ( mbVbyłoby to skrót od mX{XbV}). Aby obejść ten problem, możesz wstawić wykrzyknik do operatora, który mówi Japtowi, aby podmienił operandy. To kosztuje dodatkowy bajt, ale wciąż jest o kilka bajtów krótszy niż alternatywa. A teraz wiesz trochę więcej o Japt.

MATL , 2 bajty

&m

Używa to indeksowania 1. Wypróbuj online!

Wyjaśnienie

Meta-funkcja &wskazuje, że następna funkcja użyje (specyficznej dla funkcji) dodatkowej domyślnej specyfikacji wejścia / wyjścia. Dla funkcji m( ismember) &określa, że ​​zostanie wygenerowane drugie wyjście. Zawiera on indeks (pierwszego wystąpienia) każdego wpisu pierwszego wejścia na drugim wejściu.

Haskell, 34 bajty

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

Przykład użycia: [5,3,4,9,7,5,7] # [3,4,5,7,9]->[3,1,2,5,4,3,4]

Wbudowane elemIndexjest Data.Listi dlatego jest dłuższe niż powyższa wersja. Pętla zewnętrzna przechodzi, na pętla wewnętrzna przez pary (i,e)gdzie ijest indeksem ein m. Zachowaj igdzie erówna się bieżącemu elementowi n.

R, 20 5 bajtów

1-indeksowany; matchjest wbudowaną funkcją, która znajduje wskaźniki na drugim wejściu elementów pierwszego, tj. match(n,m)daje pożądaną odpowiedź

match

dzięki @flodel za zwrócenie uwagi, że zwrócenie funkcji jest całkowicie akceptowalne jako odpowiedź!

Wypróbuj online!

Pyth , 4 bajty

xLQE

Wypróbuj online!

Zauważ, że używa to indeksowania 0.

J , 2 bajty

i.

To nie jest kompletny program, ale wbudowana funkcja.

Użyj go jako takiego:

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

Wypróbuj online!

Zauważ, że używa to indeksowania 0.

CJam , 4 bajty

{f#}

Anonimowy blok, który oczekuje argumentów na stosie i pozostawia wynik na stosie.

Wykorzystuje indeksowanie 0.

Wypróbuj online!

Haskell, 43 bajty

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 bajtów

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

0-indeksowane.

Perl 5, 38 34 bajtów

4 bajty zapisane dzięki Dadzie

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

1-indeksowany. Staje wykazy m i n jako pojedyncze liście, jak f(@m,@n). Chodzi x0tylko o to, aby wyjście nie zaczynało się od 1,2,3,4,5itp.

PHP, 56 bajtów

Wersje online

0 Indeksowanie

dane wyjściowe jako ciąg

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

PHP, 65 bajtów

Dane wyjściowe jako tablica

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

PHP, 78 bajtów

obejście z array_map

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

dla nietypowych tablic zamień na 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

Wypróbuj online .

Poprzednia odpowiedź:

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

Wypróbuj online .

Java 7, 80 bajtów

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

0-indeksowane

Wyjaśnienie:

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

Kod testowy:

Wypróbuj tutaj.

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

Wydajność:

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