C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
namespace Ex
{
	public class Program
	{
		/*
		פעולה רקורסיבית שמקבלת שני מספרים שלמים
		ומשרשרת את המספר השני אחרי המספר הראשון
		למשל
		123, 45
		יוחזר הערך
		12345
		*/
		public static int twoNumConcat (int n1, int n2)
		{
            if (n2<10) return n1*10+n2;
			
			return n2%10 + 10*twoNumConcat(n1,n2/10);
		}
		
		/*
		פעולה שמקבלת שני מספרים שלמים
		ומחזירה מספר שהוא שירשור של שני המספרים לסירוגין.
		אם מספר אחד ארוך מהאחר אז ספרותיו יופיעו בהתחלה
		שאלה 6 קודבורד 5 רקורסיה קשה - לנסח
		*/
		public static int SodSod (int n1, int n2)   // 13, 24
		{
            if (n1<10 && n2<10) return n1*10+n2;
			if (n1<10 && n2>=10)
			{
                int d = n2%10;
				n2 = n2/10;
                return (n2*10+n1)*10+d;
			}
			if (n1>=10 && n2<10) return n1*10+n2;
			
			return n1%10*10 + n2%10+ 100*SodSod(n1/10,n2/10);
		}
		
		
		
		/*
		פעולה רקורסיבית שמקבלת מיקום של איבר בסדרת פיבונאצ׳י
		ומחזירה את האיבר הנמצא במיקום זה
		תזכורת: סדרת פיבונאצי היא סדרה בה מתקיים שכל איבר שווה לסכום שני האיברים לפניו
		למעט שני האיברים הראשונים
		0,1,1,2,3,5,8,13,21,34,......
		*/
		public static int fibonacciMember (int n)
		{
            if (n==1) return 0;
			if (n==2) return 1;
			return fibonacciMember(n-1) + fibonacciMember(n-2);
		}
		
		
		/*
		 פעולה רקורסיבית המקבלת איבר ראשון בסדרה, הפרש, ומיקום
		 ומחזירה את האיבר במיקום זה
		הנחה: הסידרה החשבונית מכילה לפחות איבר אחד
		*/
		public static int arithmeticProgressionMember (int a1, int d, int n)
		{
            if (n==1) return a1;
			return d + arithmeticProgressionMember(a1,d,n-1);
		}
		
		
		
		
		/*
		הפעולה מקבלת מספר שלם וחיובי ומחזירה את סכום כל המספרים השלמים מ-1 ועד המספר כולל
		*/
	public static int Sum (int n)
	{
        if (n==1) return 1;
        return n + Sum(n-1);
	}
		
