1에서 a.length 범위의 숫자 만 포함하는 배열 a가 주어지면 두 번째 어커런스가 최소 인덱스를 갖는 첫 번째 중복 숫자를 찾으십시오. 즉, 중복 된 숫자가 두 개 이상인 경우 두 번째 숫자가 다른 숫자의 두 번째 숫자보다 작은 인덱스를 반환합니다. 그러한 요소가 없으면 프로그램 / 기능이 정의되지 않은 동작을 초래할 수 있습니다.

예:

의 경우 a = [2, 3, 3, 1, 5, 2]출력은이어야합니다 firstDuplicate(a) = 3.

숫자 2와 3의 두 가지 중복이 있습니다. 두 번째 발생 3보다 두 번째 발생보다 작은 인덱스가 있으므로 답은 3입니다.

의 경우 a = [2, 4, 3, 5, 1]출력은이어야합니다 firstDuplicate(a) = -1.

이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.

보너스 : O (n) 시간 복잡성과 O (1) 추가 공간 복잡성으로 해결할 수 있습니까?

파이썬 2 , 34 바이트

O (n ² ) 시간, O (n) 공간

^{@vaultah 덕분에 3 바이트를 절약했으며 @xnor에서 3 바이트를 절약했습니다!}

lambda l:l[map(l.remove,set(l))<0]

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

자바 스크립트 (ES6), 47 36 31 25 바이트

ThePirateBay 덕분에 6 바이트 절약

undefined솔루션이없는 경우 반환 합니다.

