DCC/ICEx/UFMG Gleison Mendonça e Luigi Soares

DCC 203 - Programação e Desenv. de Software I Prova Substitutiva - Turmas TA1, TA2, TM3
2o semestre de 2022 15/12/2022
Estudante: Matrícula:

Instruções:
i. Este exame possui 4 página(s). Verifique se sua cópia do exame está completa.
ii. Esta prova é sem consulta: você não tem permissão para consultar o livro texto, suas notas de aula, a Internet,
seus colegas ou quaisquer outras pessoas ou fontes para concluir o exame.
iii. Se você acredita que alguma pergunta esteja subespecificada, anote as suposições que você teve que fazer para chegar
a sua resposta e justifique-as como parte de sua resposta à pergunta.
iv. Lembre-se de indentar o código de maneira apropriada e atente-se a organização, clareza e legibilidade do código!

Utilize os espaços a seguir, referentes aos arquivo de cabeçalho curso.h e aluno.h, para a definição das estruturas
solicitadas na primeira questão (se atente aos nomes dos campos!).
curso.h
1 #i f n d e f CURSO_H_
2 #define CURSO_H_
3 typedef struct Curso { Resposta da 1-a
4
5 unsigned int i d ;
6 char ∗nome ;
7 char departamento [ 4 ] ; // S i g l a de 3 c a r a c t e r e s + \0 = tamanho 4
8
9 } Curso ;
10 #endif // CURSO_H_

aluno.h
1 #i f n d e f ALUNO_H_
2 #define ALUNO_H_
3
4 #include <s t d b o o l . h>
5 #include " c u r s o . h"
6 Resposta da 1-b
7 typedef struct Aluno {
8
9 char m a t r i c u l a [ 7 ] ; // 6 d i g i t o s + \0
10 char ∗nome ;
11 Curso ∗ c u r s o ;
12
13 } Aluno ;
14
15 typedef struct VetorAlunos {
16 Resposta da 1-c
17 Aluno ∗ a l u n o s ;
18 unsigned int c a p a c i d a d e ;
19 unsigned int n ;
20
21 } VetorAlunos ;
22
23 b o o l s a l v a r A l u n o s ( VetorAlunos v , char ∗ nome_arquivo ) ;
24 #endif // ALUNO_H_

1
1. (4 pontos) Complete as estruturas Curso, Aluno e VetorAlunos, presentes no arquivos de cabeçalho curso.h e
aluno.h, de acordo com as seguintes especificações (dica: lembre-se de considerar o \0 nas strings):

(a) (1 ponto) Curso: id (inteiro não negativo), nome (string, tamanho variável, pode conter espaços) e departamento
(string, sigla de 3 caracteres)
(b) (1,5 pontos) Aluno: matricula (string, 6 dígitos), nome (string, tamanho variável, pode conter espaços) e
curso (ponteiro para a estrutura Curso)
(c) (1,5 pontos) VetorAlunos: alunos (arranjo de Alunos, tamanho variável), capacidade (inteiro não negativo)
e n (inteiro não negativo)

2. (a) (3 pontos) Complete a função f a seguir.