		/*
		פעולה שמקבלת מספר שלם וחיובי ומחזירה את העצרת של המספר
		*/
		public static int Factorial (int n)
		{
	    	if (n==1)   // תנאי עצירה
			   return 1;
		    return n*Factorial(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 NumOfDigits (int n)
	{
		if (n<10)         
			return 1;
		
		return 1 + NumOfDigits(n/10);
	}
	
		
		
		
		
		
		
		/*
		פעולה רקורסיבית שמקבלת מערך של מספרים שלמים, מחשבת ומחזירה את סכום איברי המערך
		הערה: שימוש בפעולת מעטפת
		*/
		
		// פעולת מעטפת
		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 int SumOfDigits (int n)
		{
            if (n<10) return n;
			int ans = SumOfDigitsHelp(n);
            return SumOfDigits(ans);
		}
		
		/*
		פעולת עזר שמקבלת מספר שלם ומחזירה את סכום ספרותיו
		*/
		public static int SumOfDigitsHelp (int n)
		{
            if (n<10) return n;
            return (n%10) + SumOfDigitsHelp(n/10);
		}
		
		/*
		הפעולה מקבלת מספר ממשי וחיובי
		ומחזירה את החלק העשרוני תוך שימוש בפעולות חיבור / חיסור בלבד
		*/
		public static double FractionalPart (double num)
		{
			
			if (num < 1)
			   return num;
			
			return FractionalPart(num-1);
			
			// הפעולה לא עובדת כנדרש
			
		}
		
		/*
		פעולה שמקבלת מספר שלם וחיובי ומחזירה את מכפלת כל המספרים האי-זוגיים מ-1 ועד אליו, כולל
		*/
		// פעולת מעטפת
		public static int OddsProduct (int n)
		{
			if (n%2==1)
				return OddsProductHelp(n);
			return OddsProductHelp(n-1);
		}

		/*
		פעולה שמקבלת מספר שלם וחיובי ואי-זוגי ומחזירה את מכפלת כל המספרים האי-זוגיים מ-1 ועד אליו, כולל
		*/
        public static int OddsProductHelp (int n)
		{
            if (n==1) return 1;
			return n*OddsProductHelp(n-2);
		}

		/*
		הפעולה מקבלת שני מספרים שלמים וחיוביים ומחזירה את מכפלתם
		באמצעות פעולות חיבור/חיסור בלבד
		*/
		public static int Mult (int n, int m)
		{
          if (m==1) return n;
          return n + Mult(n,m-1);
		}
		
		/*
		פעולה שמקבלת שני מספרים שלמים וחיוביים ומחזירה את תוצאת החילוק של הראשון בשני
		באמצעות פעולות חיבור/חיסור בלבד
		*/

		public static int Quotient (int n, int m)
		{
            if (n<m) return 0;
			return 1 + Quotient(n-m,m);
		}
		
		/*
		פעולה שמקבלת שני מספרים שלמים וחיוביים ומחזירה את תוצאת שארית החלוקה של הראשון בשני
		באמצעות פעולות חיבור/חיסור בלבד
		*/

		public static int Remainder (int n, int m)
		{
            if (n<m) return n;
			return Remainder(n-m,m);
		}
		
		
		/*
הפעולה מקבלת מספר שלם וחיובי ומחזירה את ההפרש המקסימלי בין שתי ספרות סמוכות		
	הנחה: המספר מכיל לפחות שתי ספרות
	*/
		public static int BigDig (int num)
		{
            if (num<100)
                return Math.Abs(num%10 - num/10);
			int n1 = num%10;
			int n2 = num/10%10;
			int def = Math.Abs(n1-n2);
			return Math.Max(def,BigDig(num/10));
		}
		
		public static void Main (string[] args)
		{
			Console.WriteLine(SodSod(135,246));   // 123456
			Console.WriteLine(SodSod(123,456));   // 142536
			Console.WriteLine(SodSod(78123,45));   // 7812435
			Console.WriteLine(SodSod(12,7456));   // 741526
			
			
			Console.WriteLine(twoNumConcat(123,45));   // 12345
			
			
			
			Console.WriteLine(fibonacciMember(6));   // 5
			
			
			
			Console.WriteLine(arithmeticProgressionMember(2,2,5));   // 10 ==> 2,4,6,8,10,...
			Console.WriteLine(arithmeticProgressionMember(2,3,5));   // 14 ==> 2,5,8,11,14,...
			Console.WriteLine(arithmeticProgressionMember(3,-2,4));  // -3 ==> 3,1,-1,-3,-5,...
			Console.WriteLine(arithmeticProgressionMember(3,-2,3));  // -1 ==> 3,1,-1,-3,-5,...
			
			
			
			
			//Console.WriteLine (Rev(123));
			//Console.WriteLine(Sum(5));   // 15
		//	Console.WriteLine(Factorial(4));   // 24
		//	Console.WriteLine(NumOfDigits(123456));   // 6
			
		//	Console.WriteLine(SumOfDigits(9983));   // 2
	//Console.WriteLine(FractionalPart(111.123));   // 0.123
			//Console.WriteLine(OddsProduct(6));   // 15
			
			//Console.WriteLine(Mult(4,3));   // 12
			//Console.WriteLine(Quotient(8,2));   // 4
			
			//Console.WriteLine(Quotient(10,3));   // 3
			
			//Console.WriteLine(Remainder(8,2));   // 0
			
			//Console.WriteLine(Remainder(10,3));   // 1
			
			//Console.WriteLine(BigDig(291655));  // 8
			
			
			
			//Console.WriteLine(1.123-1);   
			/*
			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));
			*/
		}
	}
}

​x
 
using System;
namespace Ex
{
    public class Program
    {
        /*
        פעולה רקורסיבית שמקבלת שני מספרים שלמים
        ומשרשרת את המספר השני אחרי המספר הראשון
        למשל
        123, 45
        יוחזר הערך
        12345
        */
        public static int twoNumConcat (int n1, int n2)
        {
            if (n2<10) return n1*10+n2;
            
            return n2%10 + 10*twoNumConcat(n1,n2/10);
        }
        
