Listede Olmayan En Küçük Tamsayıyı Bulun

Bir meslektaşımın kullandığı ilginç bir röportaj sorusu:

Size çok uzun, sıralanmamış 64 bitlik işaretsiz tam sayılar listesi verildiğini varsayalım. Listede bulunmayan en küçük negatif olmayan tamsayıyı nasıl bulursunuz ?

İZLEME: Sıralamayla bariz bir çözüm önerildiğine göre, bunu O (n log n) den daha hızlı yapabilir misiniz?

TAKİP: Algoritmanız, örneğin 1 GB belleğe sahip bir bilgisayarda çalışmalıdır.

AYDINLATMA: Liste RAM içindedir, ancak büyük bir kısmını tüketebilir. Önceden N diyelim listenin boyutu size verilir.

Veri yapısı yerinde değiştirilebiliyorsa ve rastgele erişimi destekliyorsa, bunu O (N) zamanı ve O (1) ek alanda yapabilirsiniz. Sadece diziyi sırayla gözden geçirin ve her dizin için dizindeki değeri değerle belirtilen dizine yazın, o konuma herhangi bir değeri yinelemeli olarak yerleştirin ve değerleri atarak> N Sonra noktayı arayan diziye tekrar gidin burada değer dizinle eşleşmiyor - bu dizide olmayan en küçük değerdir. Bu, en fazla 3N karşılaştırmasına neden olur ve yalnızca birkaç değer değerinde geçici alan kullanır.

# Pass 1, move every value to the position of its value
for cursor in range(N):
    target = array[cursor]
    while target < N and target != array[target]:
        new_target = array[target]
        array[target] = target
        target = new_target

# Pass 2, find first location where the index doesn't match the value
for cursor in range(N):
    if array[cursor] != cursor:
        return cursor
return N

İşte alanı O(N)kullanan basit bir çözüm O(N). Giriş listesini negatif olmayan sayılarla sınırladığımızı ve listede olmayan ilk negatif olmayan sayıyı bulmak istediğimizi varsayıyorum.

1. Listenin uzunluğunu bulun; diyelim öyle N.
2. NHepsi için başlatılan bir boole dizisi ayırın false.
3. XListedeki her sayı için, eğer Xküçükse N, X'thdizinin öğesini olarak ayarlayın true.
4. Diziyi dizinden başlayarak 0ilk öğeyi arayarak tarayın false. İlkini falsedizinde bulursanız I, o zaman Icevaptır. Aksi takdirde (yani tüm unsurlar olduğu zaman true) cevaptır N.

Pratikte, " Nmantıksal değer dizisi " muhtemelen bir byteveya intdizi olarak temsil edilen "bit eşlem" veya "bit kümesi" olarak kodlanacaktır . Bu genellikle daha az alan kullanır (programlama diline bağlı olarak) ve ilk taramanın falsedaha hızlı yapılmasını sağlar.

Algoritmanın nasıl / neden çalıştığı budur.

NListedeki sayıların farklı olmadığını veya bir veya daha fazlasının değerinden büyük olduğunu varsayalım N. Bu , listede olmayan aralıkta en az bir sayı olması gerektiği anlamına gelir 0 .. N - 1. Bu nedenle, en küçük eksik sayıyı bulma sorunu, bu nedenle, en küçük eksik sayıyı daha azN bulma sorununa indirgemelidir . Bu, büyük veya eşit sayıları takip etmemize gerek olmadığı anlamına gelir N... çünkü cevap onlar olmayacaktır.

Önceki paragrafın alternatifi, listenin, gelen sayıların bir permütasyonu olmasıdır 0 .. N - 1. Bu durumda, 3. adım dizinin tüm öğelerini olarak ayarlar trueve 4. adım bize ilk "eksik" sayının olduğunu söyler N.

