צירפתי את השאלה בקובץ וורד ואת הקובץ CPP עצמו בrar, הקובץ כרגע תקין ומתקמפל (אני מקווה שאמרתי את זה נכון )

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

במידה והוזנו פחות מ 8 ספרות המערכת צריכה להתריע בפני המשתמש שההזנה אינה נכונה ולתת לו נסיון נוסף עד 3 פעמים, ולאחר מכאן "לחסום אותו" (כשבתכלס הכוונה היא פשוט לתת פלט בסיגנון של "המשתמש נחסם" ואז פשוט לסיים את ההרצה)

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

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

מקרא למשתנים:

num ת.ז שהמשתמש מזין

counter מונה את מספר הספרות בת.ז

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

{ mult i digit sum a b שייכים לבדיקה של הת.ז בהנחה שהוזנו מספיק ספרות}

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

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

בשביל לצאת מלולאה באמצע אתה יכול פשוט להשתמש במילה השמורה break, או לחילופין להגדיר משתנה בוליאני שיהפוך ל-true אם הקלט תקין, ואז לשנות את תנאי העצירה של הלולאה ככה שתמשיך כל עוד משתנה הלולאה קטן מ-3 וגם שהמשתנה הבוליאני הוא false.

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

התבנית של התוכנית שלי נראת כך בערך:

{

הגדרת משתנים;

בקשה להזנת מספר;

הזנת מספר ע"י המשתמש;

{לולאה שבודקת מספר ספרות};

תנאי:

אם המספר קטן - פלט "המספר קטן"

אם המספר נכון - פעולה חישובית שבסופה תנאי:

אם המספר נכון - פלט "המספר נכון";

אם המספר אינו נכון - פלט "המספר אינו נכון";

}

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

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

2. איך משתמשים בbreak באופן טכני? אני עושה תנאי בתוך הלולאה הראשית שאם הוא מתקיים אז ?break

קראתי שוב את מה שכתבתי ויצא שברברתי משהו לא מובן בעליל

יש סיכוי שאתה רק כותב פה איך נראה התנאי הבולאני\איך נראה הbreak בתוך תוכנית כל שהיא?

אוקי, אז ככה. סתם לולאה נראית ככה:

for (int i = 0 ; i < 3 ; i++) {
 // some code here
}

אז break פשוט עובד ככה:

for (int i = 0 ; i < 3 ; i++) {
 /// some code here
 if (some condition) {
  break;
 }
}

כמובן ה-break יכול לבוא איפה שאתה רוצה בתוך הלולאה, ולא חייב להיות בתוך if (למרות שזה יהיה די טיפשי).

עם משתנה בוליאני אפשר לעשות משהו דומה:

bool done = false;
for (int i = 0 ; i < 3 && !done ; i++) {
 // some code here
 if (some condition) {
  done = true;
 }
}

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

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

מגניב, איך עושים את המלבן קוד?

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

(צרפתי את הקוד החדש)

בשביל להכניס קוד צריך ללחוץ על כפתור "הכנס קוד" (כפתור עם ציור סולמית).

ממבט על הקוד שלך אני רואה שבכלל לא כתבת את ה-for בצורה נכונה (תשווה אותו ל-for האחר שכתוב לך בקוד...). חוץ מזה, גם הלוגיקה שלך שגויה (מה בדיוק כללת בתוך הגוף של הלולאה? תחשוב רעיונית בדיוק איזה חלק של הקוד צריך להתבצע בכל איטרציה של הלולאה החיצונית)

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

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

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

עכשיו אני רק תוהה איך עושים את זה בלי להעזרת במה שהוא הראה לי { כותבים int main() במקום void ושמים תנאי עצירה לתוכנית אם מתקיים תנאי מסויים}

החבר שישבתי איתו לא גם לא ממש מצא דרך.

