GABARITO

Atenção:

1. Para deixar o código mais enxuto, todos os arrays foram declarados e inicializados;
2. Sempre que foi utilizado o termo “posição” utilizou-se o valor do índice, ou seja, inicia em 0.

01.
#include <stdio.h>

int main() {
int vet[10] = {5, 38, 3, 12, 7, 10, 6, 15, 9, 4};
int maiorValor = vet[0];
int posicaoMaior = 0;
int i;

for (i = 1; i < 10; i++) {

if (vet[i] > maiorValor) {
maiorValor = vet[i];
posicaoMaior = i;
}
}

//a posicao considerada e' o indice (inicia em 0)

printf("O maior valor encontrado foi: %d, na posicao: %d\n", maiorValor, posicaoMaior);

return 0;
}

02.
#include <stdio.h>

int main() {
int vet[10] = {5, 8, 3, 12, 7, 10, 6, 15, 9, 4};
int i, temp, inicio = 0, fim = 9;

while (inicio < fim) {

temp = vet[inicio];
vet[inicio] = vet[fim];
vet[fim] = temp;
inicio++;
fim--;
}

printf("Vetor invertido:\n");
for (i = 0; i < 10; i++) {
printf("%d ", vet[i]);
}
printf("\n");

return 0;
}
03.
#include <stdio.h>

int main() {
int vet[10] = {5, 8, 3, 12, 7, 10, 6, 15, 9, 4};
int temp, i, j;

// Ordenação em ordem crescente

for (i = 0; i < 10; i++) {
for (j = i + 1; j < 10; j++) {
if (vet[i] > vet[j]) {
temp = vet[i];
vet[i] = vet[j];
vet[j] = temp;
}
}
}

printf("Ordenado em ordem crescente:\n");

for (i = 0; i < 10; i++) {
printf("%d ", vet[i]);
}
printf("\n");

// Ordenação em ordem decrescente

for (i = 0; i < 10; i++) {
for (j = i + 1; j < 10; j++) {
if (vet[i] < vet[j]) {
temp = vet[i];
vet[i] = vet[j];
vet[j] = temp;
}
}
}

printf("Ordenado em ordem decrescente:\n");

for (i = 0; i < 10; i++) {
printf("%d ", vet[i]);
}
printf("\n");

return 0;
}

04.
#include <stdio.h>

int main() {
int vet[10] = {5, 8, 3, 12, 7, 10, 6, 15, 9, 4};
int soma = 0, media, i;

for (i = 0; i < 10; i++)

soma += vet[i];

media = soma / 10;

printf("A media dos elementos do vetor e: %d\n", media);

return 0;
}
05.
#include <stdio.h>

int main() {
int vet[10] = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}; // Vetor
int elementoProcurado = 12;
int tamanho = 10; // Tamanho do vetor
int posicao = -1; // Inicializa a posição como -1 (indicando que o elemento não foi
encontrado)
int i;

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

if (vet[i] == elementoProcurado) {
posicao = i; // Atualiza a posição se o elemento for encontrado
// Posicao = indice; assim a posicao inicia em 0
break; // Interrompe o loop, pois o elemento foi encontrado
}
}

if (posicao != -1) {
printf("O elemento %d foi encontrado na posicao %d.\n", elementoProcurado, posicao);
} else {
printf("O elemento %d nao foi encontrado no vetor.\n", elementoProcurado);
}

return 0;
}

06.
#include <stdio.h>

int main() {
int vet[10] = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20};
int elementoRemover = 12; // Elemento a ser removido
int tamanho = 10; // Tamanho do vetor
int i, j;

// Encontrar o elemento a ser removido e reorganizar o vetor

for (i = 0; i < tamanho; i++) {
if (vet[i] == elementoRemover) {
// Remover o elemento movendo os elementos subsequentes uma posição para trás
for (j = i; j < tamanho - 1; j++) {
vet[j] = vet[j + 1];
}
// Reduzir o tamanho do vetor
tamanho--;
// Decrementar o índice para verificar se o elemento removido aparece mais de uma
vez
i--;
}
}

// Imprimir o vetor após a remoção do elemento

