Experimento 1: Análise de Arrays Unidimensionais e Bidimensionais na Memória

Vamos explorar como arrays são armazenados na memória do computador, examinando os endereços de memória de cada elemento.

#include <stdio.h>
#define TAMANHO_LINHA 4
#define TAMANHO_COLUNA 2

void analisar_array_unidimensional() {
    int valores[TAMANHO_LINHA] = {1, 9, 8, 4};
    int i;
    
    // Exibe o tamanho total ocupado pelo array na memória
    printf("Tamanho em bytes: %d\n", sizeof(valores));
    
    // Apresenta o endereço de memória e o valor de cada elemento
    for (i = 0; i < TAMANHO_LINHA; ++i)
        printf("Endereco %p: valor = %d\n", &valores[i], valores[i]);
    
    // Mostra o valor do nome do array (que é um ponteiro para o primeiro elemento)
    printf("Nome do array = %p\n", valores);
}

void analisar_array_bidimensional() {
    int matriz[TAMANHO_COLUNA][TAMANHO_LINHA] = {
        {1, 9, 8, 4}, 
        {2, 0, 4, 9}
    };
    int i, j;
    
    // Tamanho total ocupado pela matriz
    printf("Tamanho em bytes: %d\n", sizeof(matriz));
    
    // Itera sobre todos os elementos mostrando endereços e valores
    for (i = 0; i < TAMANHO_COLUNA; ++i)
        for (j = 0; j < TAMANHO_LINHA; ++j)
            printf("Endereco %p: valor = %d\n", &matriz[i][j], matriz[i][j]);
    
    printf("\n");
    
    // Demonstração de que o nome do array bidimensional指向 à primeira linha
    printf("matriz = %p\n", matriz);
    printf("matriz[0] = %p\n", matriz[0]);
    printf("matriz[1] = %p\n", matriz[1]);
    printf("\n");
}

int main() {
    printf("Teste 1: Array unidimensional de inteiros\n");
    analisar_array_unidimensional();
    
    printf("\nTeste 2: Array bidimensional de inteiros\n");
    analisar_array_bidimensional();
    return 0;
}
</stdio.h>

Conclusões:

1. Elementos de um array unidimansional são armazenados de forma contínua na memória.
2. Elementos de um array bidimensional também são armazenados de forma contínua. Cada linha ocupa 16 bytes (4 elementos × 4 bytes), demonstrando que os elementos são organizados linha por linha.

Experimento 2: Passagem de Arrrays como Parâmetro para Funções

Neste experimento, verificamos como arrays são passados para funções e como calcular a média dos elementos, excluindo o maior e o menor valor.

#include <stdio.h>
#define TAMANHO_MAXIMO 100

// Protótipos das funções
void ler_valores(int dados[], int quantidade);
double calcular_media_ajustada(int dados[], int quantidade);

int main() {
    int dados[TAMANHO_MAXIMO];
    int quantidade, i;
    double resultado;

    while(printf("Digite a quantidade: "), scanf("%d", &quantidade) != EOF) {
        ler_valores(dados, quantidade);
        resultado = calcular_media_ajustada(dados, quantidade);
        printf("Resultado = %.2f\n\n", resultado);
    }
    return 0;
}

// Função para preencher o array com valores digitados pelo usuário
void ler_valores(int dados[], int quantidade) {
    int i;
    for(i = 0; i < quantidade; ++i)
        scanf("%d", &dados[i]);
}

// Função que calcula a média excluindo maior e menor valor
double calcular_media_ajustada(int dados[], int quantidade) {
    int i, maximo, minimo;
    double soma;

    maximo = minimo = dados[0];
    soma = 0;

    for(i = 0; i < quantidade; ++i) {
        soma += dados[i];
        if(dados[i] > maximo)
            maximo = dados[i];
        else if(dados[i] < minimo)
            minimo = dados[i];
    }

    return (soma - maximo - minimo) / (quantidade - 2.0);
}
</stdio.h>

Observação importante: O parâmetro formal int dados[] é tratado como um ponteiro, portanto o parâmetro real (nome do array) é passado por referência, não por valor.

Experimento 3: Arrays Bidimensionais e Funções

Arrays bidimensional requerem que a segunda dimensão seja especificada na declaração do parâmetro formal.

#include <stdio.h>
#define TAMANHO_MAXIMO 100

// Protótipos
void mostrar_matriz(int mat[][TAMANHO_MAXIMO], int dimensao);
void inicializar_matriz(int mat[][TAMANHO_MAXIMO], int dimensao, int valor);

int main() {
    int mat[TAMANHO_MAXIMO][TAMANHO_MAXIMO];
    int dimensao, valor;

    while(printf("Digite dimensao e valor: "), scanf("%d%d", &dimensao, &valor) != EOF) {
        inicializar_matriz(mat, dimensao, valor);
        mostrar_matriz(mat, dimensao);
        printf("\n");
    }
    return 0;
}

// Função para exibir os elementos da matriz
void mostrar_matriz(int mat[][TAMANHO_MAXIMO], int dimensao) {
    int i, j;
    for(i = 0; i < dimensao; ++i) {
        for(j = 0; j < dimensao; ++j)
            printf("%d ", mat[i][j]);
        printf("\n");
    }
}

