תכנות מחשב

מעיצוב לקוד

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

1. מצא את ה-משתנים ואת סוגי הנתונים שלהם.
2. המר תיבות קלט/פלט ל-INPUT / OUTPUT.
3. המר יהלומי החלטה ל-IF...ELSE...ENDIF (או CASE).
4. המר חצים של לולאה ל-WHILE, REPEAT...UNTIL או FOR.
5. המר תיבות פעולה לאסיגנות או חישובים.
6. בדוק על ידי מעקב אחר קלט קטן.

*כל סמל בתרשים זרימה הופך למילה מפתח בקוד מדומה

קבועים ומשתנים

קבוע שומר ערך שאינו מתחלף לעולם; משתנה שומר על ערך שעשוי להשתנות. הכרז אותם עם סוג:

*ערך משתנה יכול להשתנות; קבוע נשאר קבוע

CONSTANT Pi = 3.14159
DECLARE Radius : REAL
DECLARE Area : REAL

Radius ← 5
Area ← Pi * Radius * Radius

השתמש בקבועים לערכים קבועים שנשנים (Pi, MaxScore); הם הופכים את הקוד ברור וקל לשינוי במקום אחד.

במבחן, קבוע הוא התשובה לשאלה "זהה דרך מתאימה יותר לייצוג" ערך קבוע, כמו אחוז מס או נקודות מקסימום, שמופיע במספר מקומות בקוד המדומה. היתרונות שהמערכת מונה: הערך מוגדר פעם אחת ואינו ניתן לשינוי מקרי על ידי התוכנה; שינוי נעשה במקום אחד ומגיע לכל פקודה המשמשת אותו; המזהה נותן לערך משמעות (MaxScore במקום 100), כך שקוד קריא וניתן לבדיקה; ויש פחות סיכון לחטיאת הקלדה בערך ארוך כמו 3.14159. שאלה "צין ערך שניתן להחליפו בקבוע" דורשת את האותיות מהקוד המדומה (0.2, 40), ולא שם חדש.

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

שאלת "נתו את סוג המשתנה המתאים" נענית לפי אופן השימוש במשתנה בפסאודוקוד: ערך עם נקודה עשרונית הוא REAL; משהו שהוגדר ל-TRUE או FALSE הוא BOOLEAN; ערך בתוך סימני ציטוט יחידים הוא CHAR; ערך המשמש כמדד למערך, או בשימוש עם DIV ו-MOD, הוא INTEGER. כתוב את הסוג באותיות גדולות, בדיוק כפי שמופיע במדריך.

דוגמה פותרת. ציין את סוג המשתנה המתאים לכל משתנה.

Found ← FALSE
Initial ← 'K'
Price ← 12.99
Count ← Count + 1
Name ← "Li Wei"

Found היא BOOLEAN (היא מכילה FALSE); Initial היא CHAR (תווית אחת בתוך סימני ציטוט יחידים); Price היא REAL (ערך עשרוני); Count היא INTEGER (ונה שמתעלה ב-1); Name היא STRING (טקסט בתוך סימני ציטוט כפולים).

הקצאה ביטויים

השתמש ב-← עבור הקצאה:

Total ← Total + 1
Average ← Sum / Count

ביטויים משתמשים ב-אופרטורים:

• אריתמטי + - * /, פלוס DIV (חלוקה שלמה) וחילוק MOD (שארית): 7 DIV 2 = 3; 7 MOD 2 = 1.
• השוואות =, <>, <, >, <=, >=.
• לוגיקה AND, OR, NOT.

סדר עדיפות (מהגבוה לנמוך): NOT → * / DIV MOD → + - → השוואות → AND → OR. השתמשו בסוגריים כאשר אינכם בטוחים.

כניסה ויציאה

OUTPUT "Enter your name:"
INPUT Name
OUTPUT "Hello, ", Name

פונקציות מובנות ותת-תוכניות ספרייה