printf("Vetor apos a remocao do elemento %d:\n", elementoRemover);
for (i = 0; i < tamanho; i++) {
printf("%d ", vet[i]);
}
printf("\n");

return 0;
}
07.
#include <stdio.h>

int main() {
int vet1[10] = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}; // Vetor 1
int vet2[10] = {3, 6, 9, 12, 15, 18, 21, 24, 27, 30}; // Vetor 2
int vetResultado[20]; // Vetor resultante com tamanho máximo (soma dos tamanhos dos
vetores)

int tamanhoVet1 = 10; // Tamanho do vetor 1

int tamanhoVet2 = 10; // Tamanho do vetor 2
int tamanhoResultado = 0; // Tamanho do vetor resultante
int i, j, k;

// Copiar vet1 para vetResultado

for (i = 0; i < tamanhoVet1; i++) {
vetResultado[i] = vet1[i];
tamanhoResultado++;
}

// Verificar elementos únicos de vet2 e adicioná-los a vetResultado

for (i = 0; i < tamanhoVet2; i++) {
int duplicado = 0;

// Verificar se o elemento de vet2 já está em vetResultado

for (j = 0; j < tamanhoResultado; j++) {
if (vet2[i] == vetResultado[j]) {
duplicado = 1;
break;
}
}

// Se não for um elemento duplicado, adicioná-lo a vetResultado

if (!duplicado) {
vetResultado[tamanhoResultado] = vet2[i];
tamanhoResultado++;
}
}

// Imprimir o vetor resultante

printf("Vetor resultante apos unir vet1 e vet2 sem elementos duplicados:\n");
for (k = 0; k < tamanhoResultado; k++) {
printf("%d ", vetResultado[k]);
}
printf("\n");

return 0;
}

08.
#include <stdio.h>

int main() {
int vet[10] = {2, 4, 6, 8, 4, 12, 14, 4, 18, 20}; // Vetor
int valorAntigo = 4; // Valor a ser substituído
int novoValor = 10; // Novo valor
int tamanho = 10; // Tamanho do vetor
int i;

// Substituir todas as ocorrências do valorAntigo pelo novoValor

for (i = 0; i < tamanho; i++) {
 if (vet[i] == valorAntigo) {
vet[i] = novoValor;
}
}

// Imprimir o vetor após a substituição

printf("Vetor apos substituir todas as ocorrencias de %d por %d:\n", valorAntigo,
novoValor);
for (i = 0; i < tamanho; i++) {
printf("%d ", vet[i]);
}
printf("\n");

return 0;
}

09.
#include <stdio.h>

int main() {
int mtz[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}
}; // Matriz 5x5

int tamanho = 5; // Tamanho da matriz

int i;

// Exibir os elementos da diagonal principal

printf("Elementos da diagonal principal:\n");
for (i = 0; i < tamanho; i++) {
printf("%d ", mtz[i][i]);
}
printf("\n");

return 0;
}

10.
#include <stdio.h>

int main() {
int mtz[5][5] = {
{1, 0, 0, 0, 0},
{0, 1, 0, 0, 0},
{0, 0, 1, 0, 0},
{0, 0, 0, 1, 0},
{0, 0, 0, 0, 1}
}; // Matriz 5x5 identidade

int tamanho = 5; // Tamanho da matriz

int i, j;
int identidade = 1; // Assume que a matriz é identidade

// Verifica se a matriz é uma matriz identidade

for (i = 0; i < tamanho; i++) {
for (j = 0; j < tamanho; j++) {
 if ((i == j && mtz[i][j] != 1) || (i != j && mtz[i][j] != 0)) {
identidade = 0; // A matriz não é identidade
break;
}
}
if (identidade == 0) {
break;
}
}

// Exibe o resultado
if (identidade == 1) {
printf("A matriz e uma matriz identidade.\n");
} else {
printf("A matriz nao e uma matriz identidade.\n");
}

return 0;
}

11.
#include <stdio.h>

int main() {
int mtz[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}
}; // Matriz 5x5

int linhas = 5; // Quantidade de linhas

