שאלה לגבי קוד בשפת C - רק מתחיל ללמוד

[dardar14]

שאלה לגבי קוד בשפת C - רק מתחיל ללמוד

היי, אני מנסה לכתוב בשפת C קוד של חזקה, כלומר X בחזקת Y.
האם הקוד שכתבתי הוא נכון וטוב? אם לא אשמח להכוונה..
תודה
#include <stdio.h>
main ()
{
int x,y,z,sum;
sum=x;
z=1;
for(x, y, z, sum; y!=z; sum*x, z++)
printf("%d\n", sum);
return 0;
}

 

[BravoMan]

ניסית לקמפל או להריץ את הקוד?

מן הסתם לא, אחרת היית רואה שהוא לא טוב.
&nbsp
אז מה רע בו?
1. אתה לא מאתחל שום משתנה, כלומר התוכנה שלך תעבוד על סתם ערכים אקראיים שיש במקרה בזיכרון בזמן שתריץ אותה.
&nbsp
2. אתה לא מציב את תוצאת החישוב בשום מקום, כלומר לעולם לא תקבל תשובה.
&nbsp
וכמובן, יש לך יותר מידי משתנים...

 

[dardar14]

קוד ב-C

לא, לא קימפלתי אותו, אני רק מתחיל ללמוד את הנושא ואני עדיין לא מבין לגמרי איך לעבוד על הקומפיילר..
לגבי הקוד, בכוונה לא כתבתי ערכים מסוימים, אני רק רוצה את הנוסחה הכללית אליה שמים משתנים.
אני אסביר מה הייתה המחשבה שלי. אני צריך לעשות X בחזקת Y, כלומר לחשב X*X בכמות של Y פעמים. אני מתחיל ב SUM=X מכיוון שבסוף אני רוצה שהתוצאה תהייה SUM. פעם ראשונה התוצאה היא רק SUM, שזה כביכול בחזקת 1. הגדרתי את Z=1, כך שבלולאה הראשונה אם Y=1, כלומר החזקה היא 1, הלולאה תסתיים והתשובה תהיה SUM שזה כאמור X, וזה בדיוק X בחזקת 1. אם Y גדול מ-1, נגיד 3. אז הוא לא שווה ל-Z, ל-1, ולכן אני מכפיל את SUM ב-X ומוסיף עוד 1 ל-Z, כך יוצא ש-SUM הוא X*X שזה X בחזקת 2, ואז Z=2. עכשיו ה-Z שלי עדיין לא שווה ל-Y, 3 לא שווה ל-2, ולכן אני מכפיל שוב את SUM ב-X ומעלה 1 ל-Z, כך שיוצא ש-SUM הוא X*X*X, כלומר X בחזקת 3, ו-Z עולה ל-3. עכשיו הערך של Y, שהוא 3, שווה לערך של Z, ולכן הלולאה נגמרת והתוצאה היא ש-SUM הוא X בחזקת 3, וזה בדיוק לאן שרציתי להגיע.
כמובן שאני לא מתייחס לנקודה עם החזקה היא שלילית אלא בהנחה שהיא חיובית ומספר שלם בלבד, אבל עם הזמן אתקדם גם לזה..
לגבי ההערה השניה שלך, אני רוצה להדגיש שתוצאת החישוב שלי היא SUM ואני שם אותה בפונקצית PRINTF.
אני מצרף את הקוד מחדש בתמונה מכיוון שבהודעה הוא קצת התבלגן לי..
ניסיתי עכשיו לקמפל את הקוד, זה אכן לא הצליח לי וכתב לי רק 3. למה הוא לא מכפיל לי את SUM ב-X?

 

[BravoMan]

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

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

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

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

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

אני לא יודע מאיזה מקור אתה לומד, אבל לא ככה כותבים לולאת for.

משמאל לימין (חלקים מופרדים עם נקודה פסיק):

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

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

החלק השלישי נועד רק לקדם את המונה!
מה שאתה עושה בו במקום זה חישוב sum * x אבל אתה לא מציב את תוצאה החישוב חזרה ב-sum!
אם לא תציב - לא תקבל!

תשתמש ב-"עורך תוכן מלא" של תפוז, הוא מאפשר לך לצרף קוד כמו שצריך, ככה:

for (z = 1; z <= y; z++) { //אתחול, בדיקה, קידום
   sum = sum * x; //ביצוע חישוב והצבת תוצאה
}

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

בהצלחה!

 

[dardar14]

C