לרוב המשימות ישנם תת-תוכניות ספרייה מוכנים, ולכן אין צורך לכתוב אותן. רשימת ההכנסה בבחן 2 מציינת את אלו שתוכל להשתמש בהן, יחד עם שמותיהם המדויקים, הפרמטרים והסוגים המוחזרים; כל פונקציה אחרת שנדרשת בשאלה מופיעה בה. השמות למטה הם השמות ברשימת ההכנסה. VAL ו-STR הם שמות IGCSE ואינם מופיעים באף אחד ממסמכי 9618, ולכן אינם מניבים נקודות. UCASE ו-LCASE הם מקרה שונה: הם **חלק מ-**9618, מוגדרים במדריך הפסאודוקוד, אך הם מקבלים פרמטר CHAR בודד, ורשימת ההכנסה אינה מציגה אותם כלל — עבור מחרוזת טקסט שלמה בבחן 2 התת-תוכנית היא TO_UPPER.

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

מסרים מתחברים באמצעות & (הצמדה): "A" & "BC" הוא "ABC". השתמשו בשמות המדויקים מההכנסה, עם הפרמטרים בסדרם.

תאריכים ומספרים אקראיים מופיעים כהצהרות בשורה אחת. SETDATE(17, 11, 2007) בונה 17 נובמבר 2007; 12 - MONTH(MyDOB) הוא מספר החודשים מהחודש שנולד בו ועד סוף השנה; IF DAYINDEX(MyDOB) = 5 THEN בודק האם זה יום חמישי, כי ראשון הוא יום 1. RAND(n) מחזיר מספר אמיתי מ0 ועד, אך לא כולל, n, לכן מספר שלם אקראי מLow עד High כולל הוא INT(RAND(High - Low + 1)) + Low: INT(RAND(21)) - 10 נותן ערך מ-10 עד 10.

דוגמה מפורטת. חשבו כל ביטוי, נתון כי Word ← "Program", Code ← 'Q' ו-N ← 7.

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

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

כל אופרטור פועל על סוגים מסוימים: & על טקסטים, + - * / DIV MOD על מספרים, AND OR NOT על בוליאנים, ו-= <> על שני ערכים מסוג אותו סוג. טבלת "העריכו כל ביטוי, או כתבו ERROR" מסומנת באותו אופן: LENGTH(42) ו-"A" + 1 הם ERROR, מכיוון שהסוג אינו תואם לפונקציה או לאופרטור.

דוגמה מפורטת. עם Points ← 100, Active ← TRUE ו-Exempt ← FALSE, העריכו כל ביטוי.

הביטוי האחרון מצטמצם: X OR NOT X הוא TRUE ללא תלות בX, ולכן הביטוי כולו הוא פשוט NOT Exempt. חשבו תחילה את הסוגריים, ואז NOT, ואז AND, ואז OR.

בחירה קובעת אילו שלבים יופעלו.

IF age >= 18 THEN
    OUTPUT "Adult"
ELSE
    OUTPUT "Minor"
ENDIF

ליותר משני מקרים ניתן להשתמש ב-IF פנימי (nested), אך היכלות עמוקה קשה לקרוא — CASE נקי יותר כאשר בודקים ערך נגד מספר אפשרויות:

CASE OF Grade
    "A": OUTPUT "Excellent"
    "B": OUTPUT "Good"
    OTHERWISE: OUTPUT "Try again"
ENDCASE

Cambridge CASE מאפשר ערכים יחידים, רשימות ערכים (1, 2, 3:), וטווחים (1 TO 5:).

IF פנימי הוא IF בתוך ветב של IF אחר. כל IF דורש את ה-ENDIF שלו, ובוחן בוודא שכל מבנה סגור:

IF Mark >= 50 THEN
    IF Mark >= 80 THEN
        OUTPUT "Distinction"
    ELSE
        OUTPUT "Pass"
    ENDIF
ELSE
    OUTPUT "Fail"
ENDIF

גבולות הם מקומות בהם מאבדים נקודות. "ציון של 50 או יותר עובר" הוא Mark >= 50, לא Mark > 50; ה-CASE האחרון, עבור "הכל שאינו כזה", נכתב OTHERWISE, ולא תנאי כמו > 200. השוואה שגויה כאן היא שגיאת לוגיקה: התוכנית פועלת, אך מייצרת תוצאה שגויה עבור כניסות מסוימות — וטבלת מעקב עם ערך גבול כמו 50 היא הדרך למצוא זאת.

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

