ntp test - sve

namespace sortiranja
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //int[] array = { -1, 5, 7, 8, 1, -2, 0, 5, -1, 6, -9, 0, 11, -12, 3 };


            //BubbleSort(array);
            //SelectionSort(array);
            //InsertionSort(array);
            //QuickSort(array, 0, array.Length - 1);
            //MergeSort(array);

            //int target = int.Parse(Console.ReadLine());
            //int targetPositon = BinarySearchIterative(array, target, 0, array.Length - 1);
            //int targetPositon = BinarySearchRecursive(array, target, 0, array.Length - 1);
            //Console.WriteLine(targetPositon);


            //Console.WriteLine(string.Join(" ", array));


            int a = int.Parse(Console.ReadLine());
            int b = int.Parse(Console.ReadLine());

            Console.WriteLine(IsPrimeMaxOptimized(a).ToString());
            Factiorization(a);

            int nzd = EuclidAlgorithmRecursive(a, b);
            int nzd1 = EuclidAlgorithmIterative(a, b);
            Console.WriteLine(nzd);
            Console.WriteLine(nzd1);

            int nzs = NZS(a, b);
            Console.WriteLine(nzs);
        }

        private static int NZS(int a, int b)
        {
            return a * b / EuclidAlgorithmIterative(a, b);
        }

        private static int EuclidAlgorithmIterative(int a, int b)
        {
            while (b > 0)
            {
                int tmp = b;
                b = a % b;
                a = tmp;
            }

            return a;
        }

        private static int EuclidAlgorithmRecursive(int a, int b)
        {
            if (b == 0)
            {
                return a;
            }
            return EuclidAlgorithmRecursive(b, a % b);
        }


        private static void Factiorization(int num)
        {
            int root = (int)Math.Ceiling(Math.Sqrt(num));
            int i = 2;

            while (i <= root)
            {
                if (num % i == 0)
                {
                    Console.WriteLine(i);
                    num /= i;
                    root = (int)Math.Ceiling(Math.Sqrt(num));
                }
                else
                {
                    i++;
                }
            }
            if (num > 1)
            {
                Console.WriteLine(num);
            }
        }

        private static bool IsPrimeMaxOptimized(int num)
        {
            if (num == 1)
            {
                return false;
            }
            if (num == 2)
            {
                return true;
            }
            if (num % 2 == 0)
            {
                return false;
            }


            int root = (int)Math.Ceiling(Math.Sqrt(num));
            for (int i = 3; i <= root; i += 2)
            {
                if (num % i == 0)
                {
                    return false;
                }

            }

            return true;
        }




        private static void MergeSort(int[] array)
        {
            if (array.Length <= 1)
            {
                return;
            }

            int mid = array.Length / 2;

            int[] left = new int[mid];
            int[] right = new int[array.Length - mid];

            for (int i = 0; i < left.Length; i++)
            {
                left[i] = array[i];
            }

            for (int i = mid; i < array.Length; i++)
            {
                right[i - mid] = array[i];
            }


            MergeSort(left);
            MergeSort(right);

            Merge(array, left, right);
        }

        private static void Merge(int[] array, int[] left, int[] right)
        {
            int l = 0;
            int r = 0;
            int pos = 0;

            while (l < left.Length && r < right.Length)
            {
                if (left[l] <= right[r])
                {
                    array[pos] = left[l];
                    pos++;
                    l++;
                }
                else
                {
                    array[pos] = right[r];
                    pos++;
                    r++;
                }
            }

            while (l < left.Length)
            {
                array[pos] = left[l];
                pos++;
                l++;
            }

            while (r < right.Length)
            {
                array[pos] = right[r];
                pos++;
                r++;
            }

        }


        private static void QuickSort(int[] array, int l, int r)
        {
            if (l >= r)
            {
                return;
            }

            int pivotPos = Partition(array, l, r);

            QuickSort(array, l, pivotPos - 1);
            QuickSort(array, pivotPos + 1, r);
        }

        private static int Partition(int[] array, int l, int r)
        {
            int pivotPos = l;

            for (int i = l + 1; i <= r; i++)
            {
                if (array[l] > array[i])
                {
                    pivotPos++;
                    Swap(array, i, pivotPos);
                }
            }

            Swap(array, l, pivotPos);


            return pivotPos;
        }


        private static void BubbleSort(int[] array)
        {
            for (int i = 0; i < array.Length - 1; i++)
            {
                for (int j = 0; j < array.Length - 1 - i; j++)
                {
                    if (array[j] > array[j + 1])
                    {
                        Swap(array, j, j + 1);
                    }
                }
            }

        }

        private static void InsertionSort(int[] array)
        {
            for (int i = 1; i < array.Length; i++)
            {
                int key = array[i];

                int j = i - 1;
                while (j >= 0 && array[j] > key)
                {
                    array[j + 1] = array[j];
                    j--;
                }

                array[j + 1] = key;
            }

        }

        private static void SelectionSort(int[] array)
        {
            for (int i = 0; i < array.Length - 1; i++)
            {
                int minIndex = i;
                for (int j = i + 1; j < array.Length; j++)
                {
                    if (array[j] < array[minIndex])
                    {
                        minIndex = j;
                    }
                }

                Swap(array, minIndex, i);
            }
        }




        private static int BinarySearchIterative(int[] array, int target, int l, int r)
        {
            while (l <= r)
            {
                int m = (r + l) / 2;

                if (array[m] == target)
                {
                    return m;
                }
                else if (array[m] > target)
                {
                    r = m - 1;
                }
                else
                {
                    l = m + 1;
                }
            }

            return -1;
        }

        private static int BinarySearchRecursive(int[] array, int target, int l, int r)
        {
            if (l > r)
            {
                return -1;
            }

            int m = (l + r) / 2;

            if (array[m] == target)
            {
                return m;
            }
            else if (array[m] > target)
            {
                return BinarySearchRecursive(array, target, l, m - 1);
            }
            else /*if (array[m] < target)*/
            {
                return BinarySearchRecursive(array, target, m + 1, r);
            }

        }



        private static void Swap(int[] array, int i, int j)
        {
            int tmp = array[i];
            array[i] = array[j];
            array[j] = tmp;
        }

    }
}