Etant donné un tableau a ne contenant que des nombres compris entre 1 et a.length, trouvez le premier numéro en double pour lequel la deuxième occurrence a l'index minimal. En d'autres termes, s'il y a plus d'un nombre dupliqué, renvoyez le numéro pour lequel la seconde occurrence a un index plus petit que la seconde occurrence de l'autre numéro. Si de tels éléments n'existent pas, votre programme / fonction peut entraîner un comportement non défini.

Exemple:

Pour a = [2, 3, 3, 1, 5, 2], la sortie devrait être firstDuplicate(a) = 3.

Il y a 2 doublons: les nombres 2 et 3. La deuxième occurrence de 3 a un indice plus petit que la deuxième occurrence de 2 le fait, donc la réponse est 3.

Pour a = [2, 4, 3, 5, 1], la sortie devrait être firstDuplicate(a) = -1.

C'est du code-golf , donc la réponse la plus courte en octets est gagnante.

BONUS: Pouvez-vous le résoudre en complexité temporelle O (n) et en complexité spatiale O (1)?

Python 2 , 34 octets

O (n ² ) heure, O (n) espace

^{Sauvegardé 3 octets grâce à @vaultah et 3 autres de @xnor!}

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

Essayez-le en ligne!

JavaScript (ES6), 47 36 31 25 octets

Sauvegardé 6 octets grâce à ThePirateBay

Renvoie undefinedsi aucune solution n'existe.

