Resolvendo problemas envolvendo matrizes unidimensionais e bidimensionais

Este artigo considerará (e, em maior medida, fornecerá análises independentes) problemas envolvendo arrays. Melhoraremos nossas habilidades nas seguintes áreas:

1. Matrizes unidimensionais

   1. Problemas “Continuar a sequência” ;
   2. Tarefas de busca de elementos;
   3. Problemas envolvendo classificação de elementos de array.

2. Matrizes bidimensionais

   1. Tarefas “Construir uma matriz do formulário” ;
   2. Tarefas “Encontrar elementos nos locais mais inesperados (linhas, colunas, diagonais)” ;
   3. Tarefas “Organize os navios para uma batalha aquática . ”

Para todos os problemas usaremos arrays de inteiros.

Problemas envolvendo matrizes unidimensionais

Continuar a sequência

Nesta série de tarefas você precisará:

1. Determine o padrão segundo o qual esta ou aquela sequência numérica é formada.
2. Escreva uma função que forme os primeiros N elementos de uma determinada sequência como um array inteiro e exiba os elementos do array na tela.

Suponha que nos deparemos com a tarefa de continuar a seguinte série numérica:

1, 2, 3, 4, 5…

Etapa 1: Identifique o padrão. Tudo aqui é elementar – é uma série de números naturais. Passo 2: escreva uma função que formará os primeiros N elementos de uma determinada linha como um 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;
    }
}

Da mesma forma, é necessário escrever funções que continuem as seguintes sequências:

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…

Procure por elementos

Nesta série de tarefas, é necessário encontrar um elemento no array finalizado que possua algumas propriedades. Por exemplo, o elemento com o valor máximo. Para demonstrar, vamos escrever o código para uma função que pega um array e determina o índice do elemento máximo no array e, em seguida, envia esse elemento junto com seu índice para o console. Também demonstrarei como, usando a classe, java.util.concurrent.ThreadLocalRandomvocê pode gerar rapidamente um array inteiro de um determinado comprimento, composto por elementos aleatórios:

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

Agora as próprias tarefas. A partir de um array de elementos inteiros aleatórios, precisamos encontrar:

1. Máximo.
2. Mínimo.
3. Média.
4. O número de elementos entre os elementos máximo e mínimo.
5. O primeiro número primo.
6. O último número primo.
7. O número de números primos na matriz.

Você pode exibir o valor e os índices. Se não houver nenhum elemento que você esteja procurando, exiba-o na tela conforme sua conveniência. Para a última tarefa, você precisa preparar um array de elementos inteiros classificados em ordem crescente. Neste array, você precisa encontrar um elemento por valor em um número mínimo de operações ( Hint ).

Ordenação

Nesta série de problemas, você precisa classificar uma matriz de elementos inteiros usando vários algoritmos de classificação. Existem muitos materiais na Internet sobre vários algoritmos. Tente primeiro entender a essência do algoritmo e depois tente implementá-lo você mesmo. Primeiro no papel (diagrama de blocos, pseudocódigo, o que mais lhe convier) e depois no IDEA. Algoritmos para implementação:

• Tipo de bolha;
• ordenação por seleção;
• ordenação por inserção;
• classificação de mesclagem.

Problemas envolvendo matrizes bidimensionais

Desenhe uma matriz

Na próxima série de tarefas, é necessário desenhar (saída para o console) arrays bidimensionais (matrizes) compostos de uma determinada maneira: eles devem corresponder ao padrão especificado pela tarefa. Deixe-me lhe dar um exemplo. Precisamos construir e exibir uma matriz m*n(onde mé o número de linhas e né o número de elementos na linha) no formato:

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

Vamos escrever uma função que fará tudo por nós e também fornecerá uma função que exibirá lindamente a matriz no console (pode ser útil para você):

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

Agora tarefas: Exibir uma matriz m*ndo formulário: 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

Procure por elementos

Nesta seção é necessário implementar uma busca por vários elementos em diferentes partes da matriz: em uma coluna específica ou em uma linha específica. Vamos supor que temos uma matriz da 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 Como exemplo, vamos encontrar o número de elementos negativos na terceira linha:

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

Como resultado da execução do método principal, o seguinte será enviado ao console:

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 

Agora as tarefas. Para qualquer ímpar, nimprima uma matriz n*nno formato:

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

A partir desta matriz, derive:

• todos os elementos negativos;
• todos os elementos negativos na string i;
• todos os elementos negativos na coluna j;
• todos os elementos diagonais (começando no canto superior esquerdo);
• todos os elementos diagonais (começando no canto esquerdo inferior).

Batalha naval

Última seção com asterisco: sem dicas ou exemplos. As matrizes são ideais para programar o jogo de batalha naval. Uma das etapas da programação deste jogo é a colocação dos navios no campo de jogo. Se você resolver vários desses problemas, tenha certeza de que será capaz de enfrentar o combate naval. Então, dada uma matriz 10x10 composta por zeros. Vamos supor que seja um campo de batalha naval. Neste campo, 0 é uma célula vazia, 1 é um navio ou parte de um navio. Escreva funções, cada uma das quais, de acordo com as regras do jogo de batalha naval, as posiciona aleatoriamente:

• 10 navios de convés único;
• 10 míssil de dois andares;
• 5 navios de três andares;
• organiza todos os navios para o jogo de batalha naval (4 de convés único, 3 de convés duplo, 2 de três convés, 1 de quatro convés).

Isso é tudo! Como acontece com qualquer tópico de programação, os arrays são melhor aprendidos através da prática. Bom aquecimento!