Exercício 1
Clique para ver o código
#include <stdio.h>
#define TAM 4
#define LINHAS 2
void demonstracao_vetor() {
int valores[TAM] = {5, 2, 7, 3};
int contador;
printf("Tamanho em bytes do vetor: %lu\n", sizeof(valores));
for (contador = 0; contador < TAM; contador++)
printf("Endereço %p: valor %d\n", &valores[contador], valores[contador]);
printf("Apontador do vetor: %p\n", valores);
}
void demonstracao_matriz() {
int matriz[LINHAS][TAM] = {{5, 2, 7, 3}, {8, 1, 6, 4}};
int linha, coluna;
printf("Tamanho total da matriz: %lu\n", sizeof(matriz));
for (linha = 0; linha < LINHAS; linha++)
for (coluna = 0; coluna < TAM; coluna++)
printf("Posição [%d][%d]: %p -> %d\n", linha, coluna, &matriz[linha][coluna], matriz[linha][coluna]);
printf("\nReferências da matriz:\n");
printf("matriz: %p\n", matriz);
printf("matriz[0]: %p\n", matriz[0]);
printf("matriz[1]: %p\n", matriz[1]);
}
int main() {
printf("=== Vetor unidimensional ===\n");
demonstracao_vetor();
printf("\n=== Matriz bidimensional ===\n");
demonstracao_matriz();
return 0;
}
Resposta 1: O vetor unidimensional é armazenado continuamente na memória, sendo que o endereço do vetor coincide com o endereço do primeiro elemento.
Resposta 2: A matriz bidimensional é organizada por linhas na memória. Os endereços de matriz, matriz[0] e matriz[0][0] são idênticos. A diferença de 16 bytes entre matriz[0] e matriz[1] representa o espaço ocupado por uma linha inteira de números inteiros.
Exercício 2
Clique para ver o código
#include <stdio.h>
#define MAX 80
void ler_dados(int arr[], int qtd);
double calcular_media_excluida(int arr[], int qtd);
int main() {
int dados[MAX];
int quantidade;
double resultado;
while(printf("Quantidade de elementos: "), scanf("%d", &quantidade) != EOF) {
ler_dados(dados, quantidade);
resultado = calcular_media_excluida(dados, quantidade);
printf("Média calculada: %.2f\n\n", resultado);
}
return 0;
}
void ler_dados(int arr[], int qtd) {
int idx;
for(idx = 0; idx < qtd; idx++)
scanf("%d", &arr[idx]);
}
double calcular_media_excluida(int arr[], int qtd) {
int pos, maior, menor;
double acumulador;
maior = menor = arr[0];
acumulador = 0;
for(pos = 0; pos < qtd; pos++) {
acumulador += arr[pos];
if(arr[pos] > maior)
maior = arr[pos];
if(arr[pos] < menor)
menor = arr[pos];
}
return (acumulador - maior - menor) / (qtd - 2);
}
Resposta 1: Parâmetros formais: int arr[], int qtd. Parâmetros reais: dados, quantidade.
Resposta 2: A função ler_dados armazena a sequência de números inteiros fornecidos pelo usuário no vetor. A função calcular_media_excluida computa a média aritmética excluindo os valores extremos (maior e menor).
Exercício 3
Clique para ver o código
#include <stdio.h>
#define DIM 50
void imprimir_matriz(int m[][DIM], int tamanho);
void preencher_matriz(int m[][DIM], int tamanho, int valor);
int main() {
int matriz[DIM][DIM];
int dimensao, valor_preenchimento;
while (printf("Dimensão e valor: "), scanf("%d%d", &dimensao, &valor_preenchimento) != EOF) {
preencher_matriz(matriz, dimensao, valor_preenchimento);
imprimir_matriz(matriz, dimensao);
printf("\n");
}
return 0;
}
void imprimir_matriz(int m[][DIM], int tamanho) {
int r, c;
for (r = 0; r < tamanho; r++) {
for (c = 0; c < tamanho; c++)
printf("%d ", m[r][c]);
printf("\n");
}
}
void preencher_matriz(int m[][DIM], int tamanho, int valor) {
int r, c;
for (r = 0; r < tamanho; r++)
for (c = 0; c < tamanho; c++)
m[r][c] = valor;
}
Resposta 1: Exemplo: imprimir_matriz(int m[][DIM], int tamanho) como parâmetro formal e matriz, dimensao como argumentos.
Resposta 2: Não é possível alterar a definição da constante DIM após sua declaração.
Resposta 3: A função imprimir_matriz exibe todos os elementos organizados em linhas. A função preencher_matriz atribui um valor específico a todas as posições da matriz.
Exercício 4
Clique para ver o código
#include <stdio.h>
#define CAPACIDADE 60
double encontrar_mediana(int dados[], int total);
int carregar_dados(int dados[], int total);
int main() {
int conjunto[CAPACIDADE];
int total_elementos;
double mediana;
while (printf("Total de elementos: "), scanf("%d", &total_elementos) != EOF) {
carregar_dados(conjunto, total_elementos);
mediana = encontrar_mediana(conjunto, total_elementos);
printf("Mediana: %g\n\n", mediana);
}
return 0;
}
double encontrar_mediana(int dados[], int total) {
int a, b, aux;
double resultado;
for (a = 0; a < total - 1; a++) {
for (b = 0; b < total - 1 - a; b++) {
if (dados[b] > dados[b + 1]) {
aux = dados[b];
dados[b] = dados[b + 1];
dados[b + 1] = aux;
}
}
}
if (total % 2 != 0) {
resultado = dados[total / 2];
} else {
resultado = (dados[total / 2 - 1] + dados[total / 2]) / 2.0;
}
return resultado;
}
int carregar_dados(int dados[], int total) {
int pos;
for (pos = 0; pos < total; pos++) {
scanf("%d", &dados[pos]);
}
return 0;
}
Exercício 5
Clique para ver o código
#include <stdio.h>
#define ORDEM 80
void entrada_dados(int m[][ORDEM], int n);
void saida_dados(int m[][ORDEM], int n);
void deslocar_colunas_direita(int m[][ORDEM], int n);
int main() {
int tabela[ORDEM][ORDEM];
int dim;
printf("Informe a dimensão: ");
scanf("%d", &dim);
entrada_dados(tabela, dim);
printf("Matriz original:\n");
saida_dados(tabela, dim);
deslocar_colunas_direita(tabela, dim);
printf("Após deslocamento:\n");
saida_dados(tabela, dim);
return 0;
}
void entrada_dados(int m[][ORDEM], int n) {
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++)
scanf("%d", &m[i][j]);
}
}
void saida_dados(int m[][ORDEM], int n) {
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++)
printf("%4d", m[i][j]);
printf("\n");
}
}
void deslocar_colunas_direita(int m[][ORDEM], int n) {
int backup, i, j;
for (i = 0; i < n; i++) {
backup = m[i][n - 1];
for (j = n - 1; j > 0; j--) {
m[i][j] = m[i][j - 1];
}
m[i][0] = backup;
}
}
Exercício 6
Clique para ver o código
#include <stdio.h>
#define BUF 120
void converter_base(int numero, int base);
int main() {
int valor;
while (printf("Número decimal: "), scanf("%d", &valor) != EOF) {
converter_base(valor, 2);
converter_base(valor, 8);
converter_base(valor, 16);
printf("\n");
}
return 0;
}
void converter_base(int numero, int base) {
const char digitos[] = "0123456789abcdef";
char saida[BUF];
int pos = 0;
if (numero == 0) {
printf("0\n");
return;
}
while (numero > 0) {
saida[pos++] = digitos[numero % base];
numero /= base;
}
while (pos > 0) {
putchar(saida[--pos]);
}
printf("\n");
}
Exercício 7
Clique para ver o código
#include <stdio.h>
#define MAX_ORDEM 50
void entrada_quadrado(int q[][MAX_ORDEM], int n);
void saida_quadrado(int q[][MAX_ORDEM], int n);
int verificar_magico(int q[][MAX_ORDEM], int n);
int main() {
int quadrado[MAX_ORDEM][MAX_ORDEM];
int dimensao;
while (printf("Ordem do quadrado: "), scanf("%d", &dimensao) != EOF) {
printf("Preencher quadrado:\n");
entrada_quadrado(quadrado, dimensao);
printf("Quadrado informado:\n");
saida_quadrado(quadrado, dimensao);
if (verificar_magico(quadrado, dimensao))
printf("É um quadrado mágico!\n\n");
else
printf("Não é um quadrado mágico.\n\n");
}
return 0;
}
void entrada_quadrado(int q[][MAX_ORDEM], int n) {
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++)
scanf("%d", &q[i][j]);
}
}
void saida_quadrado(int q[][MAX_ORDEM], int n) {
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++)
printf("%4d", q[i][j]);
printf("\n");
}
}
int verificar_magico(int q[][MAX_ORDEM], int n) {
if (n <= 0) return 0;
int linha, col, ref;
int soma_ref = 0;
for (col = 0; col < n; col++)
soma_ref += q[0][col];
for (linha = 0; linha < n; linha++) {
int soma_linha = 0;
for (col = 0; col < n; col++)
soma_linha += q[linha][col];
if (soma_linha != soma_ref) return 0;
}
for (col = 0; col < n; col++) {
int soma_col = 0;
for (linha = 0; linha < n; linha++)
soma_col += q[linha][col];
if (soma_col != soma_ref) return 0;
}
int soma_diag1 = 0;
for (ref = 0; ref < n; ref++)
soma_diag1 += q[ref][ref];
if (soma_diag1 != soma_ref) return 0;
int soma_diag2 = 0;
for (ref = 0; ref < n; ref++)
soma_diag2 += q[ref][n - 1 - ref];
if (soma_diag2 != soma_ref) return 0;
return 1;
}
