דלג לתוכן
נושאים
  • 1 סגנון ותצורה
    1.1

    מילות מפתח וקפסלינג (Case)

    伪代码 (Pseudocode) היא השפה בה Cambridge כותבת אלגוריתמים. היא מתארת אלגוריתמים ללא צורך בשפת תכנות כללית. אתר זה מעבד תת-קבוצה מוגדרת בסגנון Cambridge כך שתוכל להריץ דוגמאות; תשובה במבחן צריכה לעקוב אחר הסימון הנקוב עבור המבחן ההוא.

    כל מילת מפתח נכתבת באותיות גדולות: IF, REPEAT, PROCEDURE, OUTPUT.

    DECLARE Count : INTEGER
    Count ← 3
    IF Count > 0
      THEN
        OUTPUT "Ready"
    ENDIF
    
    • כתוב IF, לעולם לא if או If.
    • מילת מפתח לעולם לא יכולה לשמש שם משלך: אין לך לקרוא למשתנה FOR.

    שגיאות נפוצות

    • מילות מפתח באותיות קטנות. תוכנית הניקוד מצפה לאותיות גדולות.
    • המצאת מילות מפתח. רק המילים בסיכום חומר זה מופיעות בתוכנית הלימודים.
    1.2

    זיהויים (Identifiers)

    זיהוי הוא השם שמעניקים למשתנה, לקבוע, לפרוצדורה או לפונקציה.

    DECLARE NumberOfPlayers : INTEGER
    NumberOfPlayers ← 4
    OUTPUT NumberOfPlayers
    

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

    • הוא חייב להתחיל באות גדולה: Count, לא count.
    • הוא יכול להכיל רק אותיות ומספרים — אין רוחב, אין סימני פיסוק.
    • אינו תלוי באותיות גדולות וקטנות, ולכן Count וCOUNT הם אותו שם. בחר one spelling and keep it.
    • גרם לו להיות בעל משמעות. NumberOfPlayers זוכה לתשומת לב הקורא; N לא.

    שגיאות נפוצות

    • count ← 0 — התחלה באות קטנה. 0478 דורשת אות גדולה.
    • Number of players — רוחבות אינן מותרות בתוך שם.
    1.3

    הערות ותחביט (Comments and Indentation)

    הערה מתחילה עם // ונמשכת עד לסוף השורה. היא מיועדת לאדם קורא; האלגוריתם מתעלם ממנו.

    // Swap the values of X and Y
    DECLARE X, Y, Temp : INTEGER
    X ← 1
    Y ← 2
    Temp ← X   // temporarily store X
    X ← Y
    Y ← Temp
    OUTPUT X, " ", Y
    

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

    DECLARE X, Y : INTEGER
    X ← 7
    Y ← 3
    IF X > Y
      THEN
        OUTPUT "X is bigger"
      ELSE
        OUTPUT "Y is bigger or equal"
    ENDIF
    
    • THEN ו-ELSE מוזזים שניים רוחבים מה-IF שלהם.
    • הפקודות מתחת להן מוזזות ארבעה רוחבים.
    • ENDIF מיושר תחת ה-IF שלו.
    בלוק IF-THEN-ELSE עם פסי ריבוד מוצלעים: IF וENDIF בשוליים, THEN ו ELSE בשני רווחים, כל OUTPUT בארבעה רווחים
    ספירת הרווחים: 0, 2, 4

    שגיאות נפוצות

    • חתימת THEN בשורת ה-IF. זהו סגנון A-Level 9618 — ראה נושא 11.
    • ללא הזזה כלל. המדריך חייב לראות את המבנה כדי לתת נקודות על המבנה.
  • 2 משתנים, קבועים וסוגים
    2.1

    חמישה סוגי נתונים

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

    סוג אחסון דוגמה
    INTEGER מספר שלם 42, -7
    REAL מספר שיכול להיות עם חלק שברי 3.14, -0.5
    CHAR תווית בודדת 'A'
    STRING רצף של תוויות "Hello"
    BOOLEAN TRUE או FALSE TRUE
    DECLARE Age : INTEGER
    DECLARE Price : REAL
    DECLARE Grade : CHAR
    DECLARE Name : STRING
    DECLARE Passed : BOOLEAN
    Age ← 17
    Price ← 2.50
    Grade ← 'A'
    Name ← "Mei"
    Passed ← TRUE
    OUTPUT Name, " is ", Age, " and passed: ", Passed
    
    • STRING כתוב בתוך תנווי כפולים, ו-CHAR בתוך תנווי יחידים.
    • TRUE ו-FALSE הם מילות מפתח, ולכן נכתבות באותיות גדולות וללא תנוויים.

    שגיאות נפוצות

    • כתיבת FLOAT, DOUBLE או BOOL. אלו שפות אמיתיות, ולא הסיילבוס הזה.
    • 'Hello' למחרוזת — תנווי יחידים מחזיקים רק תווית אחת.
    חמישה סוגי נתונים: INTEGER, REAL, CHAR, STRING ו BOOLEAN
    חמישה סוגי נתונים: INTEGER, REAL, CHAR, STRING ו BOOLEAN
    2.2

    DECLARE

    DECLARE מציין משתנה ומקבע את סוגו לפני השימוש בו.

    DECLARE <identifier> : <data type>
    
    DECLARE Counter : INTEGER
    DECLARE TotalToPay : REAL
    Counter ← 1
    TotalToPay ← 19.99
    OUTPUT "Item ", Counter, " costs ", TotalToPay
    

    מספר שמות מאותו סוג נכתבים בשורה אחת, מופרדים בפסיקים:

    DECLARE RoomLength, Width, Area : INTEGER
    RoomLength ← 6
    Width ← 4
    Area ← RoomLength * Width
    OUTPUT "Area = ", Area
    
    • הצהיר משתנה לפני שימושו הראשון, בקצה העליון של האלגוריתם.
    • למשתנה יש סוג קבוע לאורך כל האלגוריתם — INTEGER לעולם אינו מכיל "Mei".

    שגיאות נפוצות

    • השמטת הנקודתיים: DECLARE Counter INTEGER.
    • שימוש במשתנה שלא הוכרז מעולם. בבחינה מצופים ההצהרה.
    DECLARE מגדיר משתנה ומגדיר את סוג הערך שהוא יכול להכיל
    DECLARE מגדיר משתנה ומגדיר את סוג הערך שהוא יכול להכיל
    2.3

    קבוע

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

    CONSTANT <identifier> ← <value>
    
    CONSTANT TaxRate ← 0.20
    DECLARE Price, Tax : REAL
    Price ← 50.00
    Tax ← Price * TaxRate
    OUTPUT "Tax to pay: ", Tax
    
    • ב-0478 משתמשים בחץ, בדיוק כמו בהצבה.
    • הערך חייב להיות ליטרלי — מספר, מחרוזת, TRUE — לעולם לא חישוב ולעולם לא משתנה אחר.
    • לקבוע לעולם לא ניתן להעניק ערך חדש לאחר מכן. זוהי המהות שלו.

    שגיאות נפוצות

    • CONSTANT TaxRate = 0.20. צורת ה-= היא הכתיב המקובל ב-A-Level 9618 — ראו נושא 11.
    • הצבה לקבוע באזור מאוחר יותר באלגוריתם.
  • 3 הקצה, כניסה ויציאה
    3.1

    חץ ההצבה

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

    <identifier> ← <value>
    
    DECLARE Counter : INTEGER
    Counter ← 0
    Counter ← Counter + 1
    Counter ← Counter + 1
    OUTPUT Counter
    

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

    שלושה קווי השבה ליד תיבת Counter: 0 נשמר, אחר כך 0 + 1 מחושב ו1 נשמר, אחר כך 1 + 1 מחושב ו2 נשמר *הצד הימני תחילה, אחר כך שמירה לתוך התיבה

    • אם אינך יכול להקליד ←, כתוב <-. שניהם מתקבלים, כאן ובמבחן.
    • הצד השמאלי חייב להיות מזהה יחיד או אלמנט בודד במערך. לעולם לא חישוב.

    שגיאות נפוצות

    • Counter = 0. בפסדוקוד = הוא השוואה, ולא הקצה — והוא עלול לבלבל את שני האלמנטים; זהו הטעות הסינטקטית הנפוצה ביותר במבחן זה.
    • Counter + 1 ← Counter. החץ מצביע על הדבר שנשתנה.
    3.2

    קלט ופלט

    INPUT קורא ערך מהמשתמש לתוך משתנה. OUTPUT מציג ערך אחד או יותר.

    DECLARE Name : STRING
    DECLARE Age : INTEGER
    INPUT Name
    INPUT Age
    OUTPUT "Hello ", Name
    OUTPUT "Next year you will be ", Age + 1
    
    • INPUT לוקח בדיוק משתנה אחד, ומשתנה זה חייב להיות כבר מוגדר.
    • OUTPUT לוקח מספר כלשהר של פריטים המופרדים ב-פסיקים; הם מודפעים אחד אחרי השני ללא דבר ביניהם.
    • רצף תווים ליטרלי בתוך OUTPUT נכתב בתוך סימני ציטוט כפולים; למשתנה אין.

    הפעלת משתמש

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

    DECLARE Radius : REAL
    OUTPUT "Enter the radius: "
    INPUT Radius
    OUTPUT "The diameter is ", Radius * 2
    

    שלושה פקודות רצות מלמעלה למטה, OUTPUT מציג הנחיה, INPUT מקבל שם, OUTPUT מציג ברכה, לצד המסך שנוצר *ההנחיה מופיעה תחילה, אחר כך התשובה שנכתבה, אחר כך התגובה

    שגיאות נפוצות

    • INPUT "Enter a number", X — ההודעה היא הודעת OUTPUT נפרדת.
    • OUTPUT "Total: " + Total. 0478 מחבר פריטי פלט בפסיק; + הוא ביטוי אריתמטי ו & שייך ל-A-Level 9618 (נושא 11).
    • שכחת סימני ציטוט: OUTPUT Hello מחפש משתנה בשם Hello.
  • 4 אריתמטיקה ולוגיקה
    4.1

    מפעילים אריתמטיים

    חמישה פעולות אריתמטיות; העדיפות שלהן מצוינת למטה בטבלה.

    פעולה משמעות A הוא 7, B הוא 2
    + הוספה A + B הוא 9
    - חיסור A - B הוא 5
    * כפל A * B הוא 14
    / חלוקה A / B הוא 3.5
    ^ העלאה לחזקה A ^ B הוא 49
    DECLARE A, B : INTEGER
    A ← 7
    B ← 2
    OUTPUT "Sum: ", A + B
    OUTPUT "Product: ", A * B
    OUTPUT "Quotient: ", A / B
    OUTPUT "Power: ", A ^ B
    

    סוגרי קובייה באים ראשונים, אחר כך ^, אחר כך * ו/, אחר כך + ו- — עדיפויות רגילות . השתמש בסוגרי קובייה כל פעם שהקורא יצטרך לעצור ולחשוב.

    DECLARE Total : REAL
    Total ← (12 + 18) / 2
    OUTPUT "Mean: ", Total
    

    שגיאות נפוצות

    • צפוי ש/ ייתן מספר שלם. 7 / 2 הוא 3.5, לא 3; עבור מספר שלם השתמש ב- DIV.
    • כתיבת A x B או A ÷ B. השתמש ב* וב-/.
    4.2

    DIV ו-MOD

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

    • DIV(a, b) — כמה פעמים b נכנס לa במספר שלם, ה-מנה.
    • MOD(a, b) — מה נשאר, ה-שארית.
    OUTPUT DIV(10, 3)
    OUTPUT MOD(10, 3)
    OUTPUT DIV(17, 5)
    OUTPUT MOD(17, 5)
    

    שתי הפונקציות מקבלות שלמים וחוזרות על שלם.

    17 מחולק לקבוצות של 5: DIV נותן את 3 הקבוצות השלמות, MOD את 2 שנותרו
    17 מחולק לקבוצות של 5: DIV נותן את 3 הקבוצות השלמות, MOD את 2 שנותרו

    למה הן מיועדות

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

    DECLARE Number : INTEGER
    Number ← 12
    IF MOD(Number, 2) = 0
      THEN
        OUTPUT Number, " is even"
      ELSE
        OUTPUT Number, " is odd"
    ENDIF
    

    DIV ממיר סך כולל ליחידות שלמות — שניות לדקות, פנסים ללירות:

    DECLARE Seconds : INTEGER
    Seconds ← 200
    OUTPUT DIV(Seconds, 60), " minutes and ", MOD(Seconds, 60), " seconds"
    

    שגיאות נפוצות

    • 10 MOD 3. זהו הצורה של A-Level 9618; 0478 משתמש בצורת הפונקציה MOD(10, 3).
    • ערבוב השניים. DIV נותן את החלק השלם; MOD נותן את מה שלא התאים.
    4.3

    מופעי יחס ולוגיים

    מופע יחסי משווה שני ערכים ומייצר TRUE או FALSE.

    מופע משמעות
    = שווה ל-
    <> אינו שווה ל-
    > גדול מ-
    < קטן מ-
    >= גדול או שווה ל-
    <= קטן או שווה ל-
    DECLARE Mark : INTEGER
    Mark ← 55
    OUTPUT "Pass: ", Mark >= 50
    OUTPUT "Perfect: ", Mark = 100
    OUTPUT "Not zero: ", Mark <> 0
    

    שלושת מופעי הלוגיקה מחברים תנאים:

    • AND — צריך ששני הצדדים יהיו TRUE.
    • OR — צריך שאחד לפחות מהצדדים יהיה TRUE.
    • NOT — הופך TRUE לFALSE ולהפך.
    DECLARE Age : INTEGER
    DECLARE HasTicket : BOOLEAN
    Age ← 16
    HasTicket ← TRUE
    IF Age >= 15 AND HasTicket = TRUE
      THEN
        OUTPUT "Admitted"
    ENDIF
    IF NOT (Age > 18)
      THEN
        OUTPUT "Still a student rate"
    ENDIF
    

    שגיאות נפוצות

    • <> הוא כאן סימן אי-שוויון — ולא !=, שמיועד לשפות אחרות.
    • IF Age >= 15 AND <= 18. לכל צד של AND יש צורך בהשוואה מלאה משלו: Age >= 15 AND Age <= 18.
    • כינוי זה בפתרון כ-מופעי השוואה. המונח בתוכנית לימודים הוא יחסי.
    AND דורש שהשני בדיקות TRUE: גיל 14 עובר את השניים, גיל 10 כושל את הראשונה
    AND דורש שהשני בדיקות TRUE: גיל 14 עובר את השניים, גיל 10 כושל את הראשונה
  • 5 פעולות על מחרוזות
    5.1

    אורך, UCASE ו-LCASE

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

    LENGTH(<identifier>) מחזיר כמה תווים מחרוזת אחת מכילה — כולל רווחים.

    OUTPUT LENGTH("Happy Days")
    OUTPUT LENGTH("")
    

    UCASE(<identifier>) מחזיר את המחרוזת באותיות גדולות, LCASE(<identifier>) באותיות קטנות אף אחד מהם אינו משנה את המקורי — כל אחד מהם מחזיר ערך חדש.

    DECLARE Name : STRING
    Name ← "Happy"
    OUTPUT UCASE(Name)
    OUTPUT LCASE(Name)
    OUTPUT Name
    

    השורה האחרונה עדיין מדפיסה Happy: כדי לשמור על השינוי חובה להחזיר אותו לאחסון.

    DECLARE Name : STRING
    Name ← "Happy"
    Name ← UCASE(Name)
    OUTPUT Name
    

    השוואה ללא דאגה לגבי סוג האותיות

    UCASE בשני הצדדים היא הדרך הסטנדרטית לקבלת תשובה בכל סגנון הכתיבה:

    DECLARE Answer : STRING
    Answer ← "yes"
    IF UCASE(Answer) = "YES"
      THEN
        OUTPUT "Accepted"
    ENDIF
    

    שגיאות נפוצות

    • לצפות שUCASE(Name) ישנה את Name. החזיר את התוצאה לאחסון.
    • LENGTH סופר תווים, לא מילים. LENGTH("Happy Days") הוא 10.
    5.2

    SUBSTRING

    SUBSTRING(<identifier>, <start>, <length>) שואב חלק ממחרוזת — החל מ- מיקום start, לוקח length תווים.

    OUTPUT SUBSTRING("Happy Days", 1, 5)
    OUTPUT SUBSTRING("Happy Days", 7, 4)
    

    ⚠️ הספירה מתחילה ב-1, לא ב-0. התוו הראשון של "Happy Days" נמצא במיקום 1.

    מיקוד האותיות מתחיל מ1: SUBSTRING("Computer", 1, 4) נותן "Comp"
    מיקוד האותיות מתחיל מ1: SUBSTRING("Computer", 1, 4) נותן "Comp"

    לקיחת תוו אחד, והשאר

    DECLARE Word : STRING
    Word ← "Computer"
    OUTPUT "First letter: ", SUBSTRING(Word, 1, 1)
    OUTPUT "Last letter: ", SUBSTRING(Word, LENGTH(Word), 1)
    OUTPUT "Without the first: ", SUBSTRING(Word, 2, LENGTH(Word) - 1)
    

    LENGTH בתוך SUBSTRING הוא מה שמאפשר לשתי השורות האחרונות לעבוד עם מילת גודל כלשהו — קידוד קשיב (hard-coding) של 8 ישבור את הדבר ברגע שהמילה תשתנה.

    קריאת מחרוזת תוו אחר תוו

    DECLARE Word : STRING
    DECLARE Index : INTEGER
    Word ← "Cat"
    FOR Index ← 1 TO LENGTH(Word)
        OUTPUT SUBSTRING(Word, Index, 1)
    NEXT Index
    

    שגיאות נפוצות

    • החל מ-0. מיקום 1 הוא התוו הראשון.
    • קריאה של הארגומנט השלישי כ-מיקום סיום. זהו ספירה — SUBSTRING(W, 2, 3) לוקח שלושה תווים החל מהשני.
    • בקשה לתווים יותר ממה שהמחרוזת מכילה.
  • 6 בחירה
    6.1

    IF, THEN, ELSE, ENDIF

    בחירה מפעילה אחת מקבוצות ההוראות או אחרת, בהתאם לתנאי.

    IF <condition>
      THEN
        <statements>
    ENDIF
    
    DECLARE Mark : INTEGER
    Mark ← 72
    IF Mark >= 50
      THEN
        OUTPUT "Pass"
    ENDIF
    

    הוסף ELSE למקרה השני. בדיוק ערוץ אחד מתוך שניים יופעל — לעולם לא שניהם, לעולם לא אף אחד. המבנה הוא החלק שבו תלמידים מאבדים ציונים, ולכן לימוד אותו כצורה:

    DECLARE Mark : INTEGER
    Mark ← 41
    IF Mark >= 50
      THEN
        OUTPUT "Pass"
      ELSE
        OUTPUT "Fail"
    ENDIF
    

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

    • IF ותנאיו בשורה אחת, אין דבר אחר לאחר התנאי.
    • THEN ו-ELSE בשורות עצמאיות, מוזזות שתי מקומות תוכן.
    • ההצהירות מוזזות ארבע רמות תוךית.
    • ENDIF חוזר לעמוד של ה-IF שלו.
    IF בוחר אחד משני מסלולים; שניהם מתאחדים ב-ENDIF
    IF בוחר אחד משני מסלולים; שניהם מתאחדים ב-ENDIF

    היקפיה

    IF בתוך IF מטפל ביותר משני תוצאות. לכל אחת מהן נדרש ENDIF משלו.

    DECLARE Mark : INTEGER
    Mark ← 85
    IF Mark >= 80
      THEN
        OUTPUT "Distinction"
      ELSE
        IF Mark >= 50
          THEN
            OUTPUT "Pass"
          ELSE
            OUTPUT "Fail"
        ENDIF
    ENDIF
    

    שגיאות נפוצות

    • שכחת ENDIF. כל IF נסגר, והעדר אחד מהם הוא טעות סינטקסית שה סמן יזהה במבט מהיר.
    • IF Mark >= 50 THEN OUTPUT "Pass" בשורה אחת. אין צורה כזו קיימת באף אחד המסלולים; יש לכתוב את השלוש שורות.
    • IF Mark = 50 THEN כתיבה כ-IF Mark ← 50. החץ מבצע הערכה; = מבצע השוואה.
    6.2

    CASE OF

    כשמשתנה בודק ערכים יחידים רבים, CASE OF מקבל זאת הרבה יותר ברור מאשר ערימה של IF מוקפפים זה על זה.

    CASE OF <identifier>
        <value 1> : <statement>
        <value 2> : <statement>
        OTHERWISE <statement>
    ENDCASE
    
    DECLARE Choice : INTEGER
    Choice ← 2
    CASE OF Choice
        1 : OUTPUT "You chose north"
        2 : OUTPUT "You chose south"
        3 : OUTPUT "You chose east"
        4 : OUTPUT "You chose west"
        OTHERWISE OUTPUT "That is not a direction"
    ENDCASE
    
    • כל ענף הוא ערך, נקודה-פסיקה, ולאחריו הפעולה לבצע.
    • OTHERWISE תופס הכל שהערכים הנרדפים פספסו. הוא אופציונלי, וכתיבת אחד היא שיטה טובה — זה מה שקורה כשהמשתמש מקליד דבר לא צפוי.
    • הענף המתאים הראשון מתבצע, ושארם מוטרדים.
    CASE משווה את הערך לכל אפשרות בתור; Grade = 2 תואם לשנייה
    CASE משווה את הערך עם כל אפשרות בתור; Grade = 2 תואם את השני

    טווח, ואות

    DECLARE Grade : CHAR
    Grade ← 'B'
    CASE OF Grade
        'A' : OUTPUT "Excellent"
        'B' : OUTPUT "Good"
        'C' : OUTPUT "Satisfactory"
        OTHERWISE OUTPUT "Unclassified"
    ENDCASE
    

    שגיאות נפוצות

    • שימוש ב-CASE OF עבור תנאי. הוא בודק משתנה אחד נגד ערכים; Mark >= 50 זקוק ל-IF.
    • שכחת ENDCASE.
    • שמיטת OTHERWISE ולאחר מכן התהות מדוע ערך בלתי צפוי אינו עושה כלום.
  • 7 איטרציה
    7.1

    FOR, לולאת הספירה

    איטרציה חוזרת על פקודות. השתמש בלולאת FOR כאשר ידוע לך לפני שמתחילים כמה פעמים — לולאת המבוקלת-ספירה.

    FOR <identifier> ← <value1> TO <value2>
        <statements>
    NEXT <identifier>
    
    DECLARE Index : INTEGER
    FOR Index ← 1 TO 5
        OUTPUT "Line ", Index
    NEXT Index
    

    המונה מתחיל בערך הראשון, והלולאה פועלת פעם אחת עבור כל ערך עד ול-כולל הערך השני. 1 TO 5 רץ חמש פעמים.

    FOR Count ← 1 TO 4 מבצע ארבע מעברים, וכל 1 ו-4 נכללים *FOR Count ← 1 TO 4 מבצע ארבע מעברים, וכל 1 ו-4 נכללים

    STEP (צעד)

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

    DECLARE Index : INTEGER
    FOR Index ← 2 TO 10 STEP 2
        OUTPUT Index
    NEXT Index
    FOR Index ← 3 TO 1 STEP -1
        OUTPUT "Countdown ", Index
    NEXT Index
    

    סכומים מצטברים

    השימוש הנפוץ ביותר: משתנה מחוץ ללולאה אליו הלולאה מחברת.

    DECLARE Index, Total : INTEGER
    Total ← 0
    FOR Index ← 1 TO 10
        Total ← Total + Index
    NEXT Index
    OUTPUT "Sum of 1 to 10 is ", Total
    

    Total ← 0 חייב להימצא לפני הלולאה. בתוכה הוא יאפס בכל מעבר.

    שגיאות נפוצות

    • NEXT naming the wrong counter. Nested loops must close in the reverse order they כלומר לולאת ה-NEXT הפנימית נסגרת תחילה.
    • הנחה ש-1 TO 5 רץ ארבע פעמים. שני הקצוות כלולים.
    • שינוי המונה בתוך הלולאה. תן ל-FOR להיות האחראי עליו.
    7.2

    WHILE, לולאת תנאי מקדים

    לולאת WHILE בודקת לפני כל מעבר, ולכן יכולה לרוץ אפס פעמים. השתמש בה כאשר מספר ההשניות תלוי בדבר מה שקורה בזמן ביצוע הלולאה.

    WHILE <condition> DO
        <statements>
    ENDWHILE
    
    DECLARE Total : INTEGER
    Total ← 1
    WHILE Total < 100 DO
        Total ← Total * 2
    ENDWHILE
    OUTPUT "First power of two past 100: ", Total
    

    דבר כלשהו בתוך הלולאה חייב לגרום לבסוף לכך שהתנאי יהפוך לשלילי, אחרת הלולאה לעולם לא תסתיים. — לולאת אינסופית.

    DECLARE Count : INTEGER
    Count ← 5
    WHILE Count > 0 DO
        OUTPUT Count
        Count ← Count - 1
    ENDWHILE
    OUTPUT "Lift off"
    

    שגיאות נפוצות

    • שוכחים לשנות את המשתנה עליו הבדיקה בודקת, מה שמוביל ללולאה אינסופית.
    • משאירים מחוץ DO או ENDWHILE.
    • שימוש בWHILE כאשר ספירת ידועה. FOR מבטא את מה שאתה מתכוון באופן מדויק בשורה אחת.
    7.3

    REPEAT, לולאת תנאי סיום

    לולאת REPEAT בודקת אחרי כל עוברת, ולכן היא תמיד רצה לפחות פעם אחת.

    REPEAT
        <statements>
    UNTIL <condition>
    

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

    DECLARE Number : INTEGER
    Number ← 0
    REPEAT
        Number ← Number + 25
        OUTPUT "Trying ", Number
    UNTIL Number >= 100
    OUTPUT "Reached ", Number
    

    ️ UNTIL מגדיר את התנאי שמעוצר את הלולאה; WHILE מגדיר את זה שמ משאיר אותה פועלת. הם הפוכים זה לזה, והחלפתם היא השגיאה הקלאסית.

    בדיקה רצה לפחות פעם? משמעות התנאי
    FOR מונה לא (טווח ריק רץ אפס פעמים) —
    WHILE לפני לא המשך לפעול כל עוד זה נכון
    REPEAT אחרי כן עצור כאשר זה הופך לנכון

    שגיאות נפוצות

    • כותבים UNTIL Number < 100 כשמתכוונים ל-UNTIL Number >= 100.
    • משתמשים ב-REPEAT כשהגוף חייב להיות יכול לרצוע אפס פעמים.
    • שוכחים שה-UNTIL מסיים את המבנה — אין ENDREPEAT.

    WHILE בודק תחילה ועשוי להתבצע אפס פעמים; REPEAT בודק בסוף ומתבצע לפחות פעם אחת *WHILE בודק תחילה ועשוי להתבצע אפס פעמים; REPEAT בודק בסוף ומתבצע לפחות פעם אחת

  • 8 מערכים
    8.1

    מערכים חד-ממדיים

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

    DECLARE <identifier> : ARRAY[<lower>:<upper>] OF <data type>
    
    DECLARE Names : ARRAY[1:3] OF STRING
    Names[1] ← "Mei"
    Names[2] ← "Sam"
    Names[3] ← "Ana"
    OUTPUT Names[2]
    
    • הגבולות נכתבים lower:upper, ו-שניהם כלולים — [1:3] יש שלושה מרכיבים.
    • מערכים של Cambridge מתחילים ב-1, לא ב-0.
    • לכל מרכיב יש אותו סוג, המוגדר על ידי OF.

    מערך דו-ממדי 1: שם אחד, ערכים רבים, כל אחד נמצא באמצעות אינדקס *מערך דו-ממדי 1: שם אחד, ערכים רבים, כל אחד נמצא באמצעות אינדקס

    מילוי וקריאה באמצעות לולאת FOR

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

    DECLARE Scores : ARRAY[1:5] OF INTEGER
    DECLARE Index, Total : INTEGER
    FOR Index ← 1 TO 5
        Scores[Index] ← Index * 10
    NEXT Index
    Total ← 0
    FOR Index ← 1 TO 5
        Total ← Total + Scores[Index]
    NEXT Index
    OUTPUT "Total: ", Total
    OUTPUT "Mean: ", Total / 5
    

    מציאת הערך הגדול ביותר

    DECLARE Scores : ARRAY[1:5] OF INTEGER
    DECLARE Index, Largest : INTEGER
    Scores[1] ← 42
    Scores[2] ← 17
    Scores[3] ← 93
    Scores[4] ← 8
    Scores[5] ← 55
    Largest ← Scores[1]
    FOR Index ← 2 TO 5
        IF Scores[Index] > Largest
          THEN
            Largest ← Scores[Index]
        ENDIF
    NEXT Index
    OUTPUT "Largest: ", Largest
    

    התחל Largest מהמרכיב הראשון, לעולם לא מ-0—עם נתונים שליליים, 0 ינצח וה התשובה תהיה שגויה.

    שגיאות נפוצות

    • קריאת Scores[6] ממערך שהוכרז כ-[1:5]. זה מחוץ לגבולות האישורים.
    • כתיבת Scores(3). מערכים משתמשים בסוגריים מרובעים; סוגריים עגולים קוראים לפונקציה.
    • הכרזה של [1:5] ולאחר מכן לולאה 0 TO 4.
    8.2

    מערכים דו-ממדיים

    מערך בעל ממד 2 הוא טבלה: שורות ועמודות, שני אינדקסים.

    DECLARE <identifier> : ARRAY[<lower1>:<upper1>, <lower2>:<upper2>] OF <data type>
    
    DECLARE Grid : ARRAY[1:2, 1:3] OF INTEGER
    Grid[1,1] ← 1
    Grid[1,2] ← 2
    Grid[1,3] ← 3
    Grid[2,1] ← 4
    Grid[2,2] ← 5
    Grid[2,3] ← 6
    OUTPUT Grid[2,3]
    

    האינדקסהראשון הוא השורה, והשני הוא העמודה.

    מערך דו-ממדי 2 הוא טבלה: G[1, 2] היא שורה 1, עמודה 2 *מערך דו-ממדי 2 הוא טבלה: G[1, 2] היא שורה 1, עמודה 2

    לולאות פנימיות מסיירות בטבלה

    לולאה אחת לממד. הלולאה הפנימה גומרת שורה שלמה לפני שהחוץ ממשיכה.

    DECLARE Grid : ARRAY[1:2, 1:3] OF INTEGER
    DECLARE Row, Col : INTEGER
    FOR Row ← 1 TO 2
        FOR Col ← 1 TO 3
            Grid[Row, Col] ← Row * Col
        NEXT Col
    NEXT Row
    FOR Row ← 1 TO 2
        FOR Col ← 1 TO 3
            OUTPUT "Grid[", Row, ",", Col, "] = ", Grid[Row, Col]
        NEXT Col
    NEXT Row
    

    ⚠️ הלולאה הפנימה NEXT סוגרת את הסופרהפנימי. NEXT Row לפני NEXT Col חוצה את הלולאות ומפיק תוצאה אנונית — סימן מזהה זאת במיידי.

    שגיאות נפוצות

    • החלפת שורה ועמודה. Grid[2,3] היא שורה 2, עמודה 3.
    • Grid[Row][Col]. Cambridge כותבת זוג אחד של סוגריים עם פסיק בתוך.
    • חריגה מעבר ל NEXT, כפי שצוין לעיל.
  • 9 פרוצדורות ופונקציות
    9.1

    הליך וקריאה

    הליך הוא בלוק ממונה של פקודות. כתיבתם פעם אחת וקריאתם מ- במספר מקומות יש פירוק — הרעיון שהכל של נייר 2 נשען עליו.

    PROCEDURE <identifier>
        <statements>
    ENDPROCEDURE
    

    הליך נקרא לפי שמו, באמצעות המילה CALL:

    PROCEDURE DefaultLine
        OUTPUT "------------------------------"
    ENDPROCEDURE
    
    CALL DefaultLine
    OUTPUT "Report"
    CALL DefaultLine
    
    • ההגדרה אינה עושה דבר בעצמה. רק CALL מפעיל אותה.
    • הבקרה חוזרת לקו שמ לאחר ה CALL כאשר ההליך מסתיים.
    • ההליך אינו מחזיר ערך. אם תרצה ערך כזה, עליך להשתמש בפונקציה.

    שגיאות נפוצות

    • כתיבת DefaultLine בשורה עצמאית כדי להפעיל אותו. 0478 דורש CALL.
    • השמטת ה ENDPROCEDURE.
    • ציפייה לכך שהמשתנים של ההליך יקיימו מחוץ לו.
    9.2

    פונקציה והחזרת ערך

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

    FUNCTION <identifier>(<parameters>) RETURNS <data type>
        <statements>
        RETURN <value>
    ENDFUNCTION
    
    FUNCTION SumSquare(Number1 : INTEGER, Number2 : INTEGER) RETURNS INTEGER
        RETURN Number1 * Number1 + Number2 * Number2
    ENDFUNCTION
    
    OUTPUT "Sum of squares = ", SumSquare(10, 20)
    
    • ה RETURNS <data type> בראש הפונקציה אומר מה סוג הערך הנחזר. זה לא אופציונלי.
    • ה RETURN מגמר את הפונקציה מיד — אין ביצועים לאחריו.
    • פונקציה מעולם אינה נקראת עם ה CALL; היא משמשת שם שבה ערכה מתאים.

    פרוצדורה נקראת EXECUTE כדי לבצע משימה; פונקציה מחזירה ערך לשימוש *פרוצדורה נקראת EXECUTE כדי לבצע משימה; פונקציה מחזירה ערך לשימוש

    פונקציה בתוך תנאי

    FUNCTION IsEven(Number : INTEGER) RETURNS BOOLEAN
        RETURN MOD(Number, 2) = 0
    ENDFUNCTION
    
    DECLARE Index : INTEGER
    FOR Index ← 1 TO 6
        IF IsEven(Index)
          THEN
            OUTPUT Index, " is even"
        ENDIF
    NEXT Index
    

    שגיאות נפוצות

    • CALL SumSquare(10, 20) — CALL מקריא הליך, ולא פונקציה. השתמש בפונקציה ביטוי, כמו Answer ← SumSquare(10, 20).
    • פונקציה ללא ה RETURN בחלק ממסלוליה. כל מסלול יציאה חייב להחזיר ערך.
    • השארת RETURNS INTEGER מחוץ לכותרת.
    9.3

    פרמטרים

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

    PROCEDURE Line(Size : INTEGER)
        DECLARE Index : INTEGER
        FOR Index ← 1 TO Size
            OUTPUT "-"
        NEXT Index
    ENDPROCEDURE
    
    CALL Line(5)
    CALL Line(20)
    

    מספר פרמטרים מופרדים בפסיקים, והסדר בהקראה חייב להתאים לסדר בהגדרה:

    PROCEDURE Greet(Name : STRING, Times : INTEGER)
        DECLARE Index : INTEGER
        FOR Index ← 1 TO Times
            OUTPUT "Hello ", Name
        NEXT Index
    ENDPROCEDURE
    
    CALL Greet("Mei", 2)
    CALL Greet("Sam", 1)
    

    ⚠️ ב-0478 כל פרמטר מועבר בערך: הפרוצדורה עובדת על העתק, ולכן שינוי בו בתוך הפונקציה אינו משנה דבר מחוץ לה. כדי לקבל ערך בחזרה, השתמש ב-FUNCTION ו- RETURN אותו. (A-Level 9618 מוסיף BYREF לתכונה אחרת — נושא 11.)

    FUNCTION Doubled(Number : INTEGER) RETURNS INTEGER
        RETURN Number * 2
    ENDFUNCTION
    
    DECLARE Value : INTEGER
    Value ← 7
    Value ← Doubled(Value)
    OUTPUT Value
    

    שגיאות נפוצות

    • PROCEDURE Line(Size) ללא סוג.
    • קריאה עם הארגומנטים בסדר שגוי — Greet(2, "Mei") זהו שגיאת סוג.
    • ציפיה שהפרוצדורה תשנה את המשתנה שעברת לה. ב-0478 היא לא יכולה לעשות זאת.
  • 10 ניהול קבצים
    10.1

    כתיבה לקובץ

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

    OPENFILE <file identifier> FOR WRITE
    WRITEFILE <file identifier>, <data>
    CLOSEFILE <file identifier>
    
    OPENFILE "names.txt" FOR WRITE
    WRITEFILE "names.txt", "Mei"
    WRITEFILE "names.txt", "Sam"
    CLOSEFILE "names.txt"
    OUTPUT "Saved"
    

    שלושה מצבי קוב:

    מצב מה שהוא עושה
    WRITE יוצר קוב חדש — כל הנתון שקיים בו נאבד
    APPEND מוסיף בסוף מה שקיים
    READ קורא מתחילת הקוב
    OPENFILE "log.txt" FOR WRITE
    WRITEFILE "log.txt", "first"
    CLOSEFILE "log.txt"
    OPENFILE "log.txt" FOR APPEND
    WRITEFILE "log.txt", "second"
    CLOSEFILE "log.txt"
    OUTPUT "Both lines saved"
    
    • כל WRITEFILE כותב שורה אחת.
    • CLOSEFILE אינו אופציונלי. קובץ פתוח שאינו סגור עלול לאבד את הנתונים שעדיין מחכים להיכתב, וזהו תשובה סטנדרטית לבחינות. נכתבים, והדבר מהווה תשובה שגורה בבחנים.

    שגיאות נפוצות

    • FOR WRITE כאשר התכוונת ל-FOR APPEND, אשר מוחק את התוכן הקודם בשקט.
    • שכחת CLOSEFILE.
    • פתיחת קובץ שכבר פתוח.
    10.2

    קריאת קובץ עד לסוף

    READFILE לוקח שורה אחת למשתנה. המשתנה חייב להיות מוגדר מראש.

    OPENFILE <file identifier> FOR READ
    READFILE <file identifier>, <variable>
    CLOSEFILE <file identifier>
    

    בדרך כלל אין ידע בכמות השורות, ולכן קוראים עד לסוף ה קובץ** — הדבר שמסמך הפונקציית EOF מדווח עליו.

    OPENFILE "names.txt" FOR WRITE
    WRITEFILE "names.txt", "Mei"
    WRITEFILE "names.txt", "Sam"
    WRITEFILE "names.txt", "Ana"
    CLOSEFILE "names.txt"
    
    DECLARE Line : STRING
    OPENFILE "names.txt" FOR READ
    WHILE NOT EOF("names.txt") DO
        READFILE "names.txt", Line
        OUTPUT Line
    ENDWHILE
    CLOSEFILE "names.txt"
    

    EOF("names.txt") הוא TRUE ברגע שכל שורה נקראה, ולכן WHILE NOT EOF(...) משמעותו בעוד שיש עוד מה לקרוא.

    פותחים קובץ ל-CALL/READ, משתמשים בו שורה בשורה, ואז סוגרים אותו *פותחים קובץ ל-CALL/READ, משתמשים בו שורה בשורה, ואז סוגרים אותו

    ספירה בזמן הקריאה

    OPENFILE "marks.txt" FOR WRITE
    WRITEFILE "marks.txt", 40
    WRITEFILE "marks.txt", 65
    WRITEFILE "marks.txt", 88
    CLOSEFILE "marks.txt"
    
    DECLARE Mark, Count, Total : INTEGER
    Count ← 0
    Total ← 0
    OPENFILE "marks.txt" FOR READ
    WHILE NOT EOF("marks.txt") DO
        READFILE "marks.txt", Mark
        Count ← Count + 1
        Total ← Total + Mark
    ENDWHILE
    CLOSEFILE "marks.txt"
    OUTPUT Count, " marks, mean ", Total / Count
    

    שגיאות נפוצות

    • לולאת WHILE EOF(...) — זו שהתאפשרת רק כאשר אין דבר שנותר. רוצים לולאת NOT.
    • קריאה מעבר לסוף בגלל העדר מגן EOF בלולאה.
    • פתיחת FOR READ קובץ שלא נכתב לעולם.
  • 11 A-Level 9618: מה השתנה
    11.1

    עיצוב ואופרטורים

    קמברידג' מפרסמת שתי ספציפיקציות פסודוקוד, והן אינן תואמות. כל מה שנוגע ל נושאים 1-10 הוא IGCSE 0478. ב-A-Level 9618 מתבצע שינוי בפרטים למטה — ובתלמיד שהוא לומד את שניהם נגרעים נקודות אם הוא כותב אחד מהם במבחן של השני.

    IGCSE 0478 A-Level 9618
    THEN בשורה עצמאית, מוזז בתוך שורה 2 בשורה ה-IF
    קבועים CONSTANT Pi ← 3.142 CONSTANT Pi = 3.142
    DIV / MOD פונקציות: DIV(10, 3) אופרטורים: 10 DIV 3
    חיבור מחרוזות פסיקים ב-OUTPUT האופרטור &
    מזהה חייב להתחיל באות גדולה מאפשרת כתיבה מעורבת
    NEXT חייב לקרוא למונה שלו עדיף לעשות כך
    ROUND, RANDOM() שניהם פורסמו שום אחד מהם לא קיים

    זוהי טפסת ה-0478, והיא פועלת כאן:

    DECLARE Total : REAL
    CONSTANT Rate ← 0.5
    Total ← 10
    IF MOD(7, 2) = 1
      THEN
        OUTPUT "Odd, half rate ", Total * Rate
    ENDIF
    

    טפסת ה-9618 של אותו אלגוריתם נכתבת כך — שימו לב ל-THEN בשורה ה-IF, ל-= בתוך ה-CONSTANT, ול-MOD בין הערכים שלו:

    DECLARE Total : REAL
    CONSTANT Rate = 0.5
    Total ← 10
    IF 7 MOD 2 = 1 THEN
        OUTPUT "Odd, " & "half rate ", Total * Rate
    ENDIF
    

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

    שגיאות נפוצות

    • כתיבת THEN בשורה IF בתשובה מסוג 0478, משום שזה מה שספר לימודים או רשת. זוהי הטעות הנפוצה ביותר בין סילבוסים.
    • 10 MOD 3 ב-0478. שם זהו ה-MOD(10, 3).
    • ROUND(3.14159, 2) בתשובה 9618. ל-9618 אין כלל ROUND.
    11.2

    פרמטרים: BYVAL ו-BYREF

    ה-0478 עוברת כל פרמטר בערך (נושא 9). ה-9618 מאפשרת בחירה, ומצהירה על כך בראשית הקובץ.

    • BYVAL — ההוראה מקבלת עתק. שינוי בו אינו משנה דבר מחוץ לה. זהו הערך ברירת מחדל כאשר אף אחד מהמילים אינו כתוב.
    • BYREF — הפרוצדורה פועלת על המשתנה השלישי של הקורא בהעברה לפי הערך, כך ששינוי הוא גלוי לאחר הביקור.

    זה קיים רק ב-9618. הוא לא פועל כאן, ואינו מתקבל בתשובה ל-0478:

    PROCEDURE Increase(BYREF Value : INTEGER)
        Value ← Value + 1
    ENDPROCEDURE
    
    DECLARE Count : INTEGER
    Count ← 5
    CALL Increase(Count)
    OUTPUT Count      // prints 6
    

    BYVAL מעביר העתקה; BYREF מאפשר לפרוצדורה לשנות את המשתנה של הקורא *BYVAL מעביר העתקה; BYREF מאפשר לפרוצדורה לשנות את המשתנה של הקורא

    הדרך לקבל ערך חזרה ב-0478

    השתמש ב FUNCTION והערכ את מה שהיא מחזירה. זוהי כל התשובה ל-0478, וזו פועלת:

    FUNCTION Increased(Value : INTEGER) RETURNS INTEGER
        RETURN Value + 1
    ENDFUNCTION
    
    DECLARE Count : INTEGER
    Count ← 5
    Count ← Increased(Count)
    OUTPUT Count
    

    שגיאות נפוצות

    • כתיבת BYREF בתשובה ל-0478. המילה הזו אינה מופיעה בסילבוס הזה.
    • צפייה לכך שפרמטר רגיל ב-9618 יתנהג כמו BYREF. ללא המילה, זהו BYVAL.
    11.3

    רשומות וסוגים אחרים

    ל-9618 יש מבני נתונים שאין ל-0478. תפגוש אותם רק במסגרת A-Level, ואף אחד מהם לא פועל תחת כללי ה-0478 של עמוד זה.

    רשומה מאגדת שדות מסוגים שונים תחת שם אחד (חלק 4 ב-9618):

    TYPE Student
        DECLARE Name : STRING
        DECLARE Mark : INTEGER
    ENDTYPE
    
    DECLARE Candidate : Student
    Candidate.Name ← "Mei"
    Candidate.Mark ← 91
    OUTPUT Candidate.Name, " scored ", Candidate.Mark
    

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

    TYPE Vehicle = (Car, Bus, Taxi)
    DECLARE MyRide : Vehicle
    MyRide ← Taxi
    

    ל-9618 יש גם סוג נתונים DATE, קבצים גישה אקראית (OPENFILE … FOR RANDOM), מצביעים, וקלאסים עם CLASS … ENDCLASS למבחן האובייקטים- Oriented שלו.

    ⚠️ ל-0478 יש חמישה סוגי נתונים ומערכים, ואין שום דבר נוסף (נושא 2). תשובה ל-0478 ש מכריזה על רשומה היא בעצם תשובה לסילבוס אחר.

    שגיאות נפוצות

    • שימוש ברשומה בתשובה ל-0478. השתמש במקום זאת במערכים מקבילים — מערך אחד לכל שדה, שיתוף אינדקס.
    • חשיבה TYPE פירושה אותו דבר כמו DECLARE. TYPE מגדיר סוג חדש; DECLARE יוצר משתנה מסוג קיים.
    רקורד מקבץ שדות מסוגים שונים; סימון נקודה מגיע לכל אחד מהם
    הרשומה מקבוצה שדות מסוגים שונים; סימון נקודתי מאפשר גישה לכל אחד מהם

היכנס או צור חשבון

IGCSE, A-Level & AP