using System;

using System.Linq;

using System.Collections.Generic;

​

public class Solution

{

    public static void Main(string[] args)

    {

        var locator = new Locator();

        //part 1

        //test 1

        int? resultFindMissing = locator.FindMissing(new List<int> {1, 2, 3, 5}); //expect 4

        if(resultFindMissing != 4){

            Console.Out.WriteLine("got invalid result for case 1 (expect 4): " + resultFindMissing);

            return;

        }

        //test 2

        resultFindMissing = locator.FindMissing(new List<int> {1, 2, 3, 4, 5}); //expect null

        if(resultFindMissing != null){

            Console.Out.WriteLine("got invalid result for case 2 (expect null): " + resultFindMissing);

            return;

        }

​

        //part 2

        //test 3

        bool resultIsMissing = locator.IsMissing(new List<int> {1, 2, 3, 5}); //expect true

        if(!resultIsMissing){

            Console.Out.WriteLine("got invalid result for case 3 (expect true): " + resultIsMissing);

            return;

        }

        //test 4

        resultIsMissing = locator.IsMissing(new List<int> {1, 2, 3, 4, 5}); //expect false

        if(resultIsMissing){

            Console.Out.WriteLine("got invalid result for case 4 (expect false): " + resultIsMissing);

            return;

        }

​

        //part 3

        //test 5

        resultFindMissing = locator.FindMissing(new List<int> {3, 4, 6}); //expect 5

        if(resultFindMissing != 5){

            Console.Out.WriteLine("got invalid result for case 5 (expect 5): " + resultFindMissing);

            return;

        }

        //test 6

        resultFindMissing = locator.FindMissing(new List<int> {3, 4, 5, 6}); //expect null

        if(resultFindMissing != null){

            Console.Out.WriteLine("got invalid result for case 6 (expect null): " + resultFindMissing);

            return;

        }

​

        //part 4

        //test 7

        resultFindMissing = locator.FindMissing(new List<int> { 1, 1, 1, 2, 2, 3, 5, 5, 5, 5, 5 }); //expect 4

        if(resultFindMissing != 4){

            Console.Out.WriteLine("got invalid result for case 7 (expect 4): " + resultFindMissing);

            return;

        }

        //test 8

        resultFindMissing = locator.FindMissing(new List<int> { 1, 1, 2, 2, 3, 4, 4, 4, 4, 5, 5, 5 }); //expect null

        if(resultFindMissing != null){

            Console.Out.WriteLine("got invalid result for case 8 (expect null): " + resultFindMissing);

            return;

        }

​

        //part 5

        //test 9

        bool didThrow = false;

        try{

            locator.FindMissing(new List<int> {1, 3, 5});

        }

        catch(ArgumentOutOfRangeException){

            didThrow = true;

        }

        if(!didThrow){

            Console.Out.WriteLine("got invalid result for case 9 (expect throw exception)");

        }

        //test 10

        didThrow = false;

        try{

            locator.FindMissing(new List<int> {1, 5});

        }

        catch(ArgumentOutOfRangeException){

            didThrow = true;

        }

        if(!didThrow){

            Console.Out.WriteLine("got invalid result for case 10 (expect throw exception)");

        }

​

        //test 11

        didThrow = false;

        try{

            locator.FindMissing(new List<int> { int.MinValue, int.MaxValue });

        }

        catch(ArgumentOutOfRangeException){

            didThrow = true;

        }

        if(!didThrow){

            Console.Out.WriteLine("got invalid result for case 11 (expect throw exception)");

        }

​

        Console.Out.WriteLine("green!");

    }

}

​

public class Locator

{

    public int? FindMissing(IEnumerable<int> values)

    {

        if (null == values)

             {

                 throw new ArgumentNullException("values");

             }

             int? previous = null;

             int? missingValue = null;

             foreach (var value in values.OrderBy(x => x))

             {

                 if (value == previous)

                 {

                     continue;

                 }

                 if (previous.HasValue && value != previous + 1)

                 {

                     if (missingValue.HasValue || value - (long) previous > 2)

                     {

                         throw new ArgumentOutOfRangeException();

                     }

                     missingValue = previous + 1;

                 }

                 previous = value;

             }

             return missingValue;

    }

​

    public bool IsMissing(IEnumerable<int> values)

    {

        return null != FindMissing(values);

    }

}