양의 정수 목록을 입력으로 가져와야 합니다. 이 n 과 m을 호출하겠습니다 .

다음과 같이 가정 할 수 있습니다.

• n의 모든 정수 는 m의 일부입니다
• m의 모든 정수 는 고유합니다
• 목록이 비어 있지 않습니다

도전 과제 : n 에서 m을 구한 위치의 지수를 구하십시오 .

혼란 스러울 수 있지만 테스트 사례를 통해 작업을 명확하게 할 수 있다고 생각합니다. 예는 1- 색인이며 원한다면 0- 색인을 선택할 수 있습니다 (구체적으로 지정하십시오).

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

승자는 각 언어에서 가장 짧은 솔루션이됩니다.

_{이 방법에 의해 아주 좋은 메타 게시물입니다!}

V , 26 바이트

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

온라인으로 사용해보십시오!

V는 숫자의 개념이 거의 없거나 전혀 없기 때문에 이것은 매우 이상하고 해킹적인 해결책입니다. 입력은 다음 형식으로 제공됩니다.

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

각 줄에 후행 공백이 있습니다.

16 진 덤프 :

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

설명:

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)

이것이 명확하지 않으면 다음은 루프가 진행하는 다양한 단계 동안 버퍼의 예입니다.

1 단계 ( |커서 임)

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

2 단계 :

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

3 단계 :

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

4 단계 :

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

5 단계 :

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

6 단계 :

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

7 단계 :

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

1 단계로 돌아 가기

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

파이썬 2 , 25 바이트

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

온라인으로 사용해보십시오!

이것은 0 인덱싱을 사용합니다.

APL (Dyalog) , 1 바이트

⍳

온라인으로 사용해보십시오!

참고 : ⍳함수가 없는 같은 그것을 왼쪽 인자를주고, 그 왼쪽 인수로 스칼라을 54사용 배열로 그것을 확인해야합니다, ,그래서처럼 (,54).

Mathematica, 25 바이트

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

두 개의 입력 m과를 취하고 in n의 1 기반 인덱스를 반환합니다 .nm

망막 , 32 31 30 바이트

Kritixi Lithos 덕분에 1 바이트 절약 및 Martin Ender 덕분에 1 바이트 절약

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

0 인덱싱을 사용합니다. 입력은 각 줄에 후행 공백이 있습니다.

온라인으로 사용해보십시오!

설명

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

여기서 우리는 첫 번째 줄의 모든 숫자를 두 번째 줄의 같은 숫자 앞의 숫자로 바꿉니다.

