Tìm số nguyên nhỏ nhất không có trong danh sách

Một câu hỏi phỏng vấn thú vị mà một đồng nghiệp của tôi sử dụng:

Giả sử rằng bạn được cung cấp một danh sách rất dài, không được sắp xếp gồm các số nguyên 64 bit không dấu. Làm thế nào bạn có thể tìm số nguyên không âm nhỏ nhất không xuất hiện trong danh sách?

SAU: Bây giờ giải pháp rõ ràng bằng cách sắp xếp đã được đề xuất, bạn có thể thực hiện nó nhanh hơn O (n log n) không?

THEO DÕI: Thuật toán của bạn phải chạy trên máy tính có bộ nhớ 1GB

XÁC NHẬN: Danh sách nằm trong RAM, mặc dù nó có thể tiêu thụ một lượng lớn RAM. Bạn được cung cấp trước kích thước của danh sách, chẳng hạn như N.

Nếu cơ cấu dữ liệu có thể được thay đổi tại chỗ và hỗ trợ truy cập ngẫu nhiên thì bạn có thể thực hiện trong thời gian O (N) và O (1) không gian bổ sung. Chỉ cần đi qua mảng một cách tuần tự và với mọi chỉ mục, hãy ghi giá trị tại chỉ mục vào chỉ mục được chỉ định bởi giá trị, đặt một cách đệ quy bất kỳ giá trị nào tại vị trí đó vào vị trí của nó và loại bỏ các giá trị> N. Sau đó, quay lại mảng tìm kiếm vị trí trong đó giá trị không khớp với chỉ mục - đó là giá trị nhỏ nhất không có trong mảng. Điều này dẫn đến nhiều nhất là 3N so sánh và chỉ sử dụng một vài giá trị của không gian tạm thời.

# 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

Đây là một O(N)giải pháp đơn giản sử dụng O(N)không gian. Tôi giả định rằng chúng tôi đang giới hạn danh sách đầu vào ở các số không âm và chúng tôi muốn tìm số không âm đầu tiên không có trong danh sách.

1. Tìm độ dài của danh sách; hãy nói rằng nó là N.
2. Phân bổ một mảng Nboolean, được khởi tạo cho tất cả false.
3. Đối với mỗi số Xtrong danh sách, nếu Xnhỏ hơn N, hãy đặt X'thphần tử của mảng thành true.
4. Quét mảng bắt đầu từ chỉ mục 0, tìm kiếm phần tử đầu tiên false. Nếu bạn tìm thấy đầu tiên falseở chỉ mục I, thì đó Ilà câu trả lời. Nếu không (tức là khi tất cả các phần tử đều là true) thì câu trả lời là N.

Trong thực tế, "mảng Nboolean" có thể sẽ được mã hóa dưới dạng "bitmap" hoặc "bitet" được biểu diễn dưới dạng một bytehoặc intmảng. Điều này thường sử dụng ít dung lượng hơn (tùy thuộc vào ngôn ngữ lập trình) và cho phép quét lần đầu tiên falseđược thực hiện nhanh hơn.

Đây là cách / tại sao thuật toán hoạt động.

Giả sử rằng các Nsố trong danh sách không khác biệt, hoặc một hoặc nhiều trong số chúng lớn hơn N. Điều này có nghĩa là phải có ít nhất một số trong phạm vi 0 .. N - 1không có trong danh sách. Vì vậy bài toán tìm số bị thiếu nhỏ nhất do đó phải rút gọn thành bài toán tìm số bị thiếu nhỏ nhất nhỏ hơnN . Điều này có nghĩa là chúng ta không cần phải theo dõi những con số lớn hơn hoặc bằng N... bởi vì chúng sẽ không phải là câu trả lời.

Thay thế cho đoạn trước là danh sách là một hoán vị của các số từ 0 .. N - 1. Trong trường hợp này, bước 3 đặt tất cả các phần tử của mảng thành truevà bước 4 cho chúng ta biết rằng số "bị thiếu" đầu tiên là N.

Độ phức tạp tính toán của thuật toán là O(N)với một hằng số tương đối nhỏ. Nó làm cho hai tuyến tính đi qua danh sách hoặc chỉ một lần vượt qua nếu độ dài danh sách được biết là bắt đầu bằng. Không cần phải biểu diễn việc lưu giữ toàn bộ danh sách trong bộ nhớ, vì vậy việc sử dụng bộ nhớ tiệm cận của thuật toán chỉ là những gì cần thiết để biểu diễn mảng boolean; tức là O(N)các bit.

