using System;

namespace Ex

{

    public class Program

    {

        /*

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

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

        */

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

        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));

        }

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

        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;

        }

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

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

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

            */

        /*

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

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

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

        */

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

        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 Main (string[] args)

        {

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

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

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

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

        }

    }

}

​