Missing integer variation - O(n) solution needed [closed]

Answer 1

javascript 100% 100% first sort the array, you just need to scan positive elements so find index of 1 (if there is no 1 in array then answer is 1). then search elements after 1 till find missing number.

function solution(A) {
// write your code in JavaScript (Node.js 6.4.0)

   var missing = 1;
   // sort the array.
   A.sort(function(a, b) { return a-b });

   // try to find the 1 in sorted array if there is no 1 so answer is 1
   if ( A.indexOf(1) == -1) { return 1; }

   // just search positive numbers to find missing number 
   for ( var i = A.indexOf(1); i < A.length; i++) {
      if ( A[i] != missing) {
        missing++;
        if ( A[i] != missing ) { return missing; }
      }
   }

   // if cant find any missing number return next integer number
   return missing + 1;
}

Answer 2

Simple Java soution. Scored 100/100 in correctness and performance.

public int solution(int[] A) {
    int smallestMissingInteger = 1;
    if (A.length == 0) {
        return smallestMissingInteger;
    }
    Set<Integer> set = new HashSet<Integer>();
    for (int i = 0; i < A.length; i++) {
        if (A[i] > 0) {
            set.add(A[i]);
        }
    }
    while (set.contains(smallestMissingInteger)) {
        smallestMissingInteger++;
    }
    return smallestMissingInteger;

}

Answer 3

Build a hash table of all the values. For the numbers 1 to n + 1, check if they are in the hash table. At least one of them is not. Print out the lowest such number.

This is O(n) expected time (you can get with high probability). See @Gassa's answer for how to avoid the hash table in favor of a lookup table of size O(n).

Answer 4

My solution. 100%. In Java.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Solution {
    public int solution(int[] A) {
        Arrays.sort(A);
        ArrayList<Integer> positive = new ArrayList<>();
        for (int i = 0; i < A.length; i++) {
            if(A[i] > 0)
                positive.add(A[i]);
        }
        if(positive.isEmpty()) return 1;
        if(positive.get(0) > 1) return 1;

        for(int i = 0; i < positive.size() - 1; i++) {
            if(positive.get(i + 1) - positive.get(i) > 1)
                return positive.get(i) + 1;
        }

        return positive.get(positive.size() - 1) + 1;
    }
    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] A = {-5,1,2,3,4,6,7,8,9,5};
        System.out.println(solution.solution(A)); 
    }
}

Answer 5

1. Create a binary array bin of N+1 length (C uses 0 based indexing)

2. Traverse the binary array O(n)

3. If A[i] is within the bounds of bin then mark bin entry at index A[i] as present or true.
4. Traverse the binary array again
5. Index of any bin entry that is not present or false is your missing integer

~

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

int solution(int A[], int N) {
    // write your code in C99 (gcc 6.2.0)
    int i;
    bool *bin = (bool *)calloc((N+1),sizeof(bool));

    for (i = 0; i < N; i++)
    {
        if (A[i] > 0 && A[i] < N+1)
        {
            bin[A[i]] = true;
        }
    }

    for (i = 1; i < N+1; i++)
    {
        if (bin[i] == false)
        {
            break;
        }
    }

    return i;
}

Answer 6

C# scored 100%,

Explanation: use of lookup table where we store already seen values from input array, we only care about values that are greater than 0 and lower or equal than length on input array

    public static int solution(int[] A)
    {
        var lookUpArray = new bool[A.Length];

        for (int i = 0; i < A.Length; i++)
            if (A[i] > 0 && A[i] <= A.Length)
                lookUpArray[A[i] - 1] = true;

        for (int i = 0; i < lookUpArray.Length; i++)
            if (!lookUpArray[i])
                return i + 1;

        return A.Length + 1;
    }