| המועמדים צריכים להיות מסוגלים: | הערות והנחיות |
|---|---|
| 1 הבנת מחזור פיתוח התוכנה, מוגבל ל: ניתוח, עיצוב, כתיבת קוד ובדיקה | • כולל זיהוי כל שלב ובצוע המשימות עבור כל שלב: – ניתוח: ראייה כללית, פירוק הבעיה, זיהוי הבעיה והדרישות – עיצוב: פירוק, דיאגרמות מבנה, סכמות זרימה, פסאודו-קוד – כתיבת קוד: כתיבת קוד תוכנה ובדיקה איטרטיבית – בדיקה: בדיקת קוד תוכנה באמצעות נתוני בדיקה |
| 2 (א) הבנת כך שכל מערכת מחשב מורכבת ממערכות משנה, המורכבות ממערכות משנה נוספות (ב) הבנת כיצד בעיה ניתן לפרק לחלקים המרכיבים אותה | • כולל: – קלט – תהליכים – פלט – אחסון |
| (ג) שימוש במגוון שיטות לעצב ולבנות פתרון לבעיה | • כולל: – דיאגרמות מבנה – סכמות זרימה – פסאודו-קוד |
| 3 הסבר על מטרת אלגוריתם נתון | • כולל: – ניסוח מטרת האלגוריתם – תיאור התהליכים המעורבים באלגוריתם |
| 4 הבנת שיטות פתרון סטנדרטיות | • מוגבל ל: – חיפוש ליניארי – סינון בועות – סיכום – ספירה – מציאת ערכים מקסימליים, מינימליים וממוצעים |
| 5 (א) הבנת הצורך בבדיקות תקינות על נתוני הקלט והסוגים השונים של בדיקות אלו | • כולל: – בדיקת טווח – בדיקת אורך – בדיקת סוג – בדיקת נוכחות – בדיקת פורמט – ספרת ביקורת |
| (ב) הבנת הצורך בבדיקות אימות על נתוני הקלט והסוגים השונים של בדיקות אלו | • כולל: – בדיקה ויזואלית – בדיקת הכנסה כפולה |
| 6 הצעה ויישום נתוני בדיקה מתאימים | • מוגבל ל: – רגיל – חריג – קיצוני – גבולי • נתונים קיצוניים הם הערך הגדול ביותר/הקטן ביותר המקובל • נתונים גבוליים הם הערך הגדול ביותר/הקטן ביותר המקובל וערך הדוחה הנלווה הקטן ביותר/הגדול ביותר |
| 7 השלמת טבלת מעקב לתיעוד ריצת ניסיון של אלגוריתם | • כולל, בכל שלב באלגוריתם: – משתנים – פלט – הנחיות למשתמש |
| 8 זיהוי שגיאות באלגוריתמים נתונים והצעת דרכים לתיקון שגיאות אלו | |
| 9 כתיבה ועריכה של אלגוריתמים לבעיות או תרחישים נתונים, באמצעות: פסאודו-קוד, קוד תוכנה וסכמות זרימה | • נדרשת דיוק בכתיבת אלגוריתמים, לדוגמה x > y מקובל אך x גדול יותר מ-y אינו מקובל • ראה סעיף 4 לסמלי סכמות זרימה • ראה סעיף 4 לפסאודו-קוד |
עיצוב אלגוריתמים ופתיחת בעיות
מדעי המחשב IGCSE · נושא 7
9:16
מחזור חיי פיתוח התוכנה
כל אפליקציה בטלפון שלך נכתבה על ידי מישהו כמו זה. אך הם לא התחילו בקלידת קוד. לפני השורה הראשונה, הבעיה נחקרה, הפתרון…
קריינות באנגלית · כתוביות באנגלית ובסינית 中文 שאפשר להחליף ביניהן
סיילבוס
מקור: הסיילבוס הבינלאומי של קמבריד'ג'
7.1
מחזור חיי פיתוח התוכנה
מחזור חיי פיתוח התוכנה הוא סדרת השלבים הנדרשים ליצירת תוכנית. ישנם ארבעה שלבים.

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


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

