Manipulando matrizes

A primeira coisa que nós temos que fazer, como na grande maioria dos programas, é definir um escopo.

Com o escopo definido, nós podemos declarar a matriz em si e as variáveis que serão úteis.

Aqui está algumas informações sobre elas:

• e são variáveis contadoras;
• é uma matriz de caracteres de ordem .

A grande lógica envolvida no preenchimento de uma matriz está na utilização de duas estruturas de repetição aninhadas.

Isso acontece, pois o primeiro laço de repetição é utilizado para avançar as linhas (nesse caso) e o segundo laço para avançar as colunas.

Ou seja, o primeiro laço de repetição vai falar para o programa que está se iniciando em 0 e essa será a primeira linha da matriz que será preenchida com elementos. Em seguida, outro laço se inicia também em 0, mas esse tem a função de preencher as colunas dessa linha, fazendo assim com que o primeiro laço só avance a linha quando todas as posições dela já estiverem preenchidas (segundo laço finalizado).

Além disso, não podemos nos esquecer de colocarmos o comando %*c após o identificador de tipo. Isso pois, sempre que apertarmos a tecla Enter para confirmarmos um dos caracteres que preencherá a matriz desconsideraremos o caractere especial \n (quebra de linha) proveniente dessa tecla, que nesse caso é indesejado.

Por fim, basta realizarmos a impressão dessa matriz. Portanto, da mesma forma que os dois laços de repetição são úteis para escanear todas as posições de uma matriz, são também eles que nós utilizamos para imprimir uma.

A grande questão é que agora utilizamos o comando printf() ao invés de scanf() e devemos pular uma linha sempre que uma linha da matriz for avançar (linha 12), pois senão estaríamos imprimindo uma sequência de números e não a matriz em seu formato comum.

Vamos começar definindo o escopo do nosso programa.

Com o escopo definido, já podemos declarar as variáveis e matrizes que serão úteis para nós.

Onde:

• e são variáveis contadoras;
• são matrizes do tipo float de ordem .

Com tudo declarado, vamos iniciar a lógica do nosso programa com o preenchimento de .

Em seguida, podemos preencher a matriz com os elementos de .

Basicamente a única coisa que temos que fazer é percorrer atribuindo os seus elementos na posição contrária a . Ou seja, o elemento na linha e coluna de é atribuído a linha e coluna de de .

Ao fim desse laço de repetição, teremos preenchida e pronta para ser impressa na tela. Para isso, basta utilizarmos o seguinte trecho de código:

A primeira coisa que devemos fazer é definir um escopo para o nosso programa.

Com o escopo definido, nós podemos declarar as variáveis que nos ajudarão nesse desenvolvimento.

A seguir estão algumas informações sobre elas:

• e são variáveis contadoras;
• é a variável responsável por armazenar o número escalar inserido como entrada pelo usuário;
• é uma matriz do tipo int de ordem .

Com tudo aquilo que é necessário já declarado, podemos agora requisitar ao usuário os dados de entrada do programa.

Nesse caso, esses dados são todos os elementos de e o número escalar que será armazenado na variável .

Logo após o usuário inserir os dados de entrada, nós podemos percorrer todos os elementos de multiplicando o elemento de cada posição pelo número armazenado em e atualizando essa posição com o resultado.

Ao fim de tudo, teremos todos os elementos de sendo a multiplicação de seus valores originais (inseridos como entrada do programa) pelo número escalar.

Para realizarmos a impressão de , basta executarmos o seguinte trecho de código:

Iniciaremos o nosso programa com a definição de seu escopo.

Já que temos o escopo definido, podemos agora declarar e inicializar as variáveis que nos ajudarão a desenvolver esse programa.

Onde:

• e são variáveis contadoras;
• e são variáveis que armazenam as multiplicações das respectivas diagonais de uma matriz;
• é uma variável que armazena o determinante de uma matriz.

Com as variáveis declaradas e devidamente inicializadas, nesse momento do código devemos requisitar ao usuário o preenchimento da matriz .

Como já sabemos, para encontrarmos o determinante de uma matriz temos que subtrair a multiplicação das diagonais dela.

Para isso, primeiro descobrimos o valor de e e em seguida realizamos a subtração dessas duas variáveis, atribuindo o resultado a .

Por último, temos que realizar a impressão do valor armazenado por e isso pode ser feito com o seguinte trecho de código:

Vamos iniciar o desenvolvimento definindo o escopo do nosso programa.

Com o escopo definido, nós podemos declarar e inicializar as variáveis que serão úteis ao desenvolvimento.

Onde cada uma delas tem a seguinte função:

• e são variáveis contadoras;
• é uma variável responsável por armazenar a soma de determinada linha ;
• é uma matriz inteira de 10 linhas e 15 colunas.