// Função para inicializar todos os elementos com um valor específico
void inicializar_matriz(int mat[][TAMANHO_MAXIMO], int dimensao, int valor) {
    int i, j;
    for(i = 0; i < dimensao; ++i)
        for(j = 0; j < dimensao; ++j)
            mat[i][j] = valor;
}
</stdio.h>

Pontos importantes:

• A segunda dimensão deve ser especificada obrigatoriamente na declaração do parâmetro formal.
• A função mostrar_matriz imprime os elementos.
• A função inicializar_matriz preenche todos os elementos com um valor específico.

Experimento 4: Cálculo da Mediana

Este programa calcula a mediana de um conjunto de números usando o algoritmo bubble sort para ordenação.

#include <stdio.h>
#define TAMANHO_MAXIMO 100

// Protótipos
void ler_numeros(int numeros[], int quantidade);
double determinar_mediana(int numeros[], int quantidade);

int main() {
    int numeros[TAMANHO_MAXIMO];
    int quantidade;
    double resposta;

    while (printf("Digite a quantidade: "), scanf("%d", &quantidade) != EOF) {
        ler_numeros(numeros, quantidade);
        resposta = determinar_mediana(numeros, quantidade);
        printf("Mediana = %g\n\n", resposta);
    }

    return 0;
}

// Função para leitura dos elementos do array
void ler_numeros(int numeros[], int quantidade) {
    for (int i = 0; i < quantidade; ++i) {
        scanf("%d", &numeros[i]);
    }
}

// Função para cálculo da mediana após ordenação
double determinar_mediana(int numeros[], int quantidade) {
    // Bubble sort em ordem crescente
    for (int i = 0; i < quantidade - 1; ++i) {
        for (int j = 0; j < quantidade - i - 1; ++j) {
            if (numeros[j] > numeros[j + 1]) {
                int temp = numeros[j];
                numeros[j] = numeros[j + 1];
                numeros[j + 1] = temp;
            }
        }
    }

    // Cálculo da mediana
    if (quantidade % 2 == 1) {
        return numeros[quantidade / 2];
    } else {
        return (numeros[quantidade / 2 - 1] + numeros[quantidade / 2]) / 2.0;
    }
}
</stdio.h>

Experimento 5: Rotação de Matriz para a Direita

Este programa realiza uma rotação dos elementos de cada linha da matriz uma posição para a direita.

#include <stdio.h>
#include <stdlib.h>
#define TAMANHO_MAXIMO 100

// Protótipos
void ler_matriz(int mat[][TAMANHO_MAXIMO], int dimensao);
void exibir_matriz(int mat[][TAMANHO_MAXIMO], int dimensao);
void rotacionar_direita(int mat[][TAMANHO_MAXIMO], int dimensao);

int main() {
    int mat[TAMANHO_MAXIMO][TAMANHO_MAXIMO];
    int dimensao;

    printf("Digite a dimensao: "); 
    scanf("%d", &dimensao);
    ler_matriz(mat, dimensao);

    printf("Matriz original:\n");
    exibir_matriz(mat, dimensao);

    rotacionar_direita(mat, dimensao);

    printf("Matriz apos rotacao:\n");
    exibir_matriz(mat, dimensao);

    return 0;
}

void ler_matriz(int mat[][TAMANHO_MAXIMO], int dimensao) {
    int i, j;
    
    for (i = 0; i < dimensao; ++i) {
        for (j = 0; j < dimensao; ++j)
            scanf("%d", &mat[i][j]);
    }
}

void exibir_matriz(int mat[][TAMANHO_MAXIMO], int dimensao) {
    int i, j;

    for (i = 0; i < dimensao; ++i) {
        for (j = 0; j < dimensao; ++j)
            printf("%4d", mat[i][j]);
        printf("\n");
    }
}

void rotacionar_direita(int mat[][TAMANHO_MAXIMO], int dimensao) {
    int i, j, temporario;
    
    for (i = 0; i < dimensao; ++i) {
        for (j = dimensao - 2; j >= 0; --j) { 
            temporario = mat[i][j + 1];
            mat[i][j + 1] = mat[i][j];
            mat[i][j] = temporario;
        }
    }
}
</stdlib.h></stdio.h>

Experimento 6: Conversão de Base Numérica

Programa que converet um número decimal para binário, octal e hexadecimal.

#include <stdio.h>
#define TAMANHOBuffer 100

// Protótipo
void converter_decimal(int valor, int base);

int main() {
    int numero;

    while(printf("Digite um numero decimal: "), scanf("%d", &numero) != EOF) {
        converter_decimal(numero, 2);   // Converte para binário
        printf("\n");
        converter_decimal(numero, 8);   // Converte para octal
        printf("\n");
        converter_decimal(numero, 16);  // Converte para hexadecimal

        printf("\n");
    }

    return 0;
}

// Função que converte um número decimal para qualquer base entre 2 e 16
void converter_decimal(int valor, int base) {
    char mapeamento[] = "0123456789ABCDEF";
    char resultado[TAMANHOBuffer];
    int quociente, resto;
    int posicao = 0;

    while (1) {
        resto = valor % base;
        quociente = valor / base;
        resultado[posicao++] = mapeamento[resto];

        if (quociente == 0)
            break;
        valor = quociente;
    }
    
    for (--posicao; posicao >= 0; --posicao)
        printf("%c", resultado[posicao]);
}
</stdio.h>