package com.code;

import java.util.Arrays;

public class Test03_2 {
    
    public static int solution(int[] A) {
        // write your code in Java SE 8
        Arrays.sort(A);
        int size = A.length;
        if(size==0){
            return 1;
        }
        if(size==1){
            return A[0]==1?2:1;
        }
        if(A[size-1]==size){
            return size+1;
        }
        for (int i=0;i<size;i++){
            if(A[i]> i+1){
                return (i+1);
            }
        }
        return -1;
    }
    
    public static void main(String[] args) {
        int [] a = {1,2,3,4};
        System.out.println( solution(a));
        int [] b = {2,3,4,5};
        System.out.println(solution(b));
        int [] c = {};
        System.out.println(solution(c));
        int [] d = {1};
        System.out.println(solution(d));
    }
}
/**
A zero-indexed array A consisting of N different integers is given. 
The array contains integers in the range [1..(N + 1)], which means that exactly one element is missing.

Your goal is to find that missing element.

Write a function:

class Solution { public int solution(int[] A); }

that, given a zero-indexed array A, returns the value of the missing element.

For example, given array A such that:

  A[0] = 2
  A[1] = 3
  A[2] = 1
  A[3] = 5
the function should return 4, as it is the missing element.

Assume that:

N is an integer within the range [0..100,000];
the elements of A are all distinct;
each element of array A is an integer within the range [1..(N + 1)].
Complexity:

expected worst-case time complexity is O(N);
expected worst-case space complexity is O(1), beyond input storage (not counting the storage required for input arguments).
Elements of input arrays can be modified.

*/