Nós não conseguimos fazer nada com uma matriz vazia, por esse motivo vamos requisitar os elementos dessas 10 linhas e 15 colunas ao usuário!

Por último, nós iremos percorrer cada posição de com a intenção de somar o valor de cada linha das 10 presentes.

Para isso, utilizaremos a variável para acumular o valor de soma de cada linha e quando a leitura de uma dessas linhas for finalizada (término do segundo for) o valor armazenado em deve ser impresso na tela.

Vale ressaltar que durante a transição de cada linha, a variável deve ser reinicializada, pois cada soma deve se inicializar com o valor 0.

Vamos começar o nosso programa pelo seu escopo.

Em seguida, podemos declarar e inicializar as variáveis que nos ajudarão.

Informações:

• e são variáveis contadoras;
• é uma variável representativa booleana que informa ao programa se determinada linha ou coluna é ou não nula;
• e são variáveis que armazenam a quantidade de linha ou colunas nulas, respectivamente.

Com as variáveis que serão necessárias já declaradas e devidamente inicializadas, podemos requisitar ao usuário o preenchimento da matriz com elementos que serão inseridos por ele.

Iniciaremos a nossa busca por linhas nulas.

Para isso, reinicializaremos a variável a cada loop do laço de repetição principal (laço das linhas) enquanto verificamos se alguma coluna dessa linha possui um valor diferente de 0 (segundo laço de repetição).

A lógica consiste em atribuir valor 1 a caso algum elemento da linha sendo processada seja diferente de 0. Caso seja, sabemos que a linha não é nula, caso contrário acrescentaremos uma unidade em sua contagem (linha 17).

O mesmo ocorre quando buscamos por colunas nulas, a grande diferença está na maneira com que fazemos isso. Agora, o primeiro laço deve avançar nas colunas enquanto o segundo verifica se cada elemento dessa coluna é diferente de 0.

Basicamente, a única coisa que temos que fazer é inverter a função dos laços, o que executava primeiro para verificar linhas nulas agora executa depois e vice-versa. Vale lembrar que a variável também muda, agora utilizaremos que é a responsável pela verificação de colunas nulas.

Por fim, basta imprimirmos as variáveis e que são responsáveis por armazenar a quantidade de linhas e colunas nulas, respectivamente.

Que tal começarmos esse programa pelo seu escopo?

Com o escopo definido, nós podemos agora declarar as matrizes que serão operandos e a matriz que armazenará o resultado dessa operação. Além disso, não podemos esquecer das variáveis contadoras do programa.

Informações:

• e são variáveis contadoras;
• e são matrizes inteiras de ordem que farão o papal de operandos;
• é uma matriz inteira de ordem que será responsável por armazenar a matriz resultante da operação de soma.

Com tudo aquilo que precisamos já declarado, podemos agora requisitar ao usuário o preenchimento das duas matrizes que serão somadas.

Com todos os elementos preenchidos, podemos percorrer as duas matrizes ao mesmo tempo somando os elementos que se encontram na mesma posição.

O resultado da soma desses elementos deve ser atribuído, também no mesmo índice (posição), da .

Por fim, devemos realizar a impressão da matriz resultante chamada de . Uma vez que todos os seus elementos em suas respectivas posições se trata da soma dos elementos de e nas mesmas posições.

A primeira coisa que nós vamos fazer para resolver esse exercício é definir o escopo do programa.

Com o escopo definido, podemos declarar a matriz o vetor e as variáveis que serão úteis em nosso programa.

A seguir estão algumas informações sobre elas:

• é um vetor inteiro de cinco posições;
• é uma matriz inteira com cinco linhas e 3 colunas;
• e são variáveis contadoras.

Agora que já temos as declarações, está na hora de requisitarmos os dados de entrada ao usuário do programa.

Nesse caso, as entradas são os elementos do vetor e da matriz, respectivamente.

A lógica desse exercício consiste em utilizar duas estruturas de repetição aninhadas.

Nesse caso, o primeiro for (controlado pela variável contadora ) é responsável pelas alterações nas linhas, enquanto o segundo for é responsável pelas alterações nas colunas (elementos de uma linha).

Basicamente, a função desse trecho de código é multiplicar todos os elementos da linha que está sendo processada (índice ) na matriz pelo elemento do vetor armazenado nessa mesma linha, por isso o índice de também é .

Ou seja, o elemento 0 de multiplicará todos os elementos de que se encontram na linha 0, já o elemento 1 de multiplicará todos os elementos de que se encontram na linha 1 e assim por diante.

Ao término da execução dos laços de repetição, teremos todos os elementos de sendo o resultado da multiplicação entre determinada posição de por todos os elementos originais da matriz que se encontravam na linha equivalente a essa posição.

Basta agora realizarmos a impressão de com seus elementos atualizados: