C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Collections.Generic;
using System.Text;

namespace AshkeClass
{
    static class Ashke
    {
        public static void WriteArr <t>(t[] arr)
        {
            //writes the array
            for (int i = 0; i < arr.Length; i++)
            {
                Console.Write(arr[i]);
                if (i != arr.Length - 1)
                {
                    Console.Write(",");
                }
            }
        }// print the array
        public static void Write2DArr<t>(t[,] arr)
        {
            //writes the 2D array
            for (int r = 0; r < arr.GetLength(0); r++)
            {
                for (int c = 0; c < arr.GetLength(1); c++)
                {
                    Console.Write(arr[r, c]);
                    if (r != arr.GetLength(0) - 1 || c != arr.GetLength(1) - 1)
                    {
                        Console.Write(",");
                    }
                }
                Console.WriteLine();
            }
        }// prints the 2D array
        public static void FillArr(int[] arr, int num)
        {
            //fills the arr with num
            //int only
            for (int i = 0; i < arr.Length; i++)
            {
                arr[i] = num;
            }
        }// fills the array with the num
        public static void SwapPosInArr <t>(t[] arr, int pos1, int pos2)
        {
            t temp = arr[pos1];
            arr[pos1] = arr[pos2];
            arr[pos2] = temp;
        }// swaps between 2 positions in an array
        public static void Swap <t>(ref t num1, ref t num2)
        {
            t temp = num1;
            num1 = num2;
            num2 = temp;
        }// swaps between 2 values
        public static bool IsSortedUp(int[] arr)
        {
            for (int i = 0; i < arr.Length - 1; i++)
            {
                if (arr[i] > arr[i + 1])
                {
                    return false;
                }
            }
            return true;
        }// checks if the arr sorted
        public static bool IsSortedDown(int[] arr)
        {
            for (int i = 0; i < arr.Length - 1; i++)
            {
                if (arr[i] < arr[i + 1])
                {
                    return false;
                }
            }
            return true;
        }// checks if the arr reverse sorted
        public static void SelectionSort(int[] arr)
        {

            for (int i = 0; i < arr.Length; i++)
            {
                int smallestIndex = i;
                int smallest = arr[i];
                for (int j = i + 1; j < arr.Length; j++)
                {
                    if (smallest > arr[j])
                    {
                        smallest = arr[j];
                        smallestIndex = j;
                    }
                }
                arr[smallestIndex] = arr[i];
                arr[i] = smallest;
            }
        }// sorts by SelectionSort
        public static void ReverseSelectionSort(int[] arr)
        {

            for (int i = 0; i < arr.Length; i++)
            {
                int biggestIndex = i;
                int biggeset = arr[i];
                for (int j = i + 1; j < arr.Length; j++)
                {
                    if (biggeset < arr[j])
                    {
                        biggeset = arr[j];
                        biggestIndex = j;
                    }
                }
                arr[biggestIndex] = arr[i];
                arr[i] = biggeset;
            }
        }// sorts reversely by SelectionSort
        private static int Partition(int[] arr)
        {
            if (arr.Length == 0)
            {
                return -1;
            }
            int pivot = arr[arr.Length - 1];
            int rightPointer = arr.Length-1;
            int leftPointer = 0;
            while (leftPointer < rightPointer)
            {
                while (arr[leftPointer] <= pivot && leftPointer < rightPointer)
                {
                    leftPointer++;
                }
                while (arr[rightPointer] >= pivot && leftPointer < rightPointer)
                {
                    rightPointer--;
                }
                
                SwapPosInArr(arr, rightPointer, leftPointer);
            }
            SwapPosInArr(arr, leftPointer, arr.Length-1);
            return leftPointer;
            
            
            
        }// one part of the Quicksort, places a number in his right place
        public static void QuickSort(int[] arr) 
        {
            int tempLength = Partition(arr);
            if (tempLength == -1)
            {
                return;
            }
            int[] leftArr = new int[tempLength];
            int[] rightArr = new int[arr.Length - tempLength-1];
            int num = 0;
            for (int i = 0; i < leftArr.Length; i++)
            {
                leftArr[i] = arr[num];
                num++;
            }
            for (int i = 0; i < rightArr.Length; i++)
            {
                rightArr[i] = arr[num+1];
                num++;
            }

            QuickSort(leftArr);
            num = 1;
            for (int i = 0; i < leftArr.Length; i++)
            {
                arr[i] = leftArr[i];
                num++;
            }
            QuickSort(rightArr);
            for (int i = 0; i < rightArr.Length; i++)
            {
                arr[num] = rightArr[i];
                num++;
            }

        }// sorts by QuickSort
        private static int ReturnMax(int[] arr)
        {
            int max = arr[0];
            for (int i = 1; i < arr.Length; i++)
            {
                if (arr[i] > max)
                {
                    max = arr[i];
                }
            }
            return max;
        }// returns the largest number in the array 
        public static void CountSort(int[] arr)
        {
            int[] countArr = new int[ReturnMax(arr) + 1];
            for (int i = 0; i < countArr.Length; i++)
            {
                countArr[i] = 0;
            }
            for (int i = 0; i < countArr.Length; i++)
            {
                int count = 0;
                for (int j = 0; j < arr.Length; j++)
                {
                    if (arr[j] == i)
                    {
                        count++;
                    }
                }
                countArr[i] = count;
            }
            int temp = 0;
            for (int i = 0; i < countArr.Length; i++)
            {
                for (int j = 0; j < countArr[i]; j++)
                {
                    arr[temp] = i;
                    temp++;
                }
            }
        }//sorts by "Menaya", works when there are no negetive numbers, works without comparisons
        public static void BogoSort(int[] arr)
        {
            Random rnd = new Random();
            while (!IsSortedUp(arr))
            {
                for (int i = 0; i < arr.Length; i++)
                {
                    SwapPosInArr(arr, rnd.Next(0, arr.Length), rnd.Next(0, arr.Length));
                }
            }
        }// sorts randomly untill the array is sorted
        public static int Factorial(int num)
        {
            if (num == 1)
            {
                return num;
            }
            return num * Factorial(num - 1);
        }// returns the factorial of the number
        public static void MergeSort (int[] arr)
        {
            if (arr.Length == 1)
            {
                return;
            }
            int[] leftArr = new int[arr.Length / 2];
            int[] rightArr = new int[arr.Length - leftArr.Length];
            int num = 0;
            for (int i = 0; i < leftArr.Length; i++)
            {
                leftArr[i] = arr[i];
                num++;
            }
            for (int i = 0; i < rightArr.Length; i++)
            {
                rightArr[i] = arr[num];
                num++;
            }
            MergeSort(leftArr);
            MergeSort(rightArr);
            int leftNum = 0;
            int rightNum = 0;
            for (int i = 0; i < arr.Length; i++)
            {
                if (leftNum >= leftArr.Length)
                {
                    arr[i] = rightArr[rightNum];
                    rightNum++;
                }
                else if (rightNum >= rightArr.Length)
                {
                    arr[i] = leftArr[leftNum];
                    leftNum++;
                }
                else if (leftArr[leftNum] <= rightArr[rightNum])
                {
                    arr[i] = leftArr[leftNum];
                    leftNum++;
                }
                else
                {
                    arr[i] = rightArr[rightNum];
                    rightNum++;
                }
            }
        }// sorts by MergeSort
        public static int[] Merge(int[] leftArr, int[] rightArr)
        {
            int rightNum = 0;
            int leftNum = 0;
            int[] arr = new int[leftArr.Length + rightArr.Length];
            for (int i = 0; i < arr.Length; i++)
            {
                if (leftNum >= leftArr.Length)
                {
                    arr[i] = rightArr[rightNum];
                    rightNum++;
                }
                else if (rightNum >= rightArr.Length)
                {
                    arr[i] = leftArr[leftNum];
                    leftNum++;
                }
                else if (leftArr[leftNum] <= rightArr[rightNum])
                {
                    arr[i] = leftArr[leftNum];
                    leftNum++;
                }
                else
                {
                    arr[i] = rightArr[rightNum];
                    rightNum++;
                }
            }
            return arr;
        }// merges 2 sorted arrays into 1 sorted array
        public static int[] TriMerge1(int[] arr1, int[] arr2, int[] arr3)
        {
            int[] newArr = Merge(arr1, arr2);
            return Merge(newArr, arr3);
        }// merges 3 sorted arrays into 1 sorted array
        public static int[] TriMerge2(int[] arr1, int[] arr2, int[] arr3)
        {
            int num1 = 0, num2 = 0, num3 = 0;
            int[] arr = new int[arr1.Length + arr2.Length + arr3.Length];
            for (int i = 0; i < arr.Length; i++)
            {
                if (num1 >= arr1.Length)
                {
                    if (num2 >= arr2.Length)
                    {
                        arr[i] = arr3[num3];
                        num3++;
                    }
                    else if (num3 >= arr3.Length)
                    {
                        arr[i] = arr2[num2];
                        num2++;
                    }
                    else if (arr2[num2] <= arr3[num3])
                    {
                        arr[i] = arr2[num2];
                        num2++;
                    }
                    else
                    {
                        arr[i] = arr3[num3];
                        num3++;
                    }
                }
                else if (num2 >= arr2.Length)
                {
                    if (num1 >= arr1.Length)
                    {
                        arr[i] = arr3[num3];
                        num3++;
                    }
                    else if (num3 >= arr3.Length)
                    {
                        arr[i] = arr1[num1];
                        num1++;
                    }
                    else if (arr1[num1] <= arr3[num3])
                    {
                        arr[i] = arr1[num1];
                        num1++;
                    }
                    else
                    {
                        arr[i] = arr3[num3];
                        num3++;
                    }
                }
                else if (arr1[num1] <= arr2[num2])
                {
                    if (num3 >= arr3.Length)
                    {
                        arr[i] = arr1[num1];
                        num1++;
                    }
                    else if (arr1[num1] <= arr3[num3])
                    {
                        arr[i] = arr1[num1];
                        num1++;
                    }
                    else
                    {
                        arr[i] = arr3[num3];
                        num3++;
                    }

                }
                else
                {
                    if (num3 <= arr3.Length)
                    {
                        arr[i] = arr2[num2];
                        num2++;
                    }
                    else if (arr2[num1] <= arr3[num3])
                    {
                        arr[i] = arr2[num2];
                        num2++;
                    }
                    else
                    {
                        arr[i] = arr3[num3];
                        num3++;
                    }
                }
            }
            return arr;
        }// merges 3 sorted arrays into 1 sorted array
        public static void WriteCommon(int[] arr1, int[] arr2)
        {
            QuickSort(arr1);
            QuickSort(arr2);
            int index1 = 0, index2 = 0;
            while (index1 < arr1.Length && index2 < arr2.Length)
            {
                if (arr1[index1] == arr2[index2])
                {
                    Console.WriteLine(arr2[index2]);
                    bool flag = true;
                    while (arr1.Length > index1 + 1 && flag)
                    {
                        if (arr1[index1 + 1] == arr1[index1])
                        {
                            index1++;
                        }
                        else
                        {
                            flag = false;
                        }
                    }
                    flag = true;
                    while (arr2.Length > index2 + 1 && flag)
                    {
                        if (arr2[index2 + 1] == arr2[index2])
                        {
                            index2++;
                        }
                        else
                        {
                            flag = false;
                        }
                    }
                    index1++;
                    index2++;
                }
                else if (arr1[index1] < arr2[index2])
                {
                    index1++;
                }
                else
                {
                    index2++;
                }
            }
        }// writes all common numbers of the 2 arrays
        public static int TriSearch(int[] arr, int num)
        {
            //could sort the array here if the array isn't sorted for sure, but it will return the new index
            return TriSearch(arr, num, 0, arr.Length - 1);
        }// returns the index of the num received, works only if the array is sorted
        private static int TriSearch(int[] arr, int num, int first, int last)
        {
            int third = (last - first) / 3;
            int firstThird = third + first;
            int secondThird = firstThird + third;
            if (first == last && arr[firstThird] != num)
            {
                return -1;
            }
            if (arr[firstThird] == num)
            {
                return firstThird;
            }
            if (arr[firstThird] > num)
            {
                return TriSearch(arr, num, first, firstThird - 1);
            }
            if (arr[secondThird] >= num)
            {
                return TriSearch(arr, num, firstThird + 1, secondThird);
            }
            if (arr[last] >= num)
            {
                return TriSearch(arr, num, secondThird + 1, last);
            }
            return -2;

        }// the recursion part of the TriSearch
        public static int BinarySearch (int[] arr, int num)
        {
            //could sort the array here if the array isn't sorted for sure, but it will return the new index
            return BinarySearch(arr, num, 0, arr.Length - 1);
        }// returns the index of the num received, works only if the array is sorted
        private static int BinarySearch(int[] arr, int num, int first, int last)
        {
            int middle = (last - first)/2;
            int middleIndex = first + middle;
            if (first == last && arr[middleIndex] != num)
            {
                return -1;
            }
            if (arr[middleIndex] == num)
            {
                return middleIndex;
            }
            if (arr[middleIndex] > num)
            {
                return BinarySearch(arr, num, first, middleIndex - 1);
            }
            return BinarySearch(arr, num, middleIndex + 1, last);
        }// the recursion part of the BinarySearch
        public static bool IsFirstStringBefore(string str1, string str2)
        {
            for (int i = 0; i < Math.Max(str1.Length, str2.Length); i++)
            {
                if (i == Math.Min(str1.Length, str2.Length))
                {
                    if (i == str1.Length)
                    {
                        return true;
                    }
                    return false;
                }
                if (str1[i] < str2[i])
                {
                    return true;
                }
                else if (str1[i] > str2[i])
                {
                    return false;
                }
            }
            Console.WriteLine("Error");
            return false;
        } // return true if the first string comes first in the dictionary
        public static int QuadSearch (int[] arr, int num)
        {
            //could sort the array here if the array isn't sorted for sure, but it will return the new index
            return QuadSearch(arr, num, 0, arr.Length - 1);
        }// returns the index of the num received, works only if the array is sorted
        private static int QuadSearch(int[] arr, int num, int first, int last)
        {
            int forth = (last - first) / 4;
            int firstForth = forth + first;
            int secondForth = firstForth + forth;
            int thirdForth = secondForth + forth;
            if (firstForth == last && arr[firstForth] != num)
            {
                return -1;
            }
            if (arr[firstForth] == num)
            {
                return firstForth;
            }
            if (arr[firstForth] > num)
            {
                return QuadSearch(arr, num, first, firstForth - 1);
            }
            if (arr[secondForth] >= num)
            {
                return QuadSearch(arr, num, firstForth + 1, secondForth);
            }
            if (arr[thirdForth] >= num)
            {
                return QuadSearch(arr, num, secondForth + 1, thirdForth);
            }
            if (arr[last] >= num)
            {
                return QuadSearch(arr, num, thirdForth + 1, last);
            }
            return -2;
        }// the recursion part of the QuadSearch
        public static int[] Binary2DSearch(int[,] arr, int num)
        {
            int[] result = new int[2];
            int firstCol = 0, firstRow = 0;
            int lastCol = arr.GetLength(1) - 1, lastRow = arr.GetLength(0) - 1;
            
            while (firstRow != lastRow)
            {
                int halfColLength = (lastRow - firstRow) / 2;
                int middleRow = halfColLength + firstRow;
                if (lastRow < 0 || firstRow >= arr.GetLength(0))
                {
                    return null;
                }
                if (arr[middleRow, 0] == num)
                {
                    result[0] = middleRow;
                    result[1] = 0;
                    return result;
                }
                if (arr[middleRow,0] > num)
                {
                    lastRow = middleRow-1;
                }
                if (arr[middleRow,0] < num && arr[middleRow+1,0] > num)
                {
                    firstRow = middleRow;
                    lastRow = middleRow;
                }
                else
                {
                    firstRow = middleRow + 1;
                }
                
            }
            result[0] = firstRow;
            while (firstCol != lastCol)
            {
                int halfRowLength = (lastCol - firstCol) / 2;
                int middleCol = halfRowLength + firstCol;
                if (lastCol < 0 || firstCol >= arr.GetLength(1))
                {
                    return null;
                }
                if (arr[firstRow,middleCol] == num)
                {
                    result[1] = middleCol;
                    return result;
                }
                if (arr[firstRow, middleCol] > num)
                {
                    lastCol = middleCol - 1;
                }
                else
                {
                    firstCol = middleCol + 1;
                }
            }
            result[1] = firstCol;
            return result;
        }// return the index of the num received, works only if the 2D array is sorted
        public static void BubbleSort(int[] arr)
        {
            for (int i = 0; i < arr.Length; i++)
            {
                for (int j = i + 1; j < arr.Length; j++)
                {
                    if (arr[i] > arr[j])
                    {
                        int temp = arr[i];

                        arr[i] = arr[j];

                        arr[j] = temp;
                    }
                }
            }


        }// sorts by BubbleSort
        public static void InsertionSort(int[] arr)
        {
            for (int i = 1; i < arr.Length; i++)
            {
                int temp = arr[i];
                int j = i - 1;
                while (j >= 0 && arr[j] > temp)
                {
                    arr[j + 1] = arr[j];
                    j--;
                }
                arr[j + 1] = temp;
            }
        }// sorts by InsertionSort
        public static int  Fibonacci (int place)
        {
            if (place == 1)
            {
                return 1;
            }
            if (place == 2)
            {
                return 1;
            }
            return Fibonacci(place - 1) + Fibonacci(place - 2);
        } // returns the number at the N place in Fibonacci series
    }

}

