רקורסיה, שעון חול, ג'אווה

[McMerc]

חברס, יש לי בעיה.

אני מתכנת בג'אווה, ואני צריך לכתוב שיטה שמקבלת מספר מסויים, ועושה שעון חול ממנו, לדוגמא עבור המספר 5 אז הפלט יהיה:

5 5 5 5 5
 4 4 4 4
 3 3 3
  2 2
  1
  2 2
 3 3 3
 4 4 4 4
5 5 5 5 5

כמובן שאני חייב להשתמש ברקורסיה (כלומר שהשיטה מזמנת את עצמה עבור ערך יותר קרוב לתנאי העצירה).

למשהו יש רעיונות?

[zurkin1232]

מתודה שעון חול (n, space)

1. הדפס רווחים כמספר space

2. הדפס n n ... n

3. אם n>1 קרא לשעון חול(n-1, space+1).

4. בצע שוב את 1 ו-2.

[McMerc]

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

[adamshar]

ובכן, יש מספר שיטות לבצע את הנ"ל.

בלי להרוס לך את הפיתרון (כלומר לשלוח קטע קוד), להלן ההצעה (נניח שקולטים מס' לתוך משתנה n):

1. שני פונקציות, אחת יוצרת את החצי העליון, השניה את התחתון. 1 יטופל בפונק' הראשונה.

2. לכל אחת תנאי עצירה שונה, כמובן (n ו 1).

3. 2 לולאות for, אחת עבור הספירה 1 עד n או להיפך, והשניה עבור כל i, להדפיסו i פעמים.

4. תנאי עצירה הרקורסיה: בראשונה: i = 1.

בשניה: i = n.

תרגיל ממש לא קשה.

בהצלחה!

[McMerc]

טוב, אני פשוט אגיד לכם איפה אני נתקע.

הינה מה שכתבתי עוד לפני שפניתי לעזרה:

public static void sandGlass(int n)
	{
		if (n==1)
		{
			IO.println(" 1");
		}
		else
		{
			for (int i=0; i<n; i++)
			{
				IO.print(n+" ");
			}
			IO.println();
			sandGlass(n-1);
			for ( int i=0; i<n; i++)
			{
				IO.print(n+" ");
			}
			IO.println();
		}
	}

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

[B.D.B]

you can't use only one variable, because you need to pass to the function your end value and the current value.

the stop value is when current value is smaller than minus end value.

so if it's func(current,end), it will call it self with current-1 and it will break at current=-end. if you want the main block to call to a function with only one variable then you'll need a sub function. for example:

(c code)

int main()
{
subfunc(5);
return 0;
}

void subfunc(n)
{
func(n,n)
}

void func(curr,end)
{
if (curr>=end )
{
//code...
//code...
func (curr-1,end);
}
}

[McMerc]

you can't use only one variable, because you need to pass to the function your end value and the current value.

וזה הייתה הבעיה.

בכל מיקרה, אני עשיתי את הדבר הבאה:

	public static void sandGlass(int n, int j)
	{
		if (n>j)
		{
			j=n;
		}
		if (n==1)
		{
			for (int i=1; i<j; i++)
			{
				IO.print(" ");
			}
			IO.println("1");
		}
		else
		{
			for (int i=n; i<j; i++)
			{
				IO.print(" ");
			}
			for (int i=0; i<n; i++)
			{
				IO.print(n+" ");
			}
			IO.println();
			sandGlass(n-1,j);
			for (int i=n; i<j; i++)
			{
				IO.print(" ");
			}
			for ( int i=0; i<n; i++)
			{
				IO.print(n+" ");
			}
			IO.println();
		}
	}

ולכן אפילו אם אני מכניס ערכים לא נכונים התוצאה נכונה, למשל אם אני מכניס (5,4) אז אמורה לצוץ בעיה, אבל בגלל התיקון הקטן (ה-IF הראשון) הבעיה נפתרה.

תודה רבה.

[B.D.B]

unless I'm missing something (dunno java but it's close enough to c to understand):

- the recursive will be infinite since there's not stopping rule.

- the bottom part will not be drawn correctly.

this is what it should be:

public static void sandGlass(int n, int j)

{

if (n>j)

{

j=n;

}

if (-n<=j)

{

for (int i=0; i<j-abs(n); i++) //abs is the c function for absolute value change for the corresponding java function

{

IO.print(" ");

}

for (int i=0; i<abs(n); i++)

{

IO.print(abs(n)+" ");

}

IO.println();

if (n==1) //in order to skip 0 and avoiding writing "1" again

sandGlass(n-3,j)

else

sandGlass(n-1,j);

}

}

[McMerc]

אני לא ירדתי לסוף דעתך.

דבר ראשון התנאי עצר שלי זה כאשר N=1.

החלק התחתון מצוייר מצויין.

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

אבל אני עשיתי עד לחצי, כלומר עד ל-N=1 ואז אני משתמש גם ב-N הקודמים (בין המקורי ל-1) בשביל לצייר את החלק התחתון.

בקיצור, השיטה שלי עובדת, ואני מודע לזה שהיא יכולה להיות יותר מושלמת (אולי בעזרת הרעיון שלך).

אולי עוד מעט אני אציע שינוי, כמו שאתה אמרת (למרות שאין סיבה).

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

[B.D.B]

[ltr]no no, my bad, your way is good it's just that it's a bit more complicated so I didn't see it at first.

I don't like recursive functions that call them self before they end, I always get lost of where it was before it called itself.[/ltr]