#include<stdio.h>
#include<conio.h>
int main()
{
float a,d;
int b,mone=0;

printf("insert a number\n");
scanf("%f",&a);
b=a;
d=a-b;
while(d>0)
{

     a=(d*10);
     b=a;
     d=a-b;
     mone++;
}

printf("there is %d numbers after the point",mone);
  getch();

}     

המטרה של התוכנית היא להדפיס כמה מספרים יש אחרי הנקודה

תודה

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

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

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

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

num=5%2

התשובה תהיה 2

ואז מחשבים את השארית כך

num1=5-num*2

ואז התשובה היא 1

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

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

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

מה הכוונה לקרוא אותה כמחרוזת?

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

num=5%2

התשובה תהיה 2

ואז מחשבים את השארית כך

num1=5-num*2

ואז התשובה היא 1

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

לעשות scanf("%s", num);

ולא scanf("%f", &num);

ככה תוכל לעבור בלולאה עד שאתה רואה נקודה, ולאחר מכן לעבור בלולאה עד שאתה פוגש ב- 0.

תקצה מערך מספיק גדול של תוים, ותשתמש ב- scanf עם s% כדי לקרוא את מה שמשתמש מקליד בתור תוים.

מה שנשאר לך לעשות זה למצוא את המיקום של הנקודה ולהחסיר אותו מאורך המחרוזת שקראת.

unsigned integer - אני מניח שאתה מתכוון לתו '0\' ולא לתו '0'.

לא ממש הבנתי את מה שאמרתם

אבל אני לא מבין מה הבעיה בדרך שעשיתי את זה?

'/0' = 0

מאקרו כזה

כמו NULL.

דידס: בומרנג אמר לך למה זה לא עובד.

תנסה לקלוט מתרוזת.

אם הכנסת 3.14

אז בתא הראשון יהייה 3

בתא השניה יהייה .

בשלישי יהייה 1

ברביעי 4

עכשיו אתה עובר איבר איבר.

אם אתה רואה '.', אתה מתחיל לספור.

כל עוד לא ראית נקודה, אתה לא סופר.

for(i=0;num && num!='.';i++);

for(i=i+1, count=0;num;count++, i++);

דידס: בומרנג אמר לך למה זה לא עובד.

הההודעה הזאת?

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

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

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

אם כן

מה הכונה "לא מחזיק את המספר בצורה עשרונית."?

ד"א

מה זה מחרוזת?

תודה לכולם

מחרוזת זה מערך של תווים אחי...

אני יסביר את התוכנית שעשיתי ואיפה שיש טעות תתקנו אותי

1)המשתמש מקליד מספר למשתנה a מסוג float -נגיד המספר הוא 15.23

b=a המשתנה הוא מסוג int ולכן a=15

d=15.23-15=0.23

while(d>0)

(כל עוד d גדול מאפס הוא יעשה את הלולאה שוב וd שווה 0.23 ולכן הוא נכנס ללולאה)

a=(d*10) כלמר a =2.3

b=a כלמר b=2

d=a-b כלמר d=0.3

mone++ -המונה גדל באחד

הוא עושה שוב את הלולאה כי d=0.3

a=(d*10 כלמר a=3

b=a כלמר b=3

d=a-b כלמר d=0

mone ++ המונה גדל שוב באחד

הוא לא עושה שוב את הלולאה כי d=0

והוא צריך להדפיס את המונה (שבדוג' הזאת גדל בשתיים)

לא ככה?

מה הכונה "לא מחזיק את המספר בצורה עשרונית."?

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

כשאתה מקליד מספר ומכניס אותו ל- float הוא 'יעוגל' לבסיס בינארי, מה שלמעשה יוסיף לך ספרות בבסיס בינארי.

נגיד שלצורך העניין יש 4 ביטים שמחזיקים את המספר אחרי הנקודה, אז הערכים שהוא יכול לקבל הם כפולות של 1/16 ואם תכניס מספר כמו 0.3 הוא למעשה יעוגל ל- 0.3125 (והנה, נוספו לך 3 ספרות)

אני כתבתי תוכנית שקולתת מספר עם נקודה עשרונית ומדפיסה אותו וקלתתי 0.3 והוא הדפיס לי 0.3000000 כלומר שהוא לא מעגל את המספר

זה מה שרציתי לכתוב מקודם אבל האתר לא עבד

אם כך למה התוכנית לא עובדת?

הרגע הסבירו לך למה!

מה שקורה הוא שהמחשב לא משתמש בבסיס 10 כמונו, אלא בבסיס 2.

זה נכון גם לגבי שברים.

מה זאת אומרת?

תחשוב על המקרה שאתה רוצה לייצג את המספר 1/3 בצורה עשרונית.

אז הוא יוצא 0.333333333... ככה עד אינסוף 3-ים.

למה זה? כי ל-3 יש גורמים ראשוניים שאינם גורמים של 10 (ספציפית 3 עצמו הוא הגורם הזה).

במקרה שלנו, אתה מנסה לייצג את המספר 0.3 (שהוא 3/10) בצורה בינארית.

אז הוא גם כן יוצא מספר מחזורי אינסופי (אין לי כוח באמת לחשב אותו), מאותה סיבה - ל-10 יש גורם (5) שאינו גורם של הבסיס 2.

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

העיגול הזה גורם להרבה בעיות במחשב - מה שנקרא "שגיאות עיגול".

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

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

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