פתרון בעיות הכוללות מערכים חד מימדיים ודו מימדיים

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

1. מערכים חד מימדיים

   1. בעיות "המשך ברצף" ;
   2. משימות חיפוש אלמנטים;
   3. בעיות הקשורות למיון אלמנטים של מערך.

2. מערכים דו מימדיים

   1. משימות "בניית מטריצה ​​של הטופס" ;
   2. משימות "מצא אלמנטים במקומות הכי לא צפויים (שורות, עמודות, אלכסונים)" ;
   3. משימות "ארגן את הספינות לקרב מים . "

עבור כל הבעיות נשתמש במערכים של מספרים שלמים.

בעיות הכרוכות במערכים חד מימדיים

המשך ברצף

בסדרת המשימות הזו תצטרכו:

1. קבע את התבנית שלפיה נוצר רצף מספרי זה או אחר.
2. כתוב פונקציה שיוצרת את N האלמנטים הראשונים של רצף נתון כמערך שלמים ומציגה את רכיבי המערך על המסך.

נניח שעומדת בפנינו המשימה להמשיך את סדרת המספרים הבאה:

1, 2, 3, 4, 5…

שלב 1: זהה את התבנית. הכל כאן אלמנטרי - זו סדרה של מספרים טבעיים. שלב 2: כתוב פונקציה שתיצור את N האלמנטים הראשונים של שורה נתונה בצורה של מערך:

public class Main {

    public static void main(String[] args) {
        System.out.println(Arrays.toString(createArrayOfIntegers(10)));

        // Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    }

    public static int[] createArrayOfIntegers(int n) {
        int[] array = new int[n];
        for (int i = 1; i <= n; i++) {
            array[i-1] = i;
        }

        return array;
    }
}

באופן דומה, יש צורך לכתוב פונקציות שימשיכו את הרצפים הבאים:

A. 2,  4,  6,   8,  10...
B. 1,  3,  5,   7,   9...
C. 1,  4,  9,  16,  25...
D. 1,  8, 27,  64, 125...
E. 1, -1,  1,  -1,   1,  -1...
F. 1, -2,  3,  -4,   5,  -6...
G. 1, -4,  9, -16,  25....
H. 1,  0,  2,   0,   3,   0,  4....
I. 1,  2,  6,  24, 120, 720...
J. 1,  1,  2,   3,   5,   8, 13, 21…

חפש אלמנטים

בסדרת משימות זו, יש צורך למצוא אלמנט במערך המוגמר שיש לו כמה מאפיינים. לדוגמה, האלמנט עם הערך המקסימלי. כדי להדגים, בואו נכתוב קוד לפונקציה שלוקחת מערך וקובעת את האינדקס של האלמנט המקסימלי במערך, ולאחר מכן תוציא את האלמנט הזה יחד עם האינדקס שלו לקונסולה. אני גם אדגים כיצד, באמצעות המחלקה, java.util.concurrent.ThreadLocalRandomאתה יכול ליצור במהירות מערך שלמים באורך נתון, המורכב מאלמנטים אקראיים:

public class Main {

    public static void main(String[] args) {
        int[] array = generateRandomIntArray(10);
        findMax(array);

        /*
        Output:
        Generated random array: [50551934, -551646189, 410352642, 1822778873, -1744293692, -1140287711, 878876868, -2116893120, -797503442, -703924530]
        Max element is [1822778873] with index [3]
        */

    }


    public static int[] generateRandomIntArray(int n) {
        int[] array = ThreadLocalRandom.current().ints().limit(n).toArray();
        System.out.println("Generated random array: " + Arrays.toString(array));
        return array;
    }

    public static void findMax(int[] array) {
        int maxIndex = 0;
        int max = array[maxIndex];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
                maxIndex = i;
            }
        }

        System.out.println(String.format("Max element is [%d] with index [%d]", max, maxIndex));
    }
}

עכשיו המשימות עצמן. מתוך מערך של אלמנטים שלמים אקראיים עלינו למצוא:

1. מַקסִימוּם.
2. מִינִימוּם.
3. מְמוּצָע.
4. מספר האלמנטים בין האלמנטים המקסימליים למינימום.
5. המספר הראשוני הראשון.
6. המספר הראשוני האחרון.
7. מספר המספרים הראשוניים במערך.

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

מִיוּן

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

• מיון בועות;
• מיון בחירה;
• מיון הכנסה;
• מיזוג מיון.

בעיות הכרוכות במערכים דו מימדיים

צייר מטריצה

בסדרת המשימות הבאה, יש צורך לצייר (פלט לקונסולה) מערכים דו מימדיים (מטריצות) המורכבים בצורה מסוימת: עליהם להתאים לתבנית שצוינה במשימה. תן לי לתת לך דוגמה. עלינו לבנות ולהציג מטריצה m*n​​(היכן mהוא מספר השורות, והוא nמספר האלמנטים בשורה) של הטופס:

1, 2, 3, 4
5, 6, 7, 8
9,10,11,12