Algoritmanın hesaplama karmaşıklığı, O(N)nispeten küçük bir orantılılık sabiti ile. Listede iki doğrusal geçiş yapar veya liste uzunluğunun başladığı biliniyorsa yalnızca bir geçiş yapar. Listenin tamamını bellekte tutmaya gerek yoktur, bu nedenle algoritmanın asimtotik bellek kullanımı boole dizisini temsil etmek için gereken şeydir; yani O(N)bitler.

(Aksine, bellek içi sıralama veya bölümlemeye dayanan algoritmalar, tüm listeyi bellekte temsil edebileceğinizi varsayar. Sorunun sorulduğu biçimde, bu O(N)64 bit sözcükler gerektirir .)

@Jorn, 1'den 3'e kadar olan adımların sıralamayı saymanın bir varyasyonu olduğunu söylüyor. Bir bakıma haklı ama farklar önemli:

• Sayma sıralaması , listedeki en büyük sayı ve listedeki en küçük sayı olan (en azından) bir Xmax - Xminsayaç dizisi gerektirir . Her sayaç N durumu temsil edebilmelidir; yani bir ikili gösterimi varsayarsak, tam sayı tipinde (en azından) bitlere sahip olmak zorundadır .XmaxXminceiling(log2(N))
• Dizi boyutunu belirlemek için, bir sayma sıralaması Xmaxve belirlemek için listeden bir ilk geçiş yapması gerekir Xmin.
• Bu nedenle minimum en kötü durum alanı gereksinimi ceiling(log2(N)) * (Xmax - Xmin)bittir.

Aksine, yukarıda sunulan algoritma basitçe Nen kötü ve en iyi durumlarda bit gerektirir .

Bununla birlikte, bu analiz, eğer algoritma bir sıfırı bulmak için listeden bir ilk geçiş yaparsa (ve gerekirse liste öğelerini sayarsa), sıfırı bulursa hiç boşluk kullanmadan daha hızlı bir cevap vereceği sezgisine yol açar. Listede en az bir sıfır bulma olasılığı yüksekse kesinlikle bunu yapmaya değer. Ve bu ekstra geçiş genel karmaşıklığı değiştirmez.

DÜZENLEME: Algoritmanın açıklamasını "boole dizisi" kullanacak şekilde değiştirdim çünkü insanlar görünüşe göre orijinal açıklamamı bitler ve bit eşlemler kullanarak kafa karıştırıcı buldular.

OP şimdi orijinal listenin RAM'de tutulduğunu ve bilgisayarın sadece 1GB belleğe sahip olduğunu belirttiğinden, bir uzvun dışına çıkıp cevabın sıfır olduğunu tahmin edeceğim.

1GB RAM, listede en fazla 134,217,728 numara olabileceği anlamına gelir. Ancak 2 ⁶⁴ = 18,446,744,073,709,551,616 olası sayı vardır. Yani listede sıfır olma olasılığı 137.438.953.472'de 1'dir.

Aksine, bu yıl yıldırım çarpma olasılığım 700.000'de 1. Ve bir göktaşı çarpma olasılığım 10 trilyonda 1. Bu yüzden, cevabın sıfır olmamasından ziyade gök cismi tarafından zamansız ölümüm nedeniyle bilimsel bir dergide yazılma olasılığım yaklaşık on kat daha fazladır.

Diğer cevaplarda belirtildiği gibi, bir sıralama yapabilir ve ardından bir boşluk bulana kadar basitçe tarayabilirsiniz.

Algoritmik karmaşıklığı O (N) olarak iyileştirebilir ve boşluğu içermek için potansiyel aday olmayan bölümleri ortadan kaldırdığınız değiştirilmiş bir QuickSort kullanarak O (N) alanını koruyabilirsiniz.

• İlk bölüm aşamasında, kopyaları kaldırın.
• Bölümleme tamamlandığında, alt bölümdeki öğelerin sayısına bakın.
• Bu değer bölümü oluşturmak için kullanılan değere eşit mi?
  • Eğer öyleyse, o zaman boşluğun daha yüksek bölümde olduğu anlamına gelir.
    • Alt bölümü yok sayarak hızlı sıralamaya devam edin
  • Aksi takdirde boşluk alt kısımdadır
    • Daha yüksek bölümü yok sayarak hızlı sıralamaya devam edin