CASE OF MySwitch
    1: ThisChar ← 'a'
    2: ThisChar ← 'y'
    3: ThisChar ← '7'
    OTHERWISE: ThisChar ← '*'
ENDCASE

כל ערך הופך ל-ветב של שרשרת IFs, וה-OTHERWISE הופך ל-ELSE האחרון:

IF MySwitch = 1 THEN
    ThisChar ← 'a'
ELSE
    IF MySwitch = 2 THEN
        ThisChar ← 'y'
    ELSE
        IF MySwitch = 3 THEN
            ThisChar ← '7'
        ELSE
            ThisChar ← '*'
        ENDIF
    ENDIF
ENDIF

שתי פסקאות המכנסות אותו ערך משולבות לפסקה אחת עם רשימת ערכים: 1, 2: ThisChar ← 'a'. השומרים (guards) נבדקים סדרתי: עם טווחים כמו 1 TO 50: שלאחריו 40 TO 60:, ערך של 45 ילך ל-ветב הראשון שמתאים, ולכן הכנסה ב-ветב מאוחר יותר עשויה לעולם לא להתבצע — וכאשר ה-ветבים הקודמים כבר מכסים את כל הערכים האפשריים, גם ה-OTHERWISE לעולם לא יושג.

הליכה לכיוון ההפוך, IFs פנימיים הבוחנים מספר Booleans ברורים יותר כתנאי אחד לתוצאה: IF A AND B AND C THEN CALL Sub1(), ואז IF A AND B AND NOT C THEN CALL Sub2(), וכו'. חיבור בדיקות עם AND וOR מסיר את ההיכלות, וה-IF A THEN מתקבל במקום ה-IF A = TRUE THEN.

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

לופ מבוקר ספירה (FOR)

לופ מבוקר ספירה — השתמש בו כשאתה יודע כמה פעמים לחזור:

FOR i ← 1 TO 10
    OUTPUT i
NEXT i

ה-STEP יכול לשנות את הספירה (למשל FOR i ← 10 TO 1 STEP -1). הטוב ביותר לספירת חזרות קבועה או לעיבוד כל אלמנט ב-array.

לופ תנאי מקדים (WHILE)

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

WHILE total < 100 DO
    INPUT n
    total ← total + n
ENDWHILE

לולאת תנאי מאחורי (REPEAT...UNTIL)

לולאת תנאי מאחורי בודקת את התנאי אחרי כל עבר, ולכן היא תפעיל למינום אחת:

REPEAT
    INPUT password
UNTIL password = correctPassword

בחירת הלולאה המתאימה

• הספידה ידועה מראש → FOR.
• ייתכן שמצויה צורך באפס עברים → WHILE.
• תמיד לפחות עבר אחד → REPEAT...UNTIL.

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

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

דוגמה פותרת. איזה לולאה מתאימה לכל משימה? (א) הדפסת טבלת הכפלה של 12; (ב) המשך לקרוא מספרים עד שהמשתמש מזין 0; (ג) בקש סיסמה עד שהיא תהיה נכונה. בחר על ידי שאלה כמה פעמים הגוף מפעיל ובמתי הבדיקה מתרחשת. (א) הספידה ידועה מראש (12), לכן השתמש בלולאת FOR. (ב) הספידה אינה ידועה, והכניסה הראשונה עשויה להיות כבר 0 - ולכן הבדיקה חייבת לבוא לפני הגוף: לולאת WHILE, which runs zero or more times. (ג) הספידה אינה ידועה, אך עליך תמיד לבקש לפחות פעם אחת לפני שיש דבר לבדוק - ולכן הבדיקה מגיעה אחרי הגוף: REPEAT...UNTIL, which runs one or more times. השאלה המכריעה היא האם הגוף חייב לפעיל לפחות פעם אחת: WHILE עשויה לפעיל אפס פעמים, REPEAT תמיד תפעיל פעם אחת.

