Estruturas de dados homogêneas (matrizes)

1. Escreva um programa que alimente uma matriz M de 2 x 3 elementos inteiros e, utilizando estruturas
de repetição, apresente na tela a soma de todos os elementos da matriz.

#include <stdio.h>

int main() {

int M[2][3], i, j, soma;

soma = 0;

/* Alimenta a matriz */
for(i = 0; i < 2; i++){
for(j = 0; j < 3; j++){
printf("Informe número [%d][%d]: ", i, j);
scanf("%d", &M[i][j]);
}
}

/* Calcula a soma dos elementos da matriz */

for(i = 0; i < 2; i++){
for(j = 0; j < 3; j++){
soma = soma + M[i][j];
}
}

/* Apresenta a soma dos elementos da matriz */

printf("A soma é: %d", soma);

return 0;
}

2. Escreva um programa que alimente uma matriz M de 2 x 3 elementos inteiros e, utilizando estruturas
de repetição, apresente na tela o produto de todos os elementos da matriz.

#include <stdio.h>

int main() {

int M[2][3], i, j, produto;

produto = 1;

/* Alimenta a matriz */
for(i = 0; i < 2; i++){
 for(j = 0; j < 3; j++){
printf("Informe número [%d][%d]: ", i, j);
scanf("%d", &M[i][j]);
}
}

/* Calcula o produto dos elementos da matriz */

for(i = 0; i < 2; i++){
for(j = 0; j < 3; j++){
produto = produto * M[i][j];
}
}

/* Apresenta o produto dos elementos da matriz */

printf("O produto é: %d", produto);

return 0;
}

3. Escreva um programa que alimente uma matriz M de 2 x 3 elementos inteiros. Em seguida, leia um
número qualquer do teclado e mostre na tela o índice em que o número se encontra na matriz, ou
então a mensagem "Número não encontrado!", se o número não estiver presente na matriz.

#include <stdio.h>

int main() {

int M[2][3], i, j, num;

/* Alimenta a matriz */
for(i = 0; i < 2; i++){
for(j = 0; j < 3; j++){
printf("Informe número [%d][%d]: ", i, j);
scanf("%d", &M[i][j]);
}
}

printf("Informe número: ");

scanf("%d", &num);

/* Procura o número na matriz */

for(i = 0; i < 2; i++){
for(j = 0; j < 3; j++){
if(M[i][j] == num){
printf("Número encontrado no índice [%d][%d]", i, j);
return 0;
}
}
}
 printf("Número não encontrado!");

return 0;
}

4. Escreva um programa que leia uma matriz M de 5 x 5 elementos e, utilizando estruturas de repetição,
apresente na tela o menor valor da matriz, o maior valor da matriz, a soma dos valores da matriz e a
média dos valores da matriz.

#include <stdio.h>

int main() {

int M[5][5] = {{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}}, i, j, menor, maior, soma;

float media;

menor = M[0][0];
maior = M[0][0];
soma = 0;

for(i = 0; i < 5; i++){

for(j = 0; j < 5; j++){

if(M[i][j] < menor){

menor = M[i][j];
}

if(M[i][j] > maior){

maior = M[i][j];
}

soma = soma + M[i][j];

}
}

media = soma / 25.0;

printf("Menor valor: %d", menor);

printf("\nMaior valor: %d", maior);
printf("\nSoma: %d", soma);
printf("\nMédia: %.1f", media);

return 0;
}

5. Escreva um programa que leia uma matriz M de 5 x 5 elementos e, utilizando estruturas de repetição,
 apresente na tela a soma de todos os elementos da linha 3 da matriz.

. . . . .
. . . . .
. . . . .
x x x x x
. . . . .

#include <stdio.h>

int main() {

int M[5][5] = {{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}}, i, soma;

soma = 0;

/* Calcula a soma dos elementos */

for(i = 0; i < 5; i++){
soma = soma + M[3][i];
}

printf("A soma é: %d", soma);

return 0;
}

6. Escreva um programa que leia uma matriz M de 5 x 5 elementos e, utilizando estruturas de repetição,
apresente na tela a soma de todos os elementos da coluna 2 da matriz.

. . x . .
. . x . .
. . x . .
. . x . .
. . x . .

#include <stdio.h>

int main() {

int M[5][5] = {{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}}, i, soma;

soma = 0;

/* Calcula a soma dos elementos */

for(i = 0; i < 5; i++){
 soma = soma + M[i][2];
}

printf("A soma é: %d", soma);

return 0;
}

7. Escreva um programa que leia uma matriz M de 5 x 5 elementos e, utilizando estruturas de repetição,
apresente na tela a soma dos elementos da diagonal principal da matriz.

x . . . .
. x . . .
. . x . .
. . . x .
. . . . x

#include <stdio.h>

int main() {

int M[5][5] = {{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}}, i, soma;

soma = 0;

/* Calcula a soma dos elementos */

for(i = 0; i < 5; i++){
soma = soma + M[i][i];
}

printf("A soma é: %d", soma);

return 0;
}

8. Escreva um programa que leia uma matriz M de 5 x 5 elementos e, utilizando estruturas de repetição,
apresente na tela a soma dos elementos da diagonal secundária da matriz.

. . . . x
. . . x .
. . x . .
. x . . .
x . . . .

#include <stdio.h>
 int main() {

int M[5][5] = {{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}}, i, soma;

soma = 0;

/* Calcula a soma dos elementos */

for(i = 0; i < 5; i++){
soma = soma + M[i][4 - i];
}

printf("A soma é: %d", soma);

return 0;
}