​x
 
using System;
using System.Collections.Generic;
using System.Text;
​
namespace AshkeClass
{
    static class Ashke
    {
        public static void WriteArr <t>(t[] arr)
        {
            //writes the array
            for (int i = 0; i < arr.Length; i++)
            {
                Console.Write(arr[i]);
                if (i != arr.Length - 1)
                {
                    Console.Write(",");
                }
            }
        }// print the array
        public static void Write2DArr<t>(t[,] arr)
        {
            //writes the 2D array
            for (int r = 0; r < arr.GetLength(0); r++)
            {
                for (int c = 0; c < arr.GetLength(1); c++)
                {
                    Console.Write(arr[r, c]);
                    if (r != arr.GetLength(0) - 1 || c != arr.GetLength(1) - 1)
                    {
                        Console.Write(",");
                    }
                }
                Console.WriteLine();
            }
        }// prints the 2D array
        public static void FillArr(int[] arr, int num)
        {
            //fills the arr with num
            //int only
            for (int i = 0; i < arr.Length; i++)
            {
                arr[i] = num;
            }
        }// fills the array with the num
        public static void SwapPosInArr <t>(t[] arr, int pos1, int pos2)
        {
            t temp = arr[pos1];
            arr[pos1] = arr[pos2];
            arr[pos2] = temp;
        }// swaps between 2 positions in an array
        public static void Swap <t>(ref t num1, ref t num2)
        {
            t temp = num1;
            num1 = num2;
            num2 = temp;
        }// swaps between 2 values
        public static bool IsSortedUp(int[] arr)
        {
            for (int i = 0; i < arr.Length - 1; i++)
            {
                if (arr[i] > arr[i + 1])
                {
                    return false;
                }
            }
            return true;
        }// checks if the arr sorted
        public static bool IsSortedDown(int[] arr)
        {
            for (int i = 0; i < arr.Length - 1; i++)
            {
                if (arr[i] < arr[i + 1])
                {
                    return false;
                }
            }
            return true;
        }// checks if the arr reverse sorted
        public static void SelectionSort(int[] arr)
        {
​
            for (int i = 0; i < arr.Length; i++)
            {
                int smallestIndex = i;
                int smallest = arr[i];
                for (int j = i + 1; j < arr.Length; j++)
                {
                    if (smallest > arr[j])
                    {
                        smallest = arr[j];
                        smallestIndex = j;
                    }
                }
                arr[smallestIndex] = arr[i];
                arr[i] = smallest;
            }
        }// sorts by SelectionSort
        public static void ReverseSelectionSort(int[] arr)
        {
​
            for (int i = 0; i < arr.Length; i++)
            {
                int biggestIndex = i;
                int biggeset = arr[i];
                for (int j = i + 1; j < arr.Length; j++)
                {
                    if (biggeset < arr[j])
                    {
                        biggeset = arr[j];
                        biggestIndex = j;
                    }
                }
                arr[biggestIndex] = arr[i];
                arr[i] = biggeset;
            }
        }// sorts reversely by SelectionSort
        private static int Partition(int[] arr)
        {
            if (arr.Length == 0)
            {
                return -1;
            }
            int pivot = arr[arr.Length - 1];
            int rightPointer = arr.Length-1;
            int leftPointer = 0;
            while (leftPointer < rightPointer)
            {
                while (arr[leftPointer] <= pivot && leftPointer < rightPointer)
                {
                    leftPointer++;
                }
                while (arr[rightPointer] >= pivot && leftPointer < rightPointer)
                {
                    rightPointer--;
                }
                
                SwapPosInArr(arr, rightPointer, leftPointer);
            }
            SwapPosInArr(arr, leftPointer, arr.Length-1);
            return leftPointer;
            
            
            
        }// one part of the Quicksort, places a number in his right place
        public static void QuickSort(int[] arr) 
        {
            int tempLength = Partition(arr);
            if (tempLength == -1)
            {
                return;
            }
            int[] leftArr = new int[tempLength];
            int[] rightArr = new int[arr.Length - tempLength-1];
            int num = 0;
            for (int i = 0; i < leftArr.Length; i++)
            {
                leftArr[i] = arr[num];
                num++;
            }
            for (int i = 0; i < rightArr.Length; i++)
            {
                rightArr[i] = arr[num+1];
                num++;
            }
​
            QuickSort(leftArr);
            num = 1;
            for (int i = 0; i < leftArr.Length; i++)
            {
                arr[i] = leftArr[i];
                num++;
            }
            QuickSort(rightArr);
            for (int i = 0; i < rightArr.Length; i++)
            {
                arr[num] = rightArr[i];
                num++;
            }
​
        }// sorts by QuickSort
        private static int ReturnMax(int[] arr)
        {
            int max = arr[0];
            for (int i = 1; i < arr.Length; i++)
            {
                if (arr[i] > max)
                {
                    max = arr[i];
                }
            }
            return max;
        }// returns the largest number in the array 
        public static void CountSort(int[] arr)
        {
            int[] countArr = new int[ReturnMax(arr) + 1];
            for (int i = 0; i < countArr.Length; i++)
            {
                countArr[i] = 0;
            }
            for (int i = 0; i < countArr.Length; i++)
            {
                int count = 0;
                for (int j = 0; j < arr.Length; j++)
                {
                    if (arr[j] == i)
                    {
                        count++;
                    }
                }
                countArr[i] = count;
            }
            int temp = 0;
            for (int i = 0; i < countArr.Length; i++)
            {
                for (int j = 0; j < countArr[i]; j++)
                {
                    arr[temp] = i;
                    temp++;
                }
            }
        }//sorts by "Menaya", works when there are no negetive numbers, works without comparisons
        public static void BogoSort(int[] arr)
        {
            Random rnd = new Random();
            while (!IsSortedUp(arr))
            {
                for (int i = 0; i < arr.Length; i++)
                {
                    SwapPosInArr(arr, rnd.Next(0, arr.Length), rnd.Next(0, arr.Length));
                }
            }
        }// sorts randomly untill the array is sorted
        public static int Factorial(int num)
        {
            if (num == 1)
            {
                return num;
            }
            return num * Factorial(num - 1);
        }// returns the factorial of the number
        public static void MergeSort (int[] arr)
        {
            if (arr.Length == 1)
            {
                return;
            }
            int[] leftArr = new int[arr.Length / 2];
            int[] rightArr = new int[arr.Length - leftArr.Length];
            int num = 0;
            for (int i = 0; i < leftArr.Length; i++)
            {
                leftArr[i] = arr[i];
                num++;
            }
            for (int i = 0; i < rightArr.Length; i++)
            {
                rightArr[i] = arr[num];
                num++;
            }
            MergeSort(leftArr);
            MergeSort(rightArr);
            int leftNum = 0;
            int rightNum = 0;
            for (int i = 0; i < arr.Length; i++)
            {
                if (leftNum >= leftArr.Length)
                {
                    arr[i] = rightArr[rightNum];
                    rightNum++;
                }
                else if (rightNum >= rightArr.Length)
                {
                    arr[i] = leftArr[leftNum];
                    leftNum++;
                }
                else if (leftArr[leftNum] <= rightArr[rightNum])
                {
                    arr[i] = leftArr[leftNum];
                    leftNum++;
                }
                else
                {
                    arr[i] = rightArr[rightNum];
                    rightNum++;
                }
            }
        }// sorts by MergeSort
        public static int[] Merge(int[] leftArr, int[] rightArr)
        {
            int rightNum = 0;
            int leftNum = 0;
            int[] arr = new int[leftArr.Length + rightArr.Length];
            for (int i = 0; i < arr.Length; i++)
            {
                if (leftNum >= leftArr.Length)
                {
                    arr[i] = rightArr[rightNum];
                    rightNum++;
                }
                else if (rightNum >= rightArr.Length)
                {
                    arr[i] = leftArr[leftNum];
                    leftNum++;
                }
                else if (leftArr[leftNum] <= rightArr[rightNum])
                {
                    arr[i] = leftArr[leftNum];
                    leftNum++;
                }
                else
                {
                    arr[i] = rightArr[rightNum];
                    rightNum++;
                }
            }
            return arr;
        }// merges 2 sorted arrays into 1 sorted array
        public static int[] TriMerge1(int[] arr1, int[] arr2, int[] arr3)
        {
            int[] newArr = Merge(arr1, arr2);
            return Merge(newArr, arr3);
        }// merges 3 sorted arrays into 1 sorted array
        public static int[] TriMerge2(int[] arr1, int[] arr2, int[] arr3)
        {
            int num1 = 0, num2 = 0, num3 = 0;
            int[] arr = new int[arr1.Length + arr2.Length + arr3.Length];
            for (int i = 0; i < arr.Length; i++)
            {
                if (num1 >= arr1.Length)
                {
                    if (num2 >= arr2.Length)
                    {
                        arr[i] = arr3[num3];
                        num3++;
                    }
                    else if (num3 >= arr3.Length)
                    {
                        arr[i] = arr2[num2];
                        num2++;
                    }
                    else if (arr2[num2] <= arr3[num3])
                    {
                        arr[i] = arr2[num2];
                        num2++;
                    }
                    else
                    {
                        arr[i] = arr3[num3];
                        num3++;
                    }
                }
                else if (num2 >= arr2.Length)
                {
                    if (num1 >= arr1.Length)
                    {
                        arr[i] = arr3[num3];
                        num3++;
                    }
                    else if (num3 >= arr3.Length)
                    {
                        arr[i] = arr1[num1];
                        num1++;
                    }
                    else if (arr1[num1] <= arr3[num3])
                    {
                        arr[i] = arr1[num1];
                        num1++;
                    }
                    else
                    {
                        arr[i] = arr3[num3];
                        num3++;
                    }
                }
                else if (arr1[num1] <= arr2[num2])
                {
                    if (num3 >= arr3.Length)
                    {
                        arr[i] = arr1[num1];
                        num1++;
                    }
                    else if (arr1[num1] <= arr3[num3])
                    {
                        arr[i] = arr1[num1];
                        num1++;
                    }
                    else
                    {
                        arr[i] = arr3[num3];
                        num3++;
                    }
​
                }
                else
                {
                    if (num3 <= arr3.Length)
                    {
                        arr[i] = arr2[num2];
                        num2++;
                    }
                    else if (arr2[num1] <= arr3[num3])
                    {
                        arr[i] = arr2[num2];
                        num2++;
                    }
                    else
                    {
                        arr[i] = arr3[num3];
                        num3++;
                    }
                }
            }
            return arr;
        }// merges 3 sorted arrays into 1 sorted array
        public static void WriteCommon(int[] arr1, int[] arr2)
        {
            QuickSort(arr1);
            QuickSort(arr2);
            int index1 = 0, index2 = 0;
            while (index1 < arr1.Length && index2 < arr2.Length)
            {
                if (arr1[index1] == arr2[index2])
                {
                    Console.WriteLine(arr2[index2]);
                    bool flag = true;
                    while (arr1.Length > index1 + 1 && flag)
                    {
                        if (arr1[index1 + 1] == arr1[index1])
                        {
                            index1++;
                        }
                        else
                        {
                            flag = false;
                        }
                    }
                    flag = true;
                    while (arr2.Length > index2 + 1 && flag)
                    {
                        if (arr2[index2 + 1] == arr2[index2])
                        {
                            index2++;
                        }
                        else
                        {
                            flag = false;
                        }
                    }
                    index1++;
                    index2++;
                }
                else if (arr1[index1] < arr2[index2])
                {
                    index1++;
                }
                else
                {
                    index2++;
                }
            }
        }// writes all common numbers of the 2 arrays
        public static int TriSearch(int[] arr, int num)
        {
            //could sort the array here if the array isn't sorted for sure, but it will return the new index
            return TriSearch(arr, num, 0, arr.Length - 1);
        }// returns the index of the num received, works only if the array is sorted
        private static int TriSearch(int[] arr, int num, int first, int last)
        {
            int third = (last - first) / 3;
            int firstThird = third + first;
            int secondThird = firstThird + third;
            if (first == last && arr[firstThird] != num)
            {
                return -1;
            }
            if (arr[firstThird] == num)
            {
                return firstThird;
            }
            if (arr[firstThird] > num)
            {
                return TriSearch(arr, num, first, firstThird - 1);
            }
            if (arr[secondThird] >= num)
            {
                return TriSearch(arr, num, firstThird + 1, secondThird);
            }
            if (arr[last] >= num)
            {
                return TriSearch(arr, num, secondThird + 1, last);
            }
            return -2;
​
        }// the recursion part of the TriSearch
        public static int BinarySearch (int[] arr, int num)
        {
            //could sort the array here if the array isn't sorted for sure, but it will return the new index
            return BinarySearch(arr, num, 0, arr.Length - 1);
        }// returns the index of the num received, works only if the array is sorted
        private static int BinarySearch(int[] arr, int num, int first, int last)
        {
            int middle = (last - first)/2;
            int middleIndex = first + middle;
            if (first == last && arr[middleIndex] != num)
            {
                return -1;
            }
            if (arr[middleIndex] == num)
            {
                return middleIndex;
            }
            if (arr[middleIndex] > num)
            {
                return BinarySearch(arr, num, first, middleIndex - 1);
            }
            return BinarySearch(arr, num, middleIndex + 1, last);
        }// the recursion part of the BinarySearch
        public static bool IsFirstStringBefore(string str1, string str2)
        {
            for (int i = 0; i < Math.Max(str1.Length, str2.Length); i++)
            {
                if (i == Math.Min(str1.Length, str2.Length))
                {
                    if (i == str1.Length)
                    {
                        return true;
                    }
                    return false;
                }
                if (str1[i] < str2[i])
                {
                    return true;
                }
                else if (str1[i] > str2[i])
                {
                    return false;
                }
            }
            Console.WriteLine("Error");
            return false;
        } // return true if the first string comes first in the dictionary
        public static int QuadSearch (int[] arr, int num)
        {
            //could sort the array here if the array isn't sorted for sure, but it will return the new index
            return QuadSearch(arr, num, 0, arr.Length - 1);
        }// returns the index of the num received, works only if the array is sorted
        private static int QuadSearch(int[] arr, int num, int first, int last)
        {
            int forth = (last - first) / 4;
            int firstForth = forth + first;
            int secondForth = firstForth + forth;
            int thirdForth = secondForth + forth;
            if (firstForth == last && arr[firstForth] != num)
            {
                return -1;
            }
            if (arr[firstForth] == num)
            {
                return firstForth;
            }
            if (arr[firstForth] > num)
            {
                return QuadSearch(arr, num, first, firstForth - 1);
            }
            if (arr[secondForth] >= num)
            {
                return QuadSearch(arr, num, firstForth + 1, secondForth);
            }
            if (arr[thirdForth] >= num)
            {
                return QuadSearch(arr, num, secondForth + 1, thirdForth);
            }
            if (arr[last] >= num)
            {
                return QuadSearch(arr, num, thirdForth + 1, last);
            }
            return -2;
        }// the recursion part of the QuadSearch
        public static int[] Binary2DSearch(int[,] arr, int num)
        {
            int[] result = new int[2];
            int firstCol = 0, firstRow = 0;
            int lastCol = arr.GetLength(1) - 1, lastRow = arr.GetLength(0) - 1;
            
            while (firstRow != lastRow)
            {
                int halfColLength = (lastRow - firstRow) / 2;
                int middleRow = halfColLength + firstRow;
                if (lastRow < 0 || firstRow >= arr.GetLength(0))
                {
                    return null;
                }
                if (arr[middleRow, 0] == num)
                {
                    result[0] = middleRow;
                    result[1] = 0;
                    return result;
                }
                if (arr[middleRow,0] > num)
                {
                    lastRow = middleRow-1;
                }
                if (arr[middleRow,0] < num && arr[middleRow+1,0] > num)
                {
                    firstRow = middleRow;
                    lastRow = middleRow;
                }
                else
                {
                    firstRow = middleRow + 1;
                }
                
            }
            result[0] = firstRow;
            while (firstCol != lastCol)
            {
                int halfRowLength = (lastCol - firstCol) / 2;
                int middleCol = halfRowLength + firstCol;
                if (lastCol < 0 || firstCol >= arr.GetLength(1))
                {
                    return null;
                }
                if (arr[firstRow,middleCol] == num)
                {
                    result[1] = middleCol;
                    return result;
                }
                if (arr[firstRow, middleCol] > num)
                {
                    lastCol = middleCol - 1;
                }
                else
                {
                    firstCol = middleCol + 1;
                }
            }
            result[1] = firstCol;
            return result;
        }// return the index of the num received, works only if the 2D array is sorted
        public static void BubbleSort(int[] arr)
        {
            for (int i = 0; i < arr.Length; i++)
            {
                for (int j = i + 1; j < arr.Length; j++)
                {
                    if (arr[i] > arr[j])
                    {
                        int temp = arr[i];
​
                        arr[i] = arr[j];
​
                        arr[j] = temp;
                    }
                }
            }
​
​
        }// sorts by BubbleSort
        public static void InsertionSort(int[] arr)
        {
            for (int i = 1; i < arr.Length; i++)
            {
                int temp = arr[i];
                int j = i - 1;
                while (j >= 0 && arr[j] > temp)
                {
                    arr[j + 1] = arr[j];
                    j--;
                }
                arr[j + 1] = temp;
            }
        }// sorts by InsertionSort
        public static int  Fibonacci (int place)
        {
            if (place == 1)
            {
                return 1;
            }
            if (place == 2)
            {
                return 1;
            }
            return Fibonacci(place - 1) + Fibonacci(place - 2);
        } // returns the number at the N place in Fibonacci series
    }
​
}
​
​

View IL Code