ריצה יבשה עם טבלת סימון

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

DECLARE Count, Total : INTEGER
Count ← 1
Total ← 0
WHILE Total < 10
    Total ← Total + Count * 2
    Count ← Count + 1
ENDWHILE
OUTPUT Count, Total

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

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

CALL Start()

סוף-אם | FOR I ← 1 TO 20 ... NEXT I | | yes | | | WHILE NOT IsFull() ... ENDWHILE | | yes | yes | | CASE OF Key ... OTHERWISE ... ENDCASE | yes | | |

IF וCASE הם בחירה; FOR, WHILE וREPEAT הם איטרציה; שם שלאחריו סוגריים — Start(), IsFull() — הם קריאה לתת-תוכנית או לפונקציה, בכל מקום שבו היא מופיעה, כולל בתוך תנאי.

תכנות מובנה בונה תוכנית מתת-תוכניות קטנות וממוענות שם, כאשר לכל אחת מהן יש משימה אחת.

תהליך

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

PROCEDURE Greet(name : STRING)
    OUTPUT "Hello, ", name
ENDPROCEDURE

CALL Greet("Ada")

פונקציה

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

FUNCTION Square(x : INTEGER) RETURNS INTEGER
    RETURN x * x
ENDFUNCTION

result ← Square(5) + 1     // result = 26

השתמש ב-תהליך כאשר התת-תוכנית מבצעת פעולה; השתמש ב-פונקציה כאשר היא מחשבת ערך עבור הקורא.

הסיילבוס דורש איפה בבניית האלגוריתם כל אחד מהם מתאים. תהליך מתאים כאשר נדרשת אותה סדרת שלבים מספר פעמים (לאמת כניסה, הדפיס תפריט, להחליף שני ערכים): השלבים נכתבים פעם אחת ו-CALLים על ידי שם. פונקציה מתאימה כאשר יש לחשב ערך יחיד ולאחר מכן להשתמש בו בביטוי — סכום, תוצאת TRUE/FALSE, הערך הגדול ביותר משני מספרים — מכיוון שהערך המוחזר מחליף את הקריאה: IF IsValid(Code) THEN.

פרמטרים

פרמטר הוא משתנה שתת-תוכנית מגדירה כדי לקבל כניסה; הערכים שהקורא מספק הם ארגומנטים. שתי דרכים למסור אותם:

• pass by value — הפונקציה מקבלת עתיקה; שינויים בתוכה אינם משפיעים על הקורא. השתמש עבור קלט שרק נקרא.
• pass by reference — הפונקציה מקבלת יחוס למשתנה של הקורא; שינויים כן משפיעים על הקורא. השתמש כאשר יש צורך עדכן פרמטר.

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

PROCEDURE Swap(BYREF a : INTEGER, BYREF b : INTEGER)
    DECLARE temp : INTEGER
    temp ← a
    a ← b
    b ← temp
ENDPROCEDURE

Cambridge pseudocode כותב את סוג ההעברה בכותרת, BYVAL או BYREF, לפני כל פרמטר. אם לא נכתב שום דבר, מופרש BYVAL, ולכן פונקציה שצריכה לשנות את המשתנה של הקורא — Swap, או פרוצדורה שעודכנת סך נצברים — זקוקה לBYREF בכותרת שלה.

דוגמה עבודה. מהו התוצאה?

PROCEDURE Adjust(BYREF X : INTEGER, BYVAL Y : INTEGER)
    X ← X + Y
    Y ← Y * 2
ENDPROCEDURE

A ← 5
B ← 3
CALL Adjust(A, B)
OUTPUT A, B

X היא התייחסות לA, לכן A הופכת ל8. Y היא העתקה של B, לכן הכפל בY משאיר את B ב3. הפלט הוא 8, 3. אם הכותרת הייתה מכילה BYVAL X, הA עדיין היה 5.

משתנים מקומיים לעומת משתנים גלובליים

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

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

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

מתי להשתמש בפרוצדורה

השתמש בפרוצדורה כאשר:

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

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

מונחולוגיה

