שלום. אני צריך לבנות שיטות רקורסיביות, בלי שימוש בלולאות. אחת השיטות היא :

public int howManyEven(int[] a)
	{
		howManyEven = a;
		int n;
		int b;
		if(n + 2 == b)
			b++;
			return b++; 
	}

השיטה אמורה לקבל כפרמטר מערך של מספרים שלמים חיוביים ולהחזיר כמה מספרים זוגיים יש במערך.

האם המבנה נכון ?

תודה.

קודם כל בשביל שהשיטה תהיה רקורסיבית אתה צריך שתהיה לך קריאה רקורסיבית

דבר שני אתה לא יכול להגדיר אינדקס בתוך השיטה

מה עם הערות לפחות מה אמור להיות מה? אם זה רק ייצוג כללי

	public static int howManyEven(int[] a,int index){
		if (index == a.length)
			return 0;
		if (a[index]%2 != 0)
			return howManyEven(a,index+1);
		else
			return howManyEven(a,index+1)+1;

	}

[br]פורסם בתאריך: 13.01.2010 בשעה 12:59:22

---

ועכשיו ברובי

def howManyEven(array,index)
		if index = array.length
			return 0
		if a[index]%2 != 0
			return howManyEven(array,index+1)
		else
			return howManyEven(array,index+1)+1
	end

אני חייב להודות שבחיים לא ראיתי SYNTAX כמו זה שבהודעה המקורית.

1. בשום שלב לא הגדרת את N או B להיות שום מספר, לכן הם יהיו "אפס" (בגלל שזה טיפוס פרימיטיבי מסוג שלם), ולכן התנאי שאתה בודק אף פעם לא יתקיים (כי הם שווים ואין ביניהם הפרש של 2).

2. מה B או N אמורים לייצג? בכל מקרה, הקידום האחרון של B לעולם לא יתרחש, כיוון שאופרטור ה-++ פועל לאחר שיערוך הביטוי הנוכחי, במידה והוא מופיע אחרי ביטוי מסויים.

x++

++x

אלה שני דברים שונים.

3. למה שורת ה-RETURN נמצאת ב-INDENT כאילו היא חלק מקוד שמתרחש תחת התנאי? בגלל שאין סוגריים מסולסלים, היא תתרחש תמיד, ולכן היא צריכה להיות באותו "טור" כמו ה-IF עצמו.

4. השורה הראשונה היא חסרת משמעות - לא הגדרת בשום שלב משתנה בשם HOWMANYEVEN ולכן אתה לא יכול להציב בו את המערך שקיבלת כפרמטר. מעבר לכך, לא ברור לשם מה אתה צריך להציב את המערך שקיבלת במערך אחר, זה מיותר לחלוטין

5. בשום שלב לא ניגשת למספרים עצמם שבתוך המערך. עושים את זה ע"י שימוש באינדקס:

myArray[index] = "Yossi"

לדוגמא, ישנה את ערכו של התא במקום ה-INDEX במערך להיות "YOSSI". אותו ביטוי (ללא ההצבה) יכול לשמש אותך כדי לדעת *מה יש* בתא, ואתה חייב להשתמש בו כדי לדעת אם המספר זוגי או לא.

6. לא כללת בקוד שלך שום קריאה רקורסיבית.

קודם כל תודה.

דבר שני, הקוד נראה ככה עכשיו :

public int howManyEven(int[] a, int index)
	{
	  if(index==a.length)
	  	return 0;
		if(a[index]%2 != 0) 
			return howManyEven(a,index+1);
		else
			return howManyEven(a, index+1)+1;
	}

האם עכשיו המבנה תקין ויש משמעות נכונה לשיטה ?

תודה.

שלום,

עכשיו השיטה שלך אכן רקורסיבית. אבל אולי תוכל לשפוך אור לאיפה אתה מכוון, ונוכל לעזור יותר.

כן אבל כדאי שתתקן את האינדנטציות. עכשיו זה נראה כאילו כל המתודה עטופה ב-IF אחד גדול, בעוד זה לא המצב.

סידרתי את מבנה האינדנטציות, אני מקווה שזה ייראה כאן:

public int howManyEven(int[] a, int index)
	{
	  if(index==a.length)
	  	return 0;
		if(a[index]%2 != 0) 
			return howManyEven(a,index+1);
		else
			return howManyEven(a, index+1)+1;
	}

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

תודה.

לא, זה נראה בדיוק אותו דבר. לא משנה.

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

השאלה שלי היא האם הקוד כרגע ממש את המטרה שלו ?, ואם לא, מה עליי לעשות ?

כן הוא משיג את המטרה - השאלה אם אתה מבין מה הוא עושה :s05:

תודה.

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

public int sumArray(int[] a, int index)
	{
		if(index==a.length)
			return 0;
		if(a[index]!=0)
		return sumArray(a, index+1);
		else
			return sumArray(a,index+1)+1;
	}

האם לקוד יש מבנה נכון, ואת המשמעות הנכונה ?

תודה.

למה אתה שואל אותנו?

פתח Visual Studio, כתוב תכנית שמשתמשת בפונקציה הזו, תריץ ותראה אם זה עובד.

לא.

הקוד שכתבת יעשה את הדבר הבא:

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

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

דבר שני, אתה לא "סוכם" פה בשום מקום את הערכים שנמצאים בתאי המערך, אז איך אתה מצפה שתקבל בסוף סכום?

מה שאתה עושה זה מוסיף "1" לסכום (באופן רקורסיבי) כל פעם שאתה נתקל בתא שלא מכיל אפס.

במקום זאת, פשוט תוסיף *לסכום עד כה* את הסכום של כל אלה שנשארו.

במילים אחרות, הדרך לחשוב על מתודות רקורסיביות היא בשיטת ה- WISHFUL THINKING :

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

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

יש מבין?

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

או קיי, אז בדקתי והקוד לא עובד. תוכל לנסות לכוון אותי יותר לאיך לסכום את האיברים ?

תגיד לי חביבי, אתה קורא בכלל מה שאני כותב?

כיוונתי אותך איך לסכום את האיברים... מה אני יכול לעשות יותר מזה ??