Universidade Federal de Minas Gerais
Instituto de Ciências Exatas
Departamento de Ciência de Computação
DCC003 -- Algoritmos e Estruturas de Dados 1 -- 2013/1 -- Turma F
Prática 5 -- Prática em C
###############################################################################

INSTRUÇÕES:  Salve suas soluções num arquivo .c (o nome está indicado entre
parênteses no cabeçalho de cada exercício) e entregue no Moodle.  

IMPORTANTE:  Coloque um comentário na primeira linha do arquivo contendo o(s)
nome(s) do(s) aluno(s) que fizeram o código.  (Um comentário em C é qualquer
texto entre /* e */.)

DICAS: Para ler uma string de até 127 caracteres do teclado, use o seguinte
código:

	char linha[128];
	printf("digite uma linha:\n");
	fgets(linha, 128, stdin);

Para gerar um número aleatório em C entre 0 e RAND_MAX use a função
rand() definida dentro de stdlib.h:

	#include <stdlib.h> /* no começo do arquivo */
	int aleatorio = rand(); /* em qualquer ponto no programa */

Para alocar um vetor de X elementos do tipo Y use:

	Y * vetor = malloc(X * sizeof(Y));
	/* Por exemplo: double * vetor = malloc(10 * sizeof(double)) */
	/* Não esquecer de liberar a memória depois com free(vector)! */

Lembre-se que nomes de arranjos, quando usados sem colchetes, são convertidos
em ponteiros.  Além disso, temos que exp1[exp2] é semânticamente idêntico à
*(exp1+exp2).


Exercício 1 -- Ponteiros e arranjos (ptrarranjo.c) ############################

Neste exercício iremos praticar acesso a elementos num arranjo através de
ponteiros. Escreva um programa que inicialize um arranjo de 10 elementos (por
exemplo, aleatóriamente) e depois imprima o menor dos elementos.  Seu programa
*não* deve usar os caracteres de abrir e fechar colchetes: use alocação
dinâmica e a construção *(exp1+exp2).


Exercício 2 -- Soma de vetores (vetsoma.c) ####################################

Implemente uma função em C que recebe dois vetores de inteiros v1 e v2, mais um
inteiro N com o tamanho dos vetores.  Sua função deve alocar e retornar um
vetor de inteiros de tamanho N onde o elemento na posição i de v3 é a soma dos
elementos na posição i de v1 e v2.  Sua função deve ter a seguinte declaração:

int * soma_vetores(int *v1, int *v2, int N);

Para testar seu programa, crie uma função main() que chama sua função
soma_vetores e imprime os valores somados.


Exercício 3 -- Biblioteca de matrizes (matriz.c, matriz.h, main.c) ############

Neste exercícios iremos fazer uma biblioteca para manipulação de matrizes.
Vamos usar a seguinte estrutura para matrizes:

struct matriz {
	int **elementos;
	int linhas;
	int colunas;
};

Sua biblioteca deve implementar pelo menos as seguintes funções:

struct matriz * matriz_cria(int linhas, int colunas);
/* Esta função deve alocar uma matriz (não se esqueça de alocar espaço para os
 * elementos e testar se ocorreu erro) e retonar um ponteiro para a estrutura
 * matriz alocada. */

void matriz_libera_memoria(struct matriz *m);
/* Esta função deve liberar toda a memória associada à matriz. */

void matriz_preenche_aleatorio(struct matriz *m);
/* Esta função deve atribuir valores aleatórios para os elementos da matriz. */

void matriz_imprime(struct matriz *m);
/* Esta função deve imprimir a matriz na tela. */

struct matriz * matriz_copia(struct matriz *m);
/* Esta função deve alocar e retonar uma matriz contendo uma cópia da matriz
 * recebida como parâmetro. */

struct matriz * matriz_multiplica(struct matriz *m1, struct matriz *m2);
/* Esta função deve criar uma matriz (use matriz_cria!) e colocar nessa matriz
 * o resultado da multiplicação de m1 e m2.  Se não for possível multiplicar m1
 * e m2, retorne NULL. */

Depois de implementar as funções, faça uma função main para testá-las.  Seu
teste deve criar e imprimir duas matrizes.  Depois multiplique as matrizes e
imprima o resultado da multiplicação.  No final, libere a memória alocada pelas
matrizes.

Antes de entregar sua prática, modularize sua solução realizando os seguintes
passos:

(1) Separe a declaração da estrutura matriz e das funções no arquivo matriz.h.

(2) Coloque a definição das funções no arquivo matriz.c.  Note que matriz.c
precisa utilizar a estrutura matriz que está definida em matriz.h, logo,
coloque #include "matriz.h" dentro de matriz.c.

(3) Coloque sua função main no arquivo main.c.  Como a função main usa a
estrutura matriz e as funções do seu módulo, você precisa incluir matriz.h no
main.c também.

Para compilar e testar seu programa modularizado execute os seguintes comandos:

> gcc -Wall -c matriz.c

O -c na linha acima é necessário porque o matriz.c não tem uma função main,
logo não podemos fazer um arquivo executável (.exe).  O resultado de do comando
acima será armazenado num arquivo chamado matriz.o.

> gcc -Wall matriz.o main.c -o teste.exe

Esse comando irá compilar o main.c e gerar o arquivo teste.exe.  Precisamos
passar o arquivo matriz.o junto do main.c para que o GCC saiba onde está o
código das funções do seu módulo.