🧠 מערכים ב-Java

📘 תוכן עניינים:

מה זה מערך?
מערכים חד-ממדיים
מערכים דו-ממדיים
שאלות לדוגמה

🔍 מה זה מערך?

מערך הוא מבנה נתונים שמאפשר לשמור מספר ערכים מאותו סוג תחת שם משתנה אחד. לכל איבר במערך יש אינדקס שמתחיל מ־0.

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

1️⃣ מערכים חד-ממדיים

מערך חד־ממדי הוא רשימה של ערכים מאותו סוג. כך מגדירים ומדפיסים מערך:

int[] scores = {90, 85, 70, 100};
System.out.println(scores[0]); // מדפיס 90
System.out.println(scores.length); // אורך המערך

💡 אפשר לעבור על מערך בלולאה:

for (int i = 0; i < scores.length; i++) {
  System.out.println(scores[i]);
}

2️⃣ מערכים דו-ממדיים

מערך דו־ממדי הוא מערך של מערכים — אפשר לחשוב עליו כמו טבלה. כך יוצרים אותו:

int[][] matrix = {
  {1, 2, 3},
  {4, 5, 6},
  {7, 8, 9}
};
System.out.println(matrix[1][2]); // מדפיס 6

🔁 מעבר על כל האיברים:

for (int i = 0; i < matrix.length; i++) {
  for (int j = 0; j < matrix[i].length; j++) {
    System.out.println(matrix[i][j]);
  }
}

שאלה 1: שורת הסכום הגדול ביותר

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

// שיטה שמחזירה את סכום האיברים במערך חד-ממדי
private static int sum(int[] a) {
    int sum = 0;
    for (int i = 0; i < a.length; i++) {
        sum += a[i];
    }
    return sum;
}

// שיטה שמחזירה את אינדקס השורה עם הסכום הגדול ביותר
public static int findMaxSumRow(int[][] a) {
    int maxSum = sum(a[0]);
    int maxRow = 0;
    int curSum;

    for (int i = 1; i < a.length; i++) {
        curSum = sum(a[i]);
        if (maxSum < curSum) {
            maxSum = curSum;
            maxRow = i;
        }
    }
    return maxRow;
}

לדוגמה, עבור מטריצה כמו:

int[][] matrix = {
  {5, 6, 4, 2},
  {10, 2, 5, 6},
  {1, 4, 7, 10},
  {7, 12, 3, 20}
};

הפלט יהיה: השורה עם הסכום הגבוה ביותר היא באינדקס 3.

System.out.println("השורה עם הסכום הגבוה ביותר היא: " + findMaxSumRow(matrix));

📐 mat[i][j] ל־mat[j][i]

בדוגמה הבאה, נשתמש במטריצה בגודל 4×4 וננתח את הפונקציה שמחפשת האם הערכים באלכסון הראשי גדולים מכל מה שלפניהם בשורה, וקטנים מכל מה שמעליהם בעמודה.

public static boolean something(int[][] mat) {
  for (int i = 0; i < mat.length; i++) {
    for (int j = 0; j < i; j++) {
      if (mat[i][j] >= mat[i][i]) return false;
      if (mat[j][i] <= mat[i][i]) return false;
    }
  }
  return true;
}

🧠 משמעות התנאים:

נשתמש ב־mat[i][j] לבדיקת ערכים שנמצאים לפני לאלכסון באותה שורה (j < i).
נשתמש ב־mat[j][i] לבדיקת ערכים שנמצאים מתחת לאלכסון באותה עמודה (j < i).
המטרה לבדוק שכל ערך באלכסון mat[i][i] גדול מאלה שמצידו השמאלי, וקטן מאלה שמתחתיו.

📊 טבלת דוגמה:

i\j	0	1	2	3
0	1	8	4	10
1	-1	-2	6	5
2	1	0	3	12
3	3	1	2	4

התאים הצבועים בירוק הם תאי האלכסון הראשי, i i זה יוצר אלכסון 1,1 2,2 3,3 4,4 וכך הלאה. mat[i][i].
בכל סיבוב של הלולאה אנו בודקים 2 תנאים עבור כל תא באלכסון:
🔸 כל תא mat[i][j] שנמצא לפני האלכסון באותה שורה (j < i) חייב להיות קטן ממנו
🔸 כל תא mat[j][i] שמעל לאלכסון באותה עמודה (j < i) חייב להיות גדול ממנו

🔍 דוגמה לניתוח שורה 2:

האלכסון הוא mat[2][2] = 3:

mat[2][0] = 1 ✅ קטן מ־3 (בסדר)
mat[2][1] = 0 ✅ קטן מ־3 (בסדר)
mat[0][2] = 4 ❌ גדול מ־3 (הפרה של התנאי השני)

🔴 לכן הפונקציה מחזירה false כי יש תנאי שהופר.

📘 JavaScript - מדריך