המערכת כולה מופיעה בתיבה העליונה. כל תיבה ברמה הבאה היא משימה אחת שהמערכת מבצעת, ואפשר לפצל תיבה שוב (התשלום מתפצל למזומן ולכרטיס). קראו את התיבות בכל רמה משמאל לימין לפי סדר ביצוע המשימות. תרשים מבנה מציג את החלקים, ולא את סדר ההחלטות או הלולאות: לשם כך משתמשים בתרשים זרימה או בפסאודו־קוד.
כתיבת קוד ובדיקה
בכתיבת קוד אתה כותב את קוד התוכנה. אתה משתמש בבדיקה איטרטיבית — בודק חלקים קטנים שוב ושוב בזמן הבנייה. בבדיקה אתה מריץ את כל התוכנית עם נתוני בדיקה כדי לוודא שהיא עובדת.
| English | עברית |
|---|---|
| program development life cycle/ˈprəʊɡræm dɪˈveləpmənt laɪf ˈsaɪkl/ | מחזור חיי פיתוח תוכנה |
| analysis/əˈnæləsɪs/ | ניתוח |
| design/dɪˈzaɪn/ | עיצוב |
| coding/ˈkəʊdɪŋ/ | קוד |
| testing/ˈtestɪŋ/ | בדיקות |
| abstraction/əbˈstrækʃn/ | הפשטה |
| decomposition/ˌdiːkɒmpəˈzɪʃn/ | פירוק |
| sub-systems/sʌb ˈsɪstəmz/ | תת-מערכות |
| structure diagram/ˈstrʌktʃə ˈdaɪəɡræm/ | תרשים מבנה |
| iterative testing/ˈɪtərətɪv ˈtestɪŋ/ | בדיקה איטרטיבית |
| test data/test ˈdeɪtə/ | נתוני בדיקה |
| flowchart/ˈfləʊtʃɑːt/ | תרשים זרימה |
7.2
כלים לעיצוב
ניתן לתכנן פתרון בשלושה דרכים עיקריות.
- תרשים מבנה — מראה את חלקי המערכת וכיצד הם מחוברים זה לזה;
- תרשים זרימה — תרשים המשתמש בקופסאות וחצים כדי להציג את השלבים בסדר;
- פסאודוקוד — שלבים כתובים באנגלית פשוטה, דמוי-קוד (לא שפה אמיתית).

7.3
אלגוריתמים
אלגוריתם הוא סט של שלבים, בסדר הנכון, הפותר בעיה. כל אלגוריתם ניתן לפצול לשלושה חלקים:
- כניסה — הנתונים שנכנסים;
- עיבוד — העבודה שנעשית על הנתונים;
- יציאה — התוצאה שיוצאת.
פעולה זו נקראת פירוק לקלטים, לתהליכים ולפלטים. למשל, במשימה „מצאו את הממוצע של שלושה ציונים”: הקלטים הם שלושת הציונים; העיבוד הוא חיבורם וחלוקה ב־3; הפלט הוא הממוצע.

| English | עברית |
|---|---|
| input/ˈɪnpʊt/ | כניסה |
| processing/ˈprəʊsesɪŋ/ | עיבוד |
| output/ˈaʊtpʊt/ | פלט |
| bubble sort/ˈbʌbl sɔːt/ | מיון בועות |
| totalling/ˈtəʊtəlɪŋ/ | סיכום |
| counting/ˈkaʊntɪŋ/ | ספירה |
7.4
אימות ואישור
כשנתונים מוזנים, בודקים אותם כדי להפחית טעויות.
אישור בודק שהנתונים סבירים ועומדים בכללים. הוא אינו יכול לבדוק שהנתונים נכונים, אלא רק שהם מותרים.
| בדיקת אישור | מהו הבדיקה |
|---|---|
| בדיקת טווח | הערך נמצא בין ערך מינימלי לערך מקסימלי מותרים |
| בדיקת אורך | מספר האותיות מותר (למשל, סיסמה ≥ 8) |
| בדיקת סוג | הנתונים הם בסוג הנכון (למשל, מספר ולא אותיות) |
| בדיקת נוכחות | משהו הוזן באמת (ולא נותר ריק) |
| בדיקת תבנית | הנתונים במבנה הנכון (למשל, תאריך כ-dd/mm/yyyy) |
| ספרת ביקורת | ספרה נוספת שמחושבת עוזרת לזהות שגיאות כאשר מספר מוקלט |
התאמה בודקת שהנתונים הועתקו או הוזנו נכונה (ללא שגיאות בעת הקלדה). שתי שיטות:
- בדיקה ויזואלית – אדם משווה את הנתונים המוקלדים עם המקור;
- הזנה כפולה – הנתונים מוזנים פעמיים והשתי העתקים מוצגות למשווה.