אני לומד מספר שנקרא SAMS TEACH YOURSELF C IN 24 HOURS, שאגב כמובן לוקח הרבה יותר מ-24 ללמוד
כמובן שיש צורך בתרגול וכתיבת הקוד תוך כדי הלימוד, מצאתי קומפיילר באיזה אתר שנוח לי לעבוד איתו עד שאלמד כמו צריך את הקומפיילר שלי.
לגבי הקוד, עשיתי כמה ניסויים והצלחתי, אך יש קצת מה לשפר. באתחול הצבתי מספר. בבדיקה ניסיתי גדול שווה מ-Z אבל הוא לא נתן לי תוצאה טובה, ודווקא הלא שווה נתן לי את מה שרציתי.
עדיין עשיתי עם 4 משתנים כי זה יותר נוח, ניסיתי כמה פעמים עם 3 משתנים ועדיין לא הצלחתי. הקוד שרשמתי הוא: (הוספתי את הקוד דרך ההודעה, יש פה אפשרות להוסיף קוד, מקווה שזה בסדר..)

#include <stdio.h>

main()
{
  int x,y,z,sum;
  z=1;
  y=5;
  sum=x;
  for(x=sum=2; y!=z; z++){
         sum*=x;
           }
   printf("X raise to Y is:%d\n",sum);

    return 0;
}

מה אתה חושב על הקוד? הצבתי X=2,Y=5, והוא נתן לי את התוצאה הרצויה.
בנוסף, חשבתי לשנות כך שעל המשתמש יהיה להקליד את המספרים אותם הוא רוצה להכניס למשוואה, ניסיתי כמה פעמים להוסיף ()getchar אבל עדיין לא הצלחתי, זה בתהליך

 

[BravoMan]

אני מניח שזו שפת תכנות ראשונה שלך, אז אולי כדאי להתרחק

מספרים עם שמות קשקשנים מידי.
אני לא מכיר את הספר הזה, ולפי הפתיח הוא מתיימר ללמד מ-0, אבל אולי כדאי לחפש משהו יותר יסודי.
&nbsp
לגבי הקוד:
1. קצת הטעיתי אותך, לא בכוונה, בתנאי שרשמתי.
אם היית מנסה לחשוב מה בדיוק "יצא לא טוב", היית רואה שביצעת הכפלה אחת מיותרת. כי זה לא => זה פשוט >.
&nbsp
כשהקוד לא עובד, לא מספיק להביא קוד אחר שכן עובד, צריך גם ללמוד ולהפנים למה הקודם לא עבד.
וזה נכון החל ממי שרק מתחיל ללמוד כמוך, עד למתכנת הוותיק ביותר!
&nbsp
2. כרגע הקוד נראה תקין, אבל נראה שאתה עדיין מבולבל בכל עניין ההצבות והשימוש בלולאה:
א) אתה מאתחל את z שמשמש אותך כמונה מחוץ ללולאה.
זה עובד, אבל זה לא יפה ולא נהוג.
&nbsp
ב) אתה עושה הצבה מיותרת לפני הלולאה: אתה מציב x ב-sum, אבל עוד לא שמת שום ערך ב-x!
&nbsp
ג) אתה עושה הצבה ל-x ו-sum במקביל (למעשה בשרשרת) במקום בו אתה אמור לאתחל את המונה.
השפה מתירה את זה, אבל לא נהוג לעשות כך, וממאילה אם היו שם ערכים קודמים, אתה פשוט תדרוס אותם.
&nbsp
יש לי הרגשה שהספר לא הסביר לך טוב איך עובד כל עניין המשתנים, ואני גם רואה אותך מנסה לכתוב הרבה "קיצורי דרך".
&nbsp
שפת C אכן מרשה קיצורים כאלה (כמו =*) ומפתחים מנוסים משתמשים בהם, אבל מי שרק מתחיל ללמוד לא אמור להיתקל או לגעת בהם, אלא אמור לכתוב קוד קריא וברור לפי הכללים.
&nbsp
תחשוב על זה כמו לימוד נהיגה: כשאתה רק מתחיל אתה נוהג עם 2 ידיים על ההגה, לעולם לא עובר מהירות מותרת, מעביר הילוכים בדיוק כשהמורה אומר וכו'
&nbsp
אחרי כמה שנים מאחורי ההגה, כשתצבור ניסיון ותרגיש בטוח בעצמך, סגנון הנהיגה שלך ישתנה.
&nbsp
3. אם אתה רוצה לתת למשתמש להכניס את הערכים, תלמד על פונקציה scanf.
רוב הספרים מלמדים אותה לפני לולאות, כי היא מאוד נוחה בתרגילים כאלה.

 

[BravoMan]

והנה שני אתגרים בשבילך, אם תרצה לתרגל עוד:

1. תנסה לחשוב מה הכמות המינימלית של משתנים שצריך כדי לפתור את התרגיל הזה. 4 משתנים זו הכמות המירבית, לפני שאתה ממש מתחיל לבזבז מקום סתם.
&nbsp
2. תחשוב איך תוכל להרחיב את הקוד כדי לאפשר חישוב של כל חזקה חיובית שלמה, כלומר כולל חזקה 0 (כל מספר בחזקת 0 שווה 1).