using System;

namespace Ex

{

    public class Program

    {

        public static void Reverse (int[] ar, int i, int k)

        {

            if (i>=k) return; 

            int temp = ar[i];

            ar[i] = ar[k];

            ar[k] = temp;

            Reverse(ar,i+1,k-1);

        }

        public static int MaxElemntPos (int [] ar, int i, int end)

        {

           if (i==end)                       

                return i;

           int pos = MaxElemntPos(ar,i+1,end);

           if (ar[i] > ar[pos])

               return i;

            return pos;

        }

        public static void PancakeSort (int[] ar, int end)

        {

            if (end > 0)

            {

                int maxpos = MaxElemntPos(ar,0,end);

                Reverse(ar,0,maxpos);

                Print(ar);

                Reverse(ar,0,end);

                Print(ar);

                PancakeSort(ar,end-1);

            }

        }

        public static int Stam (int n)

        {

            if (n==0) return 0;

                if (n%2==1)

                    return n*2 + Stam(n-1);

                else

                    return (int)(Math.Pow(n,2)) + Stam(n-1);

        }

        public static int Rev (int num)

        {

           return Rev(num,0);

        }

        public static int Rev (int n,int x)

        {

           if(n == 0)

        return x; 

    return Rev(n / 10, x * 10 + n % 10);

        }

        /*

        פעולה רקורסיבית שמקבלת מערך של מספרים שלמים

        ומחזירה אמת אם כל איברי המערך זוגיים, אחרת שקר

        */

        // פעולת מעטפת

        public static bool IsAllEven (int[] ar)

        {

            return  IsAllEven(ar,0);

        }

        // פעולה רקורסיבית

        private static bool IsAllEven (int[] ar, int i)

        {

            if (i==ar.Length)                 // if (i==ar.Length-1) return (ar[i]%2==0);

                return true;

            return ar[i]%2==0 && IsAllEven(ar,i+1);

        }

        // פתרון נוסף - ריצה מהסוף להתחלה

        // פעולת מעטפת

        public static bool IsAllEven1 (int[] ar)

        {

            return  IsAllEven1(ar,ar.Length-1);

        }

        // פעולה רקורסיבית

        private static bool IsAllEven1 (int[] ar, int i)

        {

            if (i<0)                                      // if (i==0) return (ar[0]%2==0);    

                return true;

            return ar[i]%2==0 && IsAllEven1(ar,i-1);

        }

        /*

        פעולה רקורסיבית שמקבלת מערך של מספרים שלמים

        ומחזירה את האיבר הגדול ביותר במערך

        */

        // פעולת מעטפת

        public static int MaxAr (int[] ar)

        {

            return MaxAr(ar,0);                        // return MaxAr(ar,ar.Length-1);

        }

        // פעולה רקורסיבית

        private static int MaxAr (int[] ar, int i)

        {

            if (i==ar.Length-1)                       // if (i==0) return ar[0];

                return ar[i];

            return Math.Max(ar[i],MaxAr(ar,i+1));     // return Math.Max(ar[i],MaxAr(ar,i-1));

        }

            /* אופציה נוספת - ניתן לרשום את השורה האחרונה גם באופן הבא

            int tmp = MaxAr(ar,i+1);

            return Math.Max(tmp,ar[i]);

            */

        // אופציה נוספת לרישום הפעולה הרקורסיבית    

        private static int MaxAr1 (int[] ar, int i)

        {

            if (i==ar.Length-1)                       

                return ar[i];

            int tmp = MaxAr1(ar,i+1);

            if (ar[i]>tmp)

                return ar[i];

            return tmp;

        }

        /*

        פעולה רקורסיבית שמקבלת מערך של תווים

        ומחזירה את כמות הפעמים שהתו * מופיע במערך

        הערה: שימוש בפעולה עוטפת

        */

        // פעולת מעטפת

        public static int CountTav (char[] ar)

        {

            return CountTav(ar,0);

        }

        // פעולה רקורסיבית

        private static int CountTav (char[] ar, int i)

        {

            if (i==ar.Length)

                return 0;

            if (ar[i]=='*')

                return 1 + CountTav(ar,i+1);

            return 0 + CountTav(ar,i+1);

        }

        /*

        פעולה רקורסיבית שמקבלת מערך של מספרים שלמים, מחשבת ומחזירה את סכום איברי המערך

        הערה: שימוש בפעולת מעטפת

        */

        // פעולת מעטפת

        public static int SumAr (int[] ar)

        {

            return SumAr(ar,0); 

        }

        // פעולה רקורסיבית

        private static int SumAr (int [] ar, int i)

        {

            if (i==ar.Length)                            //  תנאי העצירה - סיימנו לעבור על כל איברי המערך. המערך ריק

                return 0;

            return ar[i] + SumAr(ar,i+1);        // זימון רקורסיבי והקטנת הבעיה

        }

        /*

        פעולה רקורסיבית שמקבלת מערך  מספרים שלמים ואינדקס

        ומחזירה את סכום האיברים במערך

        */

        // הערה: נרוץ כאן על המערך מהסוף להתחלה

        // אופציה 1 לפתרון

        public static int SumAr1 (int [] ar, int i)

        {

            if (i==0)                            // תנאי העצירה

                return ar[0];

            return ar[i] + SumAr1(ar,i-1);        // זימון רקורסיבי והקטנת הבעיה

        }

        // Console.WriteLine ( SumAr1(ar,ar.Length-1) );        קריאה לפעולה

        // הערה: נרוץ כאן על המערך מההתחלה לסוף

        // אופציה 2 לפתרון

        public static int SumAr2 (int [] ar, int i)

        {

            if (i==ar.Length-1)                            // תנאי העצירה

                return ar[i];

            return ar[i] + SumAr2(ar,i+1);        // זימון רקורסיבי והקטנת הבעיה

        }

        // Console.WriteLine ( SumAr2(ar,0) );        קריאה לפעולה

        // הערה: נרוץ כאן על המערך מההתחלה לסוף

        // אופציה 3 לפתרון

        public static int SumAr3 (int [] ar, int i)

        {

            if (i==ar.Length)                            //  תנאי העצירה - סיימנו לעבור על כל איברי המערך. המערך ריק

                return 0;

            return ar[i] + SumAr3(ar,i+1);        // זימון רקורסיבי והקטנת הבעיה

        }

        // Console.WriteLine ( SumAr3(ar,0) );        קריאה לפעולה

        public static void Print (int[] ar)

        {

            for (int i=0; i<ar.Length; i++)

                Console.Write(ar[i] + " ");

        }

        public static void Main (string[] args)

        {

            int [] ar = {5,2,3,4,1};

            PancakeSort(ar,4);

            Print(ar);

            //Console.WriteLine(MaxElemntPos(ar,0,4));

            //Console.WriteLine (Rev(123));

            //Console.WriteLine (Stam(3));

            /*

            int [] ar = {6,0,2};

            Console.WriteLine (SumAr1(ar,ar.Length-1));

            Console.WriteLine (SumAr2(ar,0));

            Console.WriteLine (SumAr3(ar,0));

            Console.WriteLine (SumAr(ar));

            Console.WriteLine (IsAllEven(ar));

            Console.WriteLine (IsAllEven1(ar));

            */

        }

    }

}

​