דילוג לתוכן המרכזי

סיכום מערכים

מדעי המחשב לבגרות · 5 נושאים

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

מערכים בשאלון 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.

מערך כפרמטר וכערך מוחזר

מהJavaC#
פעולה שמקבלת מערך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 המכיל מספרים שלמים חיוביים:

מציין0123456
arr3014132462380044586

לפניכם קטע תוכנית, הכתוב בשפות 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.

פתרון
1.מה מחשבים: arr[i] / 10 היא חלוקה בשלמים, והיא מורידה את ספרת האחדות. לכן num % 10 היא ספרת העשרות של arr[i].
2.מה סופרים: count גדל כשספרת העשרות של הערך שווה למציין של התא.
סיבובiarr[i]numdigitdigit == icount
אתחול-----0
103033לא0
21141144לא0
32324322כן1
43623622לא1
5480048000לא1
65458455כן2
76600לא2
סיום7---7 < 7 לא מתקיים2
3.בדיקה: הרצת הקטע על המערך מדפיסה count = 2.
4.שימו לב לתא האחרון: בעבור 6, 6 / 10 הוא 0, ולכן digit = 0 ולא 6.
תשובה

count = 2 (בתאים 2 ו-5 ספרת העשרות שווה למציין).

2. סריקת מערך: צבירה, מנייה, מקסימום וחיפוש סדרתי

סריקה מלאה וחיפוש סדרתי

רוב הפעולות על מערך הן לולאה אחת שעוברת על התאים לפי הסדר, ובכל תא עושה משהו קטן: מוסיפה לסכום, מגדילה מונה, משווה לגדול ביותר עד עכשיו.
במדויק: התכנית מבחינה בין בעיות שפתרונן מחייב סריקה מלאה של המערך (צבירה, מנייה, ממוצע, ערכי קיצון) לבין בעיות שאינן מחייבות סריקה מלאה (בדיקת קיום של תכונה). חיפוש סדרתי: עוברים על המערך מהתחלתו; אם הערך נמצא - מחזירים מיד (את המציין, או true / false), ואם הלולאה הסתיימה - הוא לא נמצא. בתכנית: "פעולה שמקבלת מערך וערך כלשהו כפרמטרים ומאחזרת את מיקום הערך במערך".

אלה אותם צובר, מונה ומקסימום של שיעור הלולאות, רק שהערכים באים מ-arr[i] ולא מהקלט. חיפוש בינרי (במערך ממוין) לא במיקוד תשפ"ז.

משימות הסריקה

משימהלפני הלולאהבתוך הלולאהאחרי הלולאה
סכוםsum = 0sum += arr[i]ממוצע: (double) sum / arr.length
מנייהcount = 0if (תנאי) count++-
מקסימוםmax = arr[0]if (arr[i] > max) max = arr[i]-
קיום ("יש לפחות אחד")-if (תנאי) return truereturn false
"כל האיברים"-if (!תנאי) return falsereturn true
חיפוש מקום-if (arr[i] == x) return ireturn -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.

פתרון
1.ב: יוצרים מערך result בגודל speeds.length, ובלולאה על כל המציינים: result[i] = getStatus(speeds[i], max, min). את speeds רק קוראים.
2.ג: כלי רכב מקבל קנס בדיוק כשהסטטוס שלו שונה מ-0 (1 או -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;     // לפחות חצי, בלי חלוקה בשלמים
}
3.בדיקה: על נתוני הדוגמה getAllStatus החזירה [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 שבתא האחרון נדרס).

דרך הפתרון

שינוי מערך בלי לאבד ערכים

1.החלפה: שומרים ערך אחד ב-temp לפני שדורסים אותו. a[i] = a[j]; a[j] = a[i]; בלי temp משאיר את שני התאים עם אותו ערך.
2.הזזה ימינה: רצים מהסוף להתחלה, כך שכל תא מועתק לפני שדורסים אותו. התא הראשון מתפנה לערך החדש.
3.סידור מחדש ששומר על הסדר: מערך עזר temp בגודל המקורי ומונה k למקום הפנוי הבא; מעבר אחד לכל קבוצה, לפי הסדר.
4.מעתיקים בחזרה את temp ל-arr בלולאה - אחרת המערך שהתקבל לא משתנה.
שים לב

הזזה ימינה משמאל לימין (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}.

פתרון
1.חיפוש סדרתי: אם תא כלשהו שווה ל-password - מחזירים false מיד, לפני שנגענו במערך.
2.הזזה ימינה מהסוף: i יורד מ-arr.length - 1 עד 1, arr[i] = arr[i - 1]. הערך שבתא האחרון נדרס - זו המחיקה של הסיסמה הישנה ביותר.
3.הכנסה: 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;
}
4.בדיקה: 300 - הוחזר false והמערך לא השתנה. 8888 - הוחזר 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}.