9. Escreva um programa que leia uma matriz M de 4 x 4 elementos e, utilizando estruturas de repetição,
apresente na tela a soma dos elementos marcados com x.

x x . .
x x . .
. . . .
. . . .

#include <stdio.h>

int main() {

int M[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}}, i,
j, soma;

soma = 0;

/* Calcula a soma dos elementos */

for(i = 0; i < 2; i++){
for(j = 0; j < 2; j++){
soma = soma + M[i][j];
}
}

printf("A soma é: %d", soma);

return 0;
}

10. Escreva um programa que leia uma matriz M de 4 x 4 elementos e, utilizando estruturas de repetição,
apresente na tela a soma dos elementos marcados com x.
 . . . .
. . . .
. . x x
. . x x

#include <stdio.h>

int main() {

int M[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}}, i,
j, soma;

soma = 0;

/* Calcula a soma dos elementos */

for(i = 2; i < 4; i++){
for(j = 2; j < 4; j++){
soma = soma + M[i][j];
}
}

printf("A soma é: %d", soma);

return 0;
}

11. Escreva um programa que leia uma matriz M de 4 x 4 elementos e, utilizando estruturas de repetição,
apresente na tela a soma dos elementos marcados com x.

x . . .
x x . .
x x x .
x x x x

#include <stdio.h>

int main() {

int M[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}}, i,
j, soma;

soma = 0;

/* Calcula a soma dos elementos */

for(i = 0; i < 4; i++){
for(j = 0; j < 4; j++){
if(i >= j){
 soma = soma + M[i][j];
}
}
}

printf("A soma é: %d", soma);

return 0;
}

12. Escreva um programa que leia uma matriz M de 4 x 4 elementos e, utilizando estruturas de repetição,
apresente na tela a soma dos elementos marcados com x.

. . . x
. . x x
. x x x
x x x x

#include <stdio.h>

int main() {

int M[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}}, i,
j, soma;

soma = 0;

/* Calcula a soma dos elementos */

for(i = 0; i < 4; i++){
for(j = 3; j >= 3 - i; j--){
soma = soma + M[i][j];
}
}

printf("A soma é: %d", soma);

return 0;
}

13. Escreva um programa que leia uma matriz M de 4 x 5 elementos e, utilizando uma estrutura de
repetição, armazene em um vetor V o menor elemento de cada linha da matriz. Exemplo:

/* Matriz M preenchida */

0 1 2 3 4
+-----+-----+-----+-----+-----+
0 | 5 | 4 | 2 | 8 | 7 |
+-----+-----+-----+-----+-----+
 1 | 3 | 6 | 9 | 1 | 4 |
+-----+-----+-----+-----+-----+
2 | 0 | 3 | 5 | 2 | 9 |
+-----+-----+-----+-----+-----+
3 | 4 | 9 | 7 | 6 | 2 |
+-----+-----+-----+-----+-----+

/* Vetor V preenchido */

0 1 2 3
+-----+-----+-----+-----+
| 2 | 1 | 0 | 2 |
+-----+-----+-----+-----+

#include <stdio.h>

int main() {

int M[4][5] = {{5, 4, 2, 8, 7}, {3, 6, 9, 1, 4}, {0, 3, 5, 2, 9}, {4, 9, 7, 6,

2}}, V[4], i, j, menor;

for(i = 0; i < 4; i++){

menor = M[i][0];

for(j = 1; j < 5; j++){

if(M[i][j] < menor){
menor = M[i][j];
}
}

V[i] = menor;
}

/* Mostra o vetor preenchido*/

for(i = 0; i < 4; i++){
printf("%d ", V[i]);
}

return 0;
}

14. Escreva um programa que leia duas matrizes (A e B) de 2 linhas e 3 colunas e, utilizando uma estrutura
de repetição, realize a troca dos elementos destas matrizes. Exemplo:

/* Matriz A */

0 1 2
 +-----+-----+-----+
0 | 10 | 20 | 30 |
+-----+-----+-----+
1 | 40 | 50 | 60 |
+-----+-----+-----+

/* Matriz B */

0 1 2
+-----+-----+-----+
0 | 1 | 2 | 3 |
+-----+-----+-----+
1 | 4 | 5 | 6 |
+-----+-----+-----+

/* Após a troca: Matriz A */

0 1 2
+-----+-----+-----+
0 | 1 | 2 | 3 |
+-----+-----+-----+
1 | 4 | 5 | 6 |
+-----+-----+-----+

/* Após a troca: Matriz B */

0 1 2
+-----+-----+-----+
0 | 10 | 20 | 30 |
+-----+-----+-----+
1 | 40 | 50 | 60 |
+-----+-----+-----+

#include <stdio.h>

int main() {

int A[2][3] = {{10, 20, 30}, {40, 50, 60}}, B[2][3] = {{1, 2, 3}, {4, 5, 6}}, i,
j, aux;

for(i = 0; i < 2; i++){

for(j = 0; j < 3; j++){
aux = A[i][j];
A[i][j] = B[i][j];
B[i][j] = aux;
}
}

printf("Matriz A:\n");
 for(i = 0; i < 2; i++){
for(j = 0; j < 3; j++){
printf("%d\t", A[i][j]);
}
printf("\n");
}

printf("\nMatriz B:\n");

for(i = 0; i < 2; i++){

for(j = 0; j < 3; j++){
printf("%d\t", B[i][j]);
}
printf("\n");
}

return 0;
}