Menu
Coddy logo textTech

פסאודו קוד: דוגמאות

15 דוגמאות פתורות בפסאודו קוד של Cambridge IGCSE ו־A-Level, מ־OUTPUT ראשון ועד מיון בועות. כל דוגמה מציגה את הפלט שלה, ואפשר להריץ אותה בעורך שלמטה.

איך לקרוא את הדוגמאות

פסאודו קוד מתאר את השלבים של תוכנית באנגלית מובנית, בלי הכללים הנוקשים של שפת תכנות אמיתית. כל הדוגמאות כאן משתמשות בסגנון של Cambridge שנדרש בבחינות IGCSE ו־A-Level: DECLARE למשתנים, ← להשמה, OUTPUT להדפסה, ובלוקים שנסגרים עם ENDIF, NEXT או ENDWHILE.

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

1. Hello, World

הדפיסו הודעה על המסך.

פסאודו קוד
OUTPUT "Hello, World!"
פלט
Hello, World!

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

2. חיבור שני מספרים

שמרו שני מספרים שלמים, חברו אותם והדפיסו את הסכום.

פסאודו קוד
DECLARE a : INTEGER
DECLARE b : INTEGER
DECLARE total : INTEGER
a ← 12
b ← 30
total ← a + b
OUTPUT "The total is ", total
פלט
The total is 42

כל משתנה מוצהר עם שם וטיפוס לפני שמשתמשים בו. החץ ← שומר ערך, ולכן את total ← a + b קוראים "total מקבל את a ועוד b". פסיק בתוך OUTPUT מחבר את הטקסט ואת הערך באותה שורה.

3. זוגי או אי־זוגי

קבעו אם מספר הוא זוגי או אי־זוגי.

פסאודו קוד
DECLARE n : INTEGER
n ← 17
IF n MOD 2 = 0 THEN
    OUTPUT n, " is even"
ELSE
    OUTPUT n, " is odd"
ENDIF
פלט
17 is odd

MOD נותן את השארית של חילוק. מספר זוגי לא משאיר שארית כשמחלקים אותו ב־2, ולכן הבדיקה היא n MOD 2 = 0. IF בוחר אחד משני ענפים ו־ENDIF סוגר את הבלוק. בפסאודו קוד = יחיד משווה בין שני ערכים; הוא אף פעם לא מבצע השמה.

4. מתן ציון למבחן

הפכו ניקוד מתוך 100 לציון: A מ־80 ומעלה, B מ־60 עד 79, ו־C מתחת ל־60.

פסאודו קוד
DECLARE score : INTEGER
DECLARE grade : CHAR
score ← 74
IF score >= 80 THEN
    grade ← 'A'
ELSE
    IF score >= 60 THEN
        grade ← 'B'
    ELSE
        grade ← 'C'
    ENDIF
ENDIF
OUTPUT "Score ", score, " gets grade ", grade
פלט
Score 74 gets grade B

הבדיקות רצות מהגבול הגבוה ביותר כלפי מטה, כך שניקוד של 74 לא עובר את הבדיקה הראשונה ועובר את השנייה. הכנסת IF אחד לתוך ה־ELSE של אחר היא הדרך שבה פסאודו קוד של Cambridge כותב שרשרת else-if. CHAR מחזיק תו יחיד בין מירכאות בודדות.

5. סכום המספרים מ־1 עד 10

חברו את כל המספרים השלמים מ־1 עד 10.

פסאודו קוד
DECLARE total : INTEGER
DECLARE i : INTEGER
total ← 0
FOR i ← 1 TO 10
    total ← total + i
NEXT i
OUTPUT "Sum of 1 to 10 is ", total
פלט
Sum of 1 to 10 is 55

לולאת FOR רצה מספר קבוע של פעמים: i מקבל את הערכים 1, 2, 3 וכן הלאה עד 10, ו־NEXT i מסמן את סוף גוף הלולאה. הסכום המצטבר מתחיל ב־0 וגדל בכל סבב. התשובה, 55, מתאימה לנוסחה n(n + 1) / 2.

6. הדפסת לוח כפל

הדפיסו את חמש השורות הראשונות של לוח הכפל של 7.

פסאודו קוד
DECLARE i : INTEGER
FOR i ← 1 TO 5
    OUTPUT "7 x ", i, " = ", 7 * i
NEXT i
פלט
7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
7 x 4 = 28
7 x 5 = 35

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

7. ספירה לאחור עם לולאת WHILE

ספרו לאחור מ־5 עד 1, ואז הדפיסו הודעת סיום.

פסאודו קוד
DECLARE count : INTEGER
count ← 5
WHILE count > 0 DO
    OUTPUT count
    count ← count - 1
