שלום לכולם, אז ככה נתונה לי המחלקה הבאהתקראו למטה יש גם נתון)

ככה יש 3 שאלות:

1) מה עושה השיטה what באופן כללי?

2) נתון מערך בגודל n המכיל מספרים שלמים ומספר שלם num. מה מבצעת השיטה

something ?

3)לכתוב את השיטות what & something בצורה רקורסיבית(ללא שימוש בלולאות בכלל) אבל אתם יכולים לשנות

את החתימות של השיטות(כלומר להוסיף פרמטירם כרצונכם).

עכשיו עניתי על 1 2 ועשיתי רקורסיה לwhat נתקעתי בsomething

תשובות(תקנו אותי אם טעיתית, תודה)

1)השיטה מחשבת סכום המספרים מlow עד low+len-1

2)השיטה מנסה למצוא מספר או רצף מספרים שסכומם יהיה שווה למשתנה num

3)

public static int what ( int [ ] array, int low, int len) {

  if (low== low+len-1)
      return array [ low+len-1];
      else
          return (array[low+len-1]+ what (array,low,len-1) );
        }

תודה לעוזרים..

קודם כל, שיפור קטן - במקום לקרוא כל פעם ל-(what(low,len-1,array, תקרא ל-(what(low+1,len-1,array (וכתוב את שאר הפונקציה בהתאם). זה יקל עליך.

לגבי something, הכי פשוט זה להוסיף את i ו-k כפרמטרים לפונקציה, וכל פעם לקרוא לפונקציה עם הערכים הבאים שלהם (זו בעצם הדרך הכללית להפוך כל לולאה רגילה לרקורסיה).

אוקיי תודה על התגובה.

השאלה שלי כשאני יוסיף את i ו k אז אני יכול להגיד גם שהקלט לk למשל יהיה רק מk>=1?

או שאני אמור לבדוק את זה בשיטה עצמה?(אני לא בטוח שצריך את זה כאן, אבל נגיד והיה צריך) יש אפשרות לבדוק את הקלט שמוכנס

כי אם אני בעצם בודק את זה ברקורסיה , זה יבדוק את התנאי כל פעם מחדש(מה שאני לא רוצה) . מקווה שהצלחת להבין את השאלה..

אז מה אם זה יבדוק את התנאי כל פעם מחדש? עולה לך כסף? הרי אתה גם צריך כל פעם לבדוק תנאים אחרים (אם i<array.length ואם k<array.length-i, לדוגמה).

פשש, באיזה רמה זה? השאלות הראשונות קלות יחסית אבל השלישית של להפוך את זה לרקורסיבי דורשת קצת חשיבה.

בכל מקרה, הכנתי פה פעולה רקורסיבית לsomething. אני דיי בטוח שהיא לא נכונה אך אשמח אם, במידה ותמצאו טעויות בה, תציינו אותם

public static boolean something(int [] array, int num, int i, int k)
{
	if (i>=array.length)
		return false;
	if (k>array.length-i)
	{
		k=1;
		return something(array,num,i+1,k);
	}
	return (what(array,i,k)==num||something(array,num,i,k+1));
}

זאת שאלה מבחינה באופ שנת 2005

בדקתי את האלגוריתם שלך הוא נראה לי נכון..

זה מה שאני הכנתי בסוף, תודה על העזרה..

  public static boolean something ( int [ ] array, int num, int i, int k) {
    if( ( k>0) && (i>=0) )

      if (what (array,i,k) ==num) {

          return true;
        }
          else if (k< array.length-i)
              return (something(array,num,i,k+1));
            else if ( i<array.length-1)
              return (something (array,num,i+1,1));

              return false;
            }

מה הכוונה:

זאת שאלה מבחינה באופ שנת 2005

? :s05:

דרך אגב, גם הכנתי גרסה רקורסיבית לפעולה הראשונה למרות שהכנת אחת בעצמך, סתם בשביל ההבנה

public static int what(int [] array, int low, int len)
{
	if (low==low+len-1)
		return array[low];
	return array[low]+what(array,low+1,len);
}

גם פה אני לא בטוח לגמרי שזה נכון אבל אין ספק שזה נחמד.

אני גם רוצה לציין שמצאתי טעות בפתרון שלך. אם הlow והlen יהיו שווים ל0? זה יבצע חיפוש בהפניה של 0+0-1 כלומר array[-1] וזה יעשה חריגה.