        /*
        פעולה שמקבלת שני מספרים שלמים
        ומחזירה מספר שהוא שירשור של שני המספרים לסירוגין.
        אם מספר אחד ארוך מהאחר אז ספרותיו יופיעו בהתחלה
        שאלה 6 קודבורד 5 רקורסיה קשה - לנסח
        */
        public static int SodSod (int n1, int n2)   // 13, 24
        {
            if (n1<10 && n2<10) return n1*10+n2;
            if (n1<10 && n2>=10)
            {
                int d = n2%10;
                n2 = n2/10;
                return (n2*10+n1)*10+d;
            }
            if (n1>=10 && n2<10) return n1*10+n2;
            
            return n1%10*10 + n2%10+ 100*SodSod(n1/10,n2/10);
        }
        
        
        
        /*
        פעולה רקורסיבית שמקבלת מיקום של איבר בסדרת פיבונאצ׳י
        ומחזירה את האיבר הנמצא במיקום זה
        תזכורת: סדרת פיבונאצי היא סדרה בה מתקיים שכל איבר שווה לסכום שני האיברים לפניו
        למעט שני האיברים הראשונים
        0,1,1,2,3,5,8,13,21,34,......
        */
        public static int fibonacciMember (int n)
        {
            if (n==1) return 0;
            if (n==2) return 1;
            return fibonacciMember(n-1) + fibonacciMember(n-2);
        }
        
        
        /*
         פעולה רקורסיבית המקבלת איבר ראשון בסדרה, הפרש, ומיקום
         ומחזירה את האיבר במיקום זה
        הנחה: הסידרה החשבונית מכילה לפחות איבר אחד
        */
        public static int arithmeticProgressionMember (int a1, int d, int n)
        {
            if (n==1) return a1;
            return d + arithmeticProgressionMember(a1,d,n-1);
        }
        
        
        
        
        /*
        הפעולה מקבלת מספר שלם וחיובי ומחזירה את סכום כל המספרים השלמים מ-1 ועד המספר כולל
        */
    public static int Sum (int n)
    {
        if (n==1) return 1;
        return n + Sum(n-1);
    }
        