(Ngược lại, các thuật toán dựa vào sắp xếp hoặc phân vùng trong bộ nhớ giả định rằng bạn có thể đại diện cho toàn bộ danh sách trong bộ nhớ. Ở dạng câu hỏi đã được hỏi, điều này sẽ yêu cầu các từ O(N)64 bit.)

@Jorn nhận xét rằng từ bước 1 đến bước 3 là một biến thể về sắp xếp đếm. Theo một nghĩa nào đó thì anh ấy đúng, nhưng sự khác biệt rất đáng kể:

• Sắp xếp đếm yêu cầu một mảng (ít nhất) Xmax - Xminbộ đếm trong đó Xmaxlà số lớn nhất trong danh sách và Xminlà số nhỏ nhất trong danh sách. Mỗi bộ đếm phải có thể đại diện cho N trạng thái; nghĩa là giả sử một biểu diễn nhị phân, nó phải có kiểu số nguyên (ít nhất) ceiling(log2(N))bit.
• Để xác định kích thước mảng, một sắp xếp đếm cần thực hiện một lần chuyển đầu tiên qua danh sách để xác định Xmaxvà Xmin.
• Do đó, yêu cầu không gian tối thiểu trong trường hợp xấu nhất là ceiling(log2(N)) * (Xmax - Xmin)bit.

Ngược lại, thuật toán được trình bày ở trên chỉ đơn giản yêu cầu Ncác bit trong trường hợp xấu nhất và tốt nhất.

Tuy nhiên, phân tích này dẫn đến trực giác rằng nếu thuật toán thực hiện lần đầu tiên đi qua danh sách để tìm số 0 (và đếm các phần tử trong danh sách nếu được yêu cầu), nó sẽ đưa ra câu trả lời nhanh hơn mà không sử dụng khoảng trắng nào nếu nó tìm thấy số 0. Điều này chắc chắn là đáng làm nếu khả năng cao là bạn tìm thấy ít nhất một số 0 trong danh sách. Và vượt qua này không thay đổi độ phức tạp tổng thể.

CHỈNH SỬA: Tôi đã thay đổi mô tả của thuật toán để sử dụng "mảng boolean" vì mọi người dường như thấy mô tả ban đầu của tôi sử dụng bit và bitmap là khó hiểu.

Vì OP hiện đã chỉ định rằng danh sách ban đầu được lưu trữ trong RAM và máy tính chỉ có 1GB bộ nhớ, tôi sẽ đi ra ngoài và dự đoán rằng câu trả lời là 0.

1GB RAM có nghĩa là danh sách có thể có nhiều nhất 134.217.728 số trong đó. Nhưng có 2 ⁶⁴ = 18.446.744.073.709.551.616 số có thể. Vì vậy, xác suất để số 0 trong danh sách là 1 trong 137.438.953.472.

Ngược lại, tỷ lệ bị sét đánh của tôi trong năm nay là 1 trên 700.000. Và tỷ lệ tôi bị thiên thạch rơi vào khoảng 1 trên 10 nghìn tỷ. Vì vậy, khả năng tôi được viết trên tạp chí khoa học do cái chết không đúng lúc bởi một thiên thể cao hơn khoảng mười lần so với câu trả lời không phải là số không.

Như đã chỉ ra trong các câu trả lời khác, bạn có thể sắp xếp, và sau đó chỉ cần quét lên cho đến khi bạn tìm thấy khoảng trống.

Bạn có thể cải thiện độ phức tạp của thuật toán thành O (N) và giữ khoảng trống O (N) bằng cách sử dụng QuickSort đã sửa đổi, nơi bạn loại bỏ các phân vùng không phải là ứng cử viên tiềm năng để chứa khoảng trống.

• Trong giai đoạn phân vùng đầu tiên, hãy loại bỏ các bản sao.
• Sau khi phân vùng hoàn tất, hãy xem số lượng các mục trong phân vùng dưới
• Giá trị này có bằng với giá trị được sử dụng để tạo phân vùng không?
  • Nếu vậy thì nó có nghĩa là khoảng trống nằm trong phân vùng cao hơn.
    • Tiếp tục với quicksort, bỏ qua phân vùng dưới
  • Nếu không thì khoảng trống nằm ở phân vùng dưới
    • Tiếp tục với quicksort, bỏ qua phân vùng cao hơn