כתיבת שגרת בדיקת תקינות
בבחינה תתבקשו לעיתים קרובות לכתוב קוד לבדיקה. השתמשו בלולאה שמבקשת קלט שוב עד שהקלט תקין, והציגו למשתמש הודעה כשהוא אינו תקין.
דוגמה פתורה. כתבו פסאודו־קוד לקליטת ציון במבחן, שחייב להיות מספר שלם מ־0 עד 100 (בדיקת טווח), ולהמשך בקשת הקלט עד להזנת ציון תקין.
DECLARE Mark : INTEGER
REPEAT
OUTPUT "Enter a mark from 0 to 100"
INPUT Mark
IF Mark < 0 OR Mark > 100
THEN
OUTPUT "Invalid: the mark must be from 0 to 100"
ENDIF
UNTIL Mark >= 0 AND Mark <= 100
התנאי UNTIL הוא הטווח התקין, והתנאי IF הוא ההפך ממנו. שימו לב ל־OR בתוך IF: ציון אינו יכול להיות קטן מ־0 וגם גדול מ־100 באותו זמן, ולכן AND שם לעולם לא יהיה אמת.
בדיקות אחרות פועלות לפי אותה תבנית, עם תנאי שונה:
| בדיקה | תנאי לערך תקין |
|---|---|
| בדיקת אורך (סיסמה בת 8 תווים לפחות) | LENGTH(Password) >= 8 |
| בדיקת נוכחות (חובה להזין שם) | Name <> "" |
| בדיקת טווח (גיל מ־16 עד 65) | Age >= 16 AND Age <= 65 |
בדיקת סוג מתבצעת בדרך כלל על ידי שפת התכנות עצמה, למשל כאשר קלט נשמר במשתנה מסוג INTEGER.
| English | עברית |
|---|---|
| pseudocode/ˈsuːdəʊkəʊd/ | כתיב פסאודו |
| algorithm/ˈælɡərɪθəm/ | אלגוריתם |
7.5
טבלאות מעקב
טבלת מעקב מקליטה את ערך כל משתנה כאשר אלגוריתם פועל, צעד אחר צעד. היא עוזרת לך:

