בעייה בשפת c ריקורסיה

[ruli yeret]

צריך לקלוט מהמשתמש את המקדם של הפולינום ואת הערך של x

למשל: עבור הפולינום הקלט יהיה 2 0 13 1- 3

שימו לב: המספר הראשון הוא של החזקה הנמוכה! יש 0 במקום שבו אין חזקה !

התוכנית תציב את המספר להצבה מסעיף ב בתוך הפולינום ותפלוט את תוצאת ההצבה.

בריקורסיה אשמח לקבל עזרה

[Access Denied]

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

תחשוב איך אתה בונה לוגיקה שבכל קריאה מורידה חלק מהבעיה (ותחשוב מה אתה מחזיר)

[matan5000]

תעלה את התמונה שוב

[ruli yeret]

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

וזה לא תמונה זה פולינום אך הוא לא נשלח...2x^4+13x^2-x+3

[Access Denied]

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

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

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

[ruli yeret]

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

וזה לא תמונה זה פולינום אך הוא לא נשלח...2x^4+13x^2-x+3

[yshekel]

לא מרגיש טבעי להשתמש פה ברקורסיה. הייתי עושה את זה בצורה איטרטיבית.

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

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

[Access Denied]

כל לולאה אפשר להפוך לרקורסיה ולהיפך

[שניצל]

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

לפותח הדיון: אם אתה רוצה להעלות תמונה לפורום, תיכנס ל http://www.imgur.com, תעלה את התמונה לשם, ותשים כאן את הלינק.

[הדוד משה]

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

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

iter()
{
    int coeff;
    scanf("%d",coeff);
    return( coeff+iter()*x );
}

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

sol=((((2x+0)x+13)x-1)x+3)

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

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

מקווה שעזרתי.

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

[Access Denied]

זה ממש לא נכון לדעתי.

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

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

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

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

לפותח הדיון: אם אתה רוצה להעלות תמונה לפורום, תיכנס ל http://www.imgur.com, תעלה את התמונה לשם, ותשים כאן את הלינק.

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

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

נ.ב.

אני אתן דוגמה שאולי תכוון את פותח הדיון -

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

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

- עוברים על המחרוזת בלולאה וסופרים כמה מספרים הוכנסו.

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

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

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

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

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

מקווה שזה מכוון אותך לפתרון אפשרי לשאלה שלך.

[הדוד משה]

אבל הקוד שלי עושה בדיוק את מה שאמרת!

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

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

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

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

[Access Denied]

הקוד שלך תמיד יתקע במקדם האחרון

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

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

[הדוד משה]

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

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

[Access Denied]

אתה טועה וחבל שאתה שולח את פותח הדיון בדרך הזו.

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

הוא כנראה לא יודע ולא אמור להשתמש במנגנוני time out כדי לא להמתין לקלט לעד.

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

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

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

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

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

תחשוב איך לפשט לו את הבעיה, לא לסבך אותה.

מקבלים קלט

מכניסים למבנה נתונים (נגיד מערך)

ואז אפשר לעבוד עם המבנה - יש לו גודל, יש גישה לחלקים במבנה וכו'.