ENDWHILE
OUTPUT "Liftoff!"
פלט
5
4
3
2
1
Liftoff!

לולאת WHILE בודקת את התנאי שלה לפני כל סבב ועוצרת ברגע שהתנאי שקרי. כאן התנאי הוא count > 0, והגוף מקטין את count באחד בכל פעם. אם משמיטים את השורה שמקטינה אותו, הלולאה לא נגמרת לעולם. השתמשו ב־WHILE כשלא יודעים מראש כמה סבבים יידרשו.

8. מציאת המספר הגדול ביותר במערך

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

פסאודו קוד
DECLARE nums : ARRAY[1:6] OF INTEGER
DECLARE i : INTEGER
DECLARE largest : INTEGER
nums[1] ← 14
nums[2] ← 3
nums[3] ← 27
nums[4] ← 9
nums[5] ← 21
nums[6] ← 6
largest ← nums[1]
FOR i ← 2 TO 6
    IF nums[i] > largest THEN
        largest ← nums[i]
    ENDIF
NEXT i
OUTPUT "The largest number is ", largest
פלט
The largest number is 27

ARRAY[1:6] מצהיר על שישה תאים שממוספרים מ־1 עד 6, כי מערכים ב־Cambridge מתחילים בדרך כלל ב־1. התוכנית מניחה שהאיבר הראשון הוא הגדול ביותר, ואז משווה אליו כל איבר אחר ושומרת את הגדול מביניהם. אחרי מעבר אחד על המערך, largest מחזיק את התשובה.

9. חישוב ממוצע

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

פסאודו קוד
DECLARE marks : ARRAY[1:4] OF INTEGER
DECLARE i : INTEGER
DECLARE total : INTEGER
marks[1] ← 70
marks[2] ← 85
marks[3] ← 64
marks[4] ← 91
total ← 0
FOR i ← 1 TO 4
    total ← total + marks[i]
NEXT i
OUTPUT "Average mark: ", total / 4
פלט
Average mark: 77.5

הלולאה מוסיפה כל איבר במערך ל־total, ואז התוכנית מחלקת במספר הציונים. האופרטור / נותן תוצאה עשרונית, ולכן הפלט הוא 77.5. השתמשו ב־DIV כשרוצים חילוק בשלמים.

11. מיון בועות

מיינו חמישה מספרים בסדר עולה.

פסאודו קוד
DECLARE nums : ARRAY[1:5] OF INTEGER
DECLARE i : INTEGER
DECLARE j : INTEGER
DECLARE temp : INTEGER
nums[1] ← 5
nums[2] ← 1
nums[3] ← 4
nums[4] ← 2
nums[5] ← 8
FOR i ← 1 TO 4
    FOR j ← 1 TO 5 - i
        IF nums[j] > nums[j + 1] THEN
            temp ← nums[j]
            nums[j] ← nums[j + 1]
            nums[j + 1] ← temp
        ENDIF
    NEXT j
NEXT i
FOR i ← 1 TO 5
    OUTPUT nums[i]
NEXT i
פלט
1
2
4
5
8

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

צפו באנימציה של האלגוריתם

12. עצרת עם פונקציה

כתבו פונקציה שמחזירה n עצרת (n!), ואז השתמשו בה כדי לחשב את 5!.

פסאודו קוד
FUNCTION Factorial(n : INTEGER) RETURNS INTEGER
    DECLARE result : INTEGER
    DECLARE i : INTEGER
    result ← 1
    FOR i ← 2 TO n
        result ← result * i
    NEXT i
    RETURN result
ENDFUNCTION

OUTPUT "5! = ", Factorial(5)
פלט
5! = 120

FUNCTION מקבלת פרמטרים, מבצעת את העבודה שלה ומחזירה ערך עם RETURN; הכותרת שלה מציינת את הטיפוס שהיא מחזירה. משתנים שמוצהרים בתוכה קיימים רק בזמן שהיא רצה. 5! הוא 5 × 4 × 3 × 2 × 1, כלומר 120.

13. ספירת התנועות במילה

ספרו כמה תנועות יש במילה PSEUDOCODE.

פסאודו קוד
DECLARE word : STRING
DECLARE letter : CHAR
DECLARE vowels : INTEGER
DECLARE i : INTEGER
word ← "PSEUDOCODE"
vowels ← 0
FOR i ← 1 TO LENGTH(word)
    letter ← SUBSTRING(word, i, 1)
    IF letter = 'A' OR letter = 'E' OR letter = 'I' OR letter = 'O' OR letter = 'U' THEN
        vowels ← vowels + 1
    ENDIF
NEXT i
OUTPUT word, " has ", vowels, " vowels"
פלט
PSEUDOCODE has 5 vowels