시간 복잡도 : O (n) :-)
공간 복잡도 : O (n) :-(

a=>a.find(c=>!(a[-c]^=1))

어떻게?

음수를 사용하여 원래 배열 a 의 새 속성 으로 저장하여 이미 발생한 값을 추적 합니다. 이렇게하면 원래 항목을 방해 할 수 없습니다.

데모

let f =

a=>a.find(c=>!(a[-c]^=1))

console.log(f([2, 3, 3, 1, 5, 2]))
console.log(f([2, 4, 3, 5, 1]))
console.log(f([1, 2, 3, 4, 1]))

Mathematica, 24 바이트

#/.{h=___,a_,h,a_,h}:>a&

Mathematica의 패턴 매칭 기능은 정말 멋집니다!

List유효하지 않은 입력에 대한 원본 을 반환합니다 .

설명

#/.

입력에서 교체 ...

{h=___,a_,h,a_,h}

List중복 요소가있는 A , 복제 전후, 사이 및 이후에 0 개 이상의 요소가있는 ...

... :>a

중복 요소로.

젤리 , 5 바이트

Ṛœ-QṪ

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

작동 원리

Ṛœ-QṪ  Main link. Argument: A (array)

Ṛ      Yield A, reversed.
   Q   Unique; yield A, deduplicated.
 œ-    Perform multiset subtraction.
       This removes the rightmost occurrence of each unique element from reversed
       A, which corresponds to the leftmost occurrence in A.
    Ṫ  Take; take the rightmost remaining element, i.e., the first duplicate of A.

하스켈 , 35 바이트

f s(h:t)|h`elem`s=h|1<2=f(h:s)t
f[]

온라인으로 사용해보십시오! 중복이 없으면 충돌이 발생합니다.

젤리 , 6 바이트

xŒQ¬$Ḣ

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

첫 번째 복제본을 반환하거나 복제본이없는 경우 0을 반환합니다.

설명

xŒQ¬$Ḣ  Input: array M
    $   Operate on M
 ŒQ       Distinct sieve - Returns a boolean mask where an index is truthy
          for the first occurrence of an element
   ¬      Logical NOT
x       Copy each value in M that many times
     Ḣ  Head

Japt , 7 바이트

æ@bX ¦Y

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

설명

 æ@   bX ¦ Y
UæXY{UbX !=Y}  Ungolfed
               Implicit: U = input array
UæXY{       }  Return the first item X (at index Y) in U where
     UbX         the first index of X in U
         !=Y     is not equal to Y.
               In other words, find the first item which has already occured.
               Implicit: output result of last expression

또는

æ@¯Y øX

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

설명

 æ@   ¯ Y øX
UæXY{Us0Y øX}  Ungolfed
               Implicit: U = input array
UæXY{       }  Return the first item X (at index Y) in U where
     Us0Y        the first Y items of U (literally U.slice(0, Y))
          øX     contains X.
               In other words, find the first item which has already occured.
               Implicit: output result of last expression

Pyth, 5 바이트

h.-Q{

테스트 스위트

Q에서 모든 요소의 첫 번째 모양을 Q에서 제거한 다음 첫 번째 요소를 반환하십시오.

Dyalog APL, 27 24 20 19 13 12 11 바이트

⊢⊃⍨0⍳⍨⊢=⍴↑∪

v16에 의존하지 않도록 수정되었습니다! 온라인으로 사용해보십시오!

어떻게? (입력 N 포함 )

• ⊢⊃⍨...- 이 지수에서 N :
  • ⍴↑∪- 중복이 제거 된 N , N0 에 맞게 오른쪽으로 채워짐
  • ⊢=-N 과 요소 별 평등
  • 0⍳⍨-첫 번째 색인 0. `

파이썬 3 , 94 92 바이트

O (n) 시간 및 O (1) 추가 메모리

def f(a):
 r=-1
 for i in range(len(a)):t=abs(a[i])-1;r=[r,i+1][a[t]<0>r];a[t]*=-1
 return r

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

알고리즘의 소스 .

설명

알고리즘의 기본 아이디어는 각 요소를 왼쪽에서 오른쪽으로 실행하고, 나타난 숫자를 추적하고, 이미 나타난 숫자에 도달하면 숫자를 반환하고, 각 요소를 순회 한 후 -1을 반환하는 것입니다.

그러나 추가 메모리를 사용하지 않고 나타난 숫자를 저장하는 영리한 방법을 사용합니다. 숫자로 색인이 지정된 요소의 부호로 저장합니다. 예를 들어, I는 사실 나타낼 수 2와 3이미함으로써 등장 a[2]하고 a[3]배열 한 인덱싱 된 경우를 제외.

펄 6 , 13 바이트

*.repeated[0]

시도 해봐

설명

• 는 *전체 문이 그래서 기간제 위치에 WhateverCode의 람다.

• 이 .repeated방법은 각 값을 처음 볼 때를 제외한 모든 값을 만드는 방법입니다.

  say [2, 3, 3, 3, 1, 5, 2, 3].repeated.perl; # (3, 3, 2, 3).Seq
  #   (      3, 3,       2, 3).Seq

• [0]Seq 의 첫 번째 값만 반환합니다 .
  값이 없으면 Nil 이 반환됩니다.
  ( 무기 호 의 기본입니다 실패 유형, 모든 종류의 자신의 정의되지 않은 값이다 그래서 무기 호 대부분의 다른 언어로 정의되지 않은 값과 다른)

Seq 를 구현하기.repeated 때문에 Seq 가 생성되므로 값을 요청할 때까지 어떤 작업도 시작하지 않으며 요청한 것을 생성하기에 충분한 작업 만 수행합니다.
따라서  두 번째 값이 첫 번째 값의 반복 인 경우 최악의 O (n)  시간 복잡성과 최상의 O (2) 시간 복잡성 이 있다고 주장하기 쉽습니다 .
메모리 복잡성에 대해서도 비슷할 수 있습니다.

APL (Dyalog) , 20 바이트

⊃n/⍨(,≢∪)¨,\n←⎕,2⍴¯1

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

2⍴¯1길이 2리스트로 형성된  음수 1 r

⎕, 입력 (니모닉 : 콘솔 박스)을 가져 와서 앞에 붙입니다.

n← 그것을 n에 저장

,\n의  접두사 (lit. 누적 누적)

(… )¨ 각 접두사에 다음의 암묵적 기능을 적용하십시오

 , [그것] 라벨 (접두사가 목록인지 확인하십시오)

 ≢ 와 다른

 ∪ 고유 요소 [?] (즉, 접두사에 중복이 있습니까?)

n/⍨이것을  사용하여 n 을 필터링 하십시오 (중복 물이 처음 발견 될 때까지 모든 요소를 ​​제거합니다)

⊃ 그것에서 첫 번째 요소를 선택

APL (Dyalog) , 11 바이트

에 따라 새로운 규칙 에는 중복이 존재하지 않는 경우, 오류가 발생합니다.

⊢⊃⍨⍬⍴⍳∘≢~⍳⍨

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

⍳⍨ 각 원소가 처음 나타나는 지표

~ 에서 제거

⍳∘≢ 모든 지수 중

⍬⍴ 그것을 스칼라로 재구성하십시오 (데이터가 없으면 0을줍니다)

⊃⍨ 그것을 사용하여 선택하십시오 (0에 오류를줍니다)

⊢ 논쟁 거리

APL, 15

{⊃⍵[(⍳⍴⍵)~⍵⍳⍵]}

중복이없는 경우 -1 대신 0을 반환 할 수있는 것처럼 보입니다 (댓글에 Adám에게 감사드립니다). 따라서 3 바이트가 적습니다.

약간의 설명 :

⍵⍳⍵         search the argument in itself: returns for  each element the index of it's first occurrence
(⍳⍴⍵)~⍵⍳⍵   create a list of all indexes, remove those found in ⍵⍳⍵; i.e. remove all first elements
⊃⍵[...]     of all remaining elements, take the first. If the array is empty, APL returns zero

참고로 이전 솔루션은 끝에 -1을 목록에 추가 했으므로 목록이 비어 있으면 대신 -1을 포함하고 첫 번째 요소는 -1이됩니다.

{⊃⍵[(⍳⍴⍵)~⍵⍳⍵],¯1}

tryapl.org에서 사용해보십시오

망막 , 26 24 바이트

1!`\b(\d+)\b(?<=\b\1 .*)

온라인으로 사용해보십시오! 설명 : \b(\d+)\b각 숫자를 차례로 일치시킨 다음 lookbehind는 숫자가 중복인지 확인합니다. 1일치 하는 경우가 아니라 st 일치 인 경우 !출력됩니다. 불행히도 lookbehind를 먼저 넣어도 작동하지 않는 것 같습니다. 그렇지 않으면 몇 바이트가 절약됩니다. 편집 : 일치하지 않는 반환 값 을 준수하기 위해 7 바이트가 추가되었습니다 -1. @MartinEnder 덕분에 2 바이트를 절약했습니다.

MATL , 8 바이트

&=Rsqf1)

중복이 없으면 오류없이 출력합니다.

MATL Online 에서 사용해보십시오 !

설명

&=   % Implict input. Matrix of all pairwise equality comparisons
R    % Keep the upper triangular part (i.e. set lower part to false)
s    % Sum of each column
q    % Subtract 1
f    % Indices of nonzero values
1)   % Get first. Gives an error is there is none. Implictly display

