1からa.lengthの範囲の数値のみを含む配列aが与えられた場合、2番目のオカレンスが最小のインデックスを持つ最初の重複する数値を見つけます。つまり、重複する番号が複数ある場合、2番目のオカレンスのインデックスが他の番号の2番目のオカレンスよりも小さいインデックスを返します。そのような要素がない場合、プログラム/関数の動作が未定義になる可能性があります。

例：

の場合a = [2, 3, 3, 1, 5, 2]、出力は firstDuplicate(a) = 3。

重複は2つあります。番号2と3です。2番目に出現する3は、2番目に出現する2よりもインデックスが小さいため、答えは3です。

の場合a = [2, 4, 3, 5, 1]、出力は firstDuplicate(a) = -1。

これはcode-golfであるため、バイト単位の最短回答が優先されます。

ボーナス：O（n）時間の複雑さとO（1）追加のスペースの複雑さでそれを解決できますか？

Python 2、34バイト

O（n ²）時間、O（n）スペース

^{@vaultahのおかげで3バイト、@ xnorからさらに3バイト節約されました！}

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

オンラインでお試しください！

JavaScript（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.

Haskell、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。`

Pythonの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を返すことです。

ただし、余分なメモリを使用せずに出現した数字を保存するには、数字でインデックス付けされた要素の符号として保存するという巧妙な方法を使用します。例えば、私は事実表すことができる2と3既に持っていることによって現れたa[2]とa[3]アレイが1インデックスである場合、負の。

Perl 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が返されます。
  （NilはFailureタイプのベースであり、すべてのタイプは独自の未定義の値であるため、Nilは他のほとんどの言語の未定義の値とは異なります）

の実装は.repeatedSeqを生成するため、値を要求するまで作業を開始せず、要求したものを生成するのに十分な作業のみを行うことに注意してください。
したがって、これは最悪でもO（n）  時間の複雑さを持ち 、2番目の値が最初の値の繰り返しである場合はせいぜいO（2）時間の複雑さを持っていると主張するのは簡単です。
メモリの複雑さについても同様のことが言えます。

APL（Dyalog）、20バイト

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

オンラインでお試しください！

2⍴¯1 負ののR長さ2つのリストにeshaped

⎕, 入力（ニーモニック：コンソールボックス）を取得し、その先頭に追加します

n←nに  保存する

,\nの  接頭辞（lit.累積連結）

(… )¨ 次の暗黙関数を各プレフィックスに適用します

 , [is] ravel（プレフィックスがリストであることを確認するだけです）

 ≢ と違う

 ∪ 一意の要素[？]（つまり、プレフィックスに重複がありますか？）

n/⍨ それを使用してnをフィルタリングします（重複が見つかった最初の要素まですべての要素を削除します）。

⊃ その中から最初の要素を選ぶ

APL（Dyalog）、11バイト

あたりとして新しいルール全く重複が存在しない場合は、エラーがスローされます。

⊢⊃⍨⍬⍴⍳∘≢~⍳⍨

オンラインでお試しください！

⍳⍨ 各要素の最初の出現のインデックス

~ から削除されました

⍳∘≢ すべてのインデックスの

⍬⍴ それをスカラーに変更します（データが利用できない場合はゼロになります）

⊃⍨ それを使用して選択します（エラーをゼロにします）

⊢ 引数

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各番号を順番に照合し、後読み機能は番号が重複しているかどうかを確認します。一致の数ではなく、1stの一致が!出力される場合。残念ながら、後読みを最初に配置しても機能しないようです。そうしないと、数バイト節約できます。編集：一致しない場合の-1戻り値に準拠するために7バイトを追加しました。@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}}

オンラインでお試しください！

JAVA（OpenJDKの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。

要素ごとに1回だけこのリストを反復処理するのに必要な時間の複雑さ（Big-O表記）は O(n)

与えられた課題は、リスト内で最初に重複した値を見つけることです。具体的にはS、リストの前のアイテムの複製である最初の値を検索しています。

させるおよびリスト内の2つの要素の位置pとqなるようにp < qしx{p} == x{q}ます。私たちの課題は、qこれらの条件を満たす最小のものを見つけることです。

この問題への明白なアプローチは、我々があればSを反復してチェックすることですx{i}別のリストに存在してTいる場合は：x{i}に存在しないT、我々はそれを保存しますT。x{i}がに存在する場合T、それは最初の重複値であり、したがって最小です。したがって、qそれを返します。このスペース効率はO(n)です。

時間の複雑O(1)さを維持しながらスペースの複雑さを達成するにO(n)は、リスト内の各オブジェクトに関する一意の情報を有限のスペースに格納する必要があります。このため、アルゴリズムが実行できる唯一の方法はO(1)スペースの複雑さは次の場合です。1. Nには、特定の有限データ型の可能な値の最大数を格納するために必要なメモリに対応する上限が与えられます。2.単一の不変変数の再割り当ては、複雑さに対してはカウントされず、変数の数（リストは複数の変数）に対してのみカウントされます。3.（他の回答に基づいて）リストは変更可能（または少なくともリストの要素は変更可能）であり、リストのデータ型は符号付き整数として事前設定されており、リスト内のさらに要素に変更を加えることができます。追加のメモリを使用せずに。

1と3は両方ともデータ型に関する仮定と仕様を必要とし、2は変数のサイズではなく変数の数のみをスペースの複雑さの計算に考慮することを要求します。これらの仮定がどれも受け入れられない場合、O(n)時間の複雑さとO(1)スペースの複雑さの両方を達成することは不可能です。

説明

男の子、これは恥ずかしいほど長い時間をかけて少しの脳力を考え出しました。

そのため、ボーナスを獲得するのは困難です。私たちは、正確に一度、リスト全体で動作するように両方が必要と我々はすでに、追加のスペースの複雑させずに反復処理しました値をトラック。

ビット操作はこれらの問題を解決します。O(1)整数のペアである「ストレージ」を初期化し、リストを反復処理し、最初の整数のi番目のビットをOR演算し、その結果を2番目の整数に格納します。

たとえば1101、があり、でOR演算を実行すると10、が得られ1111ます。別のORを行う場合10、まだあり1101ます。

エルゴ、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();
        }
    }
}

Haskell、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番目の要素のインデックスを出力します。

Python 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の絶対値として負にします。（私たちはPythonが負のインデックスを持つリストにインデックスを付けることができるので、それを負にします u=abs(a)-1）リストのインデックスuの要素が負の場合、前にそれを見て、したがって-uを返すことができます（取得するためにすべての要素が正であるため、aの絶対値）。それ以外の場合、以前に値aの要素を見たことを覚えておくために、インデックスuの要素を負に設定します。

ゼリー、4バイト

ŒQi0

オンラインでお試しください！

すべての要素が一意である場合、これは戻ります0（未定義の動作）。