using System;

namespace LAB3
{

    class AllStaticFunctions
    {
        //פעולות על מערך חד-מימדי

        public static void StartArray(int[] arr)//אתחול מערך
                                                /* טענת כניסה: ארר מערך מספרים שלמים
                                                 טענת יציאה: הפעולה מתאחלת כל תא בתא ע"י המשתמש*/
        {
            Console.WriteLine("enter " + arr.Length + " numbers");
            for (int i = 0; i < arr.Length; i++)
            {
                arr[i] = int.Parse(Console.ReadLine());
            }
        }

        public static void PrintArray(int[] arr)//הדפסת מערך
                                                /*טענת כניסה: ארר מערך של מספרים שלמים
                                                טענת יציאה: הפעולה עוברת תא תא ומדפיסה אותו למסך*/
        {
            for (int i = 0; i < arr.Length; i++)
            {
                Console.Write(arr[i] + " ");
            }
            Console.WriteLine();
        }
        public static void PrintZug(int[] arr)//פעולה המדפיסה מספרים במקום הזוגי
                                              /*טענת כניסה:ארר מערך של מספרים שלמים
                                              טענת יציאה: הפעולה מדפיסה ערכים רק מהתאים הזוגיים במערך */
        {
            for (int i = 0; i < arr.Length; i += 2)
            {
                Console.Write(arr[i] + " ");
            }
            Console.WriteLine();
        }
        public static void Printeven(int[] arr)//פעולה שמדפיסה את כל המספרים הזוגיים במערך
                                               /*טענת כניסה: ארר מערך של מספרים שלמים
                                                טענת יציאה: הפעולה עוברת תא תא, בודקת האם הערך זוגי, אם כן,מדפיסה אותו למסך*/
        {
            Console.WriteLine("all the even numbers are : ");
            for (int i = 0; i < arr.Length; i++)
            {
                if (arr[i] % 2 == 0)
                {
                    Console.Write(arr[i] + " ");
                }
            }
            Console.WriteLine();
        }
        public static void PrintEZugi(int[] arr)//פעולה המדפיסה מספרים במקום האיזוגי
        /*טענת כניסה:ארר מערך של מספרים שלמים
        טענת יציאה: הפעולה מדפיסה ערכים רק מהתאים האיזוגיים במערך */
        {
            for (int i = 1; i < arr.Length; i += 2)
            {
                Console.Write(arr[i] + " ");
            }
            Console.WriteLine();
        }
        public static void PrintUneven(int[] arr)//פעולה שמדפיסה את כל המספרים ה איזוגיים במערך
                                                 /*טענת כניסה: ארר מערך של מספרים שלמים
                                                טענת יציאה: הפעולה עוברת תא תא, בודקת האם הערך איזוגי, אם כן,מדפיסה אותו למסך*/
        {
            Console.WriteLine("all the uneven numbers are : ");
            for (int i = 0; i < arr.Length; i++)
            {
                if (arr[i] % 2 != 0)
                {
                    Console.Write(arr[i] + " ");
                }
            }
            Console.WriteLine();
        }
        public static int MaxArray(int[] arr)//חישוב המספר הגדול ביותר המערך
        /*טענת כניסה: ארר מערך מספרי שלמים
        טענת יציאה: מחשבת ומחזירה את המספר הכי גדול בכל המערך*/
        {
            int max = arr[0];
            for (int i = 1; i < arr.Length; i++)
            {
                if (arr[i] > max)
                {
                    max = arr[i];
                }
            }
            return max;
        }
        public static void PrintMax(int[] arr, int max)// הדפסת המספר הגדול ביותר במערך
                                                       /*טענת כניסה:: ארר מערך מספרים שלמים, מקס מספר
                                                    טענת יציאה: הפעולה מחפשת את מקס במערך, וכשהיא מוצאת אותו היא מדפיסה אותו*/
        {
            for (int i = 0; i < arr.Length; i++)
            {
                if (arr[i] == max)
                {
                    Console.WriteLine(arr[i]);
                }
            }
        }
        public static int MinArray(int[] arr)//חישוב המספר הקטן ביותר במערך
                                             /*טענת כניסה: ארר מערך מספרי שלמים
                                            טענת יציאה: מחשבת ומחזירה את המספר הכי קטן בכל המערך*/
        {
            int min = arr[0];
            for (int i = 1; i < arr.Length; i++)
            {
                if (arr[i] < min)
                {
                    min = arr[i];
                }
            }
            return min;
        }
        public static void PrintMin(int[] arr, int min)// הדפסת המספר הקטן ביותר במערך
        /*טענת כניסה:: ארר מערך מספרים שלמים, מין מספר
         טענת יציאה: הפעולה מחפשת את מין במערך, וכשהיא מוצאת אותו היא מדפיסה אותו*/
        {
            for (int i = 0; i < arr.Length; i++)
            {
                if (arr[i] == min)
                {
                    Console.WriteLine(arr[i]);
                }
            }
        }