• הגדרה — בלוק הPROCEDURE ... ENDPROCEDURE (או הפונקציה).
• קריאה — המקום שבו היא נקראת. ארגומנט — ערך המועבר לתוך הבloq. פרמטר — המשתנה שמקבל אותו.
• ערך חזרה — מה שהפונקציה מחזירה.
• כותרת פרוצ'ורה/פונקציה — השורה הראשונה המציגה את השם והפרמטרים (PROCEDURE Name(params) או FUNCTION Name(params) RETURNS type).
• ממשק פרוצ'ורה/פונקציה / חתימה — שם + פרמטרים + סוג החזרה: מה שנקרא צריך לדעת כדי להשתמש בה.

דוגמה מופרדת. הסבר כל מונח המשמש בכותרת FUNCTION Pass2(Count : INTEGER) RETURNS BOOLEAN.

שני המזהים בPROCEDURE MyProc(Count : INTEGER, Message : STRING) הם פרמטרים: הם מקבלים את הערכים המועברים כאשר נקראת הפרוצ'ורה, ושימשים בתוכה כמו משתנים מקומיים.

להמיר פרוצ'ורה לפונקציה: שנה PROCEDURE לFUNCTION והוסף RETURNS <type>; החלף את הOUTPUT (או את הBYREF פרמטר שעבר את התוצאה החוצה) עם פקודת RETURN; ושנה כל קריאה כך שערך החזרה ייستخدم, Result ← Unpack(Text) במקום CALL Unpack(Text, Result). לשאלת "כתוב כותרת", כתוב את השורה כולה: FUNCTION Calculate(Expression : STRING) RETURNS INTEGER. פרמטר מערך מועבר בערך, ולכן פרוצ'ורה שכותבת במערך משנה את המערך של הנקרא.

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

כתיבת מודול לבחינת נייר 2

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

*כל חלק בתשובה למודול מקבל את הנקודות שלו, לכן כתוב את כולם גם כאשר אינך בטוח

1. הכותרת, כפי שהשאלה מתארת אותה: PROCEDURE Name(Param : TYPE) או FUNCTION Name(Param : TYPE) RETURNS TYPE, עם BYREF כאשר הרutine צריך לשנות את הארגומנט.
2. הצהרות מקומיות: DECLARE כל משתנה מקומי עם סוגו, והגדרת סופרים וסכומים (Count ← 0).
3. הלולאה שביקרת בכל אלמנט: FOR Index ← 1 TO 50 למערך whose גודל נתון; WHILE NOT EOF(...) לקובץ.
4. התנאי, עם ההשוואה והגבול הנכון, על הפריט הימני: IF Score[Index] > Limit THEN.
5. העדכון בתוך הענף: הספירה הועלתה, הערך אוחסן, או ההודעה הוצגה.
6. הסיום: RETURN פעם אחת, אחרי הלולאה, בפונקציה; ENDFUNCTION או ENDPROCEDURE; וכל IF, FOR ו-WHILE סגורים.

דוגמה פתורה. מערך גלובלי Score : ARRAY[1:50] OF INTEGER מחזיק ציוני מבחן. כתוב פונקציה CountAbove(Limit : INTEGER) שמחזירה כמה ציונים גדולים מ-Limit.

FUNCTION CountAbove(BYVAL Limit : INTEGER) RETURNS INTEGER
    DECLARE Index, Count : INTEGER
    Count ← 0
    FOR Index ← 1 TO 50
        IF Score[Index] > Limit THEN
            Count ← Count + 1
        ENDIF
    NEXT Index
    RETURN Count
ENDFUNCTION

נקודות: הכותרת עם הפרמטר וה-RETURNS INTEGER; Count מוגדר ומכוון ל-0; לולאה על כל 50 האלמנטים; ההשוואה > Limit (לא >=); הספירה מעודכנת בתוך ה-IF; RETURN Count אחרי הלולאה. התוכנית הראשית משתמשת בערך ההחזר בביטוי או בהוצאה: OUTPUT "Above 70: ", CountAbove(70).

