Yalnızca 1 ile a.ongth arasındaki sayıları içeren bir dizi a verildiğinde, ikinci oluşumun minimum dizine sahip olduğu ilk kopya numarasını bulun. Başka bir deyişle, 1'den fazla çoğaltılmış sayı varsa, ikinci oluşumun diğer sayıdan ikinci oluşumundan daha küçük bir dizine sahip olduğu sayıyı döndürün. Böyle bir eleman yoksa, programınız / fonksiyonunuz tanımsız davranışa neden olabilir.

Örnek:

Çünkü a = [2, 3, 3, 1, 5, 2]çıktı olması gerekir firstDuplicate(a) = 3.

2 yineleme vardır: 2 ve 3 sayıları. 3'ün ikinci oluşumu, 2'nin ikinci oluşumundan daha küçük bir dizine sahiptir, bu nedenle cevap 3'tür.

Çünkü a = [2, 4, 3, 5, 1]çıktı olması gerekir firstDuplicate(a) = -1.

Bu kod golf , bayt cinsinden en kısa cevap kazanır.

BONUS: O (n) zaman karmaşıklığı ve O (1) ek alan karmaşıklığı ile çözebilir misiniz?

Python 2,34 bayt

O (n ² ) süre, O (n) boşluk

^{@Vaultah sayesinde 3 byte kurtarıldı ve @xnor'dan 3 tane daha kaydedildi!}

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

Çevrimiçi deneyin!

JavaScript (ES6), 47 36 31 25 bayt

ThePirateBay sayesinde 6 bayt kaydedildi

Bir undefinedçözüm yoksa döndürür .

Zaman karmaşıklığı: O (n) :-)
Uzay karmaşıklığı: O (n) :-(

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

Nasıl?

Biz yeni olarak kaydederek zaten karşılaştı değerlerin takip özelliklerinin orijinal dizi ait a negatif sayıları kullanarak. Bu şekilde, orijinal girişlere müdahale edemezler.

gösteri

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 bayt

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

Mathematica'nın desen eşleştirme özelliği çok harika!

ListGeçersiz girişi için orijinali döndürür .

açıklama

#/.

Girişte, değiştirin ...

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

Bir Listönceki 0 veya daha fazla unsurları arasındaki, ve kopyalarda sonra bir yinelenen elemanı ile ...

... :>a

Yinelenen eleman ile.

Jöle , 5 bayt

Ṛœ-QṪ

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Çevrimiçi deneyin! Çoğaltma bulunamazsa çöküyor.

Jöle , 6 bayt

xŒQ¬$Ḣ

Çevrimiçi deneyin!

İlk kopyayı ya da kopya yoksa 0'ı döndürür.

açıklama

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 bayt

æ@bX ¦Y

Çevrimiçi test edin!

açıklama

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

Alternatif:

æ@¯Y øX

Çevrimiçi test edin!

açıklama

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

h.-Q{

Test odası

Q içindeki her öğenin ilk görünümünü Q'dan kaldırın, ardından ilk öğeyi döndürün.

Dyalog APL, 27 24 20 19 13 12 11 bayt

⊢⊃⍨0⍳⍨⊢=⍴↑∪

Şimdi v16'ya bağlı olmayacak şekilde değiştirildi! Çevrimiçi deneyin!

Nasıl? ( N girişi ile )

• ⊢⊃⍨...- Bu endekste N :
  • ⍴↑∪- N kopyaları kaldırılmış, N0 sığacak şekilde sağ yastıklı N
  • ⊢=- N ile element-akıllı eşitlik
  • 0⍳⍨- İlk dizini 0. '

Python 3 , 94 92 bayt

O (n) süre ve O (1) ekstra bellek.

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

Çevrimiçi deneyin!

Algoritmanın kaynağı .

açıklama

Algoritmanın temel fikri, her bir eleman arasında soldan sağa doğru koşmak, ortaya çıkan sayıları takip etmek ve daha önce ortaya çıkmış bir sayıya ulaştığında sayıyı geri döndürmek ve her bir öğeyi geçtikten sonra -1 döndürmektir.

Ancak, fazladan bellek kullanmadan ortaya çıkan sayıları kaydetmek için akıllıca bir yol kullanır: Sayılarla indekslenen öğenin işareti olarak saklamak için. Örneğin, bu gerçeği temsil edebilir 2ve 3halihazırda sahip olarak ortaya çıkmıştır a[2]ve a[3]dizi 1 endeksli ise, olumsuz.

Perl 6 , 13 bayt

*.repeated[0]

Dene

açıklama

• Bu *bir Terim konumunda olduğundan tüm deyim bir WhateverCode lambda'dır.

• .repeatedHer değeri sonuçları, her bir değer görüldü ilk kez hariç olduğu bir yöntemdir.

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

• [0]sadece Sıradaki ilk değeri döndürür .
  Değer yoksa Nil döner .
  ( Nil , Arıza türlerinin temelidir ve tüm türlerin kendi tanımsız değerleri vardır, bu nedenle Nil , diğer birçok dilde tanımsız bir değerden farklıdır)

Not o yana uygulanması.repeated bir üretir Seq Eğer bir değere istemek kadar herhangi bir işi başlamaz araçlarının ve sadece yeterli çalışma Ne istediğine üretmek için yok.
Dolayısıyla  , ikinci değer birincinin tekrarı ise , en kötü O (n)  zaman karmaşıklığına ve en iyi ihtimalle O (2) zaman karmaşıklığına sahip olduğunu söylemek kolay olacaktır .
Benzer muhtemelen bellek karmaşıklığı söylenebilir.

APL (Dyalog) , 20 bayt

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

Çevrimiçi deneyin!

2⍴¯1 bir negatif r uzunluğu iki liste halinde eshaped

⎕, girdi almak (anımsatıcı: konsol kutusu) ve buna hazırlanın

n← bunu n olarak sakla

,\n  önekleri (lit. kümülatif bitiştirme)

(… )¨ Her önek için aşağıdaki tacit işlevini uygulayın

 , [bir] ravel (sadece önek bir liste olmasını sağlar)

 ≢ dan farklı

 ∪ benzersiz öğeler [?] (yani önekde çoğaltmalar var mı?)

n/⍨n'yi  filtrelemek için kullanın (bir yinelemenin bulunduğu ilk öğeye kadar tüm öğeleri kaldırır)

⊃ ondan ilk elemanı seç

APL (Dyalog) , 11 bayt

Gereğince yeni kurallar hiçbir çiftleri varsa, hata verir.

⊢⊃⍨⍬⍴⍳∘≢~⍳⍨

Çevrimiçi deneyin!

⍳⍨ Her elementin ilk oluşum endeksleri

~ dan silindi

⍳∘≢ tüm endekslerin

⍬⍴ Bunu bir skalaya yeniden şekillendirin (eğer veri mevcut değilse sıfır verir)

⊃⍨ almak için kullanın (sıfır hata verir)

⊢ argüman

APL, 15

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

Yinelenen bir şey olmadığında -1 yerine 0 değerini verebiliriz gibi görünüyor (yorum için Adám'a teşekkürler). Yani 3 bayt daha az.

Bir açıklama:

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

Başvuru için, eski çözüm sonunda listeye -1 ekledi, yani liste boş bırakılırsa, bunun yerine -1 içerecekti ve ilk eleman -1 olacaktı.

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

Tryapl.org'da deneyin

Retina , 26 24 bayt

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

Çevrimiçi deneyin! Explanation: \b(\d+)\bsırayla her numarayla eşleşiyor ve ardından gözbebeki sayının kopya olup olmadığını görmek için bakıyor; 1st ise, eşleşme !sayısı yerine çıktıdır. Maalesef ilk önce gözbebekini takmak işe yaramıyor gibi görünüyor, aksi takdirde birkaç bayt kurtarır. Düzenleme: Eşleşmedeki -1dönüş değerine uyması için 7 bayt eklendi . @ Martininder sayesinde 2 bayt kaydedildi.

MATL , 8 bayt

&=Rsqf1)

Yinelenen bir dosya yoksa, hata verir (çıktı olmadan).

MATL Online'da deneyin !

açıklama

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

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

@Djhurio tarafından verilen cevaptan bir kaç karakter kesin, yorum yapmak için yeterli itibarınız yok.

J, 17 16 bayt

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

Nasıl?

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

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

Çevrimiçi deneyin!

J , 12 bayt

,&_1{~~:i.0:

Çevrimiçi deneyin!

açıklama

,&_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 karakter

Sadece işe yarıyor ⎕IO←0.

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

Öngörülen "-1" olan ve nub listesinin indekslerini içeren argüman öğelerinin indeks listesinden çıkar ve kalanların ilkini seç. Kaldırma işleminden sonra sadece boş bir vektör kalırsa, ilk elemanı istenen -1'i üreten genişletilmiş argümanı indekslemek için kullanılan tanım 0'dır.

Ruby , 28 36 bayt

İlk defa mücadeleyi yanlış anladınız. O(n)zaman, O(n)mekan.

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

Çevrimiçi deneyin!

Java (OpenJDK 8) , 65 117 109 bayt

Önceki 65 baytlık çözüm:

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

Yeni çözüm 19 bayt dahilimport java.math.*;

@Nevay sayesinde -8 bayt

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

Çevrimiçi deneyin!

Düzenle

Orijinal programımdaki algoritma iyiydi, ancak kullanılan veri tipinin statik büyüklüğü, boyut belirli bir eşiğin üzerine çıktığında oldukça hızlı bir şekilde kırıldığı anlamına geliyordu.

Programın hafıza sınırını arttırmak için hesaplamada kullanılan veri tipini değiştirdim BigInteger( intveya yerine rastgele kesinlik için kullanmak long). Bununla birlikte, bu durumun O(1)uzay karmaşıklığı olarak sayılıp sayılmadığını tartışılabilir kılar .

Açıklamamı aşağıda tam olarak bırakacağım, ancak şimdi O(1)bazı varsayımlar yapmadan uzay karmaşıklığına ulaşmanın imkansız olduğuna inanıyorum .

Kanıt

NÖyle bir tamsayı olarak tanımlayın 2 <= N.

Kısıtlamanın olduğu Sbir dizi rasgele tamsayıyı temsil eden bir liste olsun .[x{1}, ..., x{N}]x{i}1 <= x{i} <= N

Her öğe için tam olarak bir kez bu listeyi yinelemek için gereken zaman karmaşıklığı (Big-O notasyonunda) O(n)

Verilen zorluk, listedeki ilk kopyalanan değeri bulmaktır. Daha spesifik Solarak, listedeki bir önceki öğenin kopyası olan ilk değeri arıyoruz .

Bu ve listede iki elementin pozisyonları olsun pve olsun . Mücadelemiz , bu koşulları karşılayan en küçüğü bulmak olur .qp < qx{p} == x{q}q

Bu soruna açık olan yaklaşım S ile yineleme yapmak ve x{i}başka bir listede var olup olmadığımızı kontrol etmektir T: Eğer x{i}yoksa T, içinde saklıyoruz T. Eğer x{i}mevcut değil T, bu nedenle ilk yinelenen değer ve küçüğüdür qve bu nedenle biz geri ver. Bu alan verimliliği O(n).

Zaman karmaşıklığını O(1)korurken alan karmaşıklığını elde etmek için O(n), her nesne hakkında benzersiz bilgiyi sınırlı bir alanda saklamamız gerekir. Bu nedenle, herhangi bir algoritmanın gerçekleştirebileceği tek yolO(1)boşluk karmaşıklığı şöyledir: 1. N, belirli bir sonlu veri türü için mümkün olan maksimum değer sayısını saklamak için gereken belleğe karşılık gelen bir üst sınır verilir. 2. Tek bir değişmez değişkenin yeniden atanması karmaşıklığa karşı sayılmaz, sadece değişkenlerin sayısı (bir liste birden fazla değişkendir). 3. (Diğer cevaplara dayanarak) Liste (veya en azından listenin elemanları) değişkendir ve listenin veri türü, listedeki öğelerde değişiklik yapılmasını sağlayan imzalı bir tamsayı olarak önceden ayarlanmıştır. ek bellek kullanmadan.

1 ve 3'ün her ikisi de veri türü hakkında varsayımlar ve spesifikasyonlar gerektirirken, 2 bu değişkenlerin büyüklüğü yerine alan karmaşıklığının hesaplanması için sadece değişkenlerin sayısının dikkate alınmasını gerektirir. Bu varsayımların hiçbiri kabul edilmezse, hem O(n)zaman karmaşıklığına hem de O(1)mekan karmaşıklığına ulaşmak imkansız olacaktır .

açıklama

Kim çocuğum, bu biraz beyin gücü düşünmek için çok utanç verici bir zaman aldı .

Bu yüzden bonusu almak zordur. Biz de tam olarak listenin tamamının üzerinde çalışmasına gerek ve biz zaten ek alan karmaşıklığı olmadan iterated ettik değerleri iz.

Bit manipülasyon bu sorunları çözer. O(1)Bir çift tamsayı olan 'depolamamızı' başlattıktan sonra listeyi yineledik, ith bitini ilk tamsayıya yerleştirip ikincisini sakladık.

Mesela 1101bizde bir VEYA işlemi gerçekleştirirsek 10, anlıyoruz 1111. Başka bir VEYA ile 10yaparsak, yine de sahibiz 1101.

Ergo, OR işlemini yaptığımızda ve aynı numara ile bittikten sonra, kopyamızı bulduk. Dizideki hiçbir kopya, programın çalışıp bir istisna atmasına neden olmaz.

PHP, 56 44 38 32 bayt

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

Bu şekilde koş:

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

açıklama

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.

Düzenlemeler

• Bir dizi yerine değişkenler kullanarak 12 bayt kaydedildi
• Eşleşme olmadığı zaman için "tanımsız davranış" kuralını kullanarak 6 bayt kurtarıldı.
• Her döngüden sonra 1 olarak ayarlamak yerine artım sonrası kullanılarak 6 bayt kaydedildi

karmaşa

Kodun yorumlanan versiyonundan da anlaşılacağı gibi, zaman karmaşıklığı doğrusaldır O(n). Hafıza açısından, maksimum n+1değişken atanacaktır. Yani bu O(n).

Java 8, 82 78 76 bayt Artık uygun değil, düzenlemede 75 67 64 bayt

Bir lambda işlevi olarak:

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

Muhtemelen çok daha küçük yapılabilir, bu çok hızlıydı.

Açıklama:

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
}

*Düzenle*

Olumsuzlama stratejisini kullanarak 75 67 64 bayt:

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

Çevrimiçi deneyin!

(@Nevay sayesinde -3 bayt)

Açıklama:

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
}

Dizi üzerinde döngü kurar, takip etmeyi reddeder. Eğer sıfır yoksa, sadece çalışır ve bir hata atar.

Her ikisi de O (n) zamanı ve O (n) uzay karmaşıklığı üzerinde çalışır.

Brachylog , 5 bayt

a⊇=bh

Çevrimiçi deneyin!

açıklama

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.

Eklenti yerleşimi aönce tüm önekleri artan uzunluk sırasına göre sıralar, ardından azalan uzunluk sırasına ekler. Bu nedenle çıktı, varsa izin veren en kısa ön ek tarafından üretilir. Bir önekde hiçbir kopya yoksa, programın geri kalanı bunun için başarısız olur, çünkü eşit elemanların her bir sırası 1 uzunluğa sahiptir ve kuyruğunun ilk elemanı yoktur. Bir önekde tekrarlanan bir eleman varsa, her ikisini de içeren uzunluk-2 sırasını seçebiliriz ve program ikincisini döndürür.

C #, 145 bayt

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

Muhtemelen C # 'da basit bir döngü ile bunu yapmanın çok daha kısa bir yoludur ama Linq ile denemek istedim.

Çevrimiçi deneyin!

Tam / Biçimli sürüm:

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 bayt

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

Çevrimiçi deneyin!

@Nimi sayesinde 9 bayt kaydedildi

Listede temel bir yol. Geçerli öğe henüz görülmediyse ( i<0) ve akümülatör listesinde ( elem x a) ise, geçerli dizini saklayın. Aksi takdirde, -1 dizinini koru. Her durumda, geçerli öğeyi akümülatör listesine ekleyin.

EDIT : Soruyu yeterince dikkatlice okumadım: bu kod bir kopya elemanın ikinci elemanının indeksini çıkarır.

Python 2, 71 65 bayt

NoneYinelenen öğe yoksa döndürür

Düzenleme: -6 bayt @ musicman523 sayesinde

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

Çevrimiçi deneyin!

O (n) zaman karmaşıklığı, O (n) alan karmaşıklığı, O (1) yardımcı alan.

Giriş listesi O (n) boşluğu kullandığından , boşluk karmaşıklığı buna bağlıdır. Yani O (n) ' den daha düşük bir alan karmaşıklığına sahip olamayız.

Orijinal listeyi değiştiriyor mu, eğer izin verilmezse, 129 byte ile aynı karmaşıklıkta yapabiliriz.

açıklama

Her öğe 0'dan büyük ve listenin boyutuna eşit veya ondan daha küçük olduğundan, liste her öğe için a - 1 (0 dizinlenmiş) dizininde bir öğe içerir. Bunu, i indeksindeki eleman negatifse daha önce gördüğümüzü söyleyerek sömürüyoruz.

N listesindeki her eleman için, a'nın mutlak değerini negatif olarak verelim. (Biz bunu olumsuz endeksleri ile piton kutu endeksi listelerinde beri negatif olalım ve biz başka türlü yapmak gerekir u=abs(a)-1 ) listesinde indeksi u eleman negatif, bunu daha önce de gördük edilirse ve bu nedenle -u dönebilirsiniz almak için ( Tüm elemanlar pozitif olduğu için a'nın mutlak değeri) . Aksi takdirde, daha önce bir değer elementi gördüğümüzü hatırlamak için u indeksindeki elementi negatif olarak ayarladık.

Jöle , 4 bayt

ŒQi0

Çevrimiçi deneyin!

Tüm öğelerin benzersiz olması durumunda, bu döndürür 0(tanımsız davranış).