Điều này tiết kiệm một số lượng lớn các tính toán.

Để minh họa một trong những cạm bẫy của O(N)tư duy, đây là một O(N)thuật toán sử dụng O(1)không gian.

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

print "no 64-bit integers are missing"

Vì tất cả các số đều dài 64 bit, chúng ta có thể sử dụng sắp xếp cơ số trên chúng, là O (n). Sắp xếp 'chúng, sau đó quét' chúng cho đến khi bạn tìm thấy những gì bạn đang tìm kiếm.

nếu số nhỏ nhất bằng 0, hãy quét về phía trước cho đến khi bạn tìm thấy khoảng trống. Nếu số nhỏ nhất không phải là số 0, thì câu trả lời là số không.

Đối với một phương pháp hiệu quả về không gian và tất cả các giá trị đều khác biệt, bạn có thể thực hiện theo không gian O( k )và thời gian O( k*log(N)*N ). Đó là không gian hiệu quả và không có dữ liệu di chuyển và tất cả các hoạt động là cơ bản (cộng trừ).

1. bộ U = N; L=0
2. Đầu tiên phân vùng không gian số trong kcác vùng. Như thế này:
   • 0->(1/k)*(U-L) + L, 0->(2/k)*(U-L) + L, 0->(3/k)*(U-L) + L...0->(U-L) + L
3. Tìm xem có bao nhiêu số ( count{i}) trong mỗi vùng. ( N*kcác bước)
4. Tìm vùng đầu tiên ( h) chưa đầy. Có nghĩa là count{h} < upper_limit{h}. ( kcác bước)
5. nếu h - count{h-1} = 1bạn có câu trả lời của mình
6. bộ U = count{h}; L = count{h-1}
7. goto 2

điều này có thể được cải thiện bằng cách sử dụng băm (cảm ơn Nic vì ý tưởng này).

1. tương tự
2. Đầu tiên phân vùng không gian số trong kcác vùng. Như thế này:
   • L + (i/k)->L + (i+1/k)*(U-L)
3. inc count{j} sử dụng j = (number - L)/k (if L < number < U)
4. tìm vùng đầu tiên ( h) không có k phần tử trong đó
5. nếu count{h} = 1h là câu trả lời của bạn
6. bộ U = maximum value in region h L = minimum value in region h

Điều này sẽ chạy trong O(log(N)*N).

Tôi chỉ sắp xếp chúng sau đó chạy qua chuỗi cho đến khi tôi tìm thấy một khoảng trống (bao gồm khoảng cách ở đầu giữa số 0 và số đầu tiên).

Về mặt thuật toán, một cái gì đó như thế này sẽ làm được:

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

Tất nhiên, nếu bạn có nhiều bộ nhớ hơn CPU grunt, bạn có thể tạo bitmask của tất cả các giá trị 64 bit có thể có và chỉ cần đặt bit cho mọi số trong danh sách. Sau đó, tìm bit 0 đầu tiên trong bitmask đó. Điều đó biến nó thành một hoạt động O (n) về mặt thời gian nhưng khá tốn kém về yêu cầu bộ nhớ :-)

Tôi nghi ngờ bạn có thể cải thiện O (n) vì tôi không thể thấy một cách làm điều đó mà không liên quan đến việc xem từng số ít nhất một lần.

Thuật toán cho thuật toán đó sẽ dọc theo các dòng của:

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")

Sắp xếp danh sách, xem xét yếu tố đầu tiên và yếu tố thứ hai, và bắt đầu đi lên cho đến khi có một khoảng trống.

Bạn có thể thực hiện trong O (n) thời gian và O (1) không gian bổ sung, mặc dù hệ số ẩn là khá lớn. Đây không phải là một cách thực tế để giải quyết vấn đề, nhưng nó có thể rất thú vị.

Đối với mỗi số nguyên 64-bit không dấu (theo thứ tự tăng dần), hãy lặp lại danh sách cho đến khi bạn tìm thấy số nguyên đích hoặc bạn đến cuối danh sách. Nếu bạn đến cuối danh sách, số nguyên đích là số nguyên nhỏ nhất không có trong danh sách. Nếu bạn đạt đến cuối số nguyên 64 bit, mọi số nguyên 64 bit đều có trong danh sách.

Đây là một hàm Python:

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