דוגמה פתורה. כתוב פונקציה IsValid(Code : STRING) שמחזירה TRUE כאשר Code הוא שתי אותיות גדולות followed by ארבעה ספרות — ה-פורמט AB1234 — ו-FALSE אחרת.

FUNCTION IsValid(BYVAL Code : STRING) RETURNS BOOLEAN
    DECLARE Index : INTEGER
    DECLARE Ch : STRING
    IF LENGTH(Code) <> 6 THEN
        RETURN FALSE
    ENDIF
    FOR Index ← 1 TO 6
        Ch ← MID(Code, Index, 1)
        IF Index <= 2 THEN
            IF Ch < "A" OR Ch > "Z" THEN
                RETURN FALSE
            ENDIF
        ELSE
            IF Ch < "0" OR Ch > "9" THEN
                RETURN FALSE
            ENDIF
        ENDIF
    NEXT Index
    RETURN TRUE
ENDFUNCTION

בדיקת האורך מגיעה קודם, כך ש-MID לעולם לא יתבקש על מיקום שלא קיים. תוקף כזה מחזיר a BOOLEAN כדי שהקורא יכול לכתוב IF IsValid(Entry) THEN ... ELSE OUTPUT "Invalid code" ENDIF: הודעה למשתמש מוצגת על ידי הקורא, לא על ידי הפונקציה — פונקציה מחשבת, procedure פועל.

דוגמה פתורה. כתוב פונקציה IsPalindrome(Word : STRING) שמחזירה TRUE כאשר Word נקרא אותו דבר הפוך, כמו "RACECAR".

השווה את האותיות מהשניים קצוות, זז פנימה: מיקום Index מצמד עם מיקום Len - Index + 1, ורק החצי הראשון צריך לבדיקה.

FUNCTION IsPalindrome(BYVAL Word : STRING) RETURNS BOOLEAN
    DECLARE Len, Index : INTEGER
    Len ← LENGTH(Word)
    FOR Index ← 1 TO Len DIV 2
        IF MID(Word, Index, 1) <> MID(Word, Len - Index + 1, 1) THEN
            RETURN FALSE
        ENDIF
    NEXT Index
    RETURN TRUE
ENDFUNCTION

אותם שלושה כלים — a FOR על המיקומים, MID(s, i, 1) לקרוא אות אחת, ו-& לבנות מחרוזת חדשה — עונים על רוב מודולי המחרוזות בPaper 2: ספירה כמה פעמים אות מופיעה (IF MID(s, i, 1) = Ch THEN Count ← Count + 1), החלפת כל instance של אות (הוסף או NewChar או האות המקורי ל-NewString בכל מיקום), הסתרת הכל למעט ארבעת הספרות האחרונות של מספר כרטיס (הוסף '*' לכל מיקום עד Len - 4), או כתיבה שלך own MID() על ידי חיבור האותיות מ-Start ל-Start + Length - 1. בקשה MID על מיקום מעבר לסוף המחרוזת היא run-time error, לכן בדוק LENGTH קודם.

קובצים. ערכים במשתנים נעלמים כאשר התוכנית נגמרת, לכן module שצריך לשמור נתונים לריצה הבאה כותב them to a file: OPENFILE "scores.txt" FOR WRITE, one WRITEFILE "scores.txt", NUM_TO_STR(Score[Index]) per line inside the loop, and CLOSEFILE "scores.txt" פעם אחת, אחרי הלולאה; קריאה back משתמש ב-FOR READ, READFILE ו-WHILE NOT EOF("scores.txt"). Topic 10 יש את הקובץ section; כאן הנקודות הם לפתיחה in the right mode, the read or write inside the loop, ו-sleeping once after it.

