1. MissingInteger 最小遗失整数 Find the minimal positive integer not occurring in a given sequence.

package com.code;

import java.util.Arrays;

public class Test04_1 {
    public static int solution(int[] A) {
        int size = A.length;
        if(size==1){ // handle one element array
            if(A[0]==1){
                return 2;
            }else{
                return 1;
            }
        }
        Arrays.sort(A); // sort by JDK
        if(A[0]>1){ // handle all elements bigger than 1
            return 1;
        }
        if(A[size-1]<=0){ // handle all elements are negative
            return 1;
        }
        int i=0;
        for(i=0;i<size-1;i++){
            if(A[i]>=0  && (A[i+1]-A[i]>1)){ // handle no consecutive array which start with 1
                    return A[i]+1;
                }
        }
        if(i==size-1){ // handle consecutive array , handle negative elements too.
            return A[size-1]+1>0?A[size-1]+1:1;
        }
        return 1;
    }
    public static void main(String[] args) {
        int [] a = {1,1,2,3,4,5};
        System.out.println(solution(a));
        int [] b = {-4,-2,0,5};
        System.out.println(solution(b));
        int [] c = {2};
        System.out.println(solution(c));
        int [] d = {-2,0,100,102,200};
        System.out.println(solution(d));
        int [] e = {2,4,5,6};
        System.out.println(solution(e));

    }
}
/**
 *
 * 1. MissingInteger
  Find the minimal positive integer not occurring in a given sequence.
 * Write a function:
 *
 * class Solution { public int solution(int[] A); }
 *
 * that, given a non-empty zero-indexed array A of N integers, returns the minimal positive integer (greater than 0) that does not occur in A.
 *
 * For example, given:
 *
 * A[0] = 1 A[1] = 3 A[2] = 6 A[3] = 4 A[4] = 1 A[5] = 2 the function should return 5.
 *
 * Assume that:
 *
 * N is an integer within the range [1..100,000]; each element of array A is an integer within the range [?2,147,483,648..2,147,483,647]. Complexity:
 *
 * expected worst-case time complexity is O(N); expected worst-case space complexity is O(N),
 * beyond input storage (not counting the storage required for input arguments). Elements of input arrays can be modified.
 *
 */