- לבדוק אם אלגוריתם פועל נכון;
- לחשב מהו הפעולה של אלגוריתם על ידי מעקב אחריו עם נתונים נתונים.
דוגמה: מעקב אחרי אלגוריתם זה עם קלט 5.
INPUT N
Total ← 0
FOR I ← 1 TO N
Total ← Total + I
NEXT I
OUTPUT Total
| i | total | OUTPUT |
|---|---|---|
| 1 | 1 | |
| 2 | 3 | |
| 3 | 6 | |
| 4 | 10 | |
| 5 | 15 | 15 |
המעקב מראה שהאלגוריתם מחבר 1 עד n. עם קלט 5, התוצאה היא 15.
דוגמה פתורה. מעקב אחרי אלגוריתם זה ותן את התוצאה.
X ← 20
Count ← 0
WHILE X > 1
X ← DIV(X, 2)
Count ← Count + 1
ENDWHILE
OUTPUT Count
DIV מחזיר רק את החלק שלם של חלוקה. לקחת שורה אחת לכל עבירה: x הופך ל-10 (ספירה 1), ואז ל-5 (ספירה 2), ואז ל-2 (ספירה 3), ואז ל-1 (ספירה 4). כעת x > 1 הוא שגוי, ולכן הלולאה נעצרת והתוצאה היא 4. שני הרגלים מגנים על סימני אלו: לבדוק את התנאי לפני כל עבירה ולא לאחר, ולכתוב שורה חדשה עבור כל עבירה - ניסיון להחזיק את הערכים בראש הוא מה שהופך את הטרייס לשגוי.
איתור ותיקון שגיאות
בשאלה נפוצה מוצג אלגוריתם שיש בו שגיאות ומתבקשים למצוא ולתקן אותן. קראו אותו שורה אחר שורה ושאלו: האם לכל משתנה ניתן ערך התחלתי? האם כל לולאה פועלת מספר פעמים מתאים? האם כל השוואה נעשית בכיוון הנכון? האם הפלט נמצא במקום הנכון?
דוגמה פתורה. אלגוריתם זה אמור לקלוט 10 מספרים ולהציג את הגדול ביותר. מצאו את שלוש השגיאות ותקנו אותן.
Largest ← 1000
FOR Count ← 1 TO 9
INPUT Number
IF Number < Largest
THEN
Largest ← Number
ENDIF
OUTPUT Largest
NEXT Count
- שורה 1: הערך ההתחלתי של
Largest ← 1000גבוה מדי, ולכן אף מספר לא יחליף אותו. תיקון:Largest ← -1000(או קלטו את המספר הראשון והשתמשו בו כערך התחלתי). - שורה 2: הלולאה פועלת רק 9 פעמים. תיקון:
FOR Count ← 1 TO 10. - שורה 4: הביטוי
<מוצא את המספר הקטן ביותר. תיקון:IF Number > Largest.
יש גם בעיה ב־OUTPUT: בתוך הלולאה הוא מדפיס אחרי כל קלט את המספר הגדול ביותר עד כה. העברתו אל אחרי NEXT Count תגרום להדפסת התשובה הסופית בלבד. לכל שגיאה, ציינו את השורה, הסבירו מה שגוי וכתבו את השורה המתוקנת במלואה.
טבלת מעקב
עבור על הלולאה ומלא את טבלת המעקב, שורה אחת לכל מעבר.
| English | עברית |
|---|---|
| trace table/treɪs ˈteɪbl/ | טבלת עקבה |
| normal/ˈnɔːml/ | נתונים רגילים |
| abnormal/əbˈnɔːml/ | נתונים חריגים |
| extreme/ekˈstriːm/ | נתוני קיצון |
| boundary/ˈbaʊndəri/ | נתון גבול |
7.6
נתוני בדיקה
נתוני בדיקה הם נתונים שמשתמשים בהם כדי לבדוק תוכנית. ישנם ארבעה סוגים שעליך לדעת.
| סוג | משמעות | דוגמה (גיל 0–120 מותר) |
|---|---|---|
| רגיל | נתונים הגיוניים שיש לקבל | 25 |
| חריג | נתונים שגויים שיש לדחות | -4 או „חתול” |
| קיצוני | הערכים הגדולים והקטנים המותרים ביותר | 0 ו-120 |
| גבולי | הערכים בכל צד של גבול (אחד מותר ואחד לא) | 120 ו-121 |
דוגמה פתורה. תוכנית מקבלת את מספר האנשים שמזמינים שולחן, מ־1 עד 12. תנו נתוני בדיקה מכל סוג, יחד עם התוצאה הצפויה.
| סוג | נתוני בדיקה | תוצאה צפויה |
|---|---|---|
| רגיל | 5 | מתקבל |
| חריג | 20 (או „שש”) | נדחה, עם הודעת שגיאה |
| קיצון | 1 ו־12 | מתקבלים |
| גבול | 12 ו־13 (או 0 ו־1) | 12 מתקבל, 13 נדחה |
ציינו תמיד את התוצאה הצפויה לצד הנתונים: בדיקה מועילה רק אם יודעים מה אמור לקרות. נתון קיצון הוא ערך הקצה עצמו; נתוני גבול הם זוג ערכים, אחד מכל צד של הגבול.

7.7
שיטות סטנדרטיות לפתרון
עליך לדעת אלגוריתמים נפוצים אלו.
חיפוש ליניארי
חיפוש ליניארי משווה כל פריט למטרה, מתחיל מהתחלה. עצור כשהערך נמצא או שהרשימה מסתיימת. הרשימה אינה צריכה להיות מסודרת. הדוגמה הבאה משתמשת במיקומים 1 עד 4.
DECLARE List : ARRAY[1:4] OF INTEGER
DECLARE I, SearchValue : INTEGER
DECLARE Found : BOOLEAN
List[1] ← 8
List[2] ← 3
List[3] ← 5
List[4] ← 1
INPUT SearchValue
Found ← FALSE
I ← 1
WHILE I <= 4 AND NOT Found
IF List[I] = SearchValue
THEN
Found ← TRUE
ENDIF
I ← I + 1
ENDWHILE
OUTPUT Found
השוואה עבודה. בחיפוש אחרי 5 מותקבלות השוואות של 8, 3 ואז 5: שלוש השוואות, כאשר Found הופך ל-TRUE. הפריט הרביעי אינו נבדק. בחיפוש אחרי 9 מותקבלות כל ארבע הערכים; Found נשאר FALSE. עצור לפני ניסיון לקרוא את המיקום 5, שהוא מחוץ לגבול המערך הזה.

