/*

This is a demo task.

​

Write a function:

​

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

​

that, given an array A of N integers, returns the smallest positive integer (greater than 0) that does not occur in A.

​

For example, given A = [1, 3, 6, 4, 1, 2], the function should return 5.

​

Given A = [1, 2, 3], the function should return 4.

​

Given A = [−1, −3], the function should return 1.

​

Write an efficient algorithm for the following assumptions:

​

N is an integer within the range [1..100,000];

each element of array A is an integer within the range [−1,000,000..1,000,000].

Copyright 2009–2019 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

​

/*logic

check the array for null or empty

check if the array has only 1 number, if that number is < 1 return 1 or add 1 to the given number

loop through the array to find the smallest and the largest number

if the largest number is < 1 then return 1

if the smallest number is 1, and the count of array is equal to the largest number, and there are no duplicates  then add 1 to the largest number

loop through the range to find the missing number

​

or 

create a hash table.

for each element in the array check if the value is > 0  and < the length of the array, then set the value as true

loop through the hash table and check if any of the value is false

and insert the given array into the table if there is no value for the coresponding key return the key as the missing number

​

*/

​

​

using System;

using System.Linq;

using System.Collections.Generic;

public class Program

{

    public static void Main()

    {

        //Console.WriteLine("Hello World");

        //int[] A = {1, 3, 6, 4, 1, 2};

        int[] A = {1, 2, 3};

        //int[] A = {};

        //int[] A = {-1, -3};

        var smallestInt = 1;

        smallestInt = GetSmallestPositiveInteger(A);

        //smallestInt = solution(A);

        //smallestInt = solution1(A);

        Console.WriteLine(smallestInt);

    }

    public static int solution(int[] array)

    {

        HashSet<int> found = new HashSet<int>();

        for (int i = 0; i < array.Length; i++)

        {

            if (array[i] > 0)

            {

                found.Add(array[i]);

            }

        }

​

        int result = 1;

        while (found.Contains(result))

        {

            result++;

        }using System;

using System.Linq;

using System.Collections.Generic;

public class Program

{

    public static void Main()

    {

        //Console.WriteLine("Hello World");

        //int[] A = {1, 3, 6, 4, 1, 2};

        int[] A = {1, 2, 3};

        //int[] A = {};

        //int[] A = {-1, -3};

        var smallestInt = 1;

        smallestInt = GetSmallestPositiveInteger(A);

        //smallestInt = solution(A);

        //smallestInt = solution1(A);

        Console.WriteLine(smallestInt);

    }

    public static int solution(int[] array)

    {

        HashSet<int> found = new HashSet<int>();

        for (int i = 0; i < array.Length; i++)

        {

            if (array[i] > 0)

            {

                found.Add(array[i]);

            }

        }

​

        int result = 1;

​

        return result;

    }

    public static int solution1(int[] A)

    {

        int flag = 1;

​

        A = A.OrderBy(x => x).ToArray();

​

        for (int i = 0; i < A.Length; i++)

        {

            if (A[i] <= 0)

                continue;

            else if (A[i] == flag)

            {

                flag++;

            }

​

        }

​

        return flag;

    }

    public static int GetSmallestPositiveInteger(int[] A) {

        var smallestInt = 1;

        //get length of the array

        var arrLn = A.Length;

        //check array for null or empty

        if((A == null)||(A.Length == 0)){ return 1;}

        return arrLn;//smallestInt;

        //sort the Array

        A = A.OrderBy(x => x).ToArray();

        //loop through the array to check for missing smallest number

        for (int i = 0; i < A.Length; i++){

            //check for any negative values

            if (A[i] <= 0)

                continue;

            else if (A[i] == smallestInt)

            {

                smallestInt++;

            }

        }

        return smallestInt;

    }

}