Experimento 1: Endereçamento de Arrays

#include <stdio.h>
#define TAM_VETOR 4
#define LINHAS 2

void demonstra_vetor() {
    int valores[TAM_VETOR] = {1, 9, 8, 4};
    int contador;
    
    printf("Memória ocupada: %zu bytes\n", sizeof(valores));
    for (contador = 0; contador < TAM_VETOR; contador++)
        printf("Endereço %p: valor %d\n", &valores[contador], valores[contador]);
    printf("Ponteiro base: %p\n", valores);
}

void demonstra_matriz() {
    int matriz[LINHAS][TAM_VETOR] = {{1, 9, 8, 4}, {2, 0, 4, 9}};
    int linha, coluna;
    
    printf("Tamanho total: %zu bytes\n", sizeof(matriz));
    for (linha = 0; linha < LINHAS; linha++)
        for (coluna = 0; coluna < TAM_VETOR; coluna++)
            printf("[%d][%d] em %p: %d\n", linha, coluna, &matriz[linha][coluna], matriz[linha][coluna]);
            
    printf("\nPonteiros de linha:\n");
    printf("Matriz: %p\n", matriz);
    printf("Linha 0: %p\n", matriz[0]);
    printf("Linha 1: %p\n", matriz[1]);
}

int main() {
    printf("=== Vetor unidimensional ===\n");
    demonstra_vetor();
    printf("\n=== Matriz bidimensional ===\n");
    demonstra_matriz();
    return 0;
}

Observações:

• Vetores são armazanados de forma contígua na memória.
• Matrizes são organizadas por linhas em memória contínua.
• A diferença entre ponteiros de linhas consecutivas é TAM_VETOR * sizeof(int).

Experimento 2: Funções com Vetores

#include <stdio.h>
#define MAX_ELEMENTOS 100

void ler_dados(int dados[], int quantidade);
double calcular_media_excludente(int dados[], int quantidade);

int main() {
    int conjunto[MAX_ELEMENTOS];
    int total, iterador;
    double resultado;
    
    while (printf("Quantidade: "), scanf("%d", &total) != EOF) {
        ler_dados(conjunto, total);
        resultado = calcular_media_excludente(conjunto, total);
        printf("Resultado: %.2f\n\n", resultado);
    }
    return 0;
}

void ler_dados(int dados[], int quantidade) {
    int pos;
    for (pos = 0; pos < quantidade; pos++)
        scanf("%d", &dados[pos]);
}

double calcular_media_excludente(int dados[], int quantidade) {
    int pos, maior_valor, menor_valor;
    double acumulador;
    
    maior_valor = menor_valor = dados[0];
    acumulador = 0.0;
    
    for (pos = 0; pos < quantidade; pos++) {
        acumulador += dados[pos];
        if (dados[pos] > maior_valor)
            maior_valor = dados[pos];
        if (dados[pos] < menor_valor)
            menor_valor = dados[pos];
    }
    
    return (acumulador - maior_valor - menor_valor) / (quantidade - 2);
}

Pontos-chave:

• Parâmetros formais: int dados[], int quantidade
• Parâmetros reais: conjunto, total
• ler_dados: preenche o vetor com entradas do usuário.
• calcular_media_excludente: calcula a média excluindo extremos.

Experimento 3: Manipulação de Matrizes

#include <stdio.h>
#define ORDEM_MAX 100

void exibir_matriz(int grade[][ORDEM_MAX], int dimensao);
void preencher_matriz(int grade[][ORDEM_MAX], int dimensao, int valor_padrao);

int main() {
    int tabela[ORDEM_MAX][ORDEM_MAX];
    int dim, preenchimento;
    
    while (printf("Dimensão e valor: "), scanf("%d%d", &dim, &preenchimento) != EOF) {
        preencher_matriz(tabela, dim, preenchimento);
        exibir_matriz(tabela, dim);
        printf("\n");
    }
    return 0;
}