        public static bool IsEqual(int[] arr)//הפעולה בוקת האם כל אברי המערך שווים זה לזה
        /*טענת כניסה:ארר מערך מספרים שלמים
         טענת יציאה: הפעולה בודקת ומזירה אמת כאשר כל המספרים במערך שווים זה לזה ושקר אחרת*/
        {
            ////bool Equal = true;
            ////for (int i = 0; i <arr.Length; i++)
            ////{
            //    //if (arr[i] != arr[0])
            //    //{
            //     //   Equal = false;
            //   // }
            ////}
            //return Equal;
            //השורות בהערה מעל הן אופציה נוספת לכתוב את הפעולה
            for (int i = 0; i < arr.Length; i++)
            {
                if (arr[i] != arr[0])
                {
                    return false;
                }

            }
            return true;
        }
        public static bool allup(int[] arr)//ערך ממויין בסדר עולה ממש(כל מספר קטן מהבא אחריו)י
        /*טענת כניסה: ארר מערך מספרים שלמים
         טענת יציאה: המערך מחזיר אמת אם המערך ממויין ושקר אחרת*/
        {
            bool istrue = true;
            for (int i = 0; i < arr.Length; i++)
            {
                if (arr[i] <= arr[i + 1])
                {
                    istrue = false;
                }
            }
            return istrue;
        }

        public static void ThirdArray(int[] arr1, int[] arr2, int[] arr3)// בניית מערך שלישי מהמספר הגדול ביותר באותו מקום משני מערכים שונים
        /*טענת כניסה: אאר 1,2 ו3 מערכים של מספרים שלמים
         טענת יציאה: הפעולה יוצרת מערך שלישי מהמספר הגדול ביותר באותו מקום משני מערכים שונים */
        {
            for (int i = 0; i < arr1.Length; i++)
            {
                if (arr1[i] > arr1[2])
                {
                    arr3[i] = arr1[i];
                }
                else
                    if (arr1[i] < arr2[i])
                {
                    arr3[i] = arr2[i];
                }
                else
                {
                    arr3[i] = 0;
                }
            }
        }
        public static void ShiftLArray(int[] a, int countA)//פעולה אשר לוקחת מערך ןמקום במערך, ומזיזה שמאלה מקום אחד ומאפסת את המקום האחרון
        /*טענת כניסה: איי מערך מספרים שלמים, קאונט איי מספר שלם
         טענת יציאה: הפעולה מזיזה את כל המספרים במערך מהמקום קואנט איי עד הסוף מקום אחד שמאלה, ושמה בסוף 0*/
        {
            while (a[countA] != 0 && countA < a.Length - 1)
            {
                a[countA] = a[countA + 1];
                countA++;
            }
            a[countA] = 0;

        }