LENGTH נותן את מספר התווים במחרוזת, ו־SUBSTRING(word, i, 1) לוקח תו אחד החל ממיקום i. הלולאה עוברת על כל תו ומוסיפה אחד למונה בכל פעם שהוא A, E, I, O או U.

14. FizzBuzz

הדפיסו את המספרים מ־1 עד 15, אבל הדפיסו Fizz עבור כפולות של 3, Buzz עבור כפולות של 5 ו־FizzBuzz עבור כפולות של שניהם.

פסאודו קוד
DECLARE i : INTEGER
FOR i ← 1 TO 15
    IF i MOD 15 = 0 THEN
        OUTPUT "FizzBuzz"
    ELSE
        IF i MOD 3 = 0 THEN
            OUTPUT "Fizz"
        ELSE
            IF i MOD 5 = 0 THEN
                OUTPUT "Buzz"
            ELSE
                OUTPUT i
            ENDIF
        ENDIF
    ENDIF
NEXT i
פלט
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz

לסדר הבדיקות יש חשיבות. 15 הוא כפולה של 3 וגם של 5, ולכן הבדיקה של 15 חייבת לבוא ראשונה; אחרת התוכנית תדפיס Fizz ולעולם לא תגיע ל־FizzBuzz. זה תרגיל חימום קלאסי בראיונות עבודה, כי הוא בודק בדיוק סוג כזה של חשיבה.

15. ניסיונות סיסמה עם REPEAT UNTIL

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

פסאודו קוד
DECLARE attempts : ARRAY[1:3] OF STRING
DECLARE tries : INTEGER
DECLARE guess : STRING
attempts[1] ← "hunter1"
attempts[2] ← "letmein"
attempts[3] ← "open sesame"
tries ← 0
REPEAT
    tries ← tries + 1
    guess ← attempts[tries]
    OUTPUT "Try ", tries, ": ", guess
UNTIL guess = "open sesame" OR tries = 3
IF guess = "open sesame" THEN
    OUTPUT "Access granted"
ELSE
    OUTPUT "Locked out"
ENDIF
פלט
Try 1: hunter1
Try 2: letmein
Try 3: open sesame
Access granted

לולאת REPEAT ... UNTIL בודקת את התנאי שלה בסוף, ולכן הגוף תמיד רץ לפחות פעם אחת. היא עוצרת כשהסיסמה תואמת או אחרי הניסיון השלישי. הניחושים מגיעים ממערך כדי שהדוגמה תרוץ בלי הקלדה; בתשובה במבחן בדרך כלל קוראים כל אחד מהם עם INPUT.

שאלות נפוצות על דוגמאות פסאודו קוד

מהי דוגמה לפסאודו קוד?

דוגמה קצרה קובעת אם עברו מבחן: IF score >= 50 THEN OUTPUT "Pass" ELSE OUTPUT "Fail" ENDIF. היא נקראת כמעט כמו אנגלית אבל פועלת לפי כללים קבועים, ולכן אפשר להמיר אותה ל־Python, ל־Java או לכל שפה אחרת שורה אחר שורה. 15 התוכניות בעמוד הזה מתחילות בשורה אחת ומגיעות עד חיפוש ומיון.

איך כותבים פסאודו קוד?

החליטו מה התוכנית צריכה לעשות, ואז כתבו את השלבים לפי הסדר עם קבוצה קטנה של מילות מפתח: DECLARE למשתנים, ← להשמה, IF להחלטות, FOR או WHILE לחזרה, ו־OUTPUT לתוצאות. הזיחו את הגוף של כל בלוק, סגרו אותו במילת הסיום שלו, וכתבו פעולה אחת בכל שורה.

האם פסאודו קוד זהה בכל הבחינות?

לא. Cambridge (IGCSE ו־A-Level) משתמשת ב־DECLARE ובחץ ←, AQA משתמשת ב־← בלי הצהרות, ה־Exam Reference Language של OCR נראית כמו Python, ו־Edexcel כותבת SET ... TO. הדוגמאות כאן משתמשות בסגנון של Cambridge; עורך הפסאודו קוד עובר בין כל ארבעת הסגנונות.

אפשר להריץ פסאודו קוד?

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

מה ההבדל בין פסאודו קוד לתרשים זרימה?

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

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

בפסאודו קוד של Cambridge, כן: מחווני הבחינה מצפים ל־DECLARE name : TYPE לפני שמשתמשים במשתנה. סגנונות אחרים, כמו זה של AQA, מוותרים על הצהרות. הצהרה על משתנה גם אומרת לקורא איזה סוג ערך הוא מחזיק.

איור של שפות התכנות ב-Coddy

עברו מפסאודו קוד לקוד אמיתי עם Coddy

להתחיל