aluno.c
1 VetorAlunos f ( VetorAlunos v , Curso c u r s o ) {
2 VetorAlunos r ;
3
4 r . capacidade = 10;
5 r .n = 0;
6 resposta
7 // Aloque e s p a c o de acordo com a c a p a c i d a d e i n i c i a l :
8 r . a l u n o s = ( Aluno ∗ ) m a l l o c ( r . c a p a c i d a d e ∗ s i z e o f ( Aluno ) ) ;
9
10 f o r ( int i = 0 ; i < v . n ; i ++) {
11 i f ( r . n >= r . c a p a c i d a d e ) {
12 // Dobre a c a p a c i d a d e :
13 r . c a p a c i d a d e ∗= 2 ; resposta
14
15 // Realoque o e s p a c o para comportar novos a l u n o s :
16 r . a l u n o s = ( Aluno ∗ ) r e a l l o c ( r . a l u n o s , r . c a p a c i d a d e ∗ s i z e o f ( Aluno ) ;
17 }
18
19 i f ( v . a l u n o s [ i ] . c u r s o −>i d == c u r s o . i d ) {
20 r . alunos [ r . n ] = v . alunos [ i ] ;
21 r . n++;
22 }
23 }
24
25 return r ;
26 }

(b) (6 pontos) Descreva o que faz a função f apresentada acima. Como você renomearia a função f? Mostre a
execução e o resultado da função, caso ela tenha sido chamada com o segundo parâmetro sendo o curso de
Ciência da Computação (ID 1) e o primeiro parâmetro sendo um vetor com os seguintes alunos:
i. Matrícula: 111111, Nome: Chico, Curso: Ciência da Computação (DCC, ID 1)
ii. Matrícula: 222222, Nome: Dara, Curso: Enfermagem (ENA, ID 2)
iii. Matrícula: 333333, Nome: Mário, Curso: Ciência da Computação (DCC, ID 1)

Resposta: A função f percorre os alunos do vetor, filtrando-os de acordo com o ID do curso passado como
parâmetro e produzindo um novo vetor apenas com os alunos deste curso específico. Portanto, nomes adequados
para a função seriam nomes como filtrarAlunos ou filtrarPorCurso. A função aloca um espaço inicial
suficiente para armazenar 10 alunos e, quando o espaço previamente armazenado se esgota, ele é dobrado. Note
que a quantidade de alunos, controlada pelo campo n da estrutura VetorAlunos, é sempre menor ou igual a
capacidade do vetor de alunos. Assumindo a entrada descrita acima, o resultado seria um vetor contendo
somente os dois alunos do curso de Ciência da Computação (CC). Na primeira iteração, será comparado o ID
do curso do primeiro aluno, o Chico, com o ID do curso de CC e este aluno será inserido no vetor. Na segunda
iteração, o ID do curso é diferente do ID do curso de CC; portanto, a aluna Dara não será adicionada ao vetor.
Por fim, o terceiro aluno, o Mário, será adicionado ao vetor.
(c) (6 pontos) Implemente a função f acima de forma RECURSIVA. Isto é, sua função NÃO pode conter
laços de repetição (for, while, do-while). Sua função deve seguir o mesmo protótipo da função f: o

2
 retorno deve ser uma estrutura VetorAlunos, e deve possuir dois parâmetros dos tipos: VetorAlunos e Curso.
Se desejar, você pode criar funções auxiliares, mas estas também NÃO podem conter laços de repetição.
Resposta com uso de funções auxiliares:

aluno.c
1 void f i l t r a r P o r C u r s o A u x ( VetorAlunos v , Curso c u r s o , int i , VetorAlunos ∗ r ) {
2 i f ( i >= v . n ) return ; // Caso base , p er co rr em os t o d o s os a l u n o s
3
4 i f ( r−>n >= r−>c a p a c i d a d e ) {
5 r−>c a p a c i d a d e ∗= 2 ;
6 r−>a l u n o s = ( Aluno ∗ ) r e a l l o c ( r−>a l u n o s , r−>c a p a c i d a d e ∗ s i z e o f ( Aluno ) ;
7 }
8
9 // Se o a l u n o e s t a cursando o c u r s o p a s s a d o por parametro ,
10 // a d i c i o n e −o ao v e t o r de a l u n o s e i n c r e m e n t e o campo
11 // ‘ n ‘ para i n d i c a r que o numero de a l u n o s aumentou .
12 if ( v . a l u n o s [ i ] . c u r s o −>i d == c u r s o . i d ) {
13 r−>a l u n o s [ r−>n ] = v . a l u n o s [ i ] ;
14 r−>n++;
15 }
16
17 // Caso r e c u r s i v o :
18 filtrarPorCursoAux (v , curso , i + 1 , r ) ;
19 }
20
21 VetorAlunos f i l t r a r P o r C u r s o ( VetorAlunos v , Curso c u r s o ) {
22 VetorAlunos r ;
23
24 r .n = 0;
25 r . capacidade = 10;
26 r . a l u n o s = ( Aluno ∗ ) m a l l o c ( r . c a p a c i d a d e ∗ s i z e o f ( Aluno ) ) ;
27
28 f i l t r a r P o r C u r s o A u x ( v , c u r s o , 0 , &r ) ;
29 return r ;
30 }

Resposta com apenas uma função:

resposta da 2-c

aluno.c
1 VetorAlunos f i l t r a r P o r C u r s o ( VetorAlunos v , Curso c u r s o ) {
2 // Caso b a s e : nao ha nenhum a l u n o no v e t o r . Nesse caso , apenas alocamos um
3 // v e t o r com c a p a c i d a d e 10 , mas sem nenhum a l u n o armazenado de f a t o .
4 i f ( v . n == 0 ) {
5 VetorAlunos r ;
6
7 r .n = 0;
8 r . capacidade = 10;
9 r . a l u n o s = ( Aluno ∗ ) m a l l o c ( r . c a p a c i d a d e ∗ s i z e o f ( Aluno ) ) ;
10
11 return r ;
12 }
13
14 // Decrementa v . n para v e r i f i c a r o s u b a r r a n j o que v a i a t e a p o s i c a o a n t e r i o r .
15 // Note que a t u a l i z a r o v a l o r do campo n nao i n f l u e n c i a no v a l o r do campo
16 // f o r a da funcao , j a que VetorAlunos f o i p a s s a d o por v a l o r e nao por
17 // r e f e r e n c i a . Outro ponto i m p o r t a n t e : p e r c e b a que a chamada r e c u r s i v a
18 // a c o n t e c e p r i m e i r o . Logo , p r i m e i r o fazemos t o d a s as chamadas e so d e p o i s
19 // v o l t a m o s "compondo" os r e s u l t a d o s de cada chamada .
20 v . n−−;
21 VetorAlunos r = f i l t r a r P o r C u r s o ( v , c u r s o ) ;

3
 22
23 // v . n f o i decrementado , l o g o agora c o r r e s p o n d e ao i n d i c e do u l t i m o a l u n o .
24 i f ( v . a l u n o s [ v . n ] . c u r s o −>i d != c u r s o . i d ) {
25 return r ;
26 }
27
28 i f ( r . n >= r . c a p a c i d a d e ) {
29 r . c a p a c i d a d e ∗= 2 ;
30 r . a l u n o s = ( Aluno ∗ ) r e a l l o c ( r . a l u n o s , r . c a p a c i d a d e ∗ s i z e o f ( Aluno ) ;
31 }
32
33 r . alunos [ r . n ] = v . alunos [ v . n ] ;
34 r . n++;
35
36 return r ;
37 }

3. (6 pontos) Implemente uma função salvarAlunos, que recebe como parâmetro um vetor de alunos e o nome do
arquivo (verifique o arquivo de cabeçalho aluno.h). Você deve criar o arquivo caso ele não exista ou sobrescrever
o conteúdo do arquivo se ele já existir. Você deve salvar a matrícula e o nome de cada aluno, além do ID do curso
(um aluno por linha). Você deve retornar falso caso não tenha sido possível abrir o arquivo ou verdadeiro caso
contrário. O arquivo final deve obedecer o seguinte formato:

1 Matricula,Nome,Curso
2 111111,Chico,1
3 222222,Dara,2

Resposta:

aluno.c
1 b o o l s a l v a r A l u n o s ( VetorAlunos v , char ∗ nome_arquivo ) {
2 FILE ∗ f p = f o p e n ( nome_arquivo , "w" ) ;
3 i f ( f p == NULL) return f a l s e ;
4
5 f p r i n t f ( fp , " M a t r i c u l a , Nome , Curso \n" ) ;
6 f o r ( int i = 0 ; i < v . n ; i ++) {
7 f p r i n t f ( fp , "%s ,%s ,%d\n" , v . a l u n o s [ i ] . m a t r i c u l a , v . a l u n o s [ i ] . nome ,
8 v . a l u n o s [ i ] . c u r s o −>i d ) ;
9 }
10
11 f c l o s e ( fp ) ;
12 return t r u e ;
13 }