        public static int SumArray(int[] arr)//פעולה אשר מחזירה לתכנית הראשית את סכום ערכי כל המערך
        /*טענת כניסה:ארר מערך מספרים שלמים
         טענת יציאה: התכנית תחשב ותחזיר את סכום התאים במערך*/
        {
            int sum = 0;
            for (int i = 0; i < arr.Length; i++)
            {
                sum += arr[i];
            }
            return sum;
        }
        public static double Arrayavg(int[] arr, int sum)//פעולה אשר מחזירה את ממוצע ערכי המעבר
                                                         /*טענת כניסה:ארר מערך מספרים שלמים
                                                         טענת יציאה: התכנית תחשב ותחזיר את ממוצע התאים במערך*/
        {
            double avg = 0;
            avg = sum / arr.Length;
            return avg;
        }
        public static void Arrsaytypeinit(int[] arr)// פעולה אשר ממיינת ערכים ע"פ סוג לתאים שונים במערך[ניתן להגדיל את הטווח ע"פ הצורך
        /*טענת כניסה: ארר מערך מספרים שלמים
         טענת יציאה: התכנית תמיין את הקלט הנכנס לפי סוגים שונים אשר נקבעו בשאלה*/
        {
            int type;
            Console.WriteLine("enter " + arr.Length + " numbers, to finish, enter -1");
            type = int.Parse(Console.ReadLine());
            while (type != -1 && type <= arr.Length && type > -2)
            {
                arr[type]++;
                Console.WriteLine("enter " + arr.Length + " numbers, to finish, enter -1");
                type = int.Parse(Console.ReadLine());
            }
        }
        public static void MakeC(int[] a, int[] b, int[] c, int count)//הפעולה בודקת האם המספר שקיבלה נמצא במערך שקיבלה, ומעבירה אותו למערך שלישי הפעולה צריכה להיות מזומנת מתוך תנאי בתוך לופ הרץ על אברי מערך אחר
        /*טענת כניסה: איי,בי וסי מערכי מספרים שלמים, קאונט מספר שלם
        טענת יצאיה: התכנית בודקת האם המספר שקיבלה נמצא במערך שקיבלה, ומעבירה אותו למערך שלישי */
        {

            for (int i = 0; i < count; i++)
            {
                if (IfFound(b, a[i]))
                {
                    c[i] = a[i];
                }

            }

        }
        public static void MakeNeweven(int[] scr, int[] des)//פעולה שמעבירה למערך ריק את כל המספרים הזוגיים ממערך אחר
        /*טענת כניסה: סורס ודסטיניישון מערכים של מספרים שלמים
          טענת יציאה: התכנית מעבירה למערך ריק את כל המספרים הזוגיים ממערך אחר */
        {
            for (int i = 0; i < arr.Length; i++)
            {
                int count = 0;
                if (arr[i] % 2 == 0)
                {
                    des[count] = arr[i];
                }
            }
        }
        public static void MakeNewNegativ(int[] scr, int[] des)//פעולה שמעבירה למערך ריק את כל המספרים השליליים ממערך אחר
        /*טענת כניסה: סורס ודסטיניישון מערכים של מספרים שלמים
         טענת יציאה: התכנית מעבירה למערך ריק את כל המספרים השליליים ממערך אחר */
        {
            for (int i = 0; i < arr.Length; i++)
            {
                int count = 0;
                if (arr[i] < 0)
                {
                    des[count] = arr[i];
                }
            }
        }

        //פעולות על מערך דו-מימדי


        public static void StartMat(int[,] mat)//אתחול מערך דו מימדי
                                               /* טענת כניסה: מאט מטריצת מספרים שלמים
                                              טענת יציאה: הפעולה מתאחלת כל תא במטריצה ע"י המשתמש*/
        {

            for (int i = 0; i < mat.GetLength(0); i++)
            {
                Console.WriteLine("enter " + mat.GetLength(1) + " numbers to place{0}", i);
                for (int j = 0; j < mat.GetLength(1); i++)
                {
                    mat[i, j] = int.Parse(Console.ReadLine());
                }
                i++;
            }
        }




