Searching array styles | C# Online Compiler

Searching array styles by Rutger Knijnenburg

using System;
using System.Diagnostics;
using System.Linq;

public class BlogApp
{
    private static int numberToFind = 0;
    private static int[] nums = Enumerable.Range(0, 1000000).ToArray();
    private static int recursiveBinaryAttempts = 0;
    private static int nonRecursiveBinaryAttempts = 0;
    private static int oldSchoolAttempts = 0;
    public static void Main(string[] args)
    {
        Array.Sort(nums);
        Boolean quitNow = false;
        string command = "";
        string commandLine = "";
        Console.WriteLine("Welcome to the 'Find my number' module. 'Like a number in a haystack!' \n/findnumber <number> to start the search!");
        while (!quitNow)
        {
            commandLine = Console.ReadLine();
            command = commandLine.Contains(" ") ? commandLine.Substring(0, commandLine.IndexOf(" ")) : commandLine; 
            switch (command)
            {
                case "/findnumber":
                    var number = commandLine.Substring(commandLine.IndexOf(' ') + 1);
					int n = 0;
                    if (number.Length == -1 || !int.TryParse(number, out n))
                    {
                        Console.WriteLine("Please2 use /findnumber <number> to start your search!");
                    }
                    else
                    {
                        numberToFind = n;
                        Console.WriteLine("====================New search!=======================");
                        Console.WriteLine("Number to find: {0}", n);
                        Console.WriteLine("Searching in array between:{0} and {1}", nums[0], nums[nums.Length - 1]);
                        StartRecursiveBinarySearch();
                        StartNonRecursiveBinarySearch();
                        StartOldSchoolStyleSearch();
                        startLambdaSearch();
                        startLinqSearch();
                    }
                    break;
                case "/quit":
                    quitNow = true;
                    break;
                default:
                    Console.WriteLine("Please use /findnumber <number> to start your search!");
                    break;
            }
        }
    }