Bu, çok sayıda hesaplama tasarrufu sağlar.

O(N)Düşünmenin tuzaklarından birini açıklamak için , burada boşluk O(N)kullanan bir algoritma var O(1).

for i in [0..2^64):
  if i not in list: return i

print "no 64-bit integers are missing"

Sayıların tümü 64 bit uzunluğunda olduğundan , bunlar üzerinde O (n) olan radix sıralama kullanabiliriz . Sıralayın, ardından aradığınızı bulana kadar tarayın.

en küçük sayı sıfır ise, bir boşluk bulana kadar ileriye doğru tarayın. En küçük sayı sıfır değilse, cevap sıfırdır.

Alanı verimli kullanan bir yöntem için ve tüm değerler farklıdır, bunu uzay O( k )ve zamanda yapabilirsiniz O( k*log(N)*N ). Alan verimlidir ve veri taşıma yoktur ve tüm işlemler temeldir (çıkarma ekleme).

1. Ayarlamak U = N; L=0
2. Önce kbölgelerdeki sayı uzayını bölümlere ayırın. Bunun gibi:
   • 0->(1/k)*(U-L) + L, 0->(2/k)*(U-L) + L, 0->(3/k)*(U-L) + L...0->(U-L) + L
3. count{i}Her bölgede kaç sayı ( ) olduğunu bulun . ( N*kadımlar)
4. hDolu olmayan ilk bölgeyi ( ) bulun . Bu demektir count{h} < upper_limit{h}. (k adımlar)
5. Eğer h - count{h-1} = 1 size cevap var
6. Ayarlamak U = count{h}; L = count{h-1}
7. 2'ye git

bu, hashing kullanılarak geliştirilebilir (bu fikir Nic için teşekkürler).

1. aynı
2. Önce kbölgelerdeki sayı uzayını bölümlere ayırın. Bunun gibi:
   • L + (i/k)->L + (i+1/k)*(U-L)
3. inc count{j} kullanma j = (number - L)/k (if L < number < U)
4. ilk bölgeyi bul (hiçinde k öğesi olmayan )
5. Eğer count{h} = 1 h Cevabınız
6. Ayarlamak U = maximum value in region h L = minimum value in region h

Bu koşacak O(log(N)*N).

Onları sıralar ve sonra bir boşluk bulana kadar diziyi çalıştırırım (başlangıçtaki sıfır ile ilk sayı arasındaki boşluk dahil).

Algoritma açısından şöyle bir şey yapabilir:

def smallest_not_in_list(list):
    sort(list)
    if list[0] != 0:
        return 0
    for i = 1 to list.last:
        if list[i] != list[i-1] + 1:
            return list[i-1] + 1
    if list[list.last] == 2^64 - 1:
        assert ("No gaps")
    return list[list.last] + 1

Elbette, CPU grunt'tan çok daha fazla belleğiniz varsa, tüm olası 64 bitlik değerlerden bir bit maskesi oluşturabilir ve listedeki her sayı için bitleri ayarlayabilirsiniz. Sonra bu bit maskesindeki ilk 0 biti arayın. Bu, zaman açısından bir O (n) işlemine dönüştürür, ancak bellek gereksinimleri açısından oldukça pahalıdır :-)

Her sayıya en az bir kez bakmayı gerektirmeyen bir yol göremediğim için O (n) 'yi geliştirebileceğinizden şüpheliyim.

Bunun için algoritma şu satırlar boyunca olacaktır:

def smallest_not_in_list(list):
    bitmask = mask_make(2^64) // might take a while :-)
    mask_clear_all (bitmask)
    for i = 1 to list.last:
        mask_set (bitmask, list[i])
    for i = 0 to 2^64 - 1:
        if mask_is_clear (bitmask, i):
            return i
    assert ("No gaps")

Listeyi sıralayın, birinci ve ikinci öğelere bakın ve boşluk olana kadar yukarı çıkmaya başlayın.