סידור בועות
סינון בועות מסדר רשימה. השווא ערכים שכנים והחלף אותם אם הערך השמאלי גדול. מעבר יחיד אינו מספיק באופן כללי. גרסה מלאה זו חוזרת מעברים עד שמעבר שלם אינו מבצע החלפות.
DECLARE List : ARRAY[1:4] OF INTEGER
DECLARE I, Temp : INTEGER
DECLARE Swapped : BOOLEAN
List[1] ← 8
List[2] ← 3
List[3] ← 5
List[4] ← 1
REPEAT
Swapped ← FALSE
FOR I ← 1 TO 3
IF List[I] > List[I + 1]
THEN
Temp ← List[I]
List[I] ← List[I + 1]
List[I + 1] ← Temp
Swapped ← TRUE
ENDIF
NEXT I
UNTIL NOT Swapped
OUTPUT List[1], ", ", List[2], ", ", List[3], ", ", List[4]
מעברים עבודה. התחל עם 8, 3, 5, 1. במעבר הראשון הרשימה הופכת ל-3, 8, 5, 1, אז ל-3, 5, 8, 1, אז ל-3, 5, 1, 8. זה מניח את הערך הגדול באחרון אך משאיר את שאר האלמנטים ללא סדר. המעבר השני מסתיים ב-3, 1, 5, 8; השלישי ב-1, 3, 5, 8. הרביעי אינו מבצע החלפות ומאשר שגרסה זו יכולה לעצור. איפס Swapped ל-FALSE בתחילת כל מעבר; הגדר אותו ל-TRUE בהחלפה כלשהי.