שלושה מאפיינים שהופכים פסאודוקוד קל יותר להבנה — התשובה לשאלה "cite three features" — הם מזהים משמעותיים (Total, לא t), התאבקות של ההצהרות בתוך כל construct, ו-הערות (// ...) שמסבירות את המטרה; מילות מפתח באותיות גדולות, statement אחת בכל שורה ורווחים בין sections also are accepted. פסאודוקוד יעיל הולך further:

• הזז אי-שינויים מחוץ למחלקות — אם ערך (אי-שינוי) אינו משתנה עם מדד המחלקה, חשב אותו פעם אחת לפני תחילת המחלקה.
• צא ממחלקה מוקדם כשהתשובה נמצאת (עצור חיפוש ליניארי ברגע שהמטרה מופיעה).
• הימנע מעבודה מיותרת — אחסן תוצאה והשתמש בה שוב במקום לחשב מחדש.
• בחר במבנת נתונים מתאימה — מערך טוב יותר מרבים של משתנים נפרדים כאשר הפריטים קשורים זה לזה.
• החלף IF מקוננים בעומק ב-CASE כאשר בודקים ערך אחד מול רבים.
• הער את הכוונה, לא את המנגנון (// validate the postcode, לא // loop 6 times).
• השתמש בשמות משמעותיים (numberOfPupils, לא n) והתחל משתנים לפני השימוש.

שלושה סוגי שגיאות, כל אחד נמצא באופן שונה:

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

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

• להבין הבדלים בין פרוצ'ורה (ללא ערך החזרה) לבין פונקציה (מחזירה ערך); לשלוט בהעברת ערך לעומת העברת כיוונית.
• לבחור את הלולאה המתאימה: לולאת נגד (FOR) כאשר מספר החזרות ידוע, לולאת תנאי (WHILE/REPEAT) במקרים אחרים.
• להבין הבדלים בין משתנים מקומיים לגלובליים ותחום תוקף; להעדיף משתנים מקומיים במודולים הניתנים לשימוש חוזר.
• להשתמש בשמות פונקציות ומסדר פרמטרים מדויקים. VAL וSTR הם שמות IGCSE ואינם מניחים נקודות; UCASE וLCASE הן פונקציות אמיתיות 9618 ממדריך הפסאודוקוד אך פועלות על תווית אחת, ולכן במבחן 2 מחרוזת טקסט שלמה דורשת TO_UPPER או TO_LOWER.
• בתשובה "כתיבת פסאודוקוד" יש לכתוב את הראשית, ההצהרות, הלולאה, התנאי, העדכון והRETURN – כל אחד מהם זוכה בנקודה: יש לכתוב את כל ששת החלקים, גם אם חלק אחד הוא חסר.

טעויות נפוצות

• קריאת פונקציה ולא שימוש בערך שהוחזר. יש להקליד את התוצאה, להשתמש בה בביטוי או בפלט: Sorted ← BubbleSort(MyArray, 7).
• העברת אורך של 1: 6 למערך בעל שבעה אלמנטים, או האינדקס האחרון שבו האורך נדרש. יש להחליט האם הפרמטר הוא אורך או אינדקס, ולבדוק שהאלמנט האחרון ייבקר.
• סגירת קובץ בתוך מחזור הקורא אותו. לפתוח פעם אחת, לסגור פעם אחת, לאחר המחזור.
• שימוש בשקלט יש作为 שם קובץ. הוספת ההרחבה שהשאלה נתנה: FileName ← Choice & ".txt".
• השארת מבנים פתוחים. כל IF זקוק ל-ENDIF, כל FOR ל-NEXT, כל WHILE ל-ENDWHILE, וכל פונקציה ל-RETURN; לקטע זה תעודת ציון.
• גבולות שגויים: > עבור "לפחות" (שהוא >=), או מתייחס ל-FOR שמתחיל ב-0 למערך המוגדר כ-[1:50].
• נגדן או סכום שאינם מוגדרים ל-0 לפני תחילת המחזור.
• בטבלת עקבות, חידוש כל משתנה בכל שורה, או שינוי ערך לפני שההצהרה המשנה אותו רצה.
• חצי מתנאי: IF x = 3 OR 4 — כל צד של OR ו-AND חייב להיות השוואה מלאה. וה-+ אינו מחבר מחרוזות; ה-& כן.
• הכרזה כמשתנה מקומי של ערך שצריך להישמר בין קריאות. סכום מצטבר או מחרוזת שנבנית לאורך מספר קריאות היא גלובלית או BYREF.