תוכנית, משתנה וביטוי
תוכנית מחשב מקבלת נתונים, מחשבת ומוציאה תוצאה. כדי לחשב היא שומרת ערכים במשתנים ומצרפת אותם לביטויים, כמו במתמטיקה.
במדויק: משתנה - מקום בזיכרון שיש לו שם, טיפוס וערך. טיפוס - סוג הערכים שהמשתנה יכול להכיל: int, double, char, boolean (ב-C# bool) ו-String (ב-C# string). ביטוי - צירוף של משתנים, קבועים, פעולות חשבון וזימוני פעולות; לכל ביטוי יש ערך וטיפוס. קלט - ערכים שהתוכנית קולטת בזמן הריצה; פלט - מה שהיא מדפיסה. בבגרות הנושא הזה מופיע בתוך שאלות מעקב וכתיבת קוד: חלוקה בשלמים, שארית, המרה בין טיפוסים, קליטה והמחלקה Math.
1. משתנים, טיפוסים והשמה: int, double, char ו-boolean
משתנה וטיפוס
משתנה הוא כמו קופסה עם תווית: התווית היא שם המשתנה, ובקופסה יש ערך אחד. הטיפוס קובע איזה ערך מותר לשים בקופסה - מספר שלם, מספר עם נקודה עשרונית, תו, או אמת ושקר.
במדויק: בהגדרה כותבים טיפוס ושם, ואפשר גם לאתחל: int count = 0;. הטיפוס והשם נקבעים בהגדרה ולא משתנים; הערך משתנה במהלך הריצה. בבחינה צריך לבחור טיפוס מתאים לכל משתנה, לאתחל צוברים, מונים ודגלים, ולעקוב אחרי הערכים בטבלת מעקב.
אותם טיפוסים משמשים גם לפרמטרים של פעולה, לערך שהיא מחזירה ולתכונות של מחלקה. מחרוזות ותווים מורחבים בשיעורים על מחרוזות ועל הטיפוס char.
הטיפוסים הבסיסיים
| טיפוס | Java | C# | ערכים לדוגמה | מתי משתמשים |
|---|---|---|---|---|
| שלם | int | int | 0, 23, -8 | מונה, סכום של שלמים, אינדקס, ספרה |
| ממשי | double | double | 5.4, 150.0 | ממוצע, מחיר, התוצאה של Math.sqrt |
| תו | char | char | 'A', '7' | תו אחד, בגרש בודד |
| בוליאני | boolean | bool | true, false | דגל: האם משהו קרה, תוצאה של תנאי |
| מחרוזת | String | string | "Dana" | רצף של תווים, במירכאות |
הגדרה, אתחול והשמה
int count = 0; // שלם
double avg = 7.5; // ממשי
boolean found = false; // בוליאני: true או false
char grade = 'A'; // תו אחד, בגרש בודד
String name = "Dana"; // מחרוזת, במירכאות
int a = 5;
int b = a; // השמה: b מקבל עותק של הערך של a
a = 7; // b לא משתנה
System.out.println(a + " " + b);הקטע מדפיס 7 5. השמה מעתיקה את הערך: אחרי b = a יש ל-b עותק של 5, ושינוי של a אחר כך לא משנה את b.
בחירת טיפוס מתוך תיאור מילולי
int: מספר חיצים, מספר ילדים, ניקוד, גיל.double: ממוצע, מחיר.boolean / bool: האם מקום העבודה בעיר, האם הייתה ירייה של 10 נקודות.= היא השמה ו-== היא השוואה. משתנה בוליאני הוא כבר תנאי: if (city) מספיק, ואין צורך לכתוב city == true.
"הפעולה מחזירה מספר שלם תלת-ספרתי" פירושו ערך int, כמו 122, ולא המחרוזת "122". את המספר בונים בחשבון: hundreds * 100 + tens * 10 + units.
דוגמה - זכאות להנחות כמספר תלת-ספרתי
מועצת העיר מזכה את תושביה בהנחות:
הזכאות מיוצגת במספר תלת-ספרתי מהספרות 1 ו-2 בלבד: 1 = זכאות, 2 = אי-זכאות. ספרת המאות - ארנונה, ספרת העשרות - גני ילדים, ספרת האחדות - חניה. למשל 122: זכאי להנחה בארנונה בלבד.
כתבו פעולה חיצונית ששמה discounts בשפת Java או Discounts בשפת C#, המקבלת שלושה משתנים: age (גיל, שלם), num (מספר הילדים, שלם) ו-city (ערך בוליאני: האם מקום העבודה בעיר). הפעולה מחזירה מספר שלם תלת-ספרתי המציין את הזכאות של התושב להנחות.
int.age >= 70 ("70 ומעלה" כולל 70), num >= 3, ו-city עצמו.hundreds * 100 + tens * 10 + units.public static int discounts(int age, int num, boolean city)
{
int hundreds = 2; // 2 = לא זכאי
int tens = 2;
int units = 2;
if (age >= 70)
hundreds = 1; // הנחה בארנונה
if (num >= 3)
tens = 1; // הנחה בגני ילדים
if (city)
units = 1; // הנחה בחניה
return hundreds * 100 + tens * 10 + units;
}| קריאה | age | num | city | מוחזר |
|---|---|---|---|---|
| 1 | 75 | 1 | false | 122 |
| 2 | 40 | 3 | true | 211 |
| 3 | 70 | 4 | true | 111 |
| 4 | 69 | 2 | false | 222 |
| 5 | 30 | 0 | true | 221 |
ספרת המאות 1 אם age >= 70 ואחרת 2; ספרת העשרות 1 אם num >= 3 ואחרת 2; ספרת האחדות 1 אם city ואחרת 2. מחזירים hundreds * 100 + tens * 10 + units, למשל 122 בעבור גיל 75, ילד אחד ועבודה מחוץ לעיר.
2. פעולות חשבון: חלוקה בשלמים, שארית והמרת טיפוסים
פעולות חשבון וטיפוס התוצאה
המחשב מחשב כמו מחשבון, עם הבדל אחד חשוב: התוצאה תלויה בטיפוסים. 7 חלקי 2, כששניהם שלמים, הוא 3 ולא 3.5.
במדויק: פעולות החשבון הן חיבור +, חיסור -, כפל *, חילוק / ושארית %. כששני האופרנדים שלמים, / היא חלוקה בשלמים (המנה, בלי החלק העשרוני) ו-% היא השארית. אם לפחות אחד מהם double, התוצאה double. המרה: (double) x הופכת שלם לממשי, ו-(int) x הופכת ממשי לשלם וקוטעת את החלק העשרוני. בבחינה חלוקה בשלמים ושארית חוזרות בכל פירוק של מספר לספרות, והמרה - בכל חישוב ממוצע.
פירוק מספר שלם לספרות בלולאה (% 10 ו-/ 10 שוב ושוב, עד 0) מורחב בשיעור על פירוק מספר לספרות. כאן - מה ביטוי אחד מחשב.
מה הערך של הביטוי
| ביטוי | ערך | למה |
|---|---|---|
7 / 2 | 3 | שני שלמים: חלוקה בשלמים |
7.0 / 2 | 3.5 | אחד ממשי: חלוקה רגילה |
7 % 2 | 1 | השארית של 7 חלקי 2 |
2 % 7 | 2 | המספר קטן מהמחלק: השארית היא המספר עצמו |
6 / 10 | 0 | מספר חד-ספרתי חלקי 10 |
(double) 7 / 2 | 3.5 | ההמרה לפני החלוקה |
(double) (7 / 2) | 3.0 | ההמרה אחרי חלוקה בשלמים: מאוחר מדי |
(int) 4.79 | 4 | המרה ל-int קוטעת, לא מעגלת |
1 + 2.5 | 3.5 | שלם ועוד ממשי: המרה אוטומטית ל-double |
חלוקה ושארית על ספרות ועל התחלקות
| מה רוצים | ביטוי | בעבור n = 324 |
|---|---|---|
| ספרת האחדות | n % 10 | 4 |
| המספר בלי ספרת האחדות | n / 10 | 32 |
| ספרת העשרות | n / 10 % 10 | 2 |
| ספרת המאות של מספר תלת-ספרתי | n / 100 | 3 |
| האם n זוגי | n % 2 == 0 | true |
| האם n מתחלק ב-7 | n % 7 == 0 | false |
סדר הפעולות וסוגריים
*, / ו-% לפני + ו--, כמו במתמטיקה: 3 + 4 * 2 הוא 11, ו-10 - 4 / 2 הוא 8.n / 10 % 10 מחושב כ-(n / 10) % 10.(3 + 4) * 2 הוא 14. בממוצע הסוגריים סביב הסכום חובה: (3 + 3 + 9 + 7 + 5) / 5 הוא 5 בשלמים, ו-(3 + 3 + 9 + 7 + 5) / 5.0 הוא 5.4.תבנית: ממוצע עם המרה, מנה ושארית
int sum = 27;
int num = 5;
double wrong = sum / num; // חלוקה בשלמים: 5, ואז 5.0
double avg = (double) sum / num; // 5.4
int units = sum % 10; // ספרת האחדות: 7
int rest = sum / 10; // בלי ספרת האחדות: 2
System.out.println(wrong + " " + avg + " " + units + " " + rest);ב-Java הקטע מדפיס 5.0 5.4 7 2. הערכים זהים בשתי השפות: ב-wrong נשמר 5, בלי חלק עשרוני, כי החלוקה בשלמים קרתה לפני ההשמה ל-double; avg הוא 5.4, units הוא 7 ו-rest הוא 2.
בממוצע של ניקודים שלמים, sum / num הוא חלוקה בשלמים. במשחק הקליעה של קיץ 2023 הניקודים 5, 7, 9, 3, 3 נותנים 27 / 5 = 5 ולא 5.4, והתנאי "בממוצע מעל 5.0" נכשל. כותבים (double) sum / num.
double wrong = sum / num; לא מציל: החלוקה בשלמים מתבצעת קודם, ורק התוצאה 5 הופכת ל-5.0. ההמרה צריכה להיות על אחד האופרנדים, לפני החלוקה.
arr[i] / 10 % 10 היא ספרת העשרות של arr[i]: % 10 פועל על המנה, לא על המספר המקורי. בעבור מספר חד-ספרתי כמו 6 מתקבל 0, לא 6.
דוגמה - מעקב אחר ספרת העשרות והאינדקס
נתון מערך arr, המכיל מספרים שלמים חיוביים:
| תא | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
|---|---|---|---|---|---|---|---|
| ערך | 30 | 141 | 324 | 623 | 8004 | 458 | 6 |
לפניכם קטע תוכנית:
int count = 0;
for (int i = 0; i < arr.length; i++)
{
int num = arr[i] / 10;
int digit = num % 10;
if (digit == i)
count++;
}עקבו בעזרת טבלת מעקב אחר ביצוע קטע התוכנית עבור המערך arr, ורשמו את ערך המשתנה count לאחר ביצוע קטע התוכנית. בטבלת המעקב יש לכלול עמודה עבור כל אחד מן המשתנים count, i, num, digit.
arr[i] / 10 מוחק את ספרת האחדות, ו-num % 10 היא ספרת האחדות של num - כלומר ספרת העשרות של arr[i].| סיבוב | i | arr[i] | num | digit | digit == i | count |
|---|---|---|---|---|---|---|
| אתחול | - | - | - | - | - | 0 |
| 1 | 0 | 30 | 3 | 3 | false | 0 |
| 2 | 1 | 141 | 14 | 4 | false | 0 |
| 3 | 2 | 324 | 32 | 2 | true | 1 |
| 4 | 3 | 623 | 62 | 2 | false | 1 |
| 5 | 4 | 8004 | 800 | 0 | false | 1 |
| 6 | 5 | 458 | 45 | 5 | true | 2 |
| 7 | 6 | 6 | 0 | 0 | false | 2 |
| סיום | 7 | - | - | - | - | 2 |
i < arr.length לא מתקיים. ההרצה של הקטע על המערך נתנה count=2.6 / 10 הוא 0, ולכן digit = 0 ולא 6.count = 2: רק בתאים 2 ו-5 ספרת העשרות שווה לאינדקס.
3. קלט ופלט: קליטת ערכים והדפסה
קלט ופלט
פלט הוא מה שהתוכנית מראה למשתמש; קלט הוא מה שהמשתמש מקליד לה. כשבשאלה כתוב "הפעולה תקלוט", אתם כותבים את הוראת הקליטה בעצמכם.
במדויק: הדפסה: ב-Java System.out.println(x) עם ירידת שורה ו-System.out.print(x) בלי; ב-C# Console.WriteLine(x) ו-Console.Write(x). קליטה ב-Java בעזרת עצם Scanner. בשאלון כתוב: "הניחו שבתוכנית כתובה ההוראה: Scanner scan = new Scanner (System.in);", וקולטים scan.nextInt() או scan.nextDouble(). קליטה ב-C#: קולטים שורה וממירים אותה: int.Parse(Console.ReadLine()), double.Parse(Console.ReadLine()). שרשור: + בין מחרוזת לערך מצרף אותם למחרוזת אחת.
בתכנית פעולות הקלט והפלט הן "קופסאות שחורות": משתמשים בהן בלי לדעת איך הן ממומשות. קליטה של כמה ערכים בלולאה וצבירה שלהם מורחבות בשיעור על צבירה ומנייה.
קליטה והדפסה ב-Java וב-C#
| מה | Java | C# |
|---|---|---|
| קליטת מספר שלם | scan.nextInt() | int.Parse(Console.ReadLine()) |
| קליטת מספר ממשי | scan.nextDouble() | double.Parse(Console.ReadLine()) |
| הדפסה וירידת שורה | System.out.println(x) | Console.WriteLine(x) |
| הדפסה בלי ירידת שורה | System.out.print(x) | Console.Write(x) |
| הדפסה של טקסט וערך | System.out.println("sum: " + sum) | Console.WriteLine("sum: " + sum) |
תבנית: קליטת ערכים והדפסת תוצאה
// Scanner scan = new Scanner(System.in); - כתובה בתוכנית, לפי הוראות השאלון
int num = scan.nextInt(); // קליטת מספר שלם
double price = scan.nextDouble(); // קליטת מספר ממשי
System.out.print("total: "); // בלי ירידת שורה
System.out.println(num * price); // עם ירידת שורהבקלט 3 ואחריו 2.5 הקטע מדפיס total: 7.5 בשורה אחת: print לא ירדה שורה.
שרשור מחרוזות: הסדר קובע
int x = 1;
int y = 2;
System.out.println("sum: " + x + y); // sum: 12
System.out.println("sum: " + (x + y)); // sum: 3
System.out.println(x + y + " is sum"); // 3 is sum+ מחושב משמאל לימין. אחרי שמופיעה מחרוזת, כל + הוא שרשור, ולכן "sum: " + x + y נותן sum: 12. כדי לחבר קודם - סוגריים. כשהמספרים באים לפני המחרוזת, הם מחוברים קודם: 3 is sum.
פעולה שקולטת נתונים
אל תחזירו true מתוך הלולאה ברגע שמופיע 10. הקליטה נעצרת באמצע, ושאר הניקודים לא נקלטים. קולטים את כל num הערכים ורק אז מחליטים.
בבחינה לדוגמה הוראת הקליטה היא Scanner input = new Scanner(System.in);, ובשאלוני 2023-2026 היא Scanner scan = new Scanner (System.in);. כותבים input.nextInt() או scan.nextInt() לפי השאלון שלפניכם.
"תקלוט" ו"תחזיר" באים יחד: קולטים בתוך הפעולה, ובסוף return, בלי הדפסה. כשכתוב "תדפיס", כמו בפעולה checkAll / CheckAll של הבחינה לדוגמה, מדפיסים.
דוגמה - קליטת ניקודים במשחק קליעה למטרה
במשחק קליעה למטרה אדם יורה כמה חיצים. הניקוד של כל ירייה הוא מספר שלם מ-0 עד 10. אדם מצליח במשחק אם מתקיים לפחות אחד מן המקרים:
דוגמאות: 5, 7, 9, 3, 3 - ממוצע 5.4, הצליח. 7, 6, 1, 7, 8, 0 - בארבע יריות מתוך שש 6 ומעלה, הצליח. 2, 10, 0 - יש 10, הצליח.
כתבו פעולה חיצונית ששמה success בשפת Java או Success בשפת C#, המקבלת מספר שלם num - מספר החיצים שהאדם ירה. הפעולה תקלוט את מספר הנקודות בעבור כל חץ, ותחזיר true אם האדם הצליח במשחק, אחרת false.
int, סכום), countHigh (int, כמה ניקודים של 6 ומעלה), hit10 (בוליאני, האם היה 10).(double) sum / num - בלי ההמרה 27 / 5 הוא 5. "רוב" הוא countHigh > num / 2.0. מחזירים את ה"או" של שלושת התנאים.public static boolean success(int num)
{
int sum = 0; // סכום הנקודות
int countHigh = 0; // כמה יריות של 6 נקודות ומעלה
boolean hit10 = false; // האם הייתה ירייה של 10
for (int i = 0; i < num; i++)
{
int score = scan.nextInt();
sum += score;
if (score >= 6)
countHigh++;
if (score == 10)
hit10 = true;
}
double avg = (double) sum / num;
return avg > 5.0 || countHigh > num / 2.0 || hit10;
}קולטים num ניקודים, סוכמים, סופרים ניקודים של 6 ומעלה ומסמנים בדגל אם היה 10. מחזירים (double) sum / num > 5.0 || countHigh > num / 2.0 || hit10.
4. המחלקה Math ומספרים אקראיים
המחלקה Math
אין צורך לכתוב בעצמכם שורש או חזקה: הפעולות האלה כבר כתובות במחלקה Math. קוראים להן בשם המחלקה, נקודה ושם הפעולה.
במדויק: המחלקה Math היא ספרייה של פעולות מתמטיות, וזימון פעולה נכתב כך: Math.sqrt(n) ב-Java ו-Math.Sqrt(n) ב-C#. הפעולות שבתכנית: abs, max, min, pow, round, sqrt ו-random. בבחינה צריך לדעת מה כל פעולה מחזירה ומאיזה טיפוס: Math.sqrt ו-Math.pow מחזירות double, ולכן שמירה במשתנה int דורשת המרה. צריך גם לדעת להגריל מספר שלם בתחום.
Math.max מופיעה גם בשאלות מעקב על מערכים, למשל בפעולה what של קיץ 2025, שמחזירה את הסכום הגדול ביותר של רצף איברים צמודים.
הפעולות של Math
| פעולה | Java | C# | מחזירה | דוגמה |
|---|---|---|---|---|
| ערך מוחלט | Math.abs(x) | Math.Abs(x) | אותו טיפוס כמו x | Math.abs(-7) = 7 |
| הגדול מבין שניים | Math.max(a, b) | Math.Max(a, b) | אותו טיפוס כמו a ו-b | Math.max(3, 8) = 8 |
| הקטן מבין שניים | Math.min(a, b) | Math.Min(a, b) | אותו טיפוס כמו a ו-b | Math.min(3, 8) = 3 |
| חזקה | Math.pow(a, b) | Math.Pow(a, b) | double | Math.pow(2, 3) = 8.0 |
| שורש ריבועי | Math.sqrt(x) | Math.Sqrt(x) | double | Math.sqrt(23) ≈ 4.796 |
| עיגול | Math.round(x) | Math.Round(x) | ב-Java שלם מטיפוס long | Math.round(4.6) = 5 |
| מספר אקראי | Math.random() | אין: משתמשים בעצם Random | double מ-0 עד 1, בלי 1 | - |
תבנית: הגרלת מספר שלם בתחום
// בראש הקובץ: import java.util.Random;
Random rnd = new Random(); // עצם אחד, לפני הלולאה
int r1 = rnd.nextInt(n); // 0 עד n-1
int r2 = rnd.nextInt(b - a + 1) + a; // a עד b
int r3 = (int) (Math.random() * n); // 0 עד n-1, בלי עצם Random
int r4 = (int) (Math.random() * (b - a + 1)) + a; // a עד bבהרצה של 200000 הגרלות עם n = 6, a = 1, b = 1000: r1 ו-r3 קיבלו ערכים מ-0 עד 5, ו-r2 ו-r4 מ-1 עד 1000.
הגרלה שנספרת רק כשהיא תקפה
import java.util.Random;.(int) קוטעת את החלק העשרוני, לא מעגלת: (int)(Math.sqrt(23)) הוא 4, אף ש-Math.sqrt(23) ≈ 4.79.
Math.pow מחזירה double, ולכן int x = Math.pow(2, 3); לא עובר קומפילציה. כותבים (int)(Math.pow(root, 2)), כמו בקיץ 2026, או מחשבים חזקה של שלמים בכפל בלולאה.
ב-C# אין Math.Random: מגרילים בעזרת Random rnd = new Random(); ו-rnd.Next(...). ב-rnd.Next(a, b) הגבול העליון b לא נכלל, ולכן לתחום 1 עד 1000 כותבים rnd.Next(1, 1001).
דוגמה א - מעקב אחר שורש שלם וריבוע
לפניכם קטע תוכנית:
int n = 23;
int steps = 0;
while (n > 0) {
int root = (int)(Math.sqrt(n));
int square = (int)(Math.pow(root, 2));
n = n - square;
steps ++;
}
System.out.println(steps);א. עקבו בעזרת טבלת מעקב אחרי ביצוע קטע התוכנית, וכתבו את המספר שקטע התוכנית מדפיס. בטבלת המעקב יש לכלול עמודה בעבור כל אחד מן המשתנים n, steps, root, square.
ב. כתבו דוגמה למספר הגדול מ-1 שמוצב ב-n בתחילת הקטע, שבעבורו קטע התוכנית מדפיס 1 (אין צורך להציג מעקב).
(int)(Math.sqrt(n)) הוא השורש השלם של n (קטיעה). square הוא הריבוע שלו - הריבוע השלם הגדול ביותר שאינו גדול מ-n. מחסירים אותו מ-n וסופרים צעד.| שלב | Math.sqrt(n) | root | square | n | steps |
|---|---|---|---|---|---|
| אתחול | - | - | - | 23 | 0 |
| 1 | 4.79... | 4 | 16 | 7 | 1 |
| 2 | 2.64... | 2 | 4 | 3 | 2 |
| 3 | 1.73... | 1 | 1 | 2 | 3 |
| 4 | 1.41... | 1 | 1 | 1 | 4 |
| 5 | 1.0 | 1 | 1 | 0 | 5 |
n > 0 לא מתקיים, ומודפס steps. ההרצה הדפיסה 5.n - square = 0: n הוא ריבוע שלם. בעבור n = 4: root = 2, square = 4, n = 0, steps = 1. בהרצה על 2 עד 100 הודפס 1 בדיוק בעבור 4, 9, 16, 25, 36, 49, 64, 81, 100.א. הקטע מדפיס 5.
ב. למשל n = 4 (כל ריבוע שלם גדול מ-1: 4, 9, 16, ...).
דוגמה ב - ערבול מערך בהגרלת אינדקסים
"מערך מעורבל" הוא מערך מטיפוס שלם שהתהליך שלהלן בוצע בו 30 פעמים:
הערה: אם בהגרלה עלו שני מספרי אינדקס זהים, ההגרלה לא תיחשב.
כתבו פעולה חיצונית ששמה shuffle בשפת Java או Shuffle בשפת C#, המקבלת מערך מטיפוס שלם arr ומערבלת אותו. הפעולה תדפיס את ערכי התאים לפי הסדר לאחר הערבול, כל ערך בשורה חדשה.
rnd.nextInt(arr.length) / rnd.Next(arr.Length) - שלם מ-0 עד אורך המערך פחות 1.i != j.public static void shuffle(int[] arr)
{
Random rnd = new Random();
int count = 0;
while (count < 30)
{
int i = rnd.nextInt(arr.length);
int j = rnd.nextInt(arr.length);
if (i != j)
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
count++;
}
}
for (int k = 0; k < arr.length; k++)
{
System.out.println(arr[k]);
}
}{1, 2} כל החלפה תקפה מחליפה את שני התאים, ואחרי 30 החלפות (מספר זוגי) הודפסו 1 ו-2 - בדיוק 30 החלפות נספרו. במערך {10, 20, 30, 40, 50, 60, 70} הודפסו 7 שורות באותם ערכים בסדר אחר.לולאת while עם מונה שגדל רק כאשר שני האינדקסים המוגרלים שונים (30 החלפות תקפות), ואחריה הדפסת המערך, ערך בכל שורה.