Lösen von Problemen mit eindimensionalen und zweidimensionalen Arrays

In diesem Artikel werden Probleme im Zusammenhang mit Arrays behandelt (und in größerem Umfang eine unabhängige Analyse bereitgestellt). Wir werden unsere Fähigkeiten in den folgenden Bereichen verbessern:

1. Eindimensionale Arrays

   1. Probleme „Sequenz fortsetzen“ ;
   2. Aufgaben zur Elementsuche;
   3. Probleme beim Sortieren von Array-Elementen.

2. Zweidimensionale Arrays

   1. Aufgaben „Konstruieren Sie eine Matrix des Formulars“ ;
   2. Aufgaben „Elemente an den unerwartetsten Stellen finden (Zeilen, Spalten, Diagonalen)“ ;
   3. Aufgaben „Ordnen Sie die Schiffe für eine Wasserschlacht an . “

Für alle Probleme verwenden wir Arrays aus ganzen Zahlen.

Probleme mit eindimensionalen Arrays

Setzen Sie die Sequenz fort

In dieser Aufgabenreihe müssen Sie:

1. Bestimmen Sie das Muster, nach dem diese oder jene Zahlenfolge gebildet wird.
2. Schreiben Sie eine Funktion, die die ersten N Elemente einer bestimmten Sequenz als ganzzahliges Array bildet und die Array-Elemente auf dem Bildschirm anzeigt.

Angenommen, wir stehen vor der Aufgabe, die folgende Zahlenreihe fortzusetzen:

1, 2, 3, 4, 5…

Schritt 1: Identifizieren Sie das Muster. Hier ist alles elementar – es handelt sich um eine Reihe natürlicher Zahlen. Schritt 2: Schreiben Sie eine Funktion, die die ersten N Elemente einer bestimmten Zeile als Array bildet:

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;
    }
}

Ebenso ist es notwendig, Funktionen zu schreiben, die die folgenden Sequenzen fortsetzen würden:

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…

Suche nach Elementen

In dieser Aufgabenreihe gilt es, im fertigen Array ein Element zu finden, das über einige Eigenschaften verfügt. Zum Beispiel das Element mit dem Maximalwert. Zur Veranschaulichung schreiben wir Code für eine Funktion, die ein Array verwendet, den Index des größten Elements im Array bestimmt und dieses Element dann zusammen mit seinem Index an die Konsole ausgibt. Ich werde auch zeigen, wie Sie mit der Klasse java.util.concurrent.ThreadLocalRandomschnell ein ganzzahliges Array einer bestimmten Länge generieren können, das aus zufälligen Elementen besteht:

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));
    }
}

Nun die Aufgaben selbst. Aus einem Array zufälliger ganzzahliger Elemente müssen wir Folgendes finden:

1. Maximal.
2. Minimum.
3. Arithmetische Mittel.
4. Die Anzahl der Elemente zwischen den maximalen und minimalen Elementen.
5. Die erste Primzahl.
6. Die letzte Primzahl.
7. Die Anzahl der Primzahlen im Array.

Sie können sowohl den Wert als auch die Indizes anzeigen. Wenn Sie kein gesuchtes Element finden, können Sie es nach Belieben auf dem Bildschirm anzeigen. Für die letzte Aufgabe müssen Sie ein Array aus ganzzahligen Elementen vorbereiten, die in aufsteigender Reihenfolge sortiert sind. In diesem Array müssen Sie ein Element nach Wert in einer minimalen Anzahl von Operationen finden ( Hinweis ).

Sortierung

In dieser Reihe von Problemen müssen Sie ein Array ganzzahliger Elemente mithilfe verschiedener Sortieralgorithmen sortieren. Im Internet gibt es eine ganze Reihe von Materialien zu verschiedenen Algorithmen. Versuchen Sie zunächst, die Essenz des Algorithmus zu verstehen, und versuchen Sie dann, ihn selbst zu implementieren. Zuerst auf Papier (Blockdiagramm, Pseudocode, was auch immer Ihnen passt) und dann in IDEA. Algorithmen zur Umsetzung:

• Blasensortierung;
• Auswahlsortierung;
• Sortieren durch Einfügen;
• Zusammenführen, sortieren.

Probleme mit zweidimensionalen Arrays

Zeichnen Sie die Matrix

In der nächsten Reihe von Aufgaben müssen zweidimensionale Arrays (Matrizen) gezeichnet (an die Konsole ausgegeben) werden, die auf eine bestimmte Weise zusammengesetzt sind: Sie müssen dem durch die Aufgabe angegebenen Muster entsprechen. Lassen Sie mich Ihnen ein Beispiel geben. m*nWir müssen eine Matrix (wobei mdie Anzahl der Zeilen und ndie Anzahl der Elemente in der Zeile ist) der Form erstellen und anzeigen :

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

Schreiben wir eine Funktion, die alles für uns erledigt, und stellen wir außerdem eine Funktion bereit, die die Matrix auf wunderbare Weise an die Konsole ausgibt (vielleicht finden Sie sie nützlich):

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();
        }
    }
}

Jetzt Aufgaben: Zeigen Sie eine Matrix m*nder Form an: 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

Suche nach Elementen

In diesem Abschnitt ist es notwendig, eine Suche nach verschiedenen Elementen in verschiedenen Teilen der Matrix zu implementieren: in einer bestimmten Spalte oder in einer bestimmten Zeile. Nehmen wir an, wir haben eine Matrix der Form: -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 Als Beispiel ermitteln wir die Anzahl der negativen Elemente in der dritten Zeile:

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();
        }
    }
}

Als Ergebnis der Ausführung der Hauptmethode wird Folgendes an die Konsole ausgegeben:

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 

Jetzt die Aufgaben. Drucken Sie für jede ungerade Zahl neine Matrix n*nder Form aus:

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

Leiten Sie aus dieser Matrix ab:

• alle negativen Elemente;
• alle negativen Elemente in der Zeichenfolge i;
• alle negativen Elemente in der Spalte j;
• alle diagonalen Elemente (beginnend in der oberen linken Ecke);
• alle diagonalen Elemente (beginnend in der unteren linken Ecke).

Seeschlacht

Letzter Abschnitt mit einem Sternchen: keine Tipps oder Beispiele. Matrizen sind ideal für die Programmierung des Seeschlachtspiels. Eine der Phasen der Programmierung dieses Spiels ist die Platzierung von Schiffen auf dem Spielfeld. Wenn Sie eine Reihe dieser Probleme lösen, können Sie sicher sein, dass Sie den Seeschlachten gewachsen sein werden. Gegeben sei also eine 10x10-Matrix, die aus Nullen besteht. Nehmen wir an, dass es sich um ein Feld handelt, auf dem Seeschlachten gespielt werden. In diesem Feld ist 0 eine leere Zelle, 1 ist ein Schiff oder Teil eines Schiffes. Schreiben Sie Funktionen, von denen jede gemäß den Regeln des Seeschlachtspiels sie zufällig platziert:

• 10 einstöckige Schiffe;
• 10 Doppeldeckkorbale;
• 5 Dreideckerschiffe;
• Ordnet alle Schiffe für das Seeschlachtspiel an (4 Eindecker, 3 Doppeldecker, 2 Dreidecker, 1 Vierdecker).

Das ist alles! Wie bei jedem Programmierthema lernt man Arrays am besten durch Übung. Viel Spaß beim Aufwärmen!