#include <iostream>
using namespace std;
int main()
{
int num , counter = 0 , numtest , mult , i , digit, sum=0 , a , b , numcounter , end , tryCounter=0 ;
do {
  cout<< "Hello, Please enter your ID"<< endl ;
  cin>>num;
  numcounter=num;

  while (numcounter>0)
    {
     counter++;
     numcounter=numcounter/10;
    }

  tryCounter++;
  } while(counter<8 && tryCounter<4) ;

if(tryCounter > 3)
   {
    cout<<"You got blocked";
    cin>>end;
    return 0; 
   }

for(i = 1 ; i <= counter; i++ )
  {

    if(i%2 == 0 )
      mult = 2 ;
    else
      mult = 1;
    digit = num%10 ;
    digit = digit * mult ; 
    if(digit > 9 )
    {
      a=digit%10;
      b=digit/10;
      digit=a+b;
    }
    sum += digit ; // sum = sum + digit 
    num = num /10 ;
   }
if (sum%10==0)
   cout<<"the ID is correct";
else
   cout<<"the ID is wrong";
cin>>end;
return 0 ;
}

זה בסדר גמור לצאת מהתכנית באמצע באמצעות return. חוץ מזה, מלכתחילה היית אמור לכתוב int main ולא void main (לכתוב void main זה לא תקני).

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

אבל כמה דברים:

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

חוץ מזה, התכנית שלך בודקת שתעודת הזהות תקינה (מבחינת ספרת ביקורת) רק פעם אחת - אבל היא אמורה לתת למשתמש שלוש הזדמנויות להכניס מספר תעודת זהות (אם הוא מההתחלה מכניס מספר תעודת זהות עם 8 ספרות ומעלה אז תהיה לו רק הזדמנות אחת).

בתנאי של הלולאה, תבדוק שמתקיימים 3 דברים - מותר למשתמש לנסות להכניס ID, מספר הספרות הוא 8 או 9, פעולת החישוב על הספרות.

משהו כזה:

while (numOfTries < 4 && (numOfDigits <8 || illegalDigits))

כאשר illegalDigits הוא משתנה בוליאני שיאותחל ל-true וישתנה ל-false אם הספרות עברו את הבדיקה.

טיפ קטן: אם אתה רוצה לדעת שבמספר יש יותר מ-X ספרות, חלק אותו במספר 1 ו-X-1 אפסים אחריו ותודא שהמספר לא קטן מ-1.

טיפ קטן: אם אתה רוצה לדעת שבמספר יש יותר מ-X ספרות, חלק אותו במספר 1 ו-X-1 אפסים אחריו ותודא שהמספר לא קטן מ-1.

למה? בשביל לבדוק אם במספר יש לפחות 8 ספרות פשוט צריך לבדוק שהוא לא קטן מ-10000000.

צודק...

בתנאי של הלולאה, תבדוק שמתקיימים 3 דברים - מותר למשתמש לנסות להכניס ID, מספר הספרות הוא 8 או 9, פעולת החישוב על הספרות.

משהו כזה:

while (numOfTries < 4 && (numOfDigits <8 || illegalDigits))

כאשר illegalDigits הוא משתנה בוליאני שיאותחל ל-true וישתנה ל-false אם הספרות עברו את הבדיקה.

טיפ קטן: אם אתה רוצה לדעת שבמספר יש יותר מ-X ספרות, חלק אותו במספר 1 ו-X-1 אפסים אחריו ותודא שהמספר לא קטן מ-1.

לא ממש בטוח שהבנתי...:

אני רוצה שלא תנתן לו האפשרות להזין יותר מ 3 פעמים. אם אני כותב numOfTries < 4 אז לפי מה שהבנתי זה יראה כך:

מספר שגוי ראשון numOfTries = 1

מספר שגוי שני numOfTries = 2

מספר שגוי שלישי numOfTries = 3