Gizli faktör oldukça büyük olmasına rağmen, O (n) zamanında ve O (1) ek boşlukta yapabilirsiniz. Bu, sorunu çözmenin pratik bir yolu değildir, ancak yine de ilginç olabilir.

Her işaretsiz 64 bit tam sayı için (artan sırada), hedef tamsayıyı bulana veya listenin sonuna ulaşana kadar listeyi yineleyin. Listenin sonuna ulaşırsanız, hedef tam sayı listede olmayan en küçük tamsayıdır. 64 bitlik tam sayıların sonuna ulaşırsanız, her 64 bitlik tam sayı listede yer alır.

İşte bir Python işlevi olarak:

def smallest_missing_uint64(source_list):
    the_answer = None

    target = 0L
    while target < 2L**64:

        target_found = False
        for item in source_list:
            if item == target:
                target_found = True

        if not target_found and the_answer is None:
            the_answer = target

        target += 1L

    return the_answer

Bu işlev, onu O (n) tutmak için kasıtlı olarak yetersizdir. Özellikle, yanıt bulunduktan sonra bile işlevin hedef tam sayıları kontrol etmeye devam ettiğini unutmayın. Fonksiyon cevap bulunur bulunmaz geri döndüyse, dış döngünün kaç kez çalıştığı, n ile bağlı olan cevabın boyutuna bağlı olacaktır. Bu değişiklik, çok daha hızlı olmasına rağmen çalışma süresini O (n ^ 2) yapar.

İlham kaynağım için egon, swilden ve Stephen C'ye teşekkürler. İlk olarak, hedef değerinin sınırlarını biliyoruz çünkü listenin boyutundan büyük olamaz. Ayrıca, 1 GB'lık bir liste en çok 134217728 (128 * 2 ^ 20) 64 bit tam sayı içerebilir.

Hashing parçası
Arama alanımızı önemli ölçüde azaltmak için hashing kullanmayı öneriyorum. İlk olarak, listenin boyutunun karekökünü alın. 1 GB'lık bir liste için bu N = 11,586'dır. N boyutunda bir tamsayı dizisi oluşturun. Listede yineleyin ve bulduğunuz her sayının karekökünü * karma değeriniz olarak alın. Hash tablonuzda, bu hash için sayacı artırın. Ardından, karma tablonuzda yineleyin. Maksimum boyutuna eşit olmayan bulduğunuz ilk kova, yeni arama alanınızı tanımlar.

Bitmap bölümü
Şimdi yeni arama alanınızın boyutuna eşit normal bir bit eşlemi oluşturun ve arama alanınızdaki her bir sayıyı bulduğunuzda bit eşlemi doldurarak kaynak listesinde tekrar yineleyin. Bitirdiğinizde, bit eşleminizdeki ilk ayarlanmayan bit size cevabınızı verecektir.

Bu, O (n) zamanda ve O (sqrt (n)) uzayda tamamlanacaktır.

(* Bunu çok daha verimli bir şekilde yapmak için bit kaydırma gibi bir şey kullanabilir ve yalnızca kova sayısını ve boyutunu buna göre değiştirebilirsiniz.)

Bir sayı listesinde yalnızca bir eksik sayı varsa, eksik sayıyı bulmanın en kolay yolu seriyi toplamak ve listedeki her bir değeri çıkarmaktır. Son değer, eksik sayıdır.

 int i = 0;
            while ( i < Array.Length)
            {

                if (Array[i] == i + 1)
                {
                    i++;
                }

                if (i < Array.Length)
                {
                    if (Array[i] <= Array.Length)
                    {//SWap

                        int temp = Array[i];
                        int AnoTemp = Array[temp - 1];
                        Array[temp - 1] = temp;
                        Array[i] = AnoTemp;

                    }
                    else
                       i++;



                }
            }

            for (int j = 0; j < Array.Length; j++)
            {
                if (Array[j] > Array.Length)
                {
                    Console.WriteLine(j + 1);
                    j = Array.Length;
                }
                else
                    if (j == Array.Length - 1)
                        Console.WriteLine("Not Found !!");

            }
        }