בואו נכתוב פונקציה שתעשה הכל בשבילנו, וגם נספק פונקציה שתוציא יפה את המטריצה ​​לקונסולה (ייתכן שתמצא אותה שימושית):

public class Main {

    public static void main(String[] args) {
        createAndDrawMatrix(3, 4);

    }

    public static void createAndDrawMatrix(int m, int n) {
        int[][] matrix = new int[m][n];

        int value = 1;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                matrix[i][j] = value;
                value ++;
            }
        }

        printMatrix(matrix);
    }

    public static void printMatrix(int[][] matrix) {
        for (int[] array : matrix) {
            for (int anInt : array) {
                System.out.print(String.format("%3d", anInt));
            }
            System.out.println();
        }
    }
}

עכשיו משימות: הצג מטריצה m*n​​של הטופס: 4, 3, 2, 1 8, 7, 6, 5, 12,11,10, 9 ----------- 1, 4, 7 2, 5, 8 3, 6, 9 ----------- 9, 8, 7 6, 5, 4 3, 2, 1 ----------- 12,11,10, 9 8, 7, 6, 5, 4, 3, 2, 1

חפש אלמנטים

בחלק זה, יש צורך ליישם חיפוש אחר אלמנטים שונים בחלקים שונים של המטריצה: בעמודה מסוימת או בשורה מסוימת. נניח שיש לנו מטריצה ​​של הצורה: -1 2 -3 4 -5 6 -7 8 -9 10 -11 12 -13 14 -15 16 -17 18 -19 20 -21 22 -23 24 -25 26 -27 28 -29 30 -31 32 -33 34 -35 כדוגמה, בוא נמצא את מספר האלמנטים השליליים בשורה השלישית:

public class Main {

    public static void main(String[] args) {
        int [][] matrix = {
                { -1,   2,   -3,    4,   -5,    6,   -7},
                {  8,  -9,   10,  -11,   12,  -13,   14},
                {-15,  16,  -17,   18,  -19,   20,  -21},
                { 22, -23,   24,  -25,   26,  -27,   28},
                {-29,  30,  -31,   32,  -33,   34,  -35}
        };

        findNegativeCountInRow(matrix, 3);
    }

    private static void findNegativeCountInRow(int[][] matrix, int rowNumber) {
        int negativeCount = 0;
        for (int element : matrix[rowNumber]){
            if (element < 0) {
                negativeCount ++;
            }
        }

        System.out.println("Matrix: ");
        printMatrix(matrix);
        System.out.println(String.format("Has %d negative elements in #%d row ", negativeCount, rowNumber));

    }

    public static void printMatrix(int[][] matrix) {
        for (int[] array : matrix) {
            for (int anInt : array) {
                System.out.print(String.format("%5d", anInt));
            }
            System.out.println();
        }
    }
}

כתוצאה מביצוע השיטה הראשית, יישלחו למסוף הנתונים הבאים:

Matrix: 
   -1    2   -3    4   -5    6   -7
    8   -9   10  -11   12  -13   14
  -15   16  -17   18  -19   20  -21
   22  -23   24  -25   26  -27   28
  -29   30  -31   32  -33   34  -35
Has 3 negative elements in #3 row 

עכשיו המשימות. עבור כל אי זוגי, nהדפס מטריצה n*n​​של הטופס:

1,  -2,  3,  
-4,  5, -6,
7,  -8,  9

ממטריצה ​​זו, הגזר:

• כל האלמנטים השליליים;
• כל האלמנטים השליליים במחרוזת i;
• כל האלמנטים השליליים בעמודה j;
• כל האלמנטים האלכסוניים (החל מהפינה השמאלית העליונה);
• כל האלמנטים האלכסוניים (החל מהפינה השמאלית התחתונה).

קרב ים

סעיף אחרון עם כוכבית: ללא טיפים או דוגמאות. מטריצות אידיאליות לתכנות משחק קרב הים. אחד השלבים של תכנות המשחק הזה הוא הצבת ספינות על מגרש המשחקים. אם תפתור מספר בעיות אלו, היה סמוך ובטוח שתוכל להתמודד עם קרב ימי. אז, בהינתן מטריצה ​​10x10 המורכבת מאפסים. בואו נניח שזה שדה למשחק קרב ימי. בשדה זה, 0 הוא תא ריק, 1 הוא ספינה או חלק מספינה. כתוב פונקציות, שכל אחת מהן, בהתאם לכללי משחק קרב הים, ממקמת אותן באופן אקראי:

• 10 ספינות חד-סיפון;
• 10 קורבלים דו-סיפונים;
• 5 ספינות שלוש קומות;
• מסדר את כל הספינות למשחק קרב הים (4 סיפון יחיד, 3 סיפון כפול, 2 שלוש סיפון, 1 ארבע סיפון).

זה הכל! כמו בכל נושא תכנות, מערכים נלמדים בצורה הטובה ביותר באמצעות תרגול. חימום שמח!