    private static void startLambdaSearch()
    {
        Console.WriteLine("=======Lambda Style=======");
        var stopwatch = new Stopwatch();
        stopwatch.Start();
        bool found = FindNumberLambdaStyle(numberToFind);
        stopwatch.Stop();
        if (found)
        {
            Console.WriteLine("Found it after in {0} milliseconds!",  stopwatch.Elapsed.TotalMilliseconds);
        }
        else
        {
            Console.WriteLine("Not found after in {0} milliseconds!",  stopwatch.Elapsed.TotalMilliseconds);
        }
    }
    private static void startLinqSearch()
    {
        Console.WriteLine("=======Linq Style=======");
        var stopwatch = new Stopwatch();
        stopwatch.Start();
        bool found = FindNumberLinqStyle(numberToFind);
        stopwatch.Stop();
        if (found)
        {
            Console.WriteLine("Found it after in {0} milliseconds!", stopwatch.Elapsed.TotalMilliseconds);
        }
        else
        {
            Console.WriteLine("Not found after in {0} milliseconds!", stopwatch.Elapsed.TotalMilliseconds);
        }
    }
    private static bool FindNumberLinqStyle(int numberTofind)
    {
        int[] found = (from num in nums
            where num == numberTofind
            select num).ToArray();
        return found.Length == 0 ? false : true;
    }
    private static bool FindNumberLambdaStyle(int numberTofind)
    {
        int[] found = nums.Where(x => x == numberTofind).ToArray();
        return found.Length == 0 ? false : true;
    }
    private static void StartRecursiveBinarySearch()
    {
        Console.WriteLine("=======Recursive Binary Style=======");
        int leftIndex = -1;
        int maxIndex = nums.Length-1;
        var stopwatch = new Stopwatch();
        stopwatch.Start();
        bool found = FindNumberRecursivelyInArrayBinaryStyle(numberToFind, leftIndex, maxIndex);
        stopwatch.Stop();
        if (found)
        {
            Console.WriteLine("Found it after looping {0} times in {1} milliseconds!", recursiveBinaryAttempts, stopwatch.Elapsed.TotalMilliseconds);
        }
        else
        {
            Console.WriteLine("Not found after looping {0} times in {1} milliseconds!", recursiveBinaryAttempts, stopwatch.Elapsed.TotalMilliseconds);
        }
        recursiveBinaryAttempts = 0;
    }
    private static void StartNonRecursiveBinarySearch()
    {
        Console.WriteLine("=======Non recursive Binary Style=======");
        var stopwatch = new Stopwatch();
        stopwatch.Start();
        bool found = FindNumberNormallyInArrayBinaryStyle(numberToFind);
        stopwatch.Stop();
        if (found)
        {
            Console.WriteLine("Found it after looping {0} times in {1} milliseconds!", nonRecursiveBinaryAttempts, stopwatch.Elapsed.TotalMilliseconds);
        }
        else
        {
            Console.WriteLine("Not found after looping {0} times in {1} milliseconds!", nonRecursiveBinaryAttempts, stopwatch.Elapsed.TotalMilliseconds);
        }
        nonRecursiveBinaryAttempts = 0;
    }
    private static void StartOldSchoolStyleSearch()
    {
        Console.WriteLine("=======OldSchool Style=======");
        var stopwatch = new Stopwatch();
        stopwatch.Start();
        bool foundOldSchool = FindNumberInArrayOldSchoolStyle(numberToFind);
        stopwatch.Stop();
        if (foundOldSchool)
        {
            Console.WriteLine("Found it after looping {0} times in {1} milliseconds!", oldSchoolAttempts, stopwatch.Elapsed.TotalMilliseconds);
        }
        else
        {
            Console.WriteLine("Not found after looping {0} times in {1} milliseconds!", oldSchoolAttempts, stopwatch.Elapsed.TotalMilliseconds);
        }
        oldSchoolAttempts = 0;
    }
	// Using a foreach
    private static bool FindNumberInArrayOldSchoolStyle(int findNumber)
    {
        foreach(int num in nums)
        {
            oldSchoolAttempts++;
            var currentNumber = num;
            if (currentNumber == findNumber)
            {
                return true;
            }
        }
        return false;
    }
	// Using a normal for loop
    /*private static bool FindNumberInArrayOldSchoolStyle(int findNumber)
    {
        for(int i = 0; i < nums.Length-1; i++)
        {
            oldSchoolAttempts++;
            var currentNumber = nums[i];
            if (currentNumber == findNumber)
            {
                return true;
            }
        }
        return false;
    }*/
	// Using a while loop
    /*private static bool FindNumberInArrayOldSchoolStyle(int findNumber)
    {
        int i = 0;
        while (i < nums.Length-1)
        {
            oldSchoolAttempts++;
            var currentNumber = nums[i];
            if (currentNumber == findNumber)
            {
                return true;
            }
            i++;
        }
        return false;
    }*/
    private static bool FindNumberNormallyInArrayBinaryStyle(int number)
    {
        int leftIndex = -1;
        int maxIndex = nums.Length-1;
        while (leftIndex + 1 < maxIndex)
        {
            nonRecursiveBinaryAttempts++;
            int lookBetween = maxIndex - leftIndex;
            int lookTill = lookBetween / 2;
            int lookAt = leftIndex + lookTill;
            long currentValue = nums[lookAt];

            if (currentValue > number)
            {
                maxIndex = lookAt;
            }
            else
            {
                leftIndex = lookAt;
            }
            if (currentValue == number)
            {
                return true;
            }
        }
        return false;
    }
    private static bool FindNumberRecursivelyInArrayBinaryStyle(int number, int leftIndex, int maxIndex)
    {
        if (leftIndex + 1 < maxIndex)
        {
            recursiveBinaryAttempts++;
            int lookBetween = maxIndex - leftIndex;
            int lookTill = lookBetween / 2;
            int lookAt = leftIndex + lookTill;
            long currentValue = nums[lookAt];

            if (currentValue > number)
            {
                maxIndex = lookAt;
            }
            else
            {
                leftIndex = lookAt;
            }
            if (currentValue == number)
            {
                return true;
            }
            else
            {
                return FindNumberRecursivelyInArrayBinaryStyle(number, leftIndex, maxIndex);
            }
        }
        else
        {
            return false;
        }
    }
}

​x
 