Numaraları tutmak için bir karma tablo kullanabiliriz. Tüm sayılar tamamlandığında, 0'dan en düşük olanı bulana kadar bir sayaç çalıştırın. Makul derecede iyi bir hash, sabit zamanda hash ve depolanır ve sabit zamanda alır.

for every i in X         // One scan Θ(1)
   hashtable.put(i, i);  // O(1)

low = 0;

while (hashtable.get(i) <> null)   // at most n+1 times
   low++;

print low;

En kötü durum n, dizide elemanlar varsa ve {0, 1, ... n-1}bu durumda, cevap nhala onu koruyarak elde edilecektir O(n).

İşte Java ile yazılmış cevabım:

Temel Fikir: 1- Geri kalanını toplarken, aynı zamanda maksimum pozitif sayıyı alırken yinelenen pozitif, sıfır ve negatif sayıları atarak dizide döngü yapın ve benzersiz pozitif sayıları bir Haritada tutun.

2- Toplamı max * (max + 1) / 2 olarak hesaplayınız.

3- 1. ve 2. adımlarda hesaplanan toplamlar arasındaki farkı bulun

4- 1'den minimum [toplam fark, maks] 'a tekrar döngü yapın ve 1. adımda doldurulan haritada olmayan ilk sayıyı döndürün.

public static int solution(int[] A) {
    if (A == null || A.length == 0) {
        throw new IllegalArgumentException();
    }

    int sum = 0;
    Map<Integer, Boolean> uniqueNumbers = new HashMap<Integer, Boolean>();
    int max = A[0];
    for (int i = 0; i < A.length; i++) {
        if(A[i] < 0) {
            continue;
        }
        if(uniqueNumbers.get(A[i]) != null) {
            continue;
        }
        if (A[i] > max) {
            max = A[i];
        }
        uniqueNumbers.put(A[i], true);
        sum += A[i];
    }
    int completeSum = (max * (max + 1)) /  2;
    for(int j = 1; j <= Math.min((completeSum - sum), max); j++) {
        if(uniqueNumbers.get(j) == null) { //O(1)
            return j;
        }
    }
    //All negative case
    if(uniqueNumbers.isEmpty()) {
        return 1;
    }
    return 0;
}

Stephen C'nin akıllıca işaret ettiği gibi, yanıt dizinin uzunluğundan daha küçük bir sayı olmalıdır. Daha sonra cevabı ikili aramayla bulurdum. Bu, en kötü durumu optimize eder (böylece görüşmeci sizi 'eğer' patolojik bir senaryoda yakalayamaz). Bir röportajda, bunu en kötü durum için optimize etmek için yaptığınızı belirtin.

İkili aramayı kullanmanın yolu, aradığınız sayıyı dizinin her bir öğesinden çıkarmak ve negatif sonuçları kontrol etmektir.

"Sıfır tahmin" yaklaşımını beğendim. Sayılar rastgele olsaydı, sıfır olasılığı yüksektir. "İnceleyen kişi" rastgele olmayan bir liste oluşturduysa, bir tane ekleyin ve tekrar tahmin edin:

LowNum=0
i=0
do forever {
  if i == N then leave /* Processed entire array */
  if array[i] == LowNum {
     LowNum++
     i=0
     }
   else {
     i++
   }
}
display LowNum

En kötü durum, n = N ile n * N'dir, ancak pratikte n'nin küçük bir sayı olma olasılığı yüksektir (örneğin 1)

Soruyu anladığımdan emin değilim. Ancak 1,2,3,5,6 listesi için ve eksik sayı 4 ise, eksik sayı O (n) 'de şu şekilde bulunabilir: (n + 2) (n + 1) / 2- (n + 1) n / 2