        public static int SumOfMainDiagnal(int[,] mat)//חישוב סכום האלכסון הראשי
                                                      /*טענת כניסה: מאט מטריצה ריבועית שאורך צלעה N
                                                       טענת יציאה: הפעולה תחשב ותחזיר את סכום ערכי התאים שנמצאים באלכסון הראשי*/
        {
            int sum = 0;
            for (int i = 0; i < mat.GetLength(1); i++)
            {
                sum += mat[i, i];
            }
            return sum;

        }
        public static int SumOfMainDiagnal(int[,] mat)//חישוב סכום האלכסון הראשי
                                                      /*טענת כניסה: מאט מטריצה ריבועית שאורך צלעה N
                                                       טענת יציאה: הפעולה תחשב ותחזיר את סכום ערכי התאים שנמצאים באלכסון הראשי*/
        {
            int sum = 0;
            for (int i = 0; i < mat.GetLength(1); i++)
            {
                sum += mat[i, i];
            }
            return sum;
        }

        public static int SumOfAboveMainDiagnal(int[,] mat)//חישוב סכום המספרים מעל האלכסון הראשי
                                                           /*טענת כניסה: מאט מטריצה ריבועית שאורך צלעה N
                                                            טענת יציאה: הפעולה תחשב ותחזיר את סכום ערכי התאים שנמצאים מעל האלכסון הראשי*/
        {
            int sum = 0;
            for (int i = 0; i < mat.GetLength(1); i++)
            {
                sum += mat[(mat.GetLength(1) + i + 1) - mat.GetLength(1), i];
            }
            return sum;
        }
        public static int SumOfBelowMainDiagnal(int[,] mat)//חישוב סכום המספרים מתחת האלכסון הראשי
                                                           /*טענת כניסה: מאט מטריצה ריבועית שאורך צלעה N
                                                            טענת יציאה: הפעולה תחשב ותחזיר את סכום ערכי התאים שנמצאים מתחת האלכסון הראשי*/
        {
            int sum = 0;
            for (int i = 0; i < mat.GetLength(1); i++)
            {
                sum += mat[i, (mat.GetLength(1) + i + 1) - mat.GetLength(1)];
            }
            return sum;
        }


        public static int SumOfSecondaryDiagnal(int[,] mat)//חישוב סכום האלכסון המשני
                                                           /*טענת כניסה: מאט מטריצה ריבועית שאורך צלעה N
                                                            טענת יציאה: הפעולה תחשב ותחזיר את סכום ערכי התאים שנמצאים באלכסון המשני*/
        {
            int sum = 0;
            for (int i = 0; i < mat.GetLength(1); i++)
            {
                sum += mat[mat.GetLength(1) - 1 - i, i];
            }
            return sum;
        }
        //מיון מערכים

        public static int PosMin(int[] a, int start)//פעולה שרצה על המערך ומחזירה את המיקום של התא בעל הערך המינימלי במערך
                                                    /*טענת כניסה: איי מערך של מספרים שלמיםת סטראט מספר שלם המייצג נק' התחלה
                                                    טענת יציאה: פעולה שרצה על המערך ומחזירה את המיקום של התא בעל הערך המינימלי במערך*/
        {
            int pos = start;
            for (int i = start; i < a.Length; i++)
            {
                if (a[i] < a[pos])
                {
                    pos = i;
                }
            }
            return pos;
        }

        public static bool IsBubbleSorted(int[] a, int end)
        /*טענת כניסה: איי מערך מספרים שלמים ואנד הוא גבול עליון של המערך
         טענת יציאה: הפעולה מעבירה את האיבר הגדול ביותר למיקום האחרון ומחזירה אמת או שקר אם ביצעה שינוי במערך*/
        {
            bool issort = true;
            int temp;
            for (int i = 0; i < end; i++)
            {
                if (a[i] > a[i + 1])
                {
                    temp = a[i + 1];
                    a[i + 1] = a[i];
                    a[i] = temp;
                    issort = false;
                }
            }
            return issort;
        }

        public static void BubbleSort(int[] a)
        /*טענת כניסה: איי מערך מספרים שלמים
         טענת יציאה: הפעולה ממיינת את במערך בשיטת מיון בועות*/
        {
            int end = a.Length - 1;
            bool sort = IsBubbleSorted(a, end);
            end--;
            while (!sort && end > 0)
            {
                sort = IsBubbleSorted(a, end);
                end--;
            }
        }