void exibir_matriz(int grade[][ORDEM_MAX], int dimensao) {
    int linha, coluna;
    for (linha = 0; linha < dimensao; linha++) {
        for (coluna = 0; coluna < dimensao; coluna++)
            printf("%4d", grade[linha][coluna]);
        printf("\n");
    }
}

void preencher_matriz(int grade[][ORDEM_MAX], int dimensao, int valor_padrao) {
    int linha, coluna;
    for (linha = 0; linha < dimensao; linha++)
        for (coluna = 0; coluna < dimensao; coluna++)
            grade[linha][coluna] = valor_padrao;
}

Detalhes importantes:

• Parâmetro formal: int grade[][ORDEM_MAX]
• Parâmetro real: nome da matriz bidimansional
• A dimensão interna (ORDEM_MAX) não pode ser omitida na declaração
• exibir_matriz: apresenta a matriz formatada por linhas e colunas
• preencher_matriz: inicializa todos os elementos com um valor específico

Experimento 4: Cálculo de Mediana

#include <stdio.h>
#define CAPACIDADE 100

void obter_valores(int colecao[], int tamanho);
double encontrar_mediana(int colecao[], int tamanho);

int main() {
    int sequencia[CAPACIDADE];
    int quantidade;
    double mediana;
    
    while (printf("Tamanho da sequência: "), scanf("%d", &quantidade) != EOF) {
        obter_valores(sequencia, quantidade);
        mediana = encontrar_mediana(sequencia, quantidade);
        printf("Mediana calculada: %g\n\n", mediana);
    }
    return 0;
}

void obter_valores(int colecao[], int tamanho) {
    int posicao;
    printf("Digite %d números inteiros: ", tamanho);
    for (posicao = 0; posicao < tamanho; posicao++)
        scanf("%d", &colecao[posicao]);
}

double encontrar_mediana(int colecao[], int tamanho) {
    int passada, indice, temp;
    
    // Ordenação por bolha
    for (passada = 0; passada < tamanho - 1; passada++) {
        for (indice = 0; indice < tamanho - passada - 1; indice++) {
            if (colecao[indice] > colecao[indice + 1]) {
                temp = colecao[indice];
                colecao[indice] = colecao[indice + 1];
                colecao[indice + 1] = temp;
            }
        }
    }
    
    if (tamanho % 2 == 1)
        return colecao[tamanho / 2];
    else
        return (colecao[tamanho / 2 - 1] + colecao[tamanho / 2]) / 2.0;
}

Experimento 5: Transformação de Matriz

#include <stdio.h>
#define ORDEM 100

void carregar_matriz(int bloco[][ORDEM], int dim);
void imprimir_matriz(int bloco[][ORDEM], int dim);
void rotacionar_direita(int bloco[][ORDEM], int dim);

int main() {
    int grid[ORDEM][ORDEM];
    int dimensao;
    
    printf("Informe a dimensão: ");
    scanf("%d", &dimensao);
    carregar_matriz(grid, dimensao);
    
    printf("Estado original:\n");
    imprimir_matriz(grid, dimensao);
    
    rotacionar_direita(grid, dimensao);
    
    printf("Após transformação:\n");
    imprimir_matriz(grid, dimensao);
    return 0;
}

void carregar_matriz(int bloco[][ORDEM], int dim) {
    int lin, col;
    for (lin = 0; lin < dim; lin++)
        for (col = 0; col < dim; col++)
            scanf("%d", &bloco[lin][col]);
}

void imprimir_matriz(int bloco[][ORDEM], int dim) {
    int lin, col;
    for (lin = 0; lin < dim; lin++) {
        for (col = 0; col < dim; col++)
            printf("%4d", bloco[lin][col]);
        printf("\n");
    }
}

void rotacionar_direita(int bloco[][ORDEM], int dim) {
    int coluna_temporaria[ORDEM];
    int linha, col;
    
    // Armazena última coluna
    for (linha = 0; linha < dim; linha++)
        coluna_temporaria[linha] = bloco[linha][dim - 1];
    
    // Desloca colunas para direita
    for (col = dim - 1; col > 0; col--)
        for (linha = 0; linha < dim; linha++)
            bloco[linha][col] = bloco[linha][col - 1];
    
    // Coloca última coluna na primeira
    for (linha = 0; linha < dim; linha++)
        bloco[linha][0] = coluna_temporaria[linha];
}