DÜZENLEME: üzgünüm, sanırım dün gece çok hızlı düşünüyordum. Her neyse, ikinci bölüm aslında O (n) 'nin geldiği yer olan sum (liste) ile değiştirilmelidir. Formül, arkasındaki fikri ortaya koymaktadır: n sıralı tam sayı için, toplam (n + 1) * n / 2 olmalıdır. Eksik bir sayı varsa, toplam, (n + 1) sıralı tamsayıların toplamından eksik sayının çıkarılmasıyla elde edilen sayıya eşit olacaktır.

Aklımda bazı orta parçalar koyduğuma işaret ettiğiniz için teşekkürler.

Tebrikler Karıncalar Aasma! Cevabı yaklaşık 15 dakika düşündüm ve bağımsız olarak, sizinkine benzer bir düşünce tarzında bir cevap buldum:

#define SWAP(x,y) { numerictype_t tmp = x; x = y; y = tmp; }
int minNonNegativeNotInArr (numerictype_t * a, size_t n) {
    int m = n;
    for (int i = 0; i < m;) {
        if (a[i] >= m || a[i] < i || a[i] == a[a[i]]) {
            m--;
            SWAP (a[i], a[m]);
            continue;
        }
        if (a[i] > i) {
            SWAP (a[i], a[a[i]]);
            continue;
        }
        i++;
    }
    return m;
}

m, "ilk i girişleri hakkında bildiklerim verildiğinde ve m-1'deki girişe kadar değerler hakkında başka hiçbir şey varsaymadığım mevcut maksimum olası çıktıyı" temsil eder.

Bu m değeri yalnızca (a [i], ..., a [m-1]) değerlerin (i, ..., m-1) bir permütasyonu ise döndürülür. Dolayısıyla, a [i]> = m veya a [i] <i ise veya a [i] == a [a [i]] ise, m'nin yanlış çıktı olduğunu ve en az bir eleman daha düşük olması gerektiğini biliyoruz. Yani m'yi azaltarak ve a [i] 'yi a [m] ile değiştirebiliriz.

Bu doğru değilse ancak a [i]> i ise, a [i]! = A [a [i]] olduğunu bildiğimizde, a [i] 'yi bir [a [i]] ile değiştirmenin eleman sayısını artıracağını biliyoruz kendi yerlerinde.

Aksi takdirde a [i] i'ye eşit olmalıdır, bu durumda bu indeks dahil tüm değerlerin indekslerine eşit olduğunu bilerek artırabiliriz.

Bunun sonsuz bir döngüye giremeyeceğinin kanıtı, alıştırma olarak okuyucuya bırakılmıştır. :)

Dafny Ants' cevabı şovları parçası neden yerinde algoritması başarısız olabilir. requiresÖn şart her öğenin değerleri dizi sınırlarının ötesine gerektiğini açıklamaktadır.

method AntsAasma(A: array<int>) returns (M: int)
  requires A != null && forall N :: 0 <= N < A.Length ==> 0 <= A[N] < A.Length;
  modifies A; 
{
  // Pass 1, move every value to the position of its value
  var N := A.Length;
  var cursor := 0;
  while (cursor < N)
  {
    var target := A[cursor];
    while (0 <= target < N && target != A[target])
    {
        var new_target := A[target];
        A[target] := target;
        target := new_target;
    }
    cursor := cursor + 1;
  }

  // Pass 2, find first location where the index doesn't match the value
  cursor := 0;
  while (cursor < N)
  {
    if (A[cursor] != cursor)
    {
      return cursor;
    }
    cursor := cursor + 1;
  }
  return N;
}

forall ...Doğrulama hatasını görmek için kodu doğrulayıcıya cümle ile ve cümle olmadan yapıştırın . İkinci hata, doğrulayıcının Geçiş 1 döngüsü için bir sonlandırma koşulu kuramamasının bir sonucudur. Bunu kanıtlamak, aracı daha iyi anlayan birine bırakılmıştır.

Java'da, girişi değiştirmeyen ve O (N) zaman ve N bit artı küçük bir sabit bellek yükü kullanan bir cevap var (burada N, listenin boyutudur):