חיבור סכום וספירה
סיכום מוסיף כל ערך נדרש לסכום רץ: Total ← Total + Value. ספירה מוסיפה 1 לכל פריט נדרש: Count ← Count + 1. הקדם שניהם לאפס לפני עיבוד הערכים.
דוגמה עבודה. ארבע ניסיונות כניסה הם −20, 4, 50 ו-6. קבל ערך רק אם הוא גדול מ-−20 וקטן מ-50. דוגמה זו מעבדת ארבע ניסיונות, לא ארבע ערכים מקובלים.
DECLARE I, Count : INTEGER
DECLARE Value, Total : REAL
Total ← 0
Count ← 0
FOR I ← 1 TO 4
INPUT Value
IF Value > -20 AND Value < 50
THEN
Total ← Total + Value
Count ← Count + 1
ENDIF
NEXT I
IF Count > 0
THEN
OUTPUT Total, ", ", Count, ", ", Total / Count
ELSE
OUTPUT "No accepted values"
ENDIF
| ערך נסיון | סכום אחרי ניסיון | ספירה אחרי ניסיון |
|---|---|---|
| −20 | 0 | 0 |
| 4 | 4 | 1 |
| 50 | 4 | 1 |
| 6 | 10 | 2 |
הגבולות המחמירים דוחים את −20 ואת 50. שתי עדכוני הנתונים מתבצעים בתוך בדיקת הקבלה, ולכן ניסיונות דחויים אינם משנים את הסך הכולל או את המניין. הממוצע של הערכים המקובלים הוא:
אל תחלק בארבע: נוספו רק שני ערכים. אם לא התקבל אף ערך, המניין הוא אפס ואין לחשב ממוצע; במקום זאת, הדפס הודעה בהימנעות מחלוקת באפס.
העברת נתונים למספר קבוע של ערכים מקובלים. אם משימה דורשת 50 ערכים מקובלים, ולא ארבע ניסיונות, החלף את לולאת FOR הקבועה ב-WHILE Count < 50 וסגור אותה עם ENDWHILE. שמור על אותו קלט ובדיקת קבלה בתוכה. קלט שנדחה משאיר את Count ללא שינוי, ולכן מבוקש קלט נוסף. בסיום, Count יהיה 50, אף על פי שמספר הניסיונות עשוי להיות גדול יותר. הדפס את הסך הכולל וחשב את הממוצע כ-Total / Count.
מקסימום, מינימום וממוצע
המקסימום הוא הערך הגדול ביותר והמינימום הוא הקטן ביותר. הממוצע הוא הסך הכולל חלקי מספר הערכים. רשימה שאינה ריקה, יש להתחיל את שניהם מהפריט הראשון. לכל פריט שנותר, החליף את המקסימום אם הערך החדש גדול ממנו, והחליף את המינימום אם הוא קטן ממנו.
דוגמה פתורה. הרשימה היא −8, −3, −12, −5. התחלת המקסימום מאפס תכשל: אין פריט ברשימה הגדול מאפס, ולכן האלגוריתם יציא מספר שאינו ברשימה. התחלה מ-−8 עובדת ללא הנחה שהנתונים חיוביים.
| ערך שנבדק זה עתיד | מקסימום עד כה | מינימום עד כה |
|---|---|---|
| −8 (התחלה) | −8 | −8 |
| −3 | −3 | −8 |
| −12 | −3 | −12 |
| −5 | −3 | −12 |
DECLARE List : ARRAY[1:4] OF INTEGER
DECLARE I, Maximum, Minimum, Total : INTEGER
List[1] ← -8
List[2] ← -3
List[3] ← -12
List[4] ← -5
Maximum ← List[1]
Minimum ← List[1]
Total ← List[1]
FOR I ← 2 TO 4
IF List[I] > Maximum
THEN
Maximum ← List[I]
ENDIF
IF List[I] < Minimum
THEN
Minimum ← List[I]
ENDIF
Total ← Total + List[I]
NEXT I
OUTPUT Maximum, ", ", Minimum, ", ", Total / 4
המקסימום הוא −3 והמינימום הוא −12. הממוצע משתמש בכל ארבעת הערכים:
הממוצע נמצא בין המינימום למקסימום; זוהי בדיקה שימושית, אך אינה הוכחה לשגיאה בחישוב. ההתחלה מפריט הראשון דורשת רשימה שאינה ריקה. טפל ברשימה ריקה בנפרד לפני שנסה לקרוא את הפריט.
| English | עברית |
|---|---|
| linear search/ˈlɪnɪə sɜːtʃ/ | חיפוש ליניארי |
| maximum/ˈmæksɪməm/ | מקסימום |
| minimum/ˈmɪnɪməm/ | מינימום |
| average/ˈævrɪdʒ/ | ממוצע |
7.8
טיפים לבחינות
- ארבעה שלבי מחזור החיים: ניתוח → עיצוב → קוד → בדיקת תקינות. הפשטה שומרת רק על מה שמעניין; פירוק מחלק בעיה לחלקים.
- התאמה (Validation) בודקת שהנתונים מגויסים (בדיקות טווח, אורך, סוג, נוכחות, פורמט); בדיקת נכונות (Verification) בודקת שהועתקו נכון (בדיקה ויזואלית או הכנסה כפולה).
- למד את ארבעה סוגי הנתונים לבדיקות: רגילים (מתקבלים), בלתי רגילים (נדחים), קיצוניים (הגדול/הקטן הנותרים המותרים), גבוליים (משני צדי גבול).
- טבלת מעקב (ערך כל משתנה בכל שלב) מראה מה אלגוריתם עושה.
- כדי לכתוב שגרת בדיקת תקינות, הכניסו את הקלט ללולאת
REPEAT … UNTILשהתנאי שלה,UNTIL, מייצג את הנתונים התקינים. - כשאתם מתקנים שגיאה, צטטו את השורה וכתבו את השורה המתוקנת במלואה.
- לדעת את האלגוריתמים הסטנדרטיים: חיפוש ליניארי (בדיקת כל פריט בסדר) ומיון בועות (החלפת זוגות סמוכים עד שאין צורך בהחלפות).
| English | עברית |
|---|---|
| validation/ˌvælɪˈdeɪʃn/ | אימות |
| range check/reɪndʒ tʃek/ | בדיקת טווח |
| length check/leŋθ tʃek/ | בדיקת אורך |
| type check/taɪp tʃek/ | בדיקת סוגים |
| presence check/ˈprezəns tʃek/ | בדיקת נוכחות |
| format check/ˈfɔːmæt tʃek/ | בדיקת פורמט |
| check digit/tʃek ˈdɪdʒɪt/ | ספרת בדיקה |
| verification/ˌverɪfɪˈkeɪʃn/ | התקפה |
| visual check/ˈvɪʒuːəl tʃek/ | בדיקה ויזואלית |
| double entry/ˈdʌbl ˈentri/ | כניסה כפולה |
שיעורים אינטראקטיביים בנושא זה
לעבור על הדברים צעד אחר צעד, עם תרגילים לבדיקה מיידית.