        public static void InsertToArray(int[] arr, int num, int count)//פעולת מיון הכנסה
                                                                       /*טענת כניסה: איי מערך נאם איבר להכנסה קאונט מספר האיברים במערך
                                                                        טענת יציאה: הפעולה מכניסה את נאם למערך תוך שמירה על מערך ממוין*/
        {
            int pos = 0;
            while (arr[pos] < num && arr[pos] < count)
            {
                pos++;
            }
            for (int i = count; i > pos; i--)
            {
                arr[i] = arr[i - 1];
            }
            arr[pos] = num;

        }

        public static int[] InsertionSort(int size)
        {
            int[] a = new int[size];
            int num;
            for (int i = 0; i < size; i++)
            {
                Console.WriteLine("enter a real number");
                num = int.Parse(Console.ReadLine());
                InsertToArray(a, num, i);
            }
        }


        //חיפוש מערכים


        public static int BinarySearch(int[] a)
        {
            Console.WriteLine("enter " + a.Length + "sorted numbers");
            for (int i = 0; i < a.Length; i++)
            {
                a[i] = int.Parse(Console.ReadLine());
            }
            int low = 0, high = a.Length - 1, middle;
            bool isfound = false;
            int num;
            Console.WriteLine("enter a number to search");
            num = int.Parse(Console.ReadLine());
            while (!isfound && low <= high)
            {
                middle = (low + high) / 2;
                if (a[middle] == num)
                {
                    isfound = true;
                }
                else
                {
                    if (a[middle] < num)
                    {
                        low = middle + 1;
                    }
                    else
                    {
                        high = middle - 1;
                    }
                }
            }
            if (isfound)
            {
                Console.WriteLine("the number " + num + " is in the " + middle + "th position of the array");
            }
            else
            {
                Console.WriteLine("the number " + num + " isn't in the array");
            }
        }

        //מיזוג מערכים

        public static int[] Merge(int[] a, int[] b)
        /*טענת כניסה: איי ובי מערכים ממויינים
          טענת יציאה: הפעולה מחזיר המערך ממויין הממזג את ערכי שני המערכים ,ואם יש שני מספרים דומים בשני המערכים, המספר יופיע פעמיים במערך הממויין*/
        {
            int[] c = new int[a.Length + b.Length];
            int p1 = 0, p2 = 0, p3 = 0;
            while (p1 < a.Length && p2 < b.Length)
            {
                if (a[p1] < b[p2])
                {
                    c[p3] = a[p1];
                    p1++;
                }
                else if (b[p2] < a[p1])
                {
                    c[p3] = b[p2];
                    p2++;

                }
                else
                {
                    c[p3] = a[p1];
                    p3++;
                    c[p3] = b[p2];
                    p1++;
                    p2++;
                }
                p3++;
            }
            while (p1 < a.Length)
            {
                c[p3] = a[p1];
                p1++;
                p3++;
            }
            while (p2 < b.Length)
            {
                c[p3] = b[p2];
                p2++;
                p3++;
            }
            return c;
        }

        static void Main(string[] args)
        {
            Console.WriteLine("enter a number");
            int[] arr = new int[int.Parse(Console.ReadLine())];//יוצר מערך באורך המספר שנקלט
            StartArray(arr);//זימון פעולה מאתחלת
            PrintArray(arr);//זימון פעולה מדפיסה
            PrintZug(arr);//זימון פעולה המדפיסה מספרים במקום הזוגי
            Printeven(arr);//זימון הפעולה שמדפיסה את כל המספרים הזוגיים במערך
            Console.WriteLine(PrintMax(arr));//זימון הפעולה שמחזירה את המספר הגדול ביותר המערך
            Console.WriteLine("does all of the numbers equal?: " + IsEqual(arr));//זימון הפעולה אשר בודת האם כל המספרים שווים זה לזה ומחזירה לפי זה ערך בוליאני
            int[] a = new int[10];

        }
    }
}