Complexité temporelle: O (n) :-)
Complexité spatiale: O (n) :-(

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

Comment?

Nous gardons une trace des valeurs déjà rencontrées en les enregistrant comme de nouvelles propriétés du tableau d' origine un en utilisant les numéros négatifs. De cette façon, ils ne peuvent pas interférer avec les entrées originales.

Démo

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 octets

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

La capacité de correspondance de motifs de Mathematica est tellement cool!

Renvoie l'original Listpour une entrée non valide.

Explication

#/.

Dans l'entrée, remplacez ...

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

A Listavec un élément en double, avec 0 ou plusieurs éléments avant, entre et après les doublons ...

... :>a

Avec l'élément dupliqué.

Gelée , 5 octets

Ṛœ-QṪ

Essayez-le en ligne!

Comment ça marche

Ṛœ-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 octets

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

Essayez-le en ligne! Se bloque si aucun doublon n'est trouvé.

Gelée , 6 octets

xŒQ¬$Ḣ

Essayez-le en ligne!

Retourne le premier doublon ou 0 s'il n'y a pas de doublon.

Explication

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 octets

æ@bX ¦Y

Testez-le en ligne!

Explication

 æ@   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

Alternativement:

æ@¯Y øX

Testez-le en ligne!

Explication

 æ@   ¯ 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 octets

h.-Q{

Suite de tests

Supprime de Q la première apparition de chaque élément de Q, puis retourne le premier élément.

Dyalog APL, 27 24 20 19 13 12 11 octets

⊢⊃⍨0⍳⍨⊢=⍴↑∪

Maintenant modifié pour ne pas dépendre de v16! Essayez-le en ligne!

Comment? (Avec entrée N )

• ⊢⊃⍨...- N à cet index:
  • ⍴↑∪- N avec les doublons enlevés, rembourré à droite 0pour s'adapter à N
  • ⊢=- égalité élémentaire avec N
  • 0⍳⍨- Index du premier 0. `

Python 3 , 94 92 octets

O (n) temps et O (1) mémoire supplémentaire.

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

Essayez-le en ligne!

Source de l'algorithme .

Explication

L'idée de base de l'algorithme est de parcourir chaque élément de gauche à droite, de garder une trace des nombres apparus et de renvoyer le nombre lorsque le nombre atteint est déjà atteint, et de renvoyer -1 après avoir parcouru chaque élément.

Cependant, il utilise un moyen astucieux pour stocker les nombres qui sont apparus sans utiliser de mémoire supplémentaire: pour les stocker en tant que signe de l'élément indexé par le nombre. Par exemple, je peux représenter le fait que 2et 3est déjà apparu en ayant a[2]et a[3]négatif, si le tableau est 1-indexé.

Perl 6 , 13 octets

*.repeated[0]

L'essayer

Explication

• Le *est dans une position à terme, donc la déclaration entière est un lambda WhateverCode .

• Le .repeatedest une méthode qui donne chaque valeur sauf la première fois que chaque valeur est vue.

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

• [0]renvoie simplement la première valeur de la Seq .
  S'il n'y a pas de valeur, Nil est renvoyé.
  ( Nil est la base des types d' échec , et tous les types ont leur propre valeur indéfinie, donc Nil est différent d'une valeur indéfinie dans la plupart des autres langues)

Notez que depuis l’ implémentation de.repeated génère une Seq, cela signifie qu’il ne commence à faire aucun travail tant que vous n’avez pas demandé une valeur et qu’il ne fait que suffisamment de travail pour générer ce que vous demandez.
Il serait donc facile de dire que cela a au pire une  complexité temporelle en O (n) , et au mieux une complexité temporelle en O (2)  si la seconde valeur est une répétition de la première.
On peut probablement en dire autant de la complexité de la mémoire.

APL (Dyalog) , 20 octets

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

Essayez-le en ligne!

2⍴¯1 négatif une r eshaped dans une liste d' ancienneté deux

⎕, obtenir une entrée (mnémonique: console) et y ajouter

n← stocker que dans n

,\ préfixes de n (lit. concaténation cumulative)

(… )¨ Applique la fonction tacite suivante à chaque préfixe

 , [est] le ravel (assure juste que le préfixe est une liste)

 ≢ différent de

 ∪ les éléments uniques [?] (le préfixe a-t-il des doublons?)

n/⍨ utilisez cela pour filtrer n (supprime tous les éléments jusqu'au premier pour lequel un doublon a été trouvé)

⊃ choisir le premier élément de celui

APL (Dyalog) , 11 octets

Conformément aux nouvelles règles , génère une erreur si aucun doublon n’existe.

⊢⊃⍨⍬⍴⍳∘≢~⍳⍨

Essayez-le en ligne!

⍳⍨ les indices de la première occurrence de chaque élément

~ retiré de

⍳∘≢ de tous les indices

⍬⍴ remodeler cela en un scalaire (donne zéro si aucune donnée n'est disponible)

⊃⍨ utilisez-le pour choisir (donne l'erreur sur zéro)

⊢ l'argument

APL, 15

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

On dirait que nous pouvons renvoyer 0 au lieu de -1 lorsqu'il n'y a pas de doublons (merci Adám pour le commentaire). Donc 3 octets de moins.

Un peu de description:

⍵⍳⍵         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

Pour référence, l'ancienne solution ajoutait -1 à la liste à la fin. Ainsi, si la liste était vide, elle contiendrait -1 et le premier élément serait -1.

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

Essayez-le sur tryapl.org

Retina , 26 à 24 octets

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

Essayez-le en ligne! Explication: fait \b(\d+)\bcorrespondre chaque numéro à tour de rôle, puis la recherche précédente cherche à savoir si le nombre est un doublon; si c'est la première 1correspondance qui est !produite, plutôt que le nombre de correspondances. Malheureusement, mettre le lookbehind en premier ne semble pas fonctionner, sinon cela économiserait plusieurs octets. Edit: 7 octets ajoutés pour se conformer à la -1valeur de retour sur aucune correspondance. 2 octets sauvés grâce à @MartinEnder.

MATL , 8 octets

&=Rsqf1)

Donne une erreur (sans sortie) s'il n'y a pas de doublon.

Essayez sur MATL Online!

Explication

&=   % 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 octets

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

Coupez quelques caractères de la réponse de @djhurio, n’avez pas assez de réputation pour commenter.

J, 17 16 octets

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

Comment?

(*/{_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 octets

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

Essayez-le en ligne!

J , 12 octets

,&_1{~~:i.0:

Essayez-le en ligne!

Explication

,&_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 caractères

Ne fonctionne que dans ⎕IO←0.

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

Supprimez de la liste des index des éléments de l'argument avec "-1" ajouté la liste des index de son nœud, puis choisissez le premier de ce qui reste. Si, après la suppression, il ne reste qu'un vecteur vide, son premier élément est, par définition, 0 et sert à indexer l'argument étendu produisant le -1 souhaité.

Ruby , 28 36 octets

Incompris le défi la première fois. O(n)temps, O(n)espace.

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

Essayez-le en ligne!

Java (OpenJDK 8) , 65 117 109 octets

Solution précédente de 65 octets:

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

Nouvelle solution. 19 octets sont inclus pourimport java.math.*;

-8 octets grâce à @Nevay

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

Essayez-le en ligne!

modifier

L'algorithme de mon programme d'origine fonctionnait bien, mais la taille statique du type de données utilisé signifiait qu'il s'était cassé assez rapidement une fois que la taille avait dépassé un certain seuil.

J'ai changé le type de données utilisé dans le calcul pour augmenter la limite de mémoire du programme afin de s'adapter à cela (en utilisant BigIntegerune précision arbitraire au lieu de intou long). Cependant, cela rend discutable si cela compte ou non comme O(1)complexité d'espace.

Je laisserai mon explication ci-dessous intacte, mais j’aimerais ajouter que j’estime maintenant qu’il est impossible de réaliser O(1)la complexité de l’espace sans faire quelques hypothèses.

Preuve

Définir Ncomme un entier tel que 2 <= N.

Soit Sune liste représentant une série d’entiers aléatoires [x{1}, ..., x{N}], où x{i}a la contrainte 1 <= x{i} <= N.

La complexité temporelle (en notation Big-O) requise pour parcourir cette liste exactement une fois par élément est O(n)

Le défi consiste à trouver la première valeur dupliquée dans la liste. Plus précisément, nous recherchons la première valeur Squi est un duplicata d’un élément précédent de la liste.

Laissez pet qsoyez les positions de deux éléments dans la liste tels que p < qet x{p} == x{q}. Notre défi consiste à trouver le plus petit qqui réponde à ces conditions.

L'approche évidente de ce problème est de parcourir S et de vérifier si notre x{i}existe dans une autre liste T: S'il x{i}n'existe pas dans T, nous le stockons dans T. Si x{i}existe dans T, c'est la première valeur en double et donc la plus petite q, et en tant que telle, nous la retournons. Cette efficacité spatiale est O(n).

Pour atteindre O(1)la complexité de l’espace tout en maintenant la O(n)complexité temporelle, nous devons stocker des informations uniques sur chaque objet de la liste dans un espace fini. De ce fait, la seule façon pour un algorithme de fonctionner àO(1)la complexité de l'espace est si: 1. N se voit attribuer une limite supérieure correspondant à la mémoire nécessaire pour stocker le nombre maximal de valeurs possibles pour un type de données fini particulier. 2. La réaffectation d'une seule variable immuable ne compte pas dans la complexité, mais uniquement dans le nombre de variables (une liste étant plusieurs variables). 3. (Basé sur d'autres réponses) La liste est (ou au moins, les éléments de la liste sont) mutable, et le type de données de la liste est prédéfini comme un entier signé, ce qui permet d'apporter des modifications aux éléments plus loin dans la liste. sans utiliser de mémoire supplémentaire.

1 et 3 nécessitent à la fois des hypothèses et des spécifications sur le type de données, tandis que 2 requiert que seul le nombre de variables soit pris en compte pour le calcul de la complexité de l'espace, plutôt que la taille de ces variables. Si aucune de ces hypothèses n’est acceptée, il serait impossible d’obtenir à la O(n)fois une complexité temporelle et une O(1)complexité spatiale.

Explication

Whoo Boy, celui-ci a mis un temps long à imaginer un peu de puissance cérébrale.

Donc, aller au bonus est difficile. Nous avons besoin que les deux contrôlent une seule fois la totalité de la liste et identifient les valeurs sur lesquelles nous avons déjà effectué une itération sans complexité d'espace supplémentaire.

La manipulation de bits résout ces problèmes. Nous initialisons notre O(1)«stockage», une paire d’entiers, puis nous parcourons la liste, OU le bit indiqué dans notre premier entier et le stockage du résultat dans le second.

Par exemple, si nous 1101effectuons une opération OR avec 10, nous obtenons 1111. Si nous faisons un autre OU avec 10, nous avons toujours 1101.

Ainsi, une fois que nous avons effectué l'opération OR et que nous nous retrouvons avec le même numéro, nous avons trouvé notre duplicata. Aucun doublon dans le tableau ne provoque l'exécution du programme et une exception.

PHP, 56 44 38 32 octets

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

Courez comme ça:

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

Explication

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.

Tweaks

• 12 octets enregistrés en utilisant des variables au lieu d'un tableau
• Sauvegardé 6 octets en utilisant la règle "comportement indéfini" pour quand il n'y a pas de correspondance.
• Sauvegardé 6 octets en utilisant post-incrémentation au lieu de mettre à 1 après chaque boucle

Complexité

Comme le montre la version commentée du code, la complexité temporelle est linéaire O(n). En termes de mémoire, un maximum de n+1variables sera attribué. Donc c'est ça O(n).

Java 8, 82 78 76 octets N'est plus viable, 75 67 64 octets ci-dessous en modification

En tant que fonction lambda:

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

Peut être probablement beaucoup plus petit, c'était très rapide.

Explication:

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
}

*Modifier*

75 67 64 octets utilisant la stratégie de négation:

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

Essayez-le en ligne!

(-3 octets grâce à @Nevay)

Explication:

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
}

Boucle sur le tableau, nier pour garder une trace. S'il n'y a pas de dupes, il suffit de lancer une erreur.

Tous deux travaillent sur la complexité en temps O (n) et en espace O (n).

Brachylog , 5 octets

a⊇=bh

Essayez-le en ligne!

Explication

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.

Le préfixe intégré à Adfix arépertorie d'abord tous les préfixes par ordre croissant de longueur, puis les suffixes par ordre décroissant. Ainsi, la sortie est produite par le préfixe le plus court qui le permet, le cas échéant. Si un préfixe n'a pas de doublons, le reste du programme échoue car chaque sous-séquence d'éléments égaux a une longueur de 1 et le premier élément de sa queue n'existe pas. Si un préfixe a un élément répété, nous pouvons choisir la sous-séquence de longueur 2 contenant les deux, et le programme renvoie la dernière.

C #, 145 octets

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

Probablement un moyen beaucoup plus court de faire cela en C # avec une simple boucle mais je voulais l'essayer avec Linq.

Essayez-le en ligne!

Version complète / formatée:

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 octets

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

Essayez-le en ligne!

9 octets sauvés grâce à @nimi

Un chemin de base à travers la liste. Si l'élément actuel n'a pas encore été vu ( i<0) et qu'il est dans la liste d'accumulateur ( elem x a), stockez l'index actuel. Sinon, gardez l'index -1. Dans tous les cas, ajoutez l'élément en cours à la liste des accumulateurs.

EDIT : Je n’ai pas lu la question suffisamment attentivement: ce code affiche l’index du deuxième élément d’un élément dupliqué.

Python 2, 71 65 octets

Renvoie Nones'il n'y a pas d'élément en double

Edit: -6 octets grâce à @ musicman523

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

Essayez-le en ligne!

O (n) complexité temporelle, O (n) complexité spatiale, O (1) espace auxiliaire.

Comme la liste d’entrée utilise O (n) espace, la complexité de l’espace est liée à cela. Ce qui signifie que nous ne pouvons pas avoir une complexité d'espace inférieure à O (n)

Modifie la liste d'origine. Si ce n'est pas autorisé, nous pourrions le faire avec la même complexité avec 129 octets.

Explication

Étant donné que chaque élément est supérieur à 0 et inférieur ou égal à la taille de la liste, la liste a pour chaque élément a, un élément d'indice a - 1 (0 indexé). Nous exploitons cela en disant que si l'élément d'indice i est négatif, nous l'avons déjà vu.

Pour chaque élément a de la liste n, on laisse u négatif la valeur absolue de a. (Nous le laissons négatif car python peut indexer des listes avec des index négatifs, sinon nous aurions besoin de le faire u=abs(a)-1 ) Si l'élément à l'index u dans la liste est négatif, nous l'avons déjà vu et pouvons donc renvoyer -u (pour obtenir le valeur absolue de a, car tous les éléments sont positifs) . Sinon, nous définissons l'élément à l'index u comme négatif, pour nous rappeler que nous avons déjà vu un élément de valeur a.

Gelée , 4 octets

ŒQi0

Essayez-le en ligne!

Si tous les éléments sont uniques, cela retourne 0(comportement indéfini).