Hàm này cố tình không hiệu quả để giữ nó là O (n). Đặc biệt lưu ý rằng hàm liên tục kiểm tra các số nguyên đích ngay cả sau khi câu trả lời đã được tìm thấy. Nếu hàm trả về ngay sau khi câu trả lời được tìm thấy, số lần vòng lặp ngoài chạy sẽ bị ràng buộc bởi kích thước của câu trả lời, được ràng buộc bởi n. Thay đổi đó sẽ làm cho thời gian chạy O (n ^ 2), mặc dù nó sẽ nhanh hơn rất nhiều.

Cảm ơn egon, swilden và Stephen C đã truyền cảm hứng cho tôi. Trước tiên, chúng tôi biết các giới hạn của giá trị mục tiêu vì nó không thể lớn hơn kích thước của danh sách. Ngoài ra, danh sách 1GB có thể chứa tối đa 134217728 (128 * 2 ^ 20) số nguyên 64 bit.

Phần băm
Tôi đề xuất sử dụng phép băm để giảm đáng kể không gian tìm kiếm của chúng tôi. Đầu tiên, căn bậc hai kích thước của danh sách. Đối với danh sách 1GB, đó là N = 11,586. Thiết lập một mảng số nguyên có kích thước N. Lặp lại danh sách và lấy căn bậc hai * của mỗi số bạn tìm thấy làm hàm băm. Trong bảng băm của bạn, hãy tăng bộ đếm cho hàm băm đó. Tiếp theo, lặp lại bảng băm của bạn. Nhóm đầu tiên bạn thấy không bằng kích thước tối đa của nó xác định không gian tìm kiếm mới của bạn.

Phần bitmap
Bây giờ hãy thiết lập một bản đồ bit thông thường bằng với kích thước của không gian tìm kiếm mới của bạn và lặp lại qua danh sách nguồn, điền vào bitmap khi bạn tìm thấy từng số trong không gian tìm kiếm của mình. Khi bạn hoàn tất, bit chưa đặt đầu tiên trong bitmap của bạn sẽ cho bạn câu trả lời.

Điều này sẽ được hoàn thành trong thời gian O (n) và không gian O (sqrt (n)).

(* Bạn có thể sử dụng một cái gì đó như dịch chuyển bit để làm điều này hiệu quả hơn rất nhiều và chỉ cần thay đổi số lượng và kích thước của các nhóm cho phù hợp.)

Nếu chỉ có một số bị thiếu trong danh sách các số, thì cách dễ nhất để tìm số bị thiếu là tính tổng chuỗi và trừ từng giá trị trong danh sách. Giá trị cuối cùng là số còn thiếu.

 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 !!");

            }
        }

Chúng ta có thể sử dụng một bảng băm để chứa các số. Sau khi tất cả các số được thực hiện, chạy bộ đếm từ 0 cho đến khi chúng tôi tìm thấy số thấp nhất. Một hàm băm hợp lý sẽ băm và lưu trữ trong thời gian không đổi, và truy xuất trong thời gian không đổi.

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;

Trường hợp xấu nhất nếu có ncác phần tử trong mảng, và {0, 1, ... n-1}trong trường hợp đó, câu trả lời sẽ nhận được tại n, vẫn giữ nguyên nó O(n).

Đây là câu trả lời của tôi được viết bằng Java:

Ý tưởng cơ bản: 1- Lặp lại mảng để loại bỏ các số dương, số không và số âm trùng lặp trong khi tính tổng các phần còn lại, nhận số dương tối đa cũng như giữ các số dương duy nhất trong một Bản đồ.

2- Tính tổng dưới dạng max * (max + 1) / 2.

3- Tìm sự khác biệt giữa các tổng được tính ở bước 1 & 2

4- Lặp lại từ 1 đến giá trị tối thiểu [tổng số chênh lệch, tối đa] và trả về số đầu tiên không có trong bản đồ được điền ở bước 1.

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

Như Stephen C đã chỉ ra một cách thông minh, câu trả lời phải là một số nhỏ hơn độ dài của mảng. Sau đó tôi sẽ tìm câu trả lời bằng cách tìm kiếm nhị phân. Điều này tối ưu hóa trường hợp xấu nhất (vì vậy người phỏng vấn không thể bắt bạn trong tình huống bệnh lý 'điều gì xảy ra nếu'). Trong một cuộc phỏng vấn, hãy chỉ ra rằng bạn đang làm điều này để tối ưu hóa cho trường hợp xấu nhất.

Cách sử dụng tìm kiếm nhị phân là trừ số bạn đang tìm kiếm cho mỗi phần tử của mảng và kiểm tra kết quả âm.

