给定一个数组a，其中只包含从1到a.length范围内的数字，请找到第一个重复的数字，其第二次出现的索引最小。换句话说，如果重复的数字多于1个，则返回其第二次出现的索引小于另一个数字的第二次出现的索引的数字。如果没有这样的元素，您的程序/函数可能会导致不确定的行为。

例：

对于a = [2, 3, 3, 1, 5, 2]，输出应为 firstDuplicate(a) = 3。

有2个重复项：数字2和3。第二次出现3的索引比第二次出现2的索引小，因此答案是3。

对于a = [2, 4, 3, 5, 1]，输出应为 firstDuplicate(a) = -1。

这是代码高尔夫球，因此最短答案以字节为单位。

奖金：您能以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具有重复元件，用前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）

• ⊢⊃⍨...- Ñ这个索引处：
  • ⍴↑∪- Ñ与重复取出，右填充0到适合Ñ
  • ⊢=-与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。

但是，它使用一种聪明的方法来存储已出现的数字而无需使用额外的内存：将它们存储为按数字索引的元素的符号。例如，如果数组是1索引的，我可以通过具有and 负数来表示2and 3已经出现的事实。a[2]a[3]

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与大多数其他语言中的未定义值不同）

请注意，由于的实现会.repeated生成一个Seq，这意味着它直到您要求一个值才开始做任何工作，并且它仅做足够的工作来生成您要的内容。
因此，很容易辩称 ， 如果第二个值是第一个值的重复，则它的O（n）时间复杂度最差，而O（2）时间复杂度则最大。
内存复杂性可能类似。

APL（Dyalog），20字节

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

在线尝试！

2⍴¯1 负一- [R E形成的长度，两个列表

⎕, 获取输入（助记符：控制台）并添加到该输入

n← 将其存储在n中

,\n的  前缀（照明累积串联）

(… )¨ 对每个前缀应用以下默认功能

 , [是] ravel（仅确保前缀是列表）

 ≢ 不同于

 ∪ 唯一元素[？]（即前缀是否重复？）

n/⍨ 使用它来过滤n（删除所有元素，直到找到第一个重复的元素）

⊃ 从中选择第一个元素

APL（Dyalog），11个字节

根据新规则，如果不存在重复项，则会引发错误。

⊢⊃⍨⍬⍴⍳∘≢~⍳⍨

在线尝试！

⍳⍨ 每个元素首次出现的索引

~ 已经从...删除

⍳∘≢ 所有指数中

⍬⍴ 将其整形为标量（如果没有可用数据，则为零）

⊃⍨ 用它来选择（给零错误）

⊢ 论点

APL，15

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

似乎当没有重复项时，我们可以返回0而不是-1，（感谢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，则!输出匹配项，而不是匹配项的计数。不幸的是，将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}}

在线尝试！

的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.*;

-8个字节，感谢@Nevay

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

在线尝试！

编辑

我原始程序中的算法很好，但是使用的数据类型的静态大小意味着一旦大小超过某个阈值，它就会很快崩溃。

我已经更改了计算中使用的数据类型，以增加程序的内存限制以适应此限制（使用BigInteger任意精度代替int或long）。但是，这是否可算作O(1)空间复杂性值得商bat 。

我将完整地保留我的解释，但我想补充一点，我现在认为如果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}不存在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个位进行或运算，然后将结果存储到第二个中。

例如，如果我们有1101，并且我们使用进行“或”运算10，我们将得到1111。如果我们再做一次OR 10，我们仍然有1101。

如此，一旦我们执行“或”运算并以相同的数字结尾，便找到了重复项。数组中没有重复项将导致程序运行并引发异常。

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字节

作为lambda函数：

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

在线尝试！

（-3字节感谢@Nevay）

说明：

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，并且其尾部的第一个元素不存在。如果前缀包含重复的元素，则可以选择包含两个元素的length-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。无论如何，都将当前元素添加到累加器列表中。

编辑：我没有足够仔细地阅读问题：此代码输出重复元素的第二个元素的索引。

Python 2，71 65字节

None如果没有重复的元素，则返回

编辑： -6字节感谢@ musicman523

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，我们令a的绝对值为负。（我们将其设为负数，因为python可以使用负索引对列表进行索引，否则我们需要这样做 u=abs(a)-1）。如果列表中索引u处的元素为负数，我们之前已经看过它，因此可以返回-u （以获取a的绝对值，因为所有元素均为正）。否则，我们将索引u的元素设置为负数，以记住我们之前已经看到了值a的元素。

果冻，4字节

ŒQi0

在线尝试！

如果所有元素都是唯一的，则返回0（未定义行为）。