R, 34 바이트

c((x=scan())[duplicated(x)],-1)[1]

@ djhurio의 답변에서 몇 글자를 잘라 내십시오. 그러나 평판이 충분하지 않습니다.

J, 17 16 바이트

(*/{_1,~i.&0)@~:

어떻게?

(*/{_1,~i.&0)@~:

             @~: returns the nub sieve which is a vector with 1 for the first occurrence of an element in the argument and 0 otherwise

        i.&0     returns the first index of duplication

    _1,~         appends _1 to the index

 */              returns 0 with duplicates (product across nub sieve)

     {           select _1 if no duplicates, otherwise return the index

R , 28 바이트

(x=scan())[duplicated(x)][1]

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

J , 12 바이트

,&_1{~~:i.0:

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

설명

,&_1{~~:i.0:  Input: array M
      ~:      Nub-sieve
          0:  The constant 0
        i.    Find the index of the first occurrence of 0 (the first duplicate)
,&_1          Append -1 to M
    {~        Select the value from the previous at the index of the first duplicate

Dyalog APL Classic, 18 자

에서 작동합니다 ⎕IO←0.

     w[⊃(⍳∘≢~⍳⍨)w←¯1,⎕]

앞에 "-1"이 붙은 인수 요소의 색인 목록에서 해당 nub의 목록 색인을 제거한 다음 남아있는 항목 중 첫 번째 항목을 선택하십시오. 제거 후에 빈 벡터 만 남은 경우 첫 번째 요소는 정의-0으로, 원하는 -1을 생성하는 확장 인수를 인덱싱하는 데 사용됩니다.

루비 , 28 36 바이트

처음으로 도전을 오해했습니다. O(n)시간, O(n)공간.

->a{d={};a.find{|e|b=d[e];d[e]=1;b}}

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

자바 (오픈 JDK 8) , 65 (117) 109 바이트

이전 65 바이트 솔루션 :

r->{for(int a,b=0,z,i=0;;b=a)if((a=b|1<<(z=r[i++]))==b)return z;}

새로운 솔루션. 19 바이트 포함import java.math.*;

@Nevay 덕분에 -8 바이트

r->{int z,i=0;for(BigInteger c=BigInteger.ZERO;c.min(c=c.setBit(z=r[i++]))!=c;);return z;}

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

편집하다

내 원래 프로그램의 알고리즘은 훌륭했지만 사용 된 데이터 유형의 정적 크기는 크기가 특정 임계 값을 초과하면 상당히 빨리 파산되었음을 의미했습니다.

계산에 사용되는 데이터 유형을 변경하여이를 수용하기 위해 프로그램의 메모리 제한을 늘리십시오 ( 또는 BigInteger대신 임의의 정밀도로 사용 ). 그러나 이것은 공간 복잡성으로 간주되는지 여부를 논란의 여지가 있습니다.intlongO(1)

아래에 설명을 그대로 두겠습니다. 그러나 이제는 O(1)약간의 가정없이 공간 복잡성 을 달성하는 것이 불가능하다고 생각합니다 .

증명

N와 같은 정수로 정의하십시오 2 <= N.

하자 S임의 일련의 정수 나타내는 목록이 [x{1}, ..., x{N}], x{i}제약이있다을 1 <= x{i} <= N.

요소 당 정확히 한 번만이 목록을 반복하는 데 필요한 시간 복잡도 (Big-O 표기법)는 다음과 같습니다. O(n)

주어진 과제는 목록에서 첫 번째로 중복 된 값을 찾는 것입니다. 더 구체적으로, 우리는 S목록의 이전 항목과 중복 되는 첫 번째 값을 검색 합니다.

하자 p및 q두 등 그 목록에있는 요소의 위치가 될 p < q및 x{p} == x{q}. 우리의 도전은 q그러한 조건을 만족시키는 가장 작은 것을 찾는 것 입니다.

이 문제에 대한 명백한 접근 방식은 S를 반복 x{i}하고 다른 목록에 존재 하는지 확인하는 것입니다. 존재 하지 않는 T경우 이를 저장합니다 . 에 존재하는 경우 첫 번째 중복 값이므로 가장 작은 값이므로 반환합니다. 이 공간 효율성은 입니다.x{i}TTx{i}TqO(n)

시간 O(1)복잡성을 유지하면서 공간 복잡성 을 달성하려면 O(n)한정된 공간에 목록의 각 개체에 대한 고유 정보를 저장해야합니다. 이 때문에 알고리즘이 수행 할 수있는 유일한 방법은O(1)공간 복잡도는 다음과 같다 : 1. N은 특정 유한 데이터 유형에 대해 가능한 최대 값을 저장하는 데 필요한 메모리에 해당하는 상한을 갖는다. 2. 단일 불변 변수의 재 할당은 복잡성, 변수의 수 (여러 변수 인 목록)에 대해서만 계산됩니다. 3. (다른 답변을 기반으로) 목록은 (또는 적어도 목록의 요소는 변경 가능), 목록의 데이터 유형은 부호있는 정수로 사전 설정되어 목록의 요소를 더 변경할 수 있습니다. 추가 메모리를 사용하지 않고.

1과 3은 데이터 유형에 대한 가정과 스펙이 필요하지만 2는 변수의 크기가 아니라 공간 복잡도 계산에 변수의 수만 고려하도록 요구합니다. 이러한 가정 중 어느 것도 받아 들여지지 않으면 O(n)시간 복잡성과 O(1)공간 복잡성을 모두 달성하는 것이 불가능할 것 입니다.

설명

우와,이 사람은 약간의 두뇌 능력 을 생각하는 데 창피한 시간 이 걸렸다 .

따라서 보너스를 받기가 어렵습니다. 전체 목록을 정확히 한 번만 조작 하고 추가 공간 복잡성없이 이미 반복 한 값을 추적 해야합니다 .

비트 조작은 이러한 문제를 해결합니다. O(1)정수 쌍인 '스토리지'를 초기화 한 다음 목록을 반복하면서 첫 번째 정수의 i 번째 비트를 OR-하고 두 번째 결과를 저장합니다.

예를 들어,가 1101있고로 OR 연산을 수행하면 10을 얻습니다 1111. 로 다른 OR을 수행해도 10여전히 있습니다 1101.

Ergo, OR 연산을 수행하고 같은 숫자로 끝나면 중복 된 것을 발견했습니다. 배열에 중복이 없으면 프로그램이 실행되어 예외가 발생합니다.

PHP, 56 44 38 32 바이트

for(;!${$argv[++$x]}++;);echo$x;

다음과 같이 실행하십시오.

php -nr 'for(;!${$argv[++$x]}++;);echo$x;' -- 2 3 3 1 5 2;echo
> 3

설명

for(
  ;
  !${                 // Loop until current value as a variable is truthy
    $argv[++$x]       // The item to check for is the next item from input
  }++;                // Post increment, the var is now truthy
);
echo $x;              // Echo the index of the duplicate.

조정

• 배열 대신 변수를 사용하여 12 바이트 절약
• 일치하지 않는 경우 "정의되지 않은 동작"규칙을 사용하여 6 바이트를 절약했습니다.
• 각 루프 후에 1로 설정하는 대신 사후 증가를 사용하여 6 바이트를 절약했습니다.

복잡성

주석 처리 된 코드 버전에서 알 수 있듯이 시간 복잡성은 선형 O(n)입니다. 메모리 측면에서 최대 n+1변수가 할당됩니다. 그렇습니다 O(n).

Java 8, 82 78 76 바이트 더 이상 사용할 수 없음, 편집시 75 67 64 바이트 이하

람다 함수로서 :

a->{Set<Long>s=new HashSet<>();for(long i:a)if(!s.add(i))return i;return-1;}

아마도 훨씬 더 작게 만들 수있을 것입니다. 이것은 매우 빠릅니다.

설명:

a->{                                //New lambda function with 'a' as input
    Set<Long>s=new HashSet<>();     //New set
    for(long i:a)                   //Iterate over a
        if(!s.add(i))               //If can't add to s, already exists
            return i;               //Return current value
        return-1;                   //No dupes, return -1
}

*편집하다*

부정 전략을 사용한 75 67 64 바이트 :

a->{int i=0,j;while((a[j=Math.abs(a[i++])-1]*=-1)<0);return++j;}

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

(@Nevay 덕분에 3 바이트)

설명:

a->{                                         //New lambda expression with 'a' as input
    int i=0,j;                               //Initialise i and declare j
    while((a[j=Math.abs(a[i++])-1]*=-1)<0);  //Negate to keep track of current val until a negative is found
    return++j;                               //Return value
}

배열을 반복하여 추적하지 않습니다. 듀피가 없으면 그냥 넘어 가서 오류를 던집니다.

이 두 가지 모두 O (n) 시간과 O (n) 공간 복잡성에서 작동합니다.

Brachylog , 5 바이트

a⊇=bh

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

설명

a⊇=bh  Input is a list.
a      There is an adfix (prefix or suffix) of the input
 ⊇     and a subsequence of that adfix
  =    whose elements are all equal.
   b   Drop its first element
    h  and output the first element of the rest.

adfix 내장 a은 먼저 모든 접두사를 길이 순서대로 증가시킨 다음 접미사를 길이 순서대로 나열합니다. 따라서 출력은 가능한 경우 가장 짧은 접두사로 생성됩니다. 접두사가 중복되지 않으면 동일한 요소의 모든 하위 시퀀스의 길이가 1이고 꼬리의 첫 번째 요소가 존재하지 않기 때문에 나머지 프로그램은 실패합니다. 접두사에 반복되는 요소가 있으면 둘 다 포함하는 길이 -2 하위 시퀀스를 선택할 수 있으며 프로그램은 후자를 반환합니다.

C #, 145 바이트

using System.Linq;a=>{var d=a.Where(n=>a.Count(t=>t==n)>1);return d.Select((n,i)=>new{n,i}).FirstOrDefault(o=>d.Take(o.i).Contains(o.n))?.n??-1;}

아마도 간단한 루프로 C # 에서이 작업을 수행하는 훨씬 짧은 방법이지만 Linq로 시도하고 싶었습니다.

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

풀 / 포맷 버전 :

namespace System.Linq
{
    class P
    {
        static void Main()
        {
            Func<int[], int> f = a =>
            {
                var d = a.Where(n => a.Count(t => t == n) > 1);
                return d.Select((n, i) => new { n, i }).FirstOrDefault(o => d.Take(o.i).Contains(o.n))?.n ?? -1;
            };

            Console.WriteLine(f(new[] { 2, 3, 3, 1, 5, 2 }));
            Console.WriteLine(f(new[] { 2, 4, 3, 5, 1 }));

            Console.ReadLine();
        }
    }
}

하스켈 , 78 69 바이트

 fst.foldl(\(i,a)(j,x)->(last$i:[j|i<0,elem x a],x:a))(-1,[]).zip[1..]

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

@nimi 덕분에 9 바이트 절약

목록을 통한 기본 경로입니다. 현재 요소가 아직 보이지 않고 i<0누적 기 목록 ( elem x a)에있는 경우 현재 색인을 저장하십시오. 그렇지 않으면 인덱스를 -1로 유지하십시오. 어쨌든 현재 요소를 누산기 목록에 추가하십시오.

편집 : 나는 질문을 충분히 읽지 못했습니다.이 코드는 중복 요소의 두 번째 요소 색인을 출력합니다.

파이썬 2, 71 65 바이트

None중복 요소가없는 경우 반환

편집 : @ musicman523 덕분에 -6 바이트

def f(n):
 for a in n:
	u=-abs(a)
	if n[u]<0:return-u
	n[u]=-n[u]

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

O (n) 시간 복잡성, O (n) 공간 복잡성, O (1) 보조 공간.

입력 목록이 O (n) 공간을 사용하므로 공간 복잡도는 이것에 의해 제한됩니다. 우리는 O (n) 보다 공간 복잡도가 낮을 ​​수 없다는 의미

원래 목록을 수정합니다. 이것이 허용되지 않으면 129 바이트 와 동일한 복잡성으로 할 수 있습니다.

설명

모든 요소가 0보다 크고 목록의 크기보다 작거나 같기 때문에 목록에는 각 요소 a에 대해 인덱스 a의 요소-1 (0 인덱스)이 있습니다. 인덱스 i의 요소가 음수이면 이전에 본 것입니다.

리스트 n의 각 원소 a에 대해, 우리는 u를 a의 절대 값으로 음수로 둡니다. (파이썬이 음의 인덱스로리스트를 인덱싱 할 수 있기 때문에 음수로 만들었습니다. 그렇지 않으면해야 할 것입니다. u=abs(a)-1 )리스트에서 인덱스 u의 요소가 음수 인 경우, 우리는 전에 그것을 보았으므로 -u를 반환 할 수 있습니다. 모든 요소가 양수이므로 a의 절대 값) . 그렇지 않으면 우리는 이전에 가치의 요소를 보았 음을 기억하기 위해 인덱스 u의 요소를 음수로 설정했습니다.

젤리 , 4 바이트

ŒQi0

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

모든 요소가 고유 한 경우 0(정의되지 않은 동작)을 반환합니다 .