Tôi thích thẩm định "đoán số không". Nếu các con số là ngẫu nhiên, rất có thể xảy ra số 0. Nếu "giám khảo" đặt danh sách không ngẫu nhiên, sau đó thêm một danh sách và đoán lại:

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

Trường hợp xấu nhất là n * N với n = N, nhưng trong thực tế n rất có thể là một số nhỏ (ví dụ: 1)

Tôi không chắc nếu tôi nhận được câu hỏi. Nhưng nếu đối với danh sách 1,2,3,5,6 và số bị thiếu là 4, thì số bị thiếu có thể được tìm thấy trong O (n) bằng: (n + 2) (n + 1) / 2- (n + 1) n / 2

EDIT: xin lỗi, tôi đoán tôi đã suy nghĩ quá nhanh tối qua. Dù sao, Phần thứ hai thực sự nên được thay thế bằng sum (danh sách), đó là nơi xuất hiện của O (n). Công thức cho thấy ý tưởng đằng sau nó: đối với n số nguyên liên tiếp, tổng phải là (n + 1) * n / 2. Nếu thiếu một số, tổng sẽ bằng tổng (n + 1) số nguyên tuần tự trừ đi số bị thiếu.

Cảm ơn vì đã chỉ ra thực tế rằng tôi đã đặt một số mảnh giữa vào tâm trí của mình.

Làm tốt lắm Kiến Aasma! Tôi đã suy nghĩ về câu trả lời trong khoảng 15 phút và độc lập đưa ra câu trả lời theo cách suy nghĩ tương tự như của bạn:

#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 đại diện cho "đầu ra tối đa hiện tại có thể có với những gì tôi biết về đầu vào thứ i đầu tiên và không giả định gì khác về các giá trị cho đến mục nhập tại m-1".

Giá trị này của m sẽ chỉ được trả về nếu (a [i], ..., a [m-1]) là một hoán vị của các giá trị (i, ..., m-1). Do đó nếu a [i]> = m hoặc nếu a [i] <i hoặc nếu a [i] == a [a [i]] chúng ta biết rằng m là đầu ra sai và phải thấp hơn ít nhất một phần tử. Vì vậy, giảm m và hoán đổi a [i] với a [m] chúng ta có thể đệ quy.

Nếu điều này không đúng nhưng a [i]> i thì khi biết rằng a [i]! = A [a [i]] chúng ta biết rằng hoán đổi [i] với [a [i]] sẽ làm tăng số lượng phần tử ở vị trí của riêng họ.

Nếu không thì a [i] phải bằng i, trong trường hợp đó chúng ta có thể tăng i khi biết rằng tất cả các giá trị lên đến và bao gồm chỉ số này đều bằng chỉ số của chúng.

Bằng chứng rằng điều này không thể đi vào một vòng lặp vô hạn được để lại như một bài tập cho người đọc. :)

Đoạn Dafny từ câu trả lời của Người Kiến cho thấy lý do tại sao thuật toán tại chỗ có thể thất bại. Điều kiện requirestrước mô tả rằng các giá trị của mỗi mục không được vượt quá giới hạn của mảng.

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

Dán mã vào trình xác thực có và không có forall ...điều khoản để xem lỗi xác minh. Lỗi thứ hai là do trình xác minh không thể thiết lập điều kiện kết thúc cho vòng lặp Vượt qua 1. Việc chứng minh điều này được giao cho người hiểu công cụ hơn.

Đây là một câu trả lời trong Java không sửa đổi đầu vào và sử dụng thời gian O (N) và N bit cộng với chi phí bộ nhớ không đổi nhỏ (trong đó N là kích thước của danh sách):

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

Đã nhận 100% cho giải pháp trên.

1) Lọc âm và 0

2) Sắp xếp / phân biệt

3) Truy cập mảng

Độ phức tạp : O (N) hoặc O (N * log (N))

sử dụng Java8

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

Một tập hợp không có thứ tự có thể được sử dụng để lưu trữ tất cả các số dương và sau đó chúng ta có thể lặp lại từ 1 đến độ dài của tập hợp không có thứ tự và xem số đầu tiên không xảy ra.

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

Giải pháp thông qua javascript cơ bản

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))

Hy vọng điều này sẽ giúp ích cho ai đó.

Với python, nó không phải là hiệu quả nhất, nhưng chính xác

#!/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

điều này có thể giúp:

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))