Risoluzione di problemi che coinvolgono array unidimensionali e bidimensionali

Questo articolo prenderà in considerazione (e, in misura maggiore, fornirà un'analisi indipendente) i problemi che coinvolgono gli array. Miglioreremo le nostre competenze nei seguenti ambiti:

1. Array unidimensionali

   1. Problemi “Continua la sequenza” ;
   2. Attività di ricerca degli elementi;
   3. Problemi che coinvolgono l'ordinamento degli elementi dell'array.

2. Array bidimensionali

   1. Compiti “Costruire una matrice della forma” ;
   2. Compiti “Trova elementi nei luoghi più inaspettati (righe, colonne, diagonali)” ;
   3. Compiti "Organizzare le navi per una battaglia sull'acqua . "

Per tutti i problemi utilizzeremo array di numeri interi.

Problemi che coinvolgono array unidimensionali

Continua la sequenza

In questa serie di attività dovrai:

1. Determina lo schema in base al quale si forma questa o quella sequenza numerica.
2. Scrivere una funzione che formi i primi N elementi di una data sequenza come un array di numeri interi e visualizzi gli elementi dell'array sullo schermo.

Supponiamo di trovarci di fronte al compito di continuare la seguente serie di numeri:

1, 2, 3, 4, 5…

Passaggio 1: identificare il modello. Qui tutto è elementare: è una serie di numeri naturali. Passaggio 2: scrivi una funzione che formerà i primi N elementi di una determinata riga come un array:

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

Allo stesso modo, è necessario scrivere funzioni che continuino le seguenti sequenze:

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…

Cerca elementi

In questa serie di attività è necessario trovare un elemento nell'array finito che abbia alcune proprietà. Ad esempio, l'elemento con il valore massimo. Per dimostrarlo, scriviamo il codice per una funzione che accetta un array e determina l'indice dell'elemento massimo nell'array, quindi restituisce questo elemento insieme al suo indice alla console. Dimostrerò anche come, utilizzando la classe, java.util.concurrent.ThreadLocalRandomè possibile generare rapidamente un array di interi di una determinata lunghezza, costituito da elementi casuali:

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

Ora i compiti stessi. Da un array di elementi interi casuali dobbiamo trovare:

1. Massimo.
2. Minimo.
3. Media.
4. Il numero di elementi tra gli elementi massimo e minimo.
5. Il primo numero primo.
6. L'ultimo numero primo.
7. Il numero di numeri primi nell'array.

È possibile visualizzare sia il valore che gli indici. Se non c'è nessun elemento che stai cercando, visualizzalo sullo schermo come desideri. Per l'ultima attività, è necessario preparare un array di elementi interi ordinati in ordine crescente. In questo array, devi trovare un elemento in base al valore in un numero minimo di operazioni ( Suggerimento ).

Ordinamento

In questa serie di problemi è necessario ordinare un array di elementi interi utilizzando vari algoritmi di ordinamento. Ci sono molti materiali su Internet su vari algoritmi. Cerca prima di comprendere l'essenza dell'algoritmo, quindi prova a implementarlo tu stesso. Prima su carta (diagramma a blocchi, pseudocodice, qualunque cosa ti piaccia), e poi in IDEA. Algoritmi per l'implementazione:

• ordinamento delle bolle;
• ordinamento della selezione;
• ordinamento per inserimento;
• unisci ordinamento.

Problemi che coinvolgono array bidimensionali

Disegna la matrice

Nella successiva serie di attività, è necessario disegnare (output sulla console) array bidimensionali (matrici) composti in un certo modo: devono corrispondere allo schema specificato dall'attività. Lasciate che vi faccia un esempio. Dobbiamo costruire e visualizzare una matrice m*n(dove mè il numero di righe e nè il numero di elementi nella riga) del modulo:

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

Scriviamo una funzione che farà tutto per noi e forniamo anche una funzione che restituirà magnificamente la matrice alla console (potresti trovarla utile):

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

Ora compiti: Visualizza una matrice m*ndel modulo: 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

Cerca elementi

In questa sezione è necessario implementare la ricerca di vari elementi in diverse parti della matrice: in una colonna specifica o in una riga specifica. Supponiamo di avere una matrice della forma: -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 Ad esempio, troviamo il numero di elementi negativi nella terza riga:

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

Come risultato dell'esecuzione del metodo main, sulla console verrà visualizzato quanto segue:

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 

Ora i compiti. Per qualsiasi dispari, nstampa una matrice n*ndella forma:

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

Da questa matrice derivano:

• tutti gli elementi negativi;
• tutti gli elementi negativi nella stringa i;
• tutti gli elementi negativi nella colonna j;
• tutti gli elementi diagonali (a partire dall'angolo in alto a sinistra);
• tutti gli elementi diagonali (a partire dall'angolo inferiore sinistro).

Battaglia navale

Ultima sezione con un asterisco: nessun suggerimento o esempio. Le matrici sono ideali per programmare il gioco della battaglia navale. Una delle fasi della programmazione di questo gioco è il posizionamento delle navi sul campo di gioco. Se risolvi alcuni di questi problemi, stai certo che sarai in grado di affrontare il combattimento navale. Quindi, data una matrice 10x10 composta da zeri. Supponiamo che sia un campo per giocare a una battaglia navale. In questo campo, 0 è una cella vuota, 1 è una nave o parte di una nave. Scrivi funzioni, ognuna delle quali, secondo le regole del gioco della battaglia navale, le posiziona in modo casuale:

• 10 navi a ponte singolo;
• 10 corbali a due piani;
• 5 navi a tre ponti;
• dispone tutte le navi per il gioco della battaglia navale (4 a ponte singolo, 3 a ponte doppio, 2 a tre ponti, 1 a quattro ponti).

È tutto! Come per qualsiasi argomento di programmazione, gli array si imparano meglio con la pratica. Buon riscaldamento!