יש לי מחלקה point שבונה נקודות,[ (x,y) ]

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

ככה נגיד נקודה ראשונה: זה ידפיס: " 1. (5,6)"

ונקודה שנייה " 2 . (5.7)" .... עד נקודה n.. בלי סוף

בקיצור סוג של counter, אז נגיד אני עושה תכונה פרטית num ואז בפעולה הבונה אני עושה num++ ובפעולה ToString אני מדפיס את ה- num הזה.

הבעיה שזה תמיד מדפיס 1, זה כאילו לא באמת תכונה פרטית כמו שאני הבנתי את זה לפחות, ה- num מתאפס מחדש כאילו בכל פעם שאני פונה למחלקה אז תמיד ב- ++ זה מגדיל לי מ-0 ל-1 במקום שה- Num ישאר על 1 ובפעם הבאה שאני בונה משהו זה יהפוך ל-2...

איך אני עושה את זה?

אתה צריך למספר את מופעי המחלקה או להוסיף את המספר רק בהדפסה?

אם למספר אז אתה צריך שני משתנים.

אחד משתנה רגיל של המחלקה שיכיל את הID שלה

והשני משתנה static שיציין איזה מספר ניתן או איזה מספר צריך לתת.

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

תודה, הבנתי אני צריך להשתמש ב- static , תודה!

במידה ואתה משתמש ב threading אז יש מצב שאתה צריך להגן על המשתנה מפני כתיבה בו זמנית ע"י שנים או יותר threads.

במידה ואתה משתמש ב threading אז יש מצב שאתה צריך להגן על המשתנה מפני כתיבה בו זמנית ע"י שנים או יותר threads.

אין לי מושג על מה אתה מדבר

אז הסר דאגה מלבך - אתה כנראה לא משתמש ב threads

יש לי שאלה נוספת,

הפעם זה ברקורסיה.

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

---

בכל אופן, יש לי דבר כזה

public static int Mystery(int num)

{

if(num==1) return 1;

else return (Mystery(num-1)+2*num-1)

}

ברגע שהוא מגיע ל- else ואז יש לו בעצם פעולה רקורסיבית כי הוא חוזר על אותה פעולה בתוך הפעולה בחיבור עם 2 כפול המספר פחות 1.

גיליתי כבר שהפלט של הפעולה הזאת תמיד יוצא num בריבוע, אבל לא הבנתי למה?

הוא מבצע כמה דברים בו זמנית? לפי ההיגיון שלי הפלט של הפעולה תמיד צריך לצאת 1 + הדבר הזה, כי הוא קודם כל עושה את ה- Mystery כל פעם עד שהוא מגיע ל- Num =1

ואז ה- Mystery הראשון שהופעל מקבל 1 + 2 כפול num פחות 1 אבל איכשהו הוא מגיע בכל פעם גם לביטוי השני ועוד זוכר אותו לרקורסיה הבאה למשל

num=3 יקבל 5 ואז בפעולה שמתבצעת בפעם השנייה הוא יוסיף ל-5, 3 איך זה?

תודה רבה

קודם כל, כשאתה כותב קוד בפורום, תשתמש בטג קוד (כפתור # ליד הכפתור של הציטוט).

לשאלתך: הפונקציה Mystery שקולה לפונקציה המתמטית המוגדרת ע"י:

f(1) = 1

f(n) = f(n-1) + 2n - 1 לכל n>1 שלם.

כל מה שצריך הוא להוכיח (לדוגמה, באינדוקציה) שהפונקציה הזו היא בעצם f(n) = n².

וממש לא הבנתי את החישוב שלך. כשאתה קורא לפונקציה אחת מתוך פונקציה אחרת (או מתוך עצמה), שום דבר לא מתרחש "במקביל". בעת קריאה לפונקציה הפנימית, הביצוע של הפונקציה החיצונית מושהה עד שהפונקציה הפנימית מסתיימת. כמובן, במקרה של רקורסיה, ייתכן שדבר כזה יקרה במספר רמות - קריאה ל-Mystery עם num=4 תגרום להשהייה שלה וקריאה עם num=3, שתגרום להשהייה שלה ולקריאה עם num=2, שתגרום לשהייה שלה ולקריאה עם num=1.

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

בכל אופן זה הכול תודה לכם

הנה הסבר אינטואיטיבי (אני מקווה) ללמה הפונקציה מחשבת את n^2.

דמיין ריבוע בגודל nXn (ששיטחו כמובן n^2)

כדי להפוך אותו לריבוע בגודל n+1 אתה יכול א) להוסיף דופן בגודל n לאחד הצדדים ואז זה נהיה מלבן בגודל n X n+1 . וב) כדי להשלים את הבניה אתה צריך להוסיף דופן בגודל n+1 בצד השני. תחשוב לגו.

לדוגמה עבור n=3

1) נתחיל עם

[glow=red,2,300]***

***

***[/glow]

2) נוסיף עוד טור בגודל 3 = n

[glow=yellow,2,300]*[/glow][glow=red,2,300]***[/glow]

[glow=yellow,2,300]*[/glow][glow=red,2,300]***[/glow]

[glow=yellow,2,300]*[/glow][glow=red,2,300]***[/glow]

3) נוסיף עוד שורה בגודל 4 = (n+1)

[glow=yellow,2,300]****[/glow]

[glow=yellow,2,300]*[/glow][glow=red,2,300]***[/glow]

[glow=yellow,2,300]*[/glow][glow=red,2,300]***[/glow]

[glow=yellow,2,300]*[/glow][glow=red,2,300]***[/glow]

בסה"כ הוספנו עוד n*2+1

עם אתה עובד על זה בכיוון של הרקורסיה בתרגיל שלך אז תקבל n*2-1

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

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

ככה זה בקיצור:

קלט: מספר חיובי שלם.

פלט: ממוצע ספרותיו, שזה סכום ספרות המספר בחילוק במספר הספרות

למשל ממוצע המספר 369 הוא 3+6+9 לחלק 3 שזה יוצא 6 (כמובן אבל צריך שיהיה בדבל כי זה לא תמיד יוצא שלם)

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

תודה

[attachment deleted by admin]

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

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

נ.ב. למה הדבקת תמונה של הקוד ולא פשוט כתבת את הקוד בפורום, בתוך טג מתאים (כפתור # שליד הכפתור של הציטוט)?

אז פשוט השפה לא מאפשרת באופן רקורסיבי לבצע ממוצע כמו שצריך בצורה כמו שפרסמתי פה?

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

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

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

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

AVG( number)
	length <- log(number)
	if length=1 return number
	newnumber <- number/10
	remainder <- number%10
	avg = AVG(newnumber)
	return (avg*(length-1)+remainder)/length

לגבי השורה שמחשבת את length אז ברור שיש בה טעות אבל אני ממש שונא חשבון אז תתקן לבד.

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

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

אבל חשוב לי ש

א) אף אחד לא קורא לפונ' שלי מכוערת חץ ממני

ב) שיהיה ברור ל blabla600 שכל בעיה שניתן לפתור באיטרציה ניתן לפתור גם ברקורסיה וההפך.