        /*
        פעולה שמקבלת מספר שלם וחיובי ומחזירה את העצרת של המספר
        */
        public static int Factorial (int n)
        {
            if (n==1)   // תנאי עצירה
               return 1;
            return n*Factorial(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 NumOfDigits (int n)
    {
        if (n<10)         
            return 1;
        
        return 1 + NumOfDigits(n/10);
    }
    
        
        
        
        
        
        
        /*
        פעולה רקורסיבית שמקבלת מערך של מספרים שלמים, מחשבת ומחזירה את סכום איברי המערך
        הערה: שימוש בפעולת מעטפת
        */
        
        // פעולת מעטפת
        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 int SumOfDigits (int n)
        {
            if (n<10) return n;
            int ans = SumOfDigitsHelp(n);
            return SumOfDigits(ans);
        }
        
        /*
        פעולת עזר שמקבלת מספר שלם ומחזירה את סכום ספרותיו
        */
        public static int SumOfDigitsHelp (int n)
        {
            if (n<10) return n;
            return (n%10) + SumOfDigitsHelp(n/10);
        }
        
        /*
        הפעולה מקבלת מספר ממשי וחיובי
        ומחזירה את החלק העשרוני תוך שימוש בפעולות חיבור / חיסור בלבד
        */
        public static double FractionalPart (double num)
        {
            
            if (num < 1)
               return num;
            
            return FractionalPart(num-1);
            
            // הפעולה לא עובדת כנדרש
            
        }
        
        /*
        פעולה שמקבלת מספר שלם וחיובי ומחזירה את מכפלת כל המספרים האי-זוגיים מ-1 ועד אליו, כולל
        */
        // פעולת מעטפת
        public static int OddsProduct (int n)
        {
            if (n%2==1)
                return OddsProductHelp(n);
            return OddsProductHelp(n-1);
        }
​
        /*
        פעולה שמקבלת מספר שלם וחיובי ואי-זוגי ומחזירה את מכפלת כל המספרים האי-זוגיים מ-1 ועד אליו, כולל
        */
        public static int OddsProductHelp (int n)
        {
            if (n==1) return 1;
            return n*OddsProductHelp(n-2);
        }
​
        /*
        הפעולה מקבלת שני מספרים שלמים וחיוביים ומחזירה את מכפלתם
        באמצעות פעולות חיבור/חיסור בלבד
        */
        public static int Mult (int n, int m)
        {
          if (m==1) return n;
          return n + Mult(n,m-1);
        }
        
        /*
        פעולה שמקבלת שני מספרים שלמים וחיוביים ומחזירה את תוצאת החילוק של הראשון בשני
        באמצעות פעולות חיבור/חיסור בלבד
        */
​
        public static int Quotient (int n, int m)
        {
            if (n<m) return 0;
            return 1 + Quotient(n-m,m);
        }
        
        /*
        פעולה שמקבלת שני מספרים שלמים וחיוביים ומחזירה את תוצאת שארית החלוקה של הראשון בשני
        באמצעות פעולות חיבור/חיסור בלבד
        */
​
        public static int Remainder (int n, int m)
        {
            if (n<m) return n;
            return Remainder(n-m,m);
        }
        
        
        /*
הפעולה מקבלת מספר שלם וחיובי ומחזירה את ההפרש המקסימלי בין שתי ספרות סמוכות     
    הנחה: המספר מכיל לפחות שתי ספרות
    */
        public static int BigDig (int num)
        {
            if (num<100)
                return Math.Abs(num%10 - num/10);
            int n1 = num%10;
            int n2 = num/10%10;
            int def = Math.Abs(n1-n2);
            return Math.Max(def,BigDig(num/10));
        }
        
        public static void Main (string[] args)
        {
            Console.WriteLine(SodSod(135,246));   // 123456
            Console.WriteLine(SodSod(123,456));   // 142536
            Console.WriteLine(SodSod(78123,45));   // 7812435
            Console.WriteLine(SodSod(12,7456));   // 741526
            
            
            Console.WriteLine(twoNumConcat(123,45));   // 12345
            
            
            
            Console.WriteLine(fibonacciMember(6));   // 5
            
            
            
            Console.WriteLine(arithmeticProgressionMember(2,2,5));   // 10 ==> 2,4,6,8,10,...
            Console.WriteLine(arithmeticProgressionMember(2,3,5));   // 14 ==> 2,5,8,11,14,...
            Console.WriteLine(arithmeticProgressionMember(3,-2,4));  // -3 ==> 3,1,-1,-3,-5,...
            Console.WriteLine(arithmeticProgressionMember(3,-2,3));  // -1 ==> 3,1,-1,-3,-5,...
            
            
            
            
            //Console.WriteLine (Rev(123));
            //Console.WriteLine(Sum(5));   // 15
        //  Console.WriteLine(Factorial(4));   // 24
        //  Console.WriteLine(NumOfDigits(123456));   // 6
            
        //  Console.WriteLine(SumOfDigits(9983));   // 2
    //Console.WriteLine(FractionalPart(111.123));   // 0.123
            //Console.WriteLine(OddsProduct(6));   // 15
            
            //Console.WriteLine(Mult(4,3));   // 12
            //Console.WriteLine(Quotient(8,2));   // 4
            
            //Console.WriteLine(Quotient(10,3));   // 3
            
            //Console.WriteLine(Remainder(8,2));   // 0
            
            //Console.WriteLine(Remainder(10,3));   // 1
            
            //Console.WriteLine(BigDig(291655));  // 8
            
            
            
            //Console.WriteLine(1.123-1);   
            /*
            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));
            */
        }
    }
}
​

Entity State: Modified

Cached Result
Last Run:	2:00:56 pm
Compile:	0.281s
Execute:	8.331s
Memory:	33.59Mb
CPU:	3.562s

View IL Code