פעולות, מחרוזות ותווים
תוכנית גדולה לא נכתבת כגוש אחד: מחלקים אותה לפעולות קטנות, וכל פעולה עושה משימה אחת. כך קל יותר לכתוב, לבדוק ולהשתמש באותו קוד שוב. הרבה מהפעולות בבגרות עובדות על טקסט: מחרוזת (String) היא רצף של תווים, ותו (char) הוא סימן אחד.
במדויק: פעולה היא רכיב תכנותי לעידון ולחלוקת קוד למשימות: יש לה כותרת (טיפוס הערך המוחזר, שם ופרמטרים) וגוף. מחרוזת - בתכנית הלימודים מוגבלת לפעולות charAt, contains, indexOf, length ולשרשור ב-+. תו - הטיפוס הבסיסי char, ערך אחד בין גרשיים, למשל 'A'.
1. פעולה: כותרת, פרמטרים וערך מוחזר
פעולה
פעולה היא "תוכנית קטנה" עם שם. נותנים לה ערכים (פרמטרים), היא מבצעת משימה, ולפעמים מחזירה תוצאה. אחרי שכתבתם פעולה אפשר לקרוא לה שוב ושוב, גם מתוך פעולה אחרת.
במדויק: כותרת הפעולה (החתימה) כוללת את public static, את טיפוס הערך המוחזר (או void כשהפעולה לא מחזירה ערך), את שם הפעולה ואת רשימת הפרמטרים - לכל פרמטר טיפוס ושם. הפקודה return מסיימת את הפעולה ומחזירה את הערך. הפרמטרים מועברים לפי ערך: הפעולה מקבלת עותק של הערך, ופרמטר מטיפוס מסוים יכול לקבל כל ביטוי מאותו טיפוס. בקריאה לפעולה, הערך המוחזר משתלב בביטוי שבו נמצאת הקריאה.
בבגרות 899371 רוב השאלות בפרק השני בנויות כשרשרת סעיפים: סעיף א כותב פעולה, וסעיף ב "חייב להיעזר בפעולה שכתבתם בסעיף א". דרך כתיבת פעולה בארבעה צעדים נמצאת בנושא "הבגרות במדעי המחשב". פעולה פנימית של מחלקה (בלי static) נמצאת בנושא "מחלקות ועצמים".
תבנית: פעולה שמחזירה ופעולה שקוראת לה
הפעולה digitSum / DigitSum (מתוך 899371 קיץ 2024) מחזירה את סכום הספרות; printSum / PrintSum קוראת לה ומדפיסה. digitSum(961) מחזירה 16.
public static int digitSum(int num) // מחזירה int
{
int sum = 0;
while (num > 0)
{
sum = sum + num % 10;
num = num / 10;
}
return sum; // מסיימת ומחזירה את הערך
}
public static void printSum(int num) // void: מדפיסה ולא מחזירה
{
int s = digitSum(num); // קריאה: הערך המוחזר נשמר במשתנה
System.out.println(s);
}| חלק בכותרת | public static int digitSum(int num) |
|---|---|
| הרשאה וסיווג | public static - בכל פעולה חיצונית |
| טיפוס מוחזר | int; boolean / bool; int[]; void - לא מחזירה |
| שם | כמו בשאלה: באות קטנה ב-Java, באות גדולה ב-C# |
| פרמטרים | טיפוס ושם לכל אחד, מופרדים בפסיק. אין פרמטרים - סוגריים ריקים () |
איך קוראים לפעולה, לפי מה שהיא מחזירה
| הפעולה מחזירה | איך משתמשים בקריאה | דוגמה מהבגרות |
|---|---|---|
מספר (int) | בהשמה או בתוך ביטוי | num1 = digitSum(num1); |
| ערך בוליאני | ישר בתנאי, גם עם ! ועם && | if (isPerfect(i)), if (!check(products)) |
| מערך | שומרים בהפניה מאותו טיפוס | int[] status = getAllStatus(speeds, max, min); |
כלום (void) | הוראה לבדה, אי אפשר לשים בביטוי | thePerfects(4, 10); |
את הארגומנטים מעבירים באותו סדר של הפרמטרים בכותרת, ומאותם טיפוסים. ארגומנט יכול להיות קריאה לפעולה אחרת: digitExists(num2, deepSum(num1)).
שימוש בפעולה נתונה או בפעולה מסעיף קודם
פרמטר מועבר לפי ערך: הפעולה עובדת על עותק. בפעולה deepSum משנים את num1 בתוך הלולאה, וזה מותר - המשתנה של מי שקרא לפעולה לא משתנה. למשל int n = 961; ואחרי digitSum(n) עדיין n שווה 961.
בפעולה שמחפשת ("האם קיים", "האם אין") מחזירים תשובה אחת מתוך הלולאה, ואת השנייה רק אחריה. בפעולה noOdd של קיץ 2025: return false מיד כשנמצא מספר מושלם אי-זוגי, ו-return true רק אחרי שהלולאה עברה על כל המספרים. return true בתוך else עוצר כבר אחרי המספר הראשון.
פעולה void לא מחזירה ערך, ולכן אי אפשר לכתוב int x = thePerfects(4, 10);. ולהפך: אם השאלה אומרת "הפעולה מחזירה", הדפסה במקום return היא תשובה שגויה.
דוגמה - סכום הספרות העמוק בעזרת פעולות נתונות
נתונה פעולה חיצונית ששמה digitSum בשפת Java או DigitSum בשפת C#, המקבלת מספר שלם num1 ומחזירה את סכום כל הספרות במספר. אפשר להשתמש בפעולה בלי לממש אותה. למשל עבור num1 = 961 הפעולה תחזיר 16.
"סכום הספרות העמוק" של מספר הוא מספר חד-ספרתי שמתקבל כשמחשבים את סכום הספרות שוב ושוב עד שמתקבל מספר חד-ספרתי. למשל: של 5 הוא 5; של 36 הוא 9; של 942378 הוא 6 (9 + 4 + 2 + 3 + 7 + 8 = 33, ואז 3 + 3 = 6).
א. כתבו פעולה חיצונית ששמה deepSum בשפת Java או DeepSum בשפת C#, המקבלת מספר שלם num1 שאינו שלילי ומחזירה את "סכום הספרות העמוק" שלו.
ב. נתונה פעולה חיצונית ששמה digitExists בשפת Java או DigitExists בשפת C#, המקבלת מספר שלם num וספרה digit, ומחזירה true אם הספרה מופיעה במספר לפחות פעם אחת, אחרת false. אפשר להשתמש בה בלי לממש אותה.
כתבו פעולה חיצונית ששמה inBoth בשפת Java או InBoth בשפת C#, המקבלת שני מספרים שלמים num1 ו-num2. הפעולה מחזירה true אם "סכום הספרות העמוק" של num1 מופיע במספר num2, וגם "סכום הספרות העמוק" של num2 מופיע במספר num1; אחרת היא מחזירה false. למשל עבור num1 = 36 ו-num2 = 942378 היא תחזיר true. הערה: חובה להיעזר בפעולה שכתבתם בסעיף א.
num1 >= 10 מחליפים אותו בערך ש-digitSum מחזירה. מספר חד-ספרתי לא נכנס ללולאה ומוחזר כמו שהוא. מותר לשנות את num1: הוא עותק.&&.public static int deepSum(int num1)
{
while (num1 >= 10) // כל עוד יש יותר מספרה אחת
{
num1 = digitSum(num1); // פעולה נתונה - לא מממשים
}
return num1;
}
public static boolean inBoth(int num1, int num2)
{
return digitExists(num2, deepSum(num1)) && digitExists(num1, deepSum(num2));
}deepSum(5) מחזירה 5, deepSum(36) מחזירה 9, deepSum(942378) מחזירה 6 (דרך 33). inBoth(36, 942378): 9 מופיע ב-942378 ו-6 מופיע ב-36, לכן true. inBoth(36, 123): 9 לא מופיע ב-123, לכן false.א. while (num1 >= 10) num1 = digitSum(num1); ואז return num1;
ב. return digitExists(num2, deepSum(num1)) && digitExists(num1, deepSum(num2)); עבור 36 ו-942378 מוחזר true.
2. מחרוזות: אורך, תו במקום, תת-מחרוזת והשוואה
מחרוזת
מחרוזת היא טקסט: מילה, סיסמה, מסר מוצפן. אפשר לחשוב עליה כמו על מערך של תווים - לכל תו יש מקום (אינדקס), והמקום הראשון הוא 0.
במדויק: הטיפוס הוא String ב-Java ו-string ב-C#, וערך נכתב בין מירכאות: "FGAV". במחרוזת באורך n התווים נמצאים במקומות 0 עד n - 1. בתכנית הלימודים המחרוזות מוגבלות לפעולות charAt, contains, indexOf, length, ולשרשור מחרוזות ומספרים באופרטור +.
הסריקה של מחרוזת היא בדיוק כמו סריקה של מערך (נושא "מערכים"): לולאה על i מ-0 עד האורך, וגישה לתו במקום i. ההבדל הוא רק בתחביר: s.charAt(i) במקום arr[i], ו-s.length() עם סוגריים במקום arr.length.
הפעולות של מחרוזת
הדוגמאות על s = "FGAV" (המחרוזת הסודית מקיץ 2026):
| פעולה | Java | C# | מחזירה | בדוגמה |
|---|---|---|---|---|
| אורך | s.length() | s.Length | מספר התווים | 4 |
| תו במקום i | s.charAt(i) | s[i] | char | s.charAt(1) הוא 'G' |
| מקום של תו או של תת-מחרוזת | s.indexOf(x) | s.IndexOf(x) | המקום של ההופעה הראשונה, או -1 | 'A' - 2; 'C' - -1; "GA" - 1 |
| האם מופיעה תת-מחרוזת | s.contains(x) | s.Contains(x) | ערך בוליאני | "GA" - true; "AG" - false |
| שרשור | s + "!" + 5 | s + "!" + 5 | מחרוזת חדשה | "FGAV!5" |
תבנית: סריקת מחרוזת תו אחר תו
הפעולה countChar / CountChar מחזירה כמה פעמים התו ch מופיע במחרוזת s. countChar("banana", 'a') מחזירה 3.
public static int countChar(String s, char ch)
{
int count = 0;
for (int i = 0; i < s.length(); i++)
{
if (s.charAt(i) == ch) // התו במקום i
count++;
}
return count;
}השוואת שתי מחרוזות תו מול תו
s1.charAt(i) != s2.charAt(i).public static boolean same(String s1, String s2)
{
if (s1.length() != s2.length())
return false; // אורך שונה - לא שוות
for (int i = 0; i < s1.length(); i++)
{
if (s1.charAt(i) != s2.charAt(i))
return false; // ההבדל הראשון מספיק
}
return true; // רק אחרי שכל התווים נבדקו
}same("ABC", "ABC") מחזירה true; same("ABC", "ABD") ו-same("ABC", "AB") מחזירות false.
indexOf מחזירה -1 כשהתו לא נמצא. בודקים place != -1 לפני שמשתמשים במקום. בבול פגיעה בודקים קודם place == i ("בול") ורק אחר כך place != -1 ("פגיעה"); בסדר ההפוך כל "בול" נספר גם כ"פגיעה".
ב-Java האורך של מחרוזת הוא s.length() עם סוגריים, והאורך של מערך הוא arr.length בלי. ב-C# שניהם Length בלי סוגריים. בפעולה originalText של קיץ 2023 יש את שניהם: str.length() ו-orig.length.
ב-Java לא משווים שתי מחרוזות ב-==: האופרטור משווה הפניות ולא את התווים. משווים תו מול תו, כמו בפעולה same. השוואה של תווים בודדים ב-== תקינה, כי char הוא טיפוס בסיסי.
דוגמה - בול פגיעה: ציונים לניחוש מחרוזת
במשחק "בול פגיעה" בוחרים מחרוזת סודית מהאותיות A-Z. כל אות מופיעה בה פעם אחת לכל היותר. בעבור כל אות במחרוזת הניחוש השחקן מקבל ציון:
לדוגמה: בעבור הניחוש "AGCF" למחרוזת הסודית "FGAV": G במקום 1 בשתיהן - "בול" אחד; A ו-F נמצאות במקומות אחרים - שתי "פגיעות"; C לא נמצאת - "החמצה" אחת.
כתבו פעולה חיצונית ששמה guess בשפת Java או Guess בשפת C#, המקבלת מחרוזת סודית secretStr ומחרוזת ניחוש playerStr (שתיהן תקינות). אם האורך של מחרוזת הניחוש שונה מהאורך של המחרוזת הסודית, הפעולה תדפיס "Size Error". אחרת היא תדפיס את מספר ה"בול", את מספר ה"פגיעה" ואת מספר ה"החמצה" (כל הדפסה בשורה חדשה).
void.playerStr.length() != secretStr.length() - מדפיסים "Size Error".c = playerStr.charAt(i), ומחפשים אותה במחרוזת הסודית: place = secretStr.indexOf(c).place == i - בול; אחרת place != -1 - פגיעה; אחרת - החמצה. כל אות מופיעה במחרוזת הסודית פעם אחת לכל היותר, ולכן indexOf מחזירה את המקום היחיד שלה.public static void guess(String secretStr, String playerStr)
{
if (playerStr.length() != secretStr.length())
{
System.out.println("Size Error");
}
else
{
int bul = 0, hit = 0, miss = 0;
for (int i = 0; i < playerStr.length(); i++)
{
char c = playerStr.charAt(i);
int place = secretStr.indexOf(c);
if (place == i)
bul++;
else if (place != -1)
hit++;
else
miss++;
}
System.out.println(bul);
System.out.println(hit);
System.out.println(miss);
}
}| מקום i | c | indexOf(c) | ציון |
|---|---|---|---|
| 0 | A | 2 | פגיעה |
| 1 | G | 1 | בול |
| 2 | C | -1 | החמצה |
| 3 | F | 0 | פגיעה |
הפעולה מדפיסה 1, 2, 1. בעבור "ABCD" ו-"ABC" היא מדפיסה Size Error.
לכל i: place = secretStr.indexOf(playerStr.charAt(i)); place == i - בול, place != -1 - פגיעה, אחרת החמצה. בדוגמה מודפס 1, 2, 1.
3. תווים: הטיפוס char
תו (char)
תו הוא סימן אחד: אות, ספרה, רווח או סימן כמו +. מחרוזת בנויה מתווים, ו-charAt מחזירה תו אחד ממנה.
במדויק: char הוא אחד מטיפוסי הנתונים הבסיסיים בתכנית (int, double, boolean, char). ערך של תו נכתב בין גרשיים: 'A', ומחרוזת בין מירכאות: "A". משווים תווים ב-== וב-!=, כמו מספרים.
מערך של תווים (char[]) הוא מערך של טיפוס בסיסי, כמו int[]. בעזרתו אפשר לסדר תווים במקומות חדשים, ואחר כך לשרשר אותם למחרוזת.
תו מול מחרוזת
| מה | תו | מחרוזת |
|---|---|---|
| טיפוס | char | String / string |
| ערך | 'A' - גרשיים | "A" - מירכאות |
| כמה סימנים | בדיוק אחד | אפס או יותר |
| השוואה | c == '+' | תו מול תו (לא == ב-Java) |
| מאיפה מקבלים | s.charAt(i) / s[i] | מחרוזת קבועה, שרשור ב-+ |
קוד התו: בתכנית ההמרות היחידות שחובה ללמד הן (int) ו-(double). את הקודים של התווים לא צריך לזכור, ולא צריך להמיר מספר לתו. מה שכן צריך לדעת על תווים: לקבל תו ב-s.charAt(i) / s[i], להשוות ב-== וב-!=, לחפש ב-indexOf / IndexOf, ולשרשר למחרוזת ב-+.
שרשור תו למחרוזת מוסיף את התו עצמו: result = result + orig[i] כש-result מחרוזת. מתחילים מ-result = "", אחרת אין למה לשרשר.
דוגמה - פענוח מסר מוצפן בעזרת מערך תווים
כדי להצפין מסר, מערבלים את סדר התווים שלו. למשל מ-World אפשר לקבל את המסר המוצפן rdoWl. למסר המוצפן מצורף "מערך מפענח" באותו גודל: בכל תא מופיע האינדקס המקורי של התו שבאותו מקום במסר המוצפן. בעבור rdoWl המערך המפענח הוא {2, 4, 1, 0, 3}: r נמצא במסר המקורי במקום 2, d במקום 4, o במקום 1, וכן הלאה.
א. רשמו את המערך המפענח בעבור המסר Study, שהוצפן למסר dyutS.
ב. כתבו פעולה חיצונית ששמה originalText בשפת Java או OriginalText בשפת C#, המקבלת מחרוזת מוצפנת str ומערך מפענח arr. הפעולה תחזיר את המחרוזת המקורית.
| מקום במוצפן | תו | מקום במקורי |
|---|---|---|
| 0 | d | 3 |
| 1 | y | 4 |
| 2 | u | 2 |
| 3 | t | 1 |
| 4 | S | 0 |
arr[i] אומר לאן התו ה-i של המסר המוצפן חוזר. יוצרים מערך תווים orig באורך המחרוזת, ולכל i מציבים orig[arr[i]] = str.charAt(i). אחר כך משרשרים את התווים של orig לפי הסדר למחרוזת שמתחילה ב-"".public static String originalText(String str, int[] arr)
{
char[] orig = new char[str.length()];
for (int i = 0; i < str.length(); i++)
{
orig[arr[i]] = str.charAt(i); // התו ה-i במסר המוצפן חוזר למקומו המקורי
}
String result = "";
for (int i = 0; i < orig.length; i++)
{
result = result + orig[i]; // שרשור תו למחרוזת
}
return result;
}originalText("rdoWl", {2, 4, 1, 0, 3}) מחזירה World, ו-originalText("dyutS", {3, 4, 2, 1, 0}) מחזירה Study.result = result + str.charAt(arr[i]) מפעיל את המערך בכיוון ההפוך, ובעבור rdoWl לא מתקבל World.א. {3, 4, 2, 1, 0}.
ב. לכל i: orig[arr[i]] = str.charAt(i), ואז משרשרים את התווים של orig לפי הסדר.