int colunas = 5; // Quantidade de colunas
int i, j;

// Encontra e exibe o maior elemento de cada linha

printf("Maiores elementos de cada linha:\n");
for (i = 0; i < linhas; i++) {
int maior = mtz[i][0]; // Assume que o primeiro elemento é o maior

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

if (mtz[i][j] > maior) {
maior = mtz[i][j]; // Atualiza o maior elemento, se necessário
}
}

printf("Linha %d: %d\n", i + 1, maior);

}

return 0;
}

12.
#include <stdio.h>

int main() {
int mtz[5][5] = {
{0, 1, 1, 1, 0},
{0, 1, 1, 1, 0},
 {0, 1, 1, 1, 0},
{0, 1, 1, 1, 0},
{0, 1, 1, 1, 0}
}; // Matriz 5x5 esparsa

int linhas = 5; // Quantidade de linhas

int colunas = 5; // Quantidade de colunas
int elementosNulos = 0;
int elementosNaoNulos = 0;
int i, j;

// Conta o número de elementos nulos e não nulos na matriz

for (i = 0; i < linhas; i++) {
for (j = 0; j < colunas; j++) {
if (mtz[i][j] == 0) {
elementosNulos++;
} else {
elementosNaoNulos++;
}
}
}

// Determina se a matriz é esparsa

if (elementosNulos > elementosNaoNulos) {
printf("A matriz e esparsa.\n");
} else {
printf("A matriz nao e esparsa.\n");
}

return 0;
}

13.
#include <stdio.h>

int main() {
int mtz[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}
}; // Matriz 5x5

int linhas = 5; // Quantidade de linhas

int colunas = 5; // Quantidade de colunas
int somaColunas[colunas]; // Array para armazenar a soma de cada coluna
int i, j;

// Inicializa a soma de cada coluna como 0

for (j = 0; j < colunas; j++) {
somaColunas[j] = 0;
}

// Calcula a soma dos elementos de cada coluna

for (i = 0; i < linhas; i++) {
for (j = 0; j < colunas; j++) {
somaColunas[j] += mtz[i][j];
}
}

// Exibe a soma dos elementos de cada coluna

 printf("Soma dos elementos de cada coluna:\n");
for (j = 0; j < colunas; j++) {
printf("Coluna %d: %d\n", j + 1, somaColunas[j]);
}

return 0;
}

14.

#include <stdio.h>

int main() {
int mtz[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}
}; // Matriz 5x5

int linhas = 5; // Quantidade de linhas

int colunas = 5; // Quantidade de colunas
int linhaASubstituir = 2; // Indica a linha a ser substituída (indice 0)
int valorSubstituto = 0; // Valor que substituirá os elementos
int j;

// Substitui os elementos da linha escolhida

if (linhaASubstituir >= 0 && linhaASubstituir < linhas) {
for (j = 0; j < colunas; j++) {
mtz[linhaASubstituir][j] = valorSubstituto;
}
printf("Linha %d substituida por %d.\n", linhaASubstituir + 1, valorSubstituto);
} else {
printf("Linha nao existente na matriz.\n");
}

// Exibe a matriz após a substituição

printf("Matriz apos substituicao:\n");
for (int i = 0; i < linhas; i++) {
for (j = 0; j < colunas; j++) {
printf("%d ", mtz[i][j]);
}
printf("\n");
}

return 0;
}

15.

#include <stdio.h>

int main() {
int vetor[25] = {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}; // Vetor com 25 elementos

int mtz[5][5]; // Matriz 5x5

int linhas = 5; // Quantidade de linhas
int colunas = 5; // Quantidade de colunas
int k = 0; // Variável para percorrer o vetor
 // Transforma o vetor em uma matriz
for (int i = 0; i < linhas; i++) {
for (int j = 0; j < colunas; j++) {
mtz[i][j] = vetor[k];
k++;
}
}

// Exibe a matriz resultante

printf("Matriz resultante:\n");
for (int i = 0; i < linhas; i++) {
for (int j = 0; j < colunas; j++) {
printf("%d ", mtz[i][j]);
}
printf("\n");
}

return 0;
}