Experimento 6: Conversão de Base Numérica

#include <stdio.h>
#define TAMANHO_PILHA 100

void converter_para_base(int numero_decimal, int base);

int main() {
    int numero;
    
    while (printf("Número decimal: "), scanf("%d", &numero) != EOF) {
        converter_para_base(numero, 2);
        converter_para_base(numero, 8);
        converter_para_base(numero, 16);
        printf("\n");
    }
    return 0;
}

void converter_para_base(int numero_decimal, int base) {
    int valor_original = numero_decimal;
    int pilha[TAMANHO_PILHA], topo = -1;
    int resto, digito;
    
    if (valor_original == 0) {
        printf("Base %d: 0\n", base);
        return;
    }
    
    // Construir representação na pilha
    while (valor_original != 0) {
        resto = valor_original % base;
        pilha[++topo] = resto;
        valor_original /= base;
    }
    
    printf("Base %d: ", base);
    while (topo >= 0) {
        digito = pilha[topo--];
        if (base == 16 && digito >= 10)
            printf("%c", 'A' + digito - 10);
        else
            printf("%d", digito);
    }
    printf("\n");
}

Experimento 7: Verificação de Matriz Mágica

#include <stdio.h>
#define ORDEM_MAXIMA 100

void ler_matriz(int m[][ORDEM_MAXIMA], int n);
void escrever_matriz(int m[][ORDEM_MAXIMA], int n);
int verificar_matriz_magica(int m[][ORDEM_MAXIMA], int n);

int main() {
    int matriz[ORDEM_MAXIMA][ORDEM_MAXIMA];
    int dimensao;
    
    while (printf("Dimensão da matriz quadrada: "), scanf("%d", &dimensao) != EOF) {
        printf("Elementos da matriz:\n");
        ler_matriz(matriz, dimensao);
        escrever_matriz(matriz, dimensao);
        
        if (verificar_matriz_magica(matriz, dimensao))
            printf("✓ É uma matriz mágica\n\n");
        else
            printf("✗ Não é uma matriz mágica\n\n");
    }
    return 0;
}

void ler_matriz(int m[][ORDEM_MAXIMA], int n) {
    int i, j;
    for (i = 0; i < n; i++)
        for (j = 0; j < n; j++)
            scanf("%d", &m[i][j]);
}

void escrever_matriz(int m[][ORDEM_MAXIMA], int n) {
    int i, j;
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++)
            printf("%4d", m[i][j]);
        printf("\n");
    }
}

int verificar_matriz_magica(int m[][ORDEM_MAXIMA], int n) {
    int soma_referencia = 0;
    int i, j, soma_corrente;
    
    // Calcula soma da primeira linha como referência
    for (j = 0; j < n; j++)
        soma_referencia += m[0][j];
    
    // Verifica somas das linhas restantes
    for (i = 1; i < n; i++) {
        soma_corrente = 0;
        for (j = 0; j < n; j++)
            soma_corrente += m[i][j];
        if (soma_corrente != soma_referencia)
            return 0;
    }
    
    // Verifica somas das colunas
    for (j = 0; j < n; j++) {
        soma_corrente = 0;
        for (i = 0; i < n; i++)
            soma_corrente += m[i][j];
        if (soma_corrente != soma_referencia)
            return 0;
    }
    
    // Verifica diagonal principal
    soma_corrente = 0;
    for (i = 0; i < n; i++)
        soma_corrente += m[i][i];
    if (soma_corrente != soma_referencia)
        return 0;
    
    // Verifica diagonal secundária
    soma_corrente = 0;
    for (i = 0; i < n; i++)
        soma_corrente += m[i][n - 1 - i];
    if (soma_corrente != soma_referencia)
        return 0;
    
    return 1;
}