טוב, או שאני ממש אידיוט או שזה באמת לא כזה פשוט.

ביצוע ממוצע- רקורסיבי. הצהרה:

double average(int a[], int size, double *avg)

זאת ולא אחרת.

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

double average(int a[], int size, double *avg)
{
	if(size>1)
	{
		avg=average(a[1], size-1, avg) + a[0]);
		return(avg);
	}
	return(a[0]);
}

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

שים לב שאתה צריך לחלק את a[0] בSIZE.

ולא בדקת אם קיבלת NULL בהתחלה.

וגם השימוש שלך במצביע לא נכון. כדי לשנות/לקבל את ערכו של double *avg, אתה צריך לרשום -

 *avg

.

ואתה צריך לשלוח את &a[1], או a+1.

אתה צריך כל פעם להכפיל ב- size-1 לחבר את החדש, ולחלק ב- size(כמו ממוצע משוקלל).

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

השימוש שלך פה ב *avg לא נכון מכה סיבות,

avg= משהו בעצם מציב לתוכו כתובת חדשה. ולא למעדכן את הערך שאילו המצביע אמור להצביע.

גם ב RETURN את מחזיר כתובת ולא ערך.

גם מה ל Integer ציין בקשר למערך.

בכל מקרה, לפי דעתי השימוש פה ב *avg מיותר.

במקרה והגעת ל size = 1, תחזיר את התא a[0].

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

גם אני לא יודע למה צריך את AVG, אבל מה איכפת לי.

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

http://he.wikipedia.org/wiki/%D7%9E%D7%9E%D7%95%D7%A6%D7%A2

כאילו מה זה הE עם כל הדברים האלה. אני מניח שבגלל שאני לא יודע תנוסחאות האלה שמריאים שם לא הולך לי טוב, או שלא D=.

עריכה:

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

ועוד משהו הוא מראה לי אחרי התשובה E+00.

ממוצע משוכלל זה ... חישוב ממוצע בגרויות למשל

הסימן הזה אומר: עבור I = 1 עד N

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

אנגלית - 98 5

לשון 60 2

פיזיקה 97 5

98*5+60*2+97*5 / 5+5+2

D= סיבכת אותי.

עריכה:

אוקי, אחרי כמה קיראות די הבנתי.

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

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

במקרה הזה, מספר היחידות זה המשקל של המקצוע.

ממוצע משוקלל מחשב בעצם את הציון הממוצע per יחידה.

נגיד נבחנת ב 3 מקצועות בעלי משקלים שונים:

אנגלית - 98 5

לשון 60 2

פיזיקה 97 4

חישוב ממוצע per מקצועה יעשה ע"י סכום כל הציונים חלקי מספר המקצועות.

(98+60+97)/3

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

98*5+60*2+97*5

סכום כל המקצועות כפול המשקל של כל אחד מהם.

ומכיוון אתה רוצה לקבל ציון עבור בל יחידה, אתה מחלק בכמות היחידות

5+2+5

ומכאן :

98*5+60*2+97*5 / 5+5+2

אבל כל זה לא ממש קשור לתרגיל.[br]פורסם בתאריך: 10.08.2007 בשעה 21:42:24

---

כי הסימן הזה בעצם כמו לולאה, עובר וסוכם.

כאשר X זה ציון, W זה יחידה. זה הולך מ I=1 עד ל N. וליד כל X ן W מופי I, זה בעצם אומר - הציון ה I כפול המשקל ה I וממשיך לסכום.

http://he.wikipedia.org/wiki/%D7%A1%D7%99%D7%92%D7%9E%D7%94

אני הבנתי את מה שרשמת ואת הנוסחא לאחר שהסברת אבל יש סתירה במה שרשמת שבילבלה אותי טיפה

זה הנוסחא

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

ואתה עשית את זה, אבל לכולם.

98*5+60*2+97*5 / 5+5+2

וכמו שראית כבר פתרתי את זה, בזכותכם.

ד"א למה אני הפעם הייתי צריך לעשות A+1 ולא יכלתי לעשות A[1] , תמיד אני עושה A[1] וזה עובד לי... אין צורך להסביר את הקטע של A+1 מהתרד הקודם..

a[1] זה הערך הנמצא במקום 1 במערך - זה משתנה בודד - אם המערך מסוג int אז a[1] יהי מסוג int.

אם הפונקציה מקבלת מערך - שזה בעצם כתובת להתחלת המערך, את צריך לשלוח כתובת ולא ערך. הכתובת נשמרת בשם המערך. ואם אתה רוצה לשלוח את הכתבות של התה הבאה אז זה .a+1

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

אני יודע את כל זה, אבל משום מה בפונקציות אחרות זה עובד לי הקטע של A[1]

הייתי רוצה לראות את זה

O my bad

largeLast(&a[1]);

D=

עוד משהו, מה לא טוב הפעם:

void average(int a[], int size, double *avg)
{
	if(size>1)
	{
		average(a+1, size-1, avg);
		*avg=(*avg * (size-1) + a[0])/size);
	}
	*avg=*avg+a[0];
}

לפי מעכב ידני הכל טוב..

ו:

ועוד משהו הוא מראה לי אחרי התשובה E+00.

או מספר אחר במקום ה00

אממ... כמה דברים

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

ובתכלס,

	*avg=*avg+a[0];

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

*avg=a[0];

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

	*avg=(*avg * (size-1) + a[0])/size);

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

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

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

*avg=(*avg * (size-1) + a[0])/size);

גם יש לך שם בעיה עם הסוגריים..

בקשר ל E00:

http://en.wikipedia.org/wiki/Scientific_notation#E_notation