מערכים בשאלון 899371
כשיש הרבה ערכים מאותו סוג - מהירויות של כל כלי הרכב, עשר הסיסמאות האחרונות, הגילים של המבקרים - לא מגדירים משתנה לכל אחד. שומרים אותם במערך: שם אחד, ותא ממוספר לכל ערך.
במדויק: בנושא מבני נתונים סדרתיים נכללים במיקוד תשפ"ז: מערכים של טיפוסי נתונים בסיסיים (int, double, char...), מושגי היסוד (מציין, אורך, גישה x[i]), הגדרה ואתחול, חיפוש סדרתי ומערך דו-ממדי. לא נכללים: חיפוש בינרי, מיון הכנסה, מיון מיזוג, השוואת היעילות שלהם, ומערך של עצמים (הוא נלמד בנושא הבחירה תכנות מונחה עצמים).
כמעט בכל שאלון 899371 יש מערך: שאלת מעקב על קטע קוד שעובר על מערך, או כתיבת פעולה שמקבלת מערך, משנה אותו או מחזירה מערך חדש.
1. מערך: הגדרה, אתחול, אינדקס ואורך
מערך, מציין ואורך
מערך הוא שורה של תאים צמודים, כולם מאותו טיפוס. לכל תא יש מספר - המציין (אינדקס) - ובעזרתו ניגשים אליו: arr[3] הוא התא שהמציין שלו 3.
במדויק: ההגדרה int[] x יוצרת משתנה; הפקודה x = new int[100] יוצרת עצם שמייצג את המערך, עם 100 תאים מטיפוס int, ו-x מפנה אליו. המציין של התא הראשון הוא 0, ושל האחרון - האורך פחות אחת. האורך הוא x.length ב-Java ו-x.Length ב-C#. כל תא x[i] הוא משתנה לכל דבר: אפשר להשים לתוכו ערך, ולהשתמש בערכו בכל ביטוי. במערך מספרים שנוצר ב-new כל התאים מאותחלים ל-0.
בשאלת מעקב על מערך מבחינים תמיד בין המציין i לבין הערך arr[i]. בשאלון 899371 של קיץ 2024 הקטע משווה ביניהם (digit == i), וזה בדיוק מה שצריך לראות במעקב. בתכנית כלולה גם הלולאה foreach (for (int x : arr) ב-Java, foreach (int x in arr) ב-C#); בה אין מציין i, ולכן בכל שאלה שצריך בה את המקום משתמשים ב-for.
הגדרה, אתחול, גישה ואורך
int[] arr = new int[5]; // 5 תאים, בכולם 0
int[] grades = {90, 75, 100}; // אתחול מקוצר: 3 תאים
grades[1] = 80; // השמה לתא שהמציין שלו 1
int n = grades.length; // 3
int last = grades[grades.length - 1]; // 100 - התא האחרון
for (int i = 0; i < grades.length; i++)
{
System.out.println(grades[i]);
}הקטע מדפיס 90, 80, 100, כל ערך בשורה. arr[0] ו-arr[4] הם 0.
מערך כפרמטר וכערך מוחזר
| מה | Java | C# |
|---|---|---|
| פעולה שמקבלת מערך | public static int f(int[] arr) | public static int F(int[] arr) |
| פעולה שמחזירה מערך | public static int[] f(...) | public static int[] F(...) |
| יצירת מערך חדש באותו גודל | int[] result = new int[arr.length]; | int[] result = new int[arr.Length]; |
| החזרת המערך | return result; | return result; |
כשהשאלה אומרת "תחזיר מערך חדש" ו"אין לשנות את המערך" - יוצרים מערך חדש ב-new, ממלאים אותו, ומחזירים אותו. המערך שהתקבל רק נקרא.
מציין תקין הוא 0 עד length - 1. בלולאה כותבים i < arr.length, לא <=. כשבגוף הלולאה יש a[i + 1], הלולאה עוצרת ב-i < a.length - 1, כמו בשאלת הזוגות הסמוכים בבחינה לדוגמה - אחרת בסיבוב האחרון פונים לתא שלא קיים.
במערך בגודל 7 מציין התא האחרון הוא 6, ולכן בסוף המעקב הלולאה נעצרת כש-i = 7. בשורה האחרונה של טבלת המעקב רושמים את i = 7 ואת התנאי שלא מתקיים.
דוגמה - מעקב: ספרת העשרות מול המציין
נתון מערך arr המכיל מספרים שלמים חיוביים:
| מציין | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
|---|---|---|---|---|---|---|---|
| arr | 30 | 141 | 324 | 623 | 8004 | 458 | 6 |
לפניכם קטע תוכנית, הכתוב בשפות Java ו-C#:
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 היא ספרת העשרות של arr[i].| סיבוב | i | arr[i] | num | digit | digit == i | count |
|---|---|---|---|---|---|---|
| אתחול | - | - | - | - | - | 0 |
| 1 | 0 | 30 | 3 | 3 | לא | 0 |
| 2 | 1 | 141 | 14 | 4 | לא | 0 |
| 3 | 2 | 324 | 32 | 2 | כן | 1 |
| 4 | 3 | 623 | 62 | 2 | לא | 1 |
| 5 | 4 | 8004 | 800 | 0 | לא | 1 |
| 6 | 5 | 458 | 45 | 5 | כן | 2 |
| 7 | 6 | 6 | 0 | 0 | לא | 2 |
| סיום | 7 | - | - | - | 7 < 7 לא מתקיים | 2 |
6 / 10 הוא 0, ולכן digit = 0 ולא 6.count = 2 (בתאים 2 ו-5 ספרת העשרות שווה למציין).
2. סריקת מערך: צבירה, מנייה, מקסימום וחיפוש סדרתי
סריקה מלאה וחיפוש סדרתי
רוב הפעולות על מערך הן לולאה אחת שעוברת על התאים לפי הסדר, ובכל תא עושה משהו קטן: מוסיפה לסכום, מגדילה מונה, משווה לגדול ביותר עד עכשיו.
במדויק: התכנית מבחינה בין בעיות שפתרונן מחייב סריקה מלאה של המערך (צבירה, מנייה, ממוצע, ערכי קיצון) לבין בעיות שאינן מחייבות סריקה מלאה (בדיקת קיום של תכונה). חיפוש סדרתי: עוברים על המערך מהתחלתו; אם הערך נמצא - מחזירים מיד (את המציין, או true / false), ואם הלולאה הסתיימה - הוא לא נמצא. בתכנית: "פעולה שמקבלת מערך וערך כלשהו כפרמטרים ומאחזרת את מיקום הערך במערך".
אלה אותם צובר, מונה ומקסימום של שיעור הלולאות, רק שהערכים באים מ-arr[i] ולא מהקלט. חיפוש בינרי (במערך ממוין) לא במיקוד תשפ"ז.
משימות הסריקה
| משימה | לפני הלולאה | בתוך הלולאה | אחרי הלולאה |
|---|---|---|---|
| סכום | sum = 0 | sum += arr[i] | ממוצע: (double) sum / arr.length |
| מנייה | count = 0 | if (תנאי) count++ | - |
| מקסימום | max = arr[0] | if (arr[i] > max) max = arr[i] | - |
| קיום ("יש לפחות אחד") | - | if (תנאי) return true | return false |
| "כל האיברים" | - | if (!תנאי) return false | return true |
| חיפוש מקום | - | if (arr[i] == x) return i | return -1 |
תבנית: חיפוש סדרתי שמחזיר מקום
public static int find(int[] arr, int x)
{
for (int i = 0; i < arr.length; i++)
{
if (arr[i] == x)
return i; // נמצא: מחזירים את המציין ועוצרים
}
return -1; // רק אחרי שעברנו על כל המערך
}במערך הסיסמאות {1223, 134, 245, 300, 111, 101, 777, 900, 195, 1234}: find(arr, 300) מחזירה 3, find(arr, 1223) מחזירה 0, ו-find(arr, 8888) מחזירה -1.
ב"קיום" וב"חיפוש" התשובה השלילית באה אחרי הלולאה. else return false בתוך הלולאה עוצר כבר בתא הראשון שלא מתאים, ובודק רק אותו.
"לפחות חצי" כותבים count * 2 >= arr.length. הבדיקה count >= arr.length / 2 נותנת תשובה שגויה במערך באורך אי-זוגי: 7 / 2 הוא 3 בחלוקה בשלמים, ואז 3 מתוך 7 נחשב "לפחות חצי".
דוגמה - מערך סטטוסים חדש ובדיקת רוב הקנסות
max ו-min הם המהירות המקסימלית והמינימלית המותרות בקטע כביש. הפעולה getStatus / GetStatus (מסעיף א) מחזירה 1 אם המהירות גבוהה ב-10 קמ"ש לפחות מ-max, -1 אם היא נמוכה ב-10 קמ"ש לפחות מ-min, ו-0 אחרת:
public static int getStatus(int speed, int max, int min)
{
if (speed >= max + 10)
return 1;
if (speed <= min - 10)
return -1;
return 0;
}המערך speeds מטיפוס שלם מכיל את מהירויות הנסיעה של כלי רכב שונים באותו קטע כביש.
ב. כתבו פעולה חיצונית ששמה getAllStatus בשפת Java או GetAllStatus בשפת C# המקבלת את המערך speeds ואת max ו-min. הפעולה תחזיר מערך חדש מטיפוס שלם בגודל זהה למערך speeds, המציג בכל תא את המספר 1 או -1 או 0 בהתאם לכלי הרכב שנמצא באותו האינדקס במערך speeds. יש להשתמש בפעולה מסעיף א. אין לשנות את המערך speeds.
ג. כלי רכב יקבל קנס אם מהירות הנסיעה שלו בקטע כביש זה גבוהה ב-10 קמ"ש לפחות מן המהירות המקסימלית המותרת, או נמוכה ב-10 קמ"ש לפחות מן המהירות המינימלית המותרת. כתבו פעולה חיצונית ששמה mostFined בשפת Java או MostFined בשפת C#, המקבלת את speeds, max ו-min, ומחזירה true אם לפחות חצי מכמות כלי הרכב במערך speeds קיבלו קנס, אחרת false. יש להשתמש בפעולה מסעיף ב.
דוגמה: בעבור max = 70, min = 30 והמערך {80, 50, 79, 90, 20, 100, 25} יוחזר בסעיף ב המערך {1, 0, 0, 1, -1, 1, 0}, ובסעיף ג - true.
speeds.length, ובלולאה על כל המציינים: result[i] = getStatus(speeds[i], max, min). את speeds רק קוראים.-1). קוראים ל-getAllStatus, סופרים את התאים השונים מ-0, ובודקים "לפחות חצי" בלי חלוקה: count * 2 >= speeds.length.public static int[] getAllStatus(int[] speeds, int max, int min)
{
int[] result = new int[speeds.length]; // מערך חדש באותו גודל
for (int i = 0; i < speeds.length; i++)
{
result[i] = getStatus(speeds[i], max, min);
}
return result;
}
public static boolean mostFined(int[] speeds, int max, int min)
{
int[] status = getAllStatus(speeds, max, min);
int count = 0;
for (int i = 0; i < status.length; i++)
{
if (status[i] != 0)
count++;
}
return count * 2 >= speeds.length; // לפחות חצי, בלי חלוקה בשלמים
}[1, 0, 0, 1, -1, 1, 0], ו-speeds נשאר [80, 50, 79, 90, 20, 100, 25]. יש 4 קנסות מתוך 7, ו-4 * 2 = 8 >= 7, לכן mostFined החזירה true. בעבור 3 קנסות מתוך 7 היא החזירה false, ובעבור 2 מתוך 4 - true.ב. מערך חדש: result[i] = getStatus(speeds[i], max, min) לכל i.
ג. סופרים תאים שונים מ-0 במערך מ-getAllStatus ומחזירים count * 2 >= speeds.length. בדוגמה: true.
3. שינוי מערך: החלפת ערכים, הזזת איברים ומערך עזר
שינוי המערך שהתקבל
חלק מהשאלות לא מבקשות לחשב משהו על המערך, אלא לשנות אותו: להכניס ערך חדש בהתחלה, לערבב, לסדר מחדש.
במדויק: משתנה המערך מפנה אל העצם שמייצג את המערך. כשמעבירים מערך לפעולה, הפעולה מקבלת הפניה לאותו מערך, ולכן כל שינוי בתאים שלו נשאר גם אחרי שהפעולה מסתיימת. פעולה כזאת היא בדרך כלל void. שלוש פעולות חוזרות: החלפה של שני ערכים בעזרת משתנה עזר, הזזה של איברים בתא אחד, ומערך עזר שבונים בו את הסידור החדש ומעתיקים בחזרה.
כשהשאלה דורשת "אין לשנות את המערך" - עושים את ההפך: יוצרים מערך חדש ומחזירים אותו (שיעור הסריקה).
תבנית: החלפה והזזה ימינה
// החלפת הערכים שבתאים i ו-j
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
// הזזה ימינה בתא אחד: מהסוף להתחלה (הערך שבתא האחרון נדרס)
for (int k = arr.length - 1; k > 0; k--)
{
arr[k] = arr[k - 1];
}
arr[0] = 0; // התא הראשון פנוי לערך חדשעל {1, 2, 3, 4, 5} עם i = 0 ו-j = 4: אחרי ההחלפה {5, 2, 3, 4, 1}, ואחרי ההזזה {0, 5, 2, 3, 4} (ה-1 שבתא האחרון נדרס).
שינוי מערך בלי לאבד ערכים
a[i] = a[j]; a[j] = a[i]; בלי temp משאיר את שני התאים עם אותו ערך.הזזה ימינה משמאל לימין (for (k = 1; ...) a[k] = a[k - 1]) מעתיקה את הערך של תא 0 לכל התאים: על {1, 2, 3, 4, 5} מתקבל {1, 1, 1, 1, 1}.
כשמספר הפעולות נספר רק בתנאי, לא משתמשים בלולאת for עם מספר סיבובים קבוע. במערך המעורבל "אם בהגרלה עלו שני מספרי אינדקס זהים, ההגרלה לא תיחשב": לולאת while עם מונה שגדל רק כש-i != j.
החלפה של איבר שלילי עם החיובי שאחריו לא שומרת על הסדר בתוך כל קבוצה. כשהשאלה מדגישה "באותו הסדר", מערך עזר עם שני מעברים הוא הדרך הבטוחה.
דוגמה א - מערך סיסמאות: חיפוש והזזה ימינה
"מערך סיסמאות" הוא מערך מטיפוס שלם בגודל 10, ובו עשר הסיסמאות האחרונות של לקוח, מהחדשה (תא 0) לישנה ביותר (התא האחרון). כשמתקבלת סיסמה חדשה, הסיסמה שבתא האחרון נמחקת, שאר הסיסמאות זזות ימינה כל אחת לתא שלידה, והחדשה נכנסת לתא 0.
כתבו פעולה בוליאנית חיצונית ששמה getPass בשפת Java או GetPass בשפת C#, המקבלת מערך סיסמאות מלא arr וסיסמה password מטיפוס שלם. אם הסיסמה חדשה (אינה זהה לשום סיסמה במערך), הפעולה תוסיף אותה בתא 0 (לאחר הזזת שאר הסיסמאות תא אחד ימינה) ותחזיר true. אחרת המערך יישאר ללא שינוי ויוחזר false.
דוגמה: בעבור המערך {1223, 134, 245, 300, 111, 101, 777, 900, 195, 1234} ו-password = 300 יוחזר false. בעבור password = 8888 יוחזר true, והמערך יהיה {8888, 1223, 134, 245, 300, 111, 101, 777, 900, 195}.
arr.length - 1 עד 1, arr[i] = arr[i - 1]. הערך שבתא האחרון נדרס - זו המחיקה של הסיסמה הישנה ביותר.arr[0] = password ומחזירים true.public static boolean getPass(int[] arr, int password)
{
for (int i = 0; i < arr.length; i++)
{
if (arr[i] == password)
return false; // הסיסמה כבר קיימת: לא משנים כלום
}
for (int i = arr.length - 1; i > 0; i--)
{
arr[i] = arr[i - 1]; // הזזה ימינה, מהסוף להתחלה
}
arr[0] = password;
return true;
}{8888, 1223, 134, 245, 300, 111, 101, 777, 900, 195}, כמו בדוגמה.חיפוש סדרתי: אם password נמצאת - return false. אחרת הזזה ימינה מהסוף (arr[i] = arr[i - 1]), arr[0] = password, return true.
דוגמה ב - חיוביים לפני שליליים בעזרת מערך עזר
ממשו את הפעולה arrange בשפת Java או Arrange בשפת C# (public static void arrange(int[] arr)). במערך arr יש מספרים חיוביים ושליליים. הפעולה מעבירה לתחילת המערך את כל המספרים החיוביים (כולל 0), וממקמת אחריהם את כל השליליים. הסדר של החיוביים בינם לבין עצמם יישאר באותו הסדר, וגם הסדר של השליליים בינם לבין עצמם.
דוגמה: {7, -2, -5, 61, 4, -1, 0, 33} ייראה בסיום הפעולה {7, 61, 4, 0, 33, -2, -5, -1}.
>= 0.< 0.void והשינוי צריך להיות במערך שהתקבל.public static void arrange(int[] arr)
{
int[] temp = new int[arr.length];
int k = 0; // המקום הפנוי הבא ב-temp
for (int i = 0; i < arr.length; i++)
{
if (arr[i] >= 0) // מעבר ראשון: החיוביים (כולל 0)
{
temp[k] = arr[i];
k++;
}
}
for (int i = 0; i < arr.length; i++)
{
if (arr[i] < 0) // מעבר שני: השליליים
{
temp[k] = arr[i];
k++;
}
}
for (int i = 0; i < arr.length; i++)
{
arr[i] = temp[i]; // מעתיקים בחזרה ל-arr
}
}7, 61, 4, 0, 33 ו-k = 5; אחרי השני {7, 61, 4, 0, 33, -2, -5, -1}, וזה מה שהתקבל ב-arr. גם {0, -9, 0} נעשה {0, 0, -9}.מעתיקים למערך עזר קודם את כל האיברים >= 0 לפי הסדר, אחריהם את כל השליליים לפי הסדר, ומעתיקים בחזרה ל-arr.
4. מערך מונים
מערך מונים
כשצריך לספור לא דבר אחד אלא כמה דברים בבת אחת - כמה מבקרים בכל מתקן, כמה יחידות מכל מוצר - מחזיקים מונה לכל אחד מהם, והמונים יושבים במערך.
במדויק: מערך מונים הוא מערך שבו התא i סופר (או צובר) את מה ששייך לקטגוריה i. גודל המערך הוא מספר הקטגוריות האפשריות, וכל התאים מתחילים ב-0 (כך מערך שנוצר ב-new). הקטגוריה קובעת את המציין: ערך בתחום 0 עד 99 משמש ישירות כמציין, במערך בגודל 100. לכן אין צורך בלולאה פנימית שמחפשת את המונה הנכון: counters[x]++.
מונים, צוברים וערכי קיצון הם המשימות הטיפוסיות של שיעור הלולאות; מערך מונים הוא הרבה מונים כאלה תחת שם אחד.
מה נכנס לתא, ואיזה תא
| מצב | המציין | העדכון |
|---|---|---|
| הערך עצמו הוא הקטגוריה (ספרה, קוד 0-99) | הערך: counters[arr[i]] | counters[arr[i]]++ |
| קטגוריות קבועות שהשאלה ממספרת (תא 0 מקפצה, תא 1 ג'קוזי...) | מספר הקטגוריה | counters[k]++ או counters[k] += allowed[k] |
| צבירה ולא מנייה (סך יחידות לכל מוצר) | הקוד של המוצר | sums[id] += quantity |
int[] counters = new int[10]; // תא לכל ערך אפשרי 0 עד 9, בכולם 0
for (int i = 0; i < arr.length; i++)
{
counters[arr[i]]++; // הערך שבתא הוא המציין של המונה
}על {3, 1, 3, 0, 9, 3, 1} מתקבל counters = {1, 2, 0, 3, 0, 0, 0, 0, 0, 1}.
גודל המערך הוא מספר הערכים האפשריים, לא הערך הגדול ביותר. לקוד בין 0 ל-99 (כולל) צריך new int[100]; במערך בגודל 99 אין תא 99.
כשכמה קטגוריות יכולות להתקיים יחד (בן 18 רשאי בשלושת המתקנים), כותבים if נפרד לכל קטגוריה ולא else if. עם else if בן 18 יקבל רק [1, 0, 0].
דוגמה - מונה לכל מתקן בבריכה
בבריכה יש 3 מתקנים: במקפצה יכולים להשתמש בני 12 ומעלה, בג'קוזי בני 16 ומעלה, ובסאונה בני 18 ומעלה.
(ב-Java הניחו שבתוכנית כתובה ההוראה Scanner input = new Scanner(System.in);.)
new int[3] - כל התאים 0. שלושה if נפרדים, אחד לכל מתקן, כי מבקר יכול להיות רשאי בכמה מתקנים.allowed = checkAge(age); כל עוד המבקר רשאי במתקן אחד לפחות (סכום שלושת התאים גדול מ-0), מוסיפים allowed[i] ל-counters[i] לכל i (1 מגדיל את המונה, 0 לא משנה), וקולטים את הבא.public static int[] checkAge(int age)
{
int[] arr = new int[3]; // כל התאים מאותחלים ל-0
if (age >= 12)
arr[0] = 1; // מקפצה
if (age >= 16)
arr[1] = 1; // ג'קוזי
if (age >= 18)
arr[2] = 1; // סאונה
return arr;
}
public static void count()
{
int[] counters = new int[3]; // מונה לכל מתקן, באותו סדר
int age = input.nextInt();
int[] allowed = checkAge(age);
while (allowed[0] + allowed[1] + allowed[2] > 0)
{
for (int i = 0; i < 3; i++)
counters[i] = counters[i] + allowed[i];
age = input.nextInt();
allowed = checkAge(age);
}
System.out.println(counters[0] + "," + counters[1] + "," + counters[2]);
}checkAge(18) החזירה [1, 1, 1], ו-checkAge(15) החזירה [1, 0, 0]. בעבור הקלט 13, 17, 25, 16, 12, 30, 19, 8 הודפס 7,5,3: למקפצה כל 7 המבקרים שלפני ה-8, לג'קוזי 17, 25, 16, 30, 19, ולסאונה 25, 30, 19.int[3]; arr[0] = 1 אם age >= 12, arr[1] = 1 אם age >= 16, arr[2] = 1 אם age >= 18.counters[i] += allowed[i]; בסוף מדפיסים את 3 המונים.5. מערך דו-ממדי
מערך דו-ממדי: שורות ועמודות
מערך דו-ממדי הוא טבלה: יש בו שורות ועמודות, וכל תא מזוהה בשני מספרים - מספר השורה ומספר העמודה. תמונה של נקודות, לוח משחק, ציונים של כל תלמיד בכל מקצוע.
במדויק: בתכנית נלמדים מערכים מלבניים בלבד - בכל שורה אותו מספר עמודות. התא בשורה i ובעמודה j הוא m[i][j] ב-Java ו-m[i, j] ב-C#, ושני המציינים מתחילים ב-0. מספר השורות: m.length ב-Java, m.GetLength(0) ב-C#. מספר העמודות: m[0].length (או m[i].length) ב-Java, m.GetLength(1) ב-C#. מערך דו-ממדי חדש מאותחל, כמו חד-ממדי, ל-0 בכל התאים.
מערך דו-ממדי נכנס למיקוד של 899371 רק בתשפ"ז. בשאלוני 899371 שבאתר הוא מופיע רק בבחינה לדוגמה (המחלקה Structure, שבה מערך דו-ממדי של נקודות). שם כל תא נבדק בקריאה אחת לפעולה של הנקודה, ומה שהשאלה בודקת הוא הסריקה בשני מציינים. המשימות הטיפוסיות בתכנית: סריקה לפי שורות ולפי עמודות, האלכסון הראשי והמשני, צבירה, הפיכה וסיבוב, מציאת הערך המקסימלי, ממוצע האיברים בכל שורה.
התחביר ב-Java וב-C#
int[][] mat = new int[3][4]; // 3 שורות, 4 עמודות, בכולם 0
int[][] m = {{1, 2, 3}, {4, 5, 6}}; // אתחול מקוצר: 2 שורות, 3 עמודות
m[1][2] = 60; // שורה 1, עמודה 2
int rows = m.length; // 2 - מספר השורות
int cols = m[0].length; // 3 - מספר העמודות| מה | Java | C# |
|---|---|---|
| הגדרה ויצירה | int[][] m = new int[3][4]; | int[,] m = new int[3, 4]; |
| תא בשורה i ובעמודה j | m[i][j] | m[i, j] |
| מספר השורות | m.length | m.GetLength(0) |
| מספר העמודות | m[0].length | m.GetLength(1) |
תבנית: לולאה כפולה ואלכסונים
// סכום כל שורה: החיצונית על השורות, הפנימית על העמודות
for (int i = 0; i < m.length; i++)
{
int sum = 0; // מאפסים בתחילת כל שורה
for (int j = 0; j < m[i].length; j++)
{
sum += m[i][j];
}
System.out.println(sum);
}
// מערך ריבועי n×n: האלכסון הראשי והמשני בלולאה אחת
int n = m.length;
int sumMain = 0, sumSecond = 0;
for (int i = 0; i < n; i++)
{
sumMain += m[i][i];
sumSecond += m[i][n - 1 - i];
}על {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} הקטע מדפיס 6, 15, 24 (סכומי השורות), ובסופו sumMain = 15 (1 + 5 + 9) ו-sumSecond = 15 (3 + 5 + 7).
| סריקה | הלולאה החיצונית | הלולאה הפנימית | התא |
|---|---|---|---|
| לפי שורות | i על השורות | j על העמודות | m[i][j] |
| לפי עמודות | j על העמודות | i על השורות | m[i][j] |
| אלכסון ראשי (n×n) | i מ-0 עד n - 1 | - | m[i][i] |
| אלכסון משני (n×n) | i מ-0 עד n - 1 | - | m[i][n - 1 - i] |
"קיימת שורה ש... לכל": שתי לולאות ודגל לכל שורה
all = true (או מונה = 0).return true.return false.באותה דרך "לכל שורה קיים...": מחליפים את התפקידים - הפנימית מחפשת, והחיצונית מחזירה false כשבשורה לא נמצא.
הדגל או המונה של שורה מאופס בתוך הלולאה החיצונית, בתחילת כל שורה. מי שמאפס אותו פעם אחת לפני שתי הלולאות ממשיך לסחוב את התוצאה מהשורה הקודמת.
השוואה של שלושה מונים כותבים red == green && green == blue. הביטוי red == green == blue לא חוקי ב-Java: red == green הוא ערך בוליאני, ואי אפשר להשוות אותו ל-int.
ב-C# כותבים m[i, j] ו-m.GetLength(0) / m.GetLength(1), לא m[i][j] ולא m[0].Length. כך גם בפתרון C# של השאלה בבחינה לדוגמה.
דוגמה - קיימת שורה שכל הנקודות בה בצבע אחר
נתונה המחלקה Pixel (נקודה בתמונה). בין הפעולות שלה: isOther() / IsOther() מחזירה true אם הנקודה בצבע שאינו כחול, אדום וירוק. אפשר להשתמש בפעולות המחלקה בלי לממש אותן.
נתונה המחלקה Structure, ולה תכונה אחת בלבד: arr - מערך דו-ממדי מטיפוס Pixel בגודל N*N.
כתבו פעולה פנימית במחלקה Structure ששמה allOthers בשפת Java או AllOthers בשפת C#. הפעולה תחזיר true אם קיימת שורה במערך arr כך שמתקיים התנאי: לכל נקודה בשורה יש צבע שונה מכחול, אדום וירוק. אחרת, הפעולה תחזיר false.
מה בודקים כאן: סריקה של מערך דו-ממדי, "קיימת שורה ש... לכל". הקריאה arr[i][j].isOther() היא רק התנאי על תא אחד, והמבנה של שתי הלולאות והדגל לא תלוי בה.
all = true, ולולאה פנימית על j. נקודה שאינה "אחרת" (!arr[i][j].isOther()) מכבה את all.public boolean allOthers()
{
for (int i = 0; i < arr.length; i++)
{
boolean all = true; // מניחים שכל הנקודות בשורה i אחרות
for (int j = 0; j < arr[i].length; j++)
{
if (!arr[i][j].isOther())
all = false; // נקודה אחת פוסלת רק את השורה הזאת
}
if (all)
return true; // נמצאה שורה מתאימה
}
return false; // אף שורה לא מתאימה
}לכל שורה: all = true; כל נקודה שאינה isOther מאפסת את all; אם all נשאר true - return true. בסוף return false.