פסאודו קוד: דוגמאות
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 ", totalThe 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"
ENDIF17 is oddMOD נותן את השארית של חילוק. מספר זוגי לא משאיר שארית כשמחלקים אותו ב־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 ", gradeScore 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 ", totalSum 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 i7 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 ", largestThe largest number is 27ARRAY[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 / 4Average mark: 77.5הלולאה מוסיפה כל איבר במערך ל־total, ואז התוכנית מחלקת במספר הציונים. האופרטור / נותן תוצאה עשרונית, ולכן הפלט הוא 77.5. השתמשו ב־DIV כשרוצים חילוק בשלמים.
10. חיפוש לינארי
מצאו את המיקום של השם Dara ברשימת שמות.
DECLARE names : ARRAY[1:5] OF STRING
DECLARE i : INTEGER
DECLARE found : BOOLEAN
names[1] ← "Ana"
names[2] ← "Ben"
names[3] ← "Chen"
names[4] ← "Dara"
names[5] ← "Eli"
found ← FALSE
i ← 1
WHILE i <= 5 AND found = FALSE DO
IF names[i] = "Dara" THEN
found ← TRUE
ELSE
i ← i + 1
ENDIF
ENDWHILE
IF found = TRUE THEN
OUTPUT "Dara is at position ", i
ELSE
OUTPUT "Not found"
ENDIFDara is at position 4חיפוש לינארי בודק את האיברים אחד אחד מההתחלה. התנאי של WHILE עוצר את הלולאה כשהשם נמצא או כשכל האיברים כבר נבדקו, והדגל found רושם איזה מהשניים קרה. הוא עובד על נתונים לא ממוינים, אבל ברשימה ארוכה הוא עלול לדרוש השוואה אחת לכל איבר.
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 i1
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! = 120FUNCTION מקבלת פרמטרים, מבצעת את העבודה שלה ומחזירה ערך עם 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 vowelsLENGTH נותן את מספר התווים במחרוזת, ו־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 i1
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"
ENDIFTry 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, מוותרים על הצהרות. הצהרה על משתנה גם אומרת לקורא איזה סוג ערך הוא מחזיק.