int smallestMissingValue(List<Integer> values) {
    BitSet bitset = new BitSet(values.size() + 1);
    for (int i : values) {
        if (i >= 0 && i <= values.size()) {
            bitset.set(i);
        }
    }
    return bitset.nextClearBit(0);
}

def solution(A):

index = 0
target = []
A = [x for x in A if x >=0]

if len(A) ==0:
    return 1

maxi = max(A)
if maxi <= len(A):
    maxi = len(A)

target = ['X' for x in range(maxi+1)]
for number in A:
    target[number]= number

count = 1
while count < maxi+1:
    if target[count] == 'X':
        return count
    count +=1
return target[count-1] + 1

Yukarıdaki çözüm için% 100 var.

1) Negatif ve Sıfırı Filtrele

2) Sırala / farklı

3) Diziyi ziyaret edin

Karmaşıklık : O (N) veya O (N * log (N))

Java8 kullanarak

public int solution(int[] A) {
            int result = 1;
    boolean found = false;
    A = Arrays.stream(A).filter(x -> x > 0).sorted().distinct().toArray();
    //System.out.println(Arrays.toString(A));
    for (int i = 0; i < A.length; i++) {
        result = i + 1;
        if (result != A[i]) {
            found = true;
            break;
        }
    }
    if (!found && result == A.length) {
        //result is larger than max element in array
        result++;
    }
    return result;
}

Tüm pozitif sayıları saklamak için bir unordered_set kullanılabilir ve daha sonra 1'den sırasız_set uzunluğuna kadar yineleyebilir ve oluşmayan ilk sayıyı görebiliriz.

int firstMissingPositive(vector<int>& nums) {

    unordered_set<int> fre;
    // storing each positive number in a hash.
    for(int i = 0; i < nums.size(); i +=1)
    {
        if(nums[i] > 0)
            fre.insert(nums[i]);
     }

    int i = 1;
    // Iterating from 1 to size of the set and checking 
    // for the occurrence of 'i'

    for(auto it = fre.begin(); it != fre.end(); ++it)
    {
        if(fre.find(i) == fre.end())
            return i;
        i +=1;
    }

    return i;
}

Temel JavaScript aracılığıyla çözüm

var a = [1, 3, 6, 4, 1, 2];

function findSmallest(a) {
var m = 0;
  for(i=1;i<=a.length;i++) {
    j=0;m=1;
    while(j < a.length) {
      if(i === a[j]) {
        m++;
      }
      j++;
    }
    if(m === 1) {
      return i;
    }
  }
}

console.log(findSmallest(a))

Umarım bu birine yardımcı olur.

Python ile en verimli değil, doğru

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
import datetime

# write your code in Python 3.6

def solution(A):
    MIN = 0
    MAX = 1000000
    possible_results = range(MIN, MAX)

    for i in possible_results:
        next_value = (i + 1)
        if next_value not in A:
            return next_value
    return 1

test_case_0 = [2, 2, 2]
test_case_1 = [1, 3, 44, 55, 6, 0, 3, 8]
test_case_2 = [-1, -22]
test_case_3 = [x for x in range(-10000, 10000)]
test_case_4 = [x for x in range(0, 100)] + [x for x in range(102, 200)]
test_case_5 = [4, 5, 6]
print("---")
a = datetime.datetime.now()
print(solution(test_case_0))
print(solution(test_case_1))
print(solution(test_case_2))
print(solution(test_case_3))
print(solution(test_case_4))
print(solution(test_case_5))

def solution(A):
    A.sort()
    j = 1
    for i, elem in enumerate(A):
        if j < elem:
            break
        elif j == elem:
            j += 1
            continue
        else:
            continue
    return j

bu yardımcı olabilir:

0- A is [5, 3, 2, 7];
1- Define B With Length = A.Length;                            (O(1))
2- initialize B Cells With 1;                                  (O(n))
3- For Each Item In A:
        if (B.Length <= item) then B[Item] = -1                (O(n))
4- The answer is smallest index in B such that B[index] != -1  (O(n))