G1`

그런 다음 두 번째 줄을 삭제하고 새로운 첫 줄만 출력으로 남겨 둡니다.

자바 , 104 81 바이트

Business cat 덕분에 1 바이트.

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

온라인으로 사용해보십시오!

C #, 32 바이트

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

이것은 람다 식의 코드이므로 유효해야합니다.

해결책은 0 기반 인덱스입니다. 나는 그것이 어떻게 작동하는지 꽤 진보적이라고 생각합니다. 그것은 단순히 n의 항목을 취하고 m의 항목의 인덱스를 선택합니다.

옥타브, 25 바이트

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

온라인으로 사용해보십시오!

하스켈 , 32 바이트

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

온라인으로 사용해보십시오! 하나의 색인.

다른 시도 :

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

이것은 기본 제공 연산자이며 k0부터 시작하는 인덱싱을 사용합니다.

?

예:

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

05AB1E , 5 바이트

v²yk,

온라인으로 사용해보십시오!

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

젤리 , 3 바이트

iЀ

온라인으로 사용해보십시오!

명세서

• 입력 : 두 인수, 첫 번째는 m이고 두 번째는 n 입니다.
• 출력 : 하나의 배열

자바 스크립트 (ES6), 28 바이트

카레 구문으로 배열을 취합니다 (n)(m). 인덱스가 0입니다.

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

펄 6 , 31 바이트

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

시도 해봐

넓히는:

-> \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 인덱스

Japt , 4 바이트

m!bV

온라인으로 테스트하십시오!

설명

여기서 설명 할 것이 많지 않지만, Japt의 흥미로운 기능을 보여줍니다. 일반적으로 다음 m과 같이 함수를 전달합니다 .

mX{VbX}

이것은 기본적으로 U.map(X => V.indexOf(X))( U암시 적입니다). 그러나 두 값 사이에서 하나의 작업 ( b여기서 on V및 X)을 수행 할 때 연산자와 다른 값을 제공하면 Japt가 그 기능을 수행합니다. 이것은 mX{X+2}골프를 할 수 있음을 의미 합니다m+2 .

그러나 값의 순서가 잘못된 경우에는 작동하지 않습니다 ( mbV약칭 mX{XbV}). 이 문제를 해결하기 위해 Japt에게 피연산자를 교체하도록 지시하는 느낌표를 연산자 앞에 추가 할 수 있습니다. 이것은 추가 바이트 비용이 들지만 여전히 다른 것보다 몇 바이트 짧습니다. 그리고 지금 당신은 Japt에 대해 조금 더 알고 있습니다.

MATL , 2 바이트

&m

1- 인덱싱을 사용합니다. 온라인으로 사용해보십시오!

설명

메타 기능 &은 다음 기능이 (기능별) 보조 기본 입력 / 출력 사양을 사용함을 나타냅니다. 함수 m( ismember)의 &경우 두 번째 출력이 생성되도록 지정합니다. 여기에는 두 번째 입력에서 첫 번째 입력의 각 항목에 대한 색인 (첫 번째 발생)이 포함됩니다.

하스켈, 34 바이트

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

사용 예 : [5,3,4,9,7,5,7] # [3,4,5,7,9]->[3,1,2,5,4,3,4]

내장 elemIndex은 Data.List위의 버전보다 길고 길다. 외부 루프를 통한 이동 n및 쌍을 통해 내부 루프 의 인덱스 에서 . 킵 곳 의 현재 요소를 동일을 .(i,e)iemien

R, 20 5 바이트

1- 색인; match첫 번째 요소의 두 번째 입력에서 인덱스를 찾고 즉, match(n,m)원하는 대답을 제공 하는 내장 함수입니다.

match

함수를 반환하는 것이 답으로 완벽하게 허용된다는 점을 지적한 @flodel에게 감사드립니다!

온라인으로 사용해보십시오!

Pyth , 4 바이트

xLQE

온라인으로 사용해보십시오!

이것은 0 인덱싱을 사용합니다.

J , 2 바이트

i.

이것은 완전한 프로그램이 아니라 내장 기능입니다.

다음과 같이 사용하십시오.

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

온라인으로 사용해보십시오!

이것은 0 인덱싱을 사용합니다.

CJam , 4 바이트

{f#}

스택에서 인수를 예상하고 스택에 결과를 남기는 익명 블록.

0 인덱싱을 사용합니다.

온라인으로 사용해보십시오!

하스켈, 43 바이트

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)

클로저, 25 바이트

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

인덱스가 0입니다.

펄 5, 38 34 바이트

Dada 덕분에 4 바이트 절약

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

1- 색인. 목록 m 과 n 을 같은 단일 목록으로 가져옵니다 f(@m,@n). 은 x0로 시작의 출력을 유지하기 위해 그냥 1,2,3,4,5등,

PHP, 56 바이트

온라인 버전

인덱싱

문자열로 출력

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

PHP, 65 바이트

배열로 출력

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

PHP, 78 바이트

해결 방법 array_map

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

고유 한 배열이 아닌 array_flip($_GET[1])[$v] array_search($v,$_GET[1])

배쉬 + 코어 유틸리티, 51

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

온라인으로 사용해보십시오 .

이전 답변 :

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

온라인으로 사용해보십시오 .

자바 7, 80 바이트

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

0 인덱스

설명:

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

테스트 코드 :

여기에서 시도하십시오.

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

산출:

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