DCC/ICEx/UFMG Luigi D. C.

Soares
DCC 203 - Programação e Desenv. de Software I Segunda Prova - Turma TM3
2o semestre de 2022 08/11/2022

Estudante: Matrícula:

Instruções:
i. Este exame possui 4 página(s). Verifique se sua cópia do exame está completa.
ii. Escreva seu nome na primeira página das suas respostas e forneça todas as suas respostas à mão.
iii. 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.
iv. 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.
v. Códigos devem ser escritos na linguagem C. Caso não se lembre de alguma sintaxe específica, descreva da forma mais
clara e sucinta possível o que está querendo fazer.

vi. Lembre-se de indentar o código de maneira apropriada e atente-se a organização, clareza e legibilidade do código!

Este ano tem Copa do Mundo! O país inteiro se prepara para torcer para a equipe canarinho conquistar mais um
título, tornando-se hexacampeã. Na Copa do Mundo, depois de uma fase de grupos, dezesseis equipes disputam a Fase
final, composta de quinze jogos eliminatórios. A figura abaixo mostra a tabela de jogos da Fase final:

Figura 1: Fonte: https://br.spoj.com/problems/COPA1/

Na tabela de jogos acima, as dezesseis equipes finalistas são representadas por letras maiúsculas (de A a P), e os
jogos são numerados de 1 a 15. Por exemplo, o jogo 3 é entre as equipes identificadas por E e F; o vencedor desse jogo
enfrentará o vencedor do jogo 4, e o perdedor será eliminado. A equipe que vencer os quatro jogos da Fase final será a
campeã (por exemplo, para a equipe K ser campeã ela deve vencer os jogos 6, 11, 14 e 15.

Nas questões a seguir, iremos modelar as fases eliminatórias de um campeonato, seguindo um formato similar ao da
copa do mundo, representado acima. As seguintes mudanças serão adotadas: (i) a fase inicial terá uma quantidade k de
jogos (k múltiplo de 2, k ≤ 64) e (ii) iremos representar cada time como um inteiro, pois poderemos ter mais de 26 times.

Plog k
Entrada: A entrada é composta de um inteiro k representando o número de jogos da primeira fase, seguido de i=02 2ki
linhas. Cada linha contém o resultado de um jogo. A primeira linha contém o resultado do jogo de número 1, a segunda
linha o resultado do jogo de número 2, e assim por diante. Isto é, as k primeiras linhas contém o resultado dos jogos da
primeira fase, as k/2 linhas seguintes contém o resultado dos jogos da segunda fase, e assim por diante. A primeira linha
contém o resultado do jogo entre os times 0 e 1, a segunda linha contém o resultado do jogo entre os times 2 e 3, e assim

1
 sucessivamente, até acabarem os jogos da primeira fase. A partir da segunda fase, o código dos times que jogam cada
fase depende do resultado dos jogos da fase anterior. O resultado de um jogo é representado por dois números inteiros M
e N separados por um espaço em branco, indicando respectivamente o número de gols da equipe representada à esquerda
e à direita na tabela de jogos (0 ≤ M ≤ 20, 0 ≤ N ≤ 20 e M ̸= N , i.e. vamos desconsiderar empates).

Exemplo:
8
4 1
1 0
0 4
3 1
2 3
1 2
2 0
0 2
1 2
4 3
0 1
3 2
3 4
1 4
1 0
No primeiro jogo, o time 0 ganhou do time 1. No segundo jogo, o time 2 ganhou do time 3. No terceiro jogo, o time
4 perdeu do time 5. No quarto jogo, o time 6 ganhou do time 7. Consequentemente, o nono jogo foi entre os times 0 e 2
(os vencedores dos dois primeiros jogos) e o décimo jogo foi entre os times 5 e 6. Ao final, o time campeão foi o time 5.
O espaço a seguir é referente ao arquivo de cabeçalho que será utilizado para construir o programa principal na última
questão. Utilize este espaço para definir as estruturas descritas nas questões 1 e 2. Você também deve utilizar este espaço
para declarar qualquer função que venha a implementar, incluindo as funções solicitadas nas questões 3 e 4.

campeonato.h
1 #i f n d e f CAMPEONATO_H_
2 #define CAMPEONATO_H_
3
4 // Questao 0 1 : e s t r u t u r a " P a r t i d a "
5 struct P a r t i d a {
6 int timeA ;
7 int time B ;
8 int golsA ;
9 int g o l s B ;
10 }
11
12
13 // Questao 0 2 : e s t r u t u r a " Fase "
14 struct Fase {
15 struct P a r t i d a p a r t i d a s [ 6 4 ] ;
16 int num_partidas ;
17 }
18
19
20 // Questao 0 3 : d e c l a r a c a o da f u n c a o " v e n c e d o r "
21 int v e n c e d o r ( struct P a r t i d a p ) ;
22
23
24 // Questao 0 4 : d e c l a r a c a o da f u n c a o " p r o x _ f a s e "
25 void p r o x _ f a s e ( struct Fase ∗ a t u a l , struct Fase ∗ prox ) ;
26
27
28 #endif

2
 1. (3 pontos) Crie uma estrutura Partida para representar uma partida do campeonato. Esta estrutura deve conter:
• Os campos timeA (inteiro) e timeB (inteiro), representando os códigos dos times.
• Os campos golsA (inteiro) e golsB (inteiro), representando o número de gols feitos por cada time.
2. (3 pontos) Crie uma estrutura Fase para representar uma fase do campeonato. Esta estrutura de conter:
• Um campo partidas (arranjo de elementos do tipo struct Partida, de tamanho constante 64).
• Um campo num_partidas (inteiro) representando o número efetivo de partidas naquela fase.
3. (5 pontos) Crie uma função vencedor que recebe um parâmetro do tipo struct Partida e retorna o inteiro que
representa o time vencedor da partida. Lembre-se de adicionar a declaração da função no arquivo de cabeçalho.
campeonato.c
1 #include " campeonato . h"
2
3 int v e n c e d o r ( struct P a r t i d a p ) {
4 i f ( p . golsA > p . g o l s B ) {
5 return p . timeA ;
6 }
7
8 return p . timeB ;
9 }
10
11
12
13
14

4. (7 pontos) Escreva uma função prox_fase que recebe um primeiro parâmetro atual e um segundo parâmetro prox.
O tipo dos dois parâmetros deve ser um ponteiro para struct Fase. Esta função não tem retorno (i.e. o retorno
é void). Esta função deve percorrer a fase atual do campeonato, identificando os times vencedores de cada partida,
e preencher a próxima fase (i.e. preencher o parâmetro prox com as partidas da próxima fase). Lembre-se, também,
de atualizar o campo num_partidas de prox com a quantidade de partidas da fase seguinte. Esta função não deve
preencher o resultado dos jogos da próxima fase, apenas definir os times de cada partida.
campeonato.c
1
2
3 void p r o x _ f a s e ( struct Fase ∗ a t u a l , struct Fase ∗ prox ) {
4 prox−>num_partidas = a t u a l −>num_partidas / 2 ;
5 int i = 0 ;
6
7 f o r ( int j = 0 ; j < prox−>num_partidas ; j ++) {
8 // a t u a l −>p a r t i d a s eh e q u i v a l e n t e a (∗ a t u a l ) . p a r t i d a s ( a t u a l eh p o n t e i r o )
9 int v e n c e d o r 1 = v e n c e d o r ( a t u a l −>p a r t i d a s [ i ] ) ;
10 int v e n c e d o r 2 = v e n c e d o r ( a t u a l −>p a r t i d a s [ i + 1 ] ) ;
11
12 // A s i n t a x e a b a i x o c o r r e s p o n d e a i n i c i a l i z a c a o de uma
13 // e s t r u t u r a . Os campos sao i n f o r m a d o s na ordem d e c l a r a d a
14 // na d e f i n i c a o da e s t r u t u r a : timeA , timeB , golsA , g o l s B .
15 // Definimos g o l s A e g o l s B com o v a l o r −1 apenas para i n d i c a r
16 // que a p a r t i d a a i nd a nao a c o n t e c e u .
17 struct P a r t i d a p = { vencedor1 , vencedor2 , −1, −1};
18 prox−>p a r t i d a s [ j ] = p ;
19
20 i += 2 ;
21 }
22 }
23
24
25

3
 5. (7 pontos) O programa a seguir irá utilizar as estruturas e funções definidas nas questões anteriores para determinar
o vencedor de um campeonato, seguindo a estrutura de entrada de dados definida anteriormente (i.e. cada linha
contém o resultado de um jogo). Você pode assumir que as funções implementadas nas questões anteriores estão
corretas. O código está parcialmente completo, você deve apenas completar as linhas que estão faltando.
main.c
1 #include <s t d i o . h>
2 #include " campeonato . h"
3
4 int main ( int argc , char ∗ argv [ ] ) {
5 int k ;
6 s c a n f ( "%d" , &k ) ;
7
8 // Primeiro , vamos c o n s t r u i r a f a s e i n i c i a l ( k j o g o s ) :
9 struct Fase i n i c i a l ;
10 i n i c i a l . num_partidas = k ;
11
12 int timeA = 0 , timeB = 1 ;
13 f o r ( int i = 0 ; i < k ; i ++) {
14 struct P a r t i d a p ;
15 p . timeA = timeA ;
16 p . timeB = timeB ;
17 s c a n f ( "%d␣%d" , &p . golsA , &p . g o l s B ) ;
18
19 // Quais sao os i d e n t i f i c a d o r e s dos d o i s proximos t i m e s ?
20
21 timeA += 2_____; timeB += 2_____;
22
23 // I n s i r a a p a r t i d a na f a s e i n i c i a l :
24
25 i n i c i a l . p a r t i d a s [ i ] = p______;
26 }
27
28 // Em s e g u i d a , vamos p r e e n c h e r as f a s e s s e g u i n t e s :
29 // Quantos j o g o s tem a segunda f a s e ?
30
31 k = k / 2____________;
32 struct Fase a t u a l = i n i c i a l ;
33 while ( k > 0 ) {
34 struct Fase prox ;
35 // U t i l i z e a f u n c a o p r o x _ f a s e que v o c e c r i o u para p r e e n c h e r " prox " ;
36
37 p r o x _ f a s e (& a t u a l , &prox )___________________________;
38
39 // Agora vamos l e r os r e s u l t a d o s dos j o g o s da proxima f a s e :
40 f o r ( int i = 0 ; i < prox . num_partidas ; i ++) {
41 s c a n f ( "%d␣%d" , &prox . p a r t i d a s [ i ] . golsA , &prox . p a r t i d a s [ i ] . g o l s B ) ;
42 }
43
44 // Quantos j o g o s tem a proxima f a s e ?
45 // Dica : o c a l c u l o eh o mesmo que para a segunda f a s e .
46
47 k = k / 2____________;
48 a t u a l = prox ;
49 }
50
51 // " a t u a l " s a i do l o o p sendo a u l t i m a f a s e ( f i n a l ) . Imprima o campeao :
52
53 p r i n t f ( "Campeao : ␣%d\n" , v e n c e d o r ( a t u a l . p a r t i d a s [ 0 ] ) )__________________;
54 return 0 ;
55 }