במצב הזה numOfTriesעדיין קטן ממש מארבע ולכן הלולאה תפעל פעם נוספת לא? נראה לי שאני צודק כי כשאני כותב קטן ממש מ3 אז באמת אפשר לתת עד 3 מספרים

בנוסף ברגע ש numOfDigits גדול או שווה ל 8 הלולאה תסתיים בכל מקרה, אז תפקידו של המשתנה הבולאני?

#include <iostream>
using namespace std;
int main()
{
int num , counter = 0 , numtest , mult , i , digit, sum=0 , a , b , numcounter , end , tryCounter=0 ;
do {
  cout<< "Hello, Please enter your ID"<<endl;
  cin>>num;
  numcounter=num;

  while (numcounter>0)
    {
     counter++;
     numcounter=numcounter/10;
    }

  tryCounter++;
  } while(counter<8 && tryCounter<3) ;

if(tryCounter=3&&counter<8)
   {
    cout<<"You got blocked";
    cin>>end;
    return 0;

   }

for(i = 1 ; i <= counter; i++ )
  {

    if(i%2 == 0 )
      mult = 2 ;
    else
      mult = 1;
    digit = num%10 ;
    digit = digit * mult ; 
    if(digit > 9 )
    {
      a=digit%10;
      b=digit/10;
      digit=a+b;
    }
    sum += digit ; // sum = sum + digit 
    num = num /10 ;
   }
if (sum%10==0)
   cout<<"the ID is correct";
else
   cout<<"the ID is wrong";
cin>>end;
return 0 ;
}

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

הבעיה היא שכאשר אני מזין 3 מספרים קטנים מ8 התוכנית מתעלמת מהתנאי שהצבתי לה

if(tryCounter=3&&counter<8)
   {
    cout<<"You got blocked";
    cin>>end;
    return 0;

   }

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

התנאי דורש ש:

א - tryCounter יהיה שווה ל3. מה שתופס כי בסוף כל הזנה הוא עלה באחד (כשהוא מתחיל מ0) אז הזנה ראשונה->1

הזנה שניה->2 הזנה שלישית->3 (כאן הלולאה do while רואה שtryCounter כבר לא קטן ממש מ3 ומסתיימת)

ב - counter קטן מ8 מה שגם תופס כי אני מזין בכוונה מספר עם פחות מ 8 ספרות...

חשבתי וחשבתי ואני לא מוצא את הבעיה.

תבצע debugging ותבדוק את הערכים של כל המשתנים הרלונטים בכל איטרציה.

???

בשביל להריץ את התוכנית אני לוחץ F5 ורשום ליד זהdebugging אבל לא הבנתי את השאר.

אחרי שאני מריץ וסוגר את החלון השחור שבו כל הפעולות מתבצעות יש בתחתית התוכנה חלון בשם Output אז אם לזה אתה מתכוון רשום שם:

'sdf.exe': Loaded 'C:\Users\Yehuda\Documents\Visual Studio 2010\Projects\sdf\Debug\sdf.exe', Symbols loaded.

'sdf.exe': Loaded 'C:\Windows\SysWOW64\ntdll.dll', Cannot find or open the PDB file

'sdf.exe': Loaded 'C:\Windows\SysWOW64\kernel32.dll', Cannot find or open the PDB file

'sdf.exe': Loaded 'C:\Windows\SysWOW64\KernelBase.dll', Cannot find or open the PDB file

'sdf.exe': Loaded 'C:\Windows\SysWOW64\msvcp100d.dll', Symbols loaded.

'sdf.exe': Loaded 'C:\Windows\SysWOW64\msvcr100d.dll', Symbols loaded.

The thread 'Win32 Thread' (0x304) has exited with code -1073741510 (0xc000013a).

The program '[1920] sdf.exe: Native' has exited with code -1073741510 (0xc000013a).

אין לי מושג מה זה אבל רשום שם Cannot find or open the PDB file וזו נראה כמו איזו בעיה.

(sdf זה שם הקובץ)