פתרון
1.מערך עזר temp באותו גודל, ומונה k - המקום הפנוי הבא ב-temp.
2.מעבר ראשון: מעתיקים ל-temp, לפי הסדר, כל איבר >= 0.
3.מעבר שני: מעתיקים אחריהם, לפי הסדר, כל איבר < 0.
4.מעבר שלישי: מעתיקים את temp בחזרה ל-arr, כי הפעולה 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
    }
}
5.בדיקה: אחרי המעבר הראשון temp מתחיל ב-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 ומעלה.

1.כתבו פעולה בשם checkAge (ב-C# CheckAge) שתקבל מספר שלם age, ותחזיר מערך חד-ממדי של מספרים שלמים בגודל 3: תא 0 מקפצה, תא 1 ג'קוזי, תא 2 סאונה. בתא יופיע 1 בעבור מתקן שהמבקר רשאי להשתמש בו, ו-0 בעבור מתקן שאינו רשאי.
2.כתבו פעולה בשם count (ב-C# Count) שתקלוט בעבור יום מסוים את גילו של כל מבקר בבריכה. הקלט מסתיים כאשר ייקלט מבקר שאינו רשאי להשתמש בשום מתקן. הפעולה תדפיס את מספר המבקרים שרשאים להשתמש בכל אחד מן המתקנים באותו יום. דוגמה להדפסה: 10,20,15

(ב-Java הניחו שבתוכנית כתובה ההוראה Scanner input = new Scanner(System.in);.)

פתרון
1.checkAge: new int[3] - כל התאים 0. שלושה if נפרדים, אחד לכל מתקן, כי מבקר יכול להיות רשאי בכמה מתקנים.
2.count: מערך מונים counters בגודל 3, באותו סדר כמו המערך ש-checkAge מחזירה. לולאת זקיף: קולטים גיל ומחשבים allowed = checkAge(age); כל עוד המבקר רשאי במתקן אחד לפחות (סכום שלושת התאים גדול מ-0), מוסיפים allowed[i] ל-counters[i] לכל i (1 מגדיל את המונה, 0 לא משנה), וקולטים את הבא.
3.הסיום: המבקר שעצר את הקלט לא נספר, כי הלולאה נגמרת לפני שמוסיפים אותו.
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]);
}
4.בדיקה: 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.
תשובה
1.מערך int[3]; arr[0] = 1 אם age >= 12, arr[1] = 1 אם age >= 16, arr[2] = 1 אם age >= 18.
2.לולאת זקיף עם checkAge: כל עוד המבקר רשאי במתקן כלשהו - 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 - מספר העמודות
מהJavaC#
הגדרה ויצירהint[][] m = new int[3][4];int[,] m = new int[3, 4];
תא בשורה i ובעמודה jm[i][j]m[i, j]
מספר השורותm.lengthm.GetLength(0)
מספר העמודותm[0].lengthm.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]
דרך הפתרון

"קיימת שורה ש... לכל": שתי לולאות ודגל לכל שורה

1.הלולאה החיצונית עוברת על השורות - היא ה"קיימת".
2.בתחילת כל שורה מאפסים את הדגל: all = true (או מונה = 0).
3.הלולאה הפנימית עוברת על התאים בשורה - היא ה"לכל". תא שלא מתאים מכבה את הדגל.
4.אחרי הלולאה הפנימית: אם הדגל עדיין true - return true.
5.אחרי הלולאה החיצונית: 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() היא רק התנאי על תא אחד, והמבנה של שתי הלולאות והדגל לא תלוי בה.

1."קיימת שורה" - לולאה חיצונית על השורות i.
2."לכל נקודה בשורה" - בתחילת כל שורה all = true, ולולאה פנימית על j. נקודה שאינה "אחרת" (!arr[i][j].isOther()) מכבה את all.
3.אחרי כל שורה: אם all עדיין true - מצאנו שורה ומחזירים true. אחרי כל השורות - false.
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;                      // אף שורה לא מתאימה
}
4.בדיקה (R/G/B - נקודה אדומה/ירוקה/כחולה, O ו-Y - צבע אחר): בעבור השורות RGB, ORG, BOO הוחזר false - בכל שורה יש נקודה אדומה, ירוקה או כחולה. בעבור RRG, OYO, BGR הוחזר true - השורה שהמציין שלה 1 כולה "אחרות". מערך 1×1 עם R - false.
תשובה

לכל שורה: all = true; כל נקודה שאינה isOther מאפסת את all; אם all נשאר true - return true. בסוף return false.

כל האתר במבט אחד

קיצורי דרך לכל הכלים, הבגרויות והקורסים

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