using System;
using System.Diagnostics;
using System.Linq;
​
public class BlogApp
{
    private static int numberToFind = 0;
    private static int[] nums = Enumerable.Range(0, 1000000).ToArray();
    private static int recursiveBinaryAttempts = 0;
    private static int nonRecursiveBinaryAttempts = 0;
    private static int oldSchoolAttempts = 0;
    public static void Main(string[] args)
    {
        Array.Sort(nums);
        Boolean quitNow = false;
        string command = "";
        string commandLine = "";
        Console.WriteLine("Welcome to the 'Find my number' module. 'Like a number in a haystack!' \n/findnumber <number> to start the search!");
        while (!quitNow)
        {
            commandLine = Console.ReadLine();
            command = commandLine.Contains(" ") ? commandLine.Substring(0, commandLine.IndexOf(" ")) : commandLine; 
            switch (command)
            {
                case "/findnumber":
                    var number = commandLine.Substring(commandLine.IndexOf(' ') + 1);
                    int n = 0;
                    if (number.Length == -1 || !int.TryParse(number, out n))
                    {
                        Console.WriteLine("Please2 use /findnumber <number> to start your search!");
                    }
                    else
                    {
                        numberToFind = n;
                        Console.WriteLine("====================New search!=======================");
                        Console.WriteLine("Number to find: {0}", n);
                        Console.WriteLine("Searching in array between:{0} and {1}", nums[0], nums[nums.Length - 1]);
                        StartRecursiveBinarySearch();
                        StartNonRecursiveBinarySearch();
                        StartOldSchoolStyleSearch();
                        startLambdaSearch();
                        startLinqSearch();
                    }
                    break;
                case "/quit":
                    quitNow = true;
                    break;
                default:
                    Console.WriteLine("Please use /findnumber <number> to start your search!");
                    break;
            }
        }
    }
​
    private static void startLambdaSearch()
    {
        Console.WriteLine("=======Lambda Style=======");
        var stopwatch = new Stopwatch();
        stopwatch.Start();
        bool found = FindNumberLambdaStyle(numberToFind);
        stopwatch.Stop();
        if (found)
        {
            Console.WriteLine("Found it after in {0} milliseconds!",  stopwatch.Elapsed.TotalMilliseconds);
        }
        else
        {
            Console.WriteLine("Not found after in {0} milliseconds!",  stopwatch.Elapsed.TotalMilliseconds);
        }
    }
    private static void startLinqSearch()
    {
        Console.WriteLine("=======Linq Style=======");
        var stopwatch = new Stopwatch();
        stopwatch.Start();
        bool found = FindNumberLinqStyle(numberToFind);
        stopwatch.Stop();
        if (found)
        {
            Console.WriteLine("Found it after in {0} milliseconds!", stopwatch.Elapsed.TotalMilliseconds);
        }
        else
        {
            Console.WriteLine("Not found after in {0} milliseconds!", stopwatch.Elapsed.TotalMilliseconds);
        }
    }
    private static bool FindNumberLinqStyle(int numberTofind)
    {
        int[] found = (from num in nums
            where num == numberTofind
            select num).ToArray();
        return found.Length == 0 ? false : true;
    }
    private static bool FindNumberLambdaStyle(int numberTofind)
    {
        int[] found = nums.Where(x => x == numberTofind).ToArray();
        return found.Length == 0 ? false : true;
    }
    private static void StartRecursiveBinarySearch()
    {
        Console.WriteLine("=======Recursive Binary Style=======");
        int leftIndex = -1;
        int maxIndex = nums.Length-1;
        var stopwatch = new Stopwatch();
        stopwatch.Start();
        bool found = FindNumberRecursivelyInArrayBinaryStyle(numberToFind, leftIndex, maxIndex);
        stopwatch.Stop();
        if (found)
        {
            Console.WriteLine("Found it after looping {0} times in {1} milliseconds!", recursiveBinaryAttempts, stopwatch.Elapsed.TotalMilliseconds);
        }
        else
        {
            Console.WriteLine("Not found after looping {0} times in {1} milliseconds!", recursiveBinaryAttempts, stopwatch.Elapsed.TotalMilliseconds);
        }
        recursiveBinaryAttempts = 0;
    }
    private static void StartNonRecursiveBinarySearch()
    {
        Console.WriteLine("=======Non recursive Binary Style=======");
        var stopwatch = new Stopwatch();
        stopwatch.Start();
        bool found = FindNumberNormallyInArrayBinaryStyle(numberToFind);
        stopwatch.Stop();
        if (found)
        {
            Console.WriteLine("Found it after looping {0} times in {1} milliseconds!", nonRecursiveBinaryAttempts, stopwatch.Elapsed.TotalMilliseconds);
        }
        else
        {
            Console.WriteLine("Not found after looping {0} times in {1} milliseconds!", nonRecursiveBinaryAttempts, stopwatch.Elapsed.TotalMilliseconds);
        }
        nonRecursiveBinaryAttempts = 0;
    }
    private static void StartOldSchoolStyleSearch()
    {
        Console.WriteLine("=======OldSchool Style=======");
        var stopwatch = new Stopwatch();
        stopwatch.Start();
        bool foundOldSchool = FindNumberInArrayOldSchoolStyle(numberToFind);
        stopwatch.Stop();
        if (foundOldSchool)
        {
            Console.WriteLine("Found it after looping {0} times in {1} milliseconds!", oldSchoolAttempts, stopwatch.Elapsed.TotalMilliseconds);
        }
        else
        {
            Console.WriteLine("Not found after looping {0} times in {1} milliseconds!", oldSchoolAttempts, stopwatch.Elapsed.TotalMilliseconds);
        }
        oldSchoolAttempts = 0;
    }
    // Using a foreach
    private static bool FindNumberInArrayOldSchoolStyle(int findNumber)
    {
        foreach(int num in nums)
        {
            oldSchoolAttempts++;
            var currentNumber = num;
            if (currentNumber == findNumber)
            {
                return true;
            }
        }
        return false;
    }
    // Using a normal for loop
    /*private static bool FindNumberInArrayOldSchoolStyle(int findNumber)
    {
        for(int i = 0; i < nums.Length-1; i++)
        {
            oldSchoolAttempts++;
            var currentNumber = nums[i];
            if (currentNumber == findNumber)
            {
                return true;
            }
        }
        return false;
    }*/
    // Using a while loop
    /*private static bool FindNumberInArrayOldSchoolStyle(int findNumber)
    {
        int i = 0;
        while (i < nums.Length-1)
        {
            oldSchoolAttempts++;
            var currentNumber = nums[i];
            if (currentNumber == findNumber)
            {
                return true;
            }
            i++;
        }
        return false;
    }*/
    private static bool FindNumberNormallyInArrayBinaryStyle(int number)
    {
        int leftIndex = -1;
        int maxIndex = nums.Length-1;
        while (leftIndex + 1 < maxIndex)
        {
            nonRecursiveBinaryAttempts++;
            int lookBetween = maxIndex - leftIndex;
            int lookTill = lookBetween / 2;
            int lookAt = leftIndex + lookTill;
            long currentValue = nums[lookAt];
​
            if (currentValue > number)
            {
                maxIndex = lookAt;
            }
            else
            {
                leftIndex = lookAt;
            }
            if (currentValue == number)
            {
                return true;
            }
        }
        return false;
    }
    private static bool FindNumberRecursivelyInArrayBinaryStyle(int number, int leftIndex, int maxIndex)
    {
        if (leftIndex + 1 < maxIndex)
        {
            recursiveBinaryAttempts++;
            int lookBetween = maxIndex - leftIndex;
            int lookTill = lookBetween / 2;
            int lookAt = leftIndex + lookTill;
            long currentValue = nums[lookAt];
​
            if (currentValue > number)
            {
                maxIndex = lookAt;
            }
            else
            {
                leftIndex = lookAt;
            }
            if (currentValue == number)
            {
                return true;
            }
            else
            {
                return FindNumberRecursivelyInArrayBinaryStyle(number, leftIndex, maxIndex);
            }
        }
        else
        {
            return false;
        }
    }
}

Zadej první číslo:

Last Run:	4:31:59 pm
Compile:	0.035s
Execute:	0.13s
Memory:	0b
CPU:	0.165s

View IL Code