Description

Primeiro Projecto
Jogo do Galo
Neste primeiro projecto de Fundamentos da Programa¸c˜ao os alunos ira˜o desenvolver as fun¸co˜es de forma a implementar um programa em Python que permita a um jogador humano jogar o Jogo do Galo contra o computador.
1 Descri¸c˜ao do jogo
1.1 Regras do jogo
O jogo do galo ´e um jogo muito popular de papel e l´apis para dois jogadores, jogando com os s´ımbolos ’X’ e ’O’ de forma alternada nas posi¸c˜oes de um tabuleiro de dimens˜ao 3×3. O jogador que conseguir colocar trˆes dos seus s´ımbolos numa linha horizontal, vertical ou diagonal ´e o vencedor. Se na˜o haver nenhum vencedor apo´s se terem marcado todas as posic¸˜oes poss´ıveis, o jogo termina num empate.
1.2 Estrat´egia de jogo
O jogo do galo ´e um jogo com uma combinato´ria simples que permite desenvolver soluc¸˜oes eficientes para a escolha do melhor movimento baseada em algoritmos de teoria de jogos . Alternativamente, e conforme o usado por Newell e Simon’s em 1972 , os jogadores podem realizar um jogo perfeito (para ganhar ou pelo menos empatar) se, cada vez que for sua vez de jogar, escolherem a primeira ac¸ca˜o dispon´ıvel da lista a seguir:
1. Vito´ria:
Se o jogador tiver duas das suas pe¸cas em linha e uma posic¸˜ao livre ent˜ao deve marcar na posi¸ca˜o livre (ganhando o jogo);
2. Bloqueio:
Se o adversa´rio tiver duas das suas pe¸cas em linha e uma posi¸ca˜o livre ent˜ao deve marcar na posi¸ca˜o livre (para bloquear o advers´ario);
3. Bifurca¸c˜ao:
Se o jogador tiver duas linhas/colunas/diagonais que se intersectam, onde cada uma cont´em uma das suas pe¸cas
e se a posic¸˜ao de intersec¸ca˜o estiver livre
ent˜ao deve marcar na posi¸ca˜o de intersec¸ca˜o (criando duas formas de vencer na jogada seguinte);
4. Bloqueio de bifurca¸c˜ao:
Se o adversa´rio tiver apenas uma bifurcac¸˜ao ent˜ao o jogador deve bloquear a bifurcac¸˜ao (escolher a posic¸˜ao livre da intersec¸ca˜o) sen˜ao o jogador deve criar um dois em linha para for¸car o oponente a defender, desde que a defesa n˜ao resulte na criac¸˜ao de uma bifurcac¸˜ao para o oponente;
5. Centro:
Se a posic¸˜ao central estiver livre ent˜ao jogar na posi¸ca˜o central;
6. Canto oposto:
Se o adversa´rio estiver num canto e se o canto diagonalmente oposto for uma posic¸˜ao livre
ent˜ao jogar nesse canto oposto;
7. Canto vazio:
Se um canto for uma posi¸ca˜o livre ent˜ao jogar nesse canto;
8. Lateral vazio:
Se uma posi¸c˜ao lateral (que nem ´e o centro, nem um canto) for livre ent˜ao jogar nesse lateral.
2 Trabalho a realizar
O objetivo do primeiro projecto ´e escrever um programa em Python, correspondendo a`s fun¸c˜oes descritas nesta secc¸˜ao, que permita jogar ao Jogo do Galo conforme descrito anteriormente. Para isso, devera´ definir o conjunto de func¸˜oes solicitadas, assim como algumas fun¸co˜es auxiliares adicionais, caso considere necessa´rio.
2.1 Representa¸c˜ao do tabuleiro
Considere que um tabuleiro de dimensa˜o 3×3 ´e representado internamente (ou seja, no seu programa) por um tuplo com 3 tuplos, cada um deles contendo 3 valores inteiros. Os valores representam cada uma das posi¸c˜oes do tabuleiro podendo tomar valores iguais a 1, -1 ou 0, dependendo se a posi¸ca˜o tiver sido marcada com os s´ımbolos ’X’, ’O’ ou se estiver livre, respectivamente. Considere tamb´em que cada uma das posi¸co˜es dum tabuleiro ´e representada internamente por um nu´mero inteiro seguindo a ordem da esquerda para a direita e de cima para baixo como ilustrado na Figura 1. As fun¸c˜oes a escrever durante o projecto s˜ao as seguintes:
2.1.1 eh tabuleiro: universal → booleano (1.25 valores)
Esta fun¸c˜ao recebe um argumento de qualquer tipo e devolve True se o seu argumento corresponde a um tabuleiro e False caso contra´rio, sem nunca gerar erros.
Coluna
1 2 3
1 2 3
4 5 6
7 8 9
1
2
3
Figura 1: Posi¸co˜es dum tabuleiro do jogo do galo.
>>> tab = ((1,0,0),(-1,1,0),(1,-1,-1))
>>> eh_tabuleiro(tab)
True
>>> tab = ((1,0,0),(’O’,1,0),(1,-1,-1))
>>> eh_tabuleiro(tab)
False
>>> tab = ((1,0,0),(-1,1,0),(1,-1))
>>> eh_tabuleiro(tab) False
2.1.2 eh posicao: universal → booleano (0.5 valores)
Esta fun¸c˜ao recebe um argumento de qualquer tipo e devolve True se o seu argumento corresponde a uma posi¸ca˜o e False caso contr´ario, sem nunca gerar erros. Considere que as posi¸co˜es no tabuleiro sa˜o definidas por um inteiro, como indicado na Figura 1.
>>> eh_posicao(9)
True
>>> eh_posicao(-2)
False
>>> eh_posicao((1,)) False
2.1.3 obter coluna: tabuleiro ×inteiro → vector (0.75 valores)
Esta func¸˜ao recebe um tabuleiro e um inteiro com valor de 1 a 3 que representa o nu´mero da coluna, e devolve um vector com os valores dessa coluna. Se algum dos argumentos dados forem inva´lidos, a fun¸ca˜o deve gerar um erro com a mensagem ’obter coluna: algum dos argumentos e invalido’.
>>> tab = ((1,-1,0),(1,0,-1),(1,-1,0))
>>> obter_coluna(tab, 2) (-1, 0, -1)
>>> obter_coluna(tab, 1) (1, 1, 1)
>>> obter_coluna(tab, 4)
Traceback (most recent call last): <…>
ValueError: obter_coluna: algum dos argumentos e invalido
2.1.4 obter linha: tabuleiro ×inteiro → vector (0.5 valores)
Esta func¸˜ao recebe um tabuleiro e um inteiro com valor de 1 a 3 que representa o nu´mero da linha, e devolve um vector com os valores dessa linha. Se algum dos argumentos dados forem inv´alidos, a fun¸ca˜o deve gerar um erro com a mensagem ’obter linha: algum dos argumentos e invalido’.
>>> tab = ((1,-1,0),(1,0,-1),(1,-1,0))
>>> obter_linha(tab, 2) (1, 0, -1)
>>> obter_linha(tab, 1) (1, -1, 0)
>>> obter_linha(tab, 4)
Traceback (most recent call last): <…>
ValueError: obter_linha: algum dos argumentos e invalido
2.1.5 obter diagonal: tabuleiro ×inteiro → vector (0.75 valores)
Esta fun¸ca˜o recebe um tabuleiro e um inteiro que representa a direc¸ca˜o da diagonal, 1 para descendente da esquerda para a direita e 2 para ascendente da esquerda para a direita, e devolve um vector com os valores dessa diagonal. Se algum dos argumentos dados forem inva´lidos, a fun¸c˜ao deve gerar um erro com a mensagem ’obter diagonal: algum dos argumentos e invalido’.
>>> tab = ((1,-1,-1),(1,0,-1),(1,-1,0))
>>> obter_diagonal(tab, 1) (1, 0, 0)
>>> obter_diagonal(tab, 2) (1, 0, -1)
>>> obter_diagonal(tab, 3)
Traceback (most recent call last): <…>
ValueError: obter_diagonal: algum dos argumentos e invalido
2.1.6 tabuleiro str: tabuleiro → cad. carateres (1.25 valores)
Esta fun¸ca˜o recebe um tabuleiro e devolve a cadeia de caracteres que o representa (a representac¸˜ao externa ou representa¸c˜ao “para os nossos olhos”), de acordo com o exemplo na seguinte interacc¸˜ao. Se o argumento dado for inv´alido, a fun¸ca˜o deve gerar um erro com a mensagem ’tabuleiro str: o argumento e invalido’.
>>> tab = ((1,-1,0),(1,0,-1),(1,-1,0))
>>> tabuleiro_str(tab)
’ X | O | ———– X | | O ———– X | O | ’
>>> print(tabuleiro_str(tab))
X | O |
———-X | | O
———–
X | O |
>>> tabuleiro_str(((1,-1,0),(1,0,-1)))
Traceback (most recent call last): <…>
ValueError: tabuleiro_str: o argumento e invalido
2.2 Fun¸c˜oes de inspec¸c˜ao e manipula¸c˜ao do tabuleiro
2.2.1 eh posicao livre: tabuleiro ×posicao → booleano (0.75 valores)
Esta fun¸ca˜o recebe um tabuleiro e uma posi¸ca˜o, e devolve True se a posi¸ca˜o corresponde a uma posi¸ca˜o livre do tabuleiro e False caso contra´rio. Se algum dos argumentos dado for inv´alido, a fun¸ca˜o deve gerar um erro com a mensagem ’eh posicao livre: algum dos argumentos e invalido’.
>>> tab = ((1,-1,0),(1,-1,0),(1,-1,0))
>>> eh_posicao_livre(tab, 9) True
>>> eh_posicao_livre(tab, 7)
False
>>> eh_posicao_livre(tab, (-1,))
Traceback (most recent call last): <…>
ValueError: eh_posicao_livre: algum dos argumentos e invalido
2.2.2 obter posicoes livres: tabuleiro → vector (0.75 valores)
Esta fun¸ca˜o recebe um tabuleiro, e devolve o vector ordenado com todas as posi¸co˜es livres do tabuleiro. Se o argumento dado for inva´lido, a func¸˜ao deve gerar um erro com a mensagem ’obter posicoes livres: o argumento e invalido’.
>>> tab = ((1,-1,0),(1,-1,0),(1,-1,0)) >>> obter_posicoes_livres(tab)
(3, 6, 9)
>>> tab = ((1,-1,0),(1,-1,0),(1,-1))
>>> obter_posicoes_livres(tab)
Traceback (most recent call last): <…>
ValueError: obter_posicoes_livres: o argumento e invalido
2.2.3 jogador ganhador: tabuleiro → inteiro (2 valores)
Esta fun¸ca˜o recebe um tabuleiro, e devolve um valor inteiro a indicar o jogador que ganhou a partida no tabuleiro passado por argumento, sendo o valor igual a 1 se ganhou o jogador que joga com ’X’, -1 se ganhou o jogador que joga com ’O’, ou 0 se na˜o ganhou nenhum jogador. Se o argumento dado for inva´lido, a fun¸ca˜o deve gerar um erro com a mensagem ’jogador ganhador: o argumento e invalido’.
>>> tab = ((1,-1,0),(1,0,-1),(0,-1,0))
>>> jogador_ganhador(tab)
0
>>> tab = ((1,-1,0),(1,0,-1),(1,-1,0))
>>> jogador_ganhador(tab)
1
>>> tab = ((1,1,-1),(-1,-1,1),(-1,-1,1))
>>> jogador_ganhador(tab)
-1
>>> tab = ((1,1,-1),(-1,-1,1),(1,-1))
>>> jogador_ganhador(tab)
Traceback (most recent call last): <…>
ValueError: jogador_ganhador: o argumento e invalido
2.2.4 marcar posicao: tabuleiro ×inteiro ×posicao → tabuleiro (1 valor)
Esta fun¸c˜ao recebe um tabuleiro, um inteiro identificando um jogador (1 para o jogador ’X’ ou -1 para o jogador ’O’) e uma posi¸c˜ao livre, e devolve um novo tabuleiro modificado com uma nova marca do jogador nessa posi¸ca˜o. Se algum dos argumentos dados forem inva´lidos, a fun¸c˜ao deve gerar um erro com a mensagem ’marcar posicao: algum dos argumentos e invalido’.
>>> tab = ((1,-1,0),(1,0,-1),(1,-1,0))
>>> marcar_posicao(tab, -1, 5)
((1, -1, 0), (1, -1, -1), (1, -1, 0))
>>> marcar_posicao(tab, 1, 3)
((1, -1, 1), (1, 0, -1), (1, -1, 0))
>>> marcar_posicao(tab, 1, 1)
Traceback (most recent call last): <…>
ValueError: marcar_posicao: algum dos argumentos e invalido
2.3 Fun¸c˜oes de jogo
2.3.1 escolher posicao manual: tabuleiro → posicao (0.5 valores)
Esta fun¸c˜ao realiza a leitura de uma posi¸c˜ao introduzida manualmente por um jogador e devolve esta posi¸ca˜o escolhida. Se o argumento dado for inva´lido, a fun¸ca˜o deve gerar um erro com a mensagem ’escolher posicao manual: o argumento e invalido’. A fun¸c˜ao deve apresentar a mensagem ’Turno do jogador. Escolha uma posicao livre: ’, para pedir ao utilizador para introduzir uma posi¸ca˜o livre. Pode assumir que o utilizador introduzira´ sempre um nu´mero inteiro. Se o valor introduzido n˜ao corresponder a uma posi¸ca˜o livre do tabuleiro, a fun¸ca˜o deve gerar um erro com a mensagem ’escolher posicao manual: a posicao escolhida e invalida’.
>>> tab = ((1,-1,0),(1,0,-1),(1,-1,0))
>>> escolher_posicao_manual(tab)
Turno do jogador. Escolha uma posicao livre: 3
3
>>> escolher_posicao_manual(tab)
Turno do jogador. Escolha uma posicao livre: 12
Traceback (most recent call last): <…>
ValueError: escolher_posicao_manual: a posicao introduzida e invalida
2.3.2 escolher posicao auto: tabuleiro ×inteiro ×cad. carateres → posicao (4 valores)
Esta fun¸c˜ao recebe um tabuleiro, um inteiro identificando um jogador (1 para o jogador ’X’ ou -1 para o jogador ’O’) e uma cadeia de carateres correspondente a` estrat´egia, e devolve a posi¸c˜ao escolhida automaticamente de acordo com a estrat´egia seleccionada. Se algum dos argumentos dados forem inva´lidos, a fun¸c˜ao deve gerar um erro com a mensagem ’escolher posicao auto: algum dos argumentos e invalido’. As estrat´egias a seguir devem ser as seguintes:
• ’basico’ (1 valor) – deve considerar em ordem os crit´erios 5, 7 e 8 descritos nas sec¸ca˜o 1.2;
• ’normal’ (1.5 valores) – deve considerar em ordem os crit´erios 1, 2, 5, 6, 7 e 8 descritos nas secc¸˜ao 1.2;
• ’perfeito’ (1.5 valores) – deve seguir uma abordagem perfeita, de acordo com a estrat´egia completa descrita na sec¸c˜ao 1.2.
Sempre que houver mais do que uma posic¸˜ao que cumpra um dos crit´erios definidos nas estrat´egias anteriores, deve escolher a primeira posi¸ca˜o seguindo a numera¸ca˜o das posi¸co˜es definida anteriormente na Figura 1 (da esquerda para a direita e de cima para baixo).
>>> tab = ((0,0,0),(0,1,0),(-1,0,0))
>>> escolher_posicao_auto(tab, 1, ’basico’) 1
>>> escolher_posicao_auto(tab, 1, ’normal’)
3
>>> tab = ((0,0,-1),(-1,1,0),(1,0,0))
>>> escolher_posicao_auto(tab, 1, ’normal’)
1
>>> escolher_posicao_auto(tab, 1, ’perfeito’) 8
>>> escolher_posicao_auto(tab, ’O’, ’basico’)
Traceback (most recent call last): <…>
ValueError: escolher_posicao_auto: algum dos argumentos e invalido
2.3.3 jogo do galo: cad. carateres ×cad. carateres → cad. carateres (2 valores)
Esta fun¸c˜ao corresponde `a fun¸ca˜o principal que permite jogar um jogo completo de Jogo do Galo de um jogador contra o computador. O jogo come¸ca sempre com o jogador ’X’ a marcar uma posi¸ca˜o livre e termina quando um dos jogadores vence ou, se n˜ao existem posi¸co˜es livres no tabuleiro. A func¸˜ao recebe duas cadeias de caracteres e devolve o identificador do jogador ganhador (’X’ ou ’O’). Em caso de empate, a fun¸ca˜o deve devolver a cadeia de caracteres ’EMPATE’. O primeiro argumento corresponde a marca (’X’ ou ’O’) que deseja utilizar o jogador humano, e o segundo argumento selecciona a estrat´egia de jogo utilizada pela ma´quina. Se algum dos argumentos dados forem inv´alidos, a fun¸ca˜o deve gerar um erro com a mensagem ’jogo do galo: algum dos argumentos e invalido’. A fun¸ca˜o deve apresentar a mensagem ’Turno do computador (<estrategia>):’, em que <estrategia> corresponde a` cadeia de caracteres passada como argumento, quando for o turno do computador.
Exemplo 1
>>> jogo_do_galo(’O’, ’basico’) Bem-vindo ao JOGO DO GALO.
O jogador joga com ’O’.
Turno do computador (basico):
| |
———–
| X |
———–
| |
Turno do jogador. Escolha uma posicao livre: 1
O | |
———–
| X |
———–
| |
Turno do computador (basico):
O | | X
———–
| X |
———–
| |
Turno do jogador. Escolha uma posicao livre: 7
O | | X
———–
| X |
———–
O | |
Turno do computador (basico):
O | | X
———–
| X |
———–
O | | X
Turno do jogador. Escolha uma posicao livre: 4
O | | X
———–
O | X |
———–
O | | X
’O’
>>>
Exemplo 2
>>> jogo_do_galo(’X’, ’perfeito’) Bem-vindo ao JOGO DO GALO.
O jogador joga com ’X’.
Turno do jogador. Escolha uma posicao livre: 1
X | |
———–
| |
———–
| |
Turno do computador (perfeito):
X | |
———–
| O |
———–
| |
Turno do jogador. Escolha uma posicao livre: 9
X | |
———–
| O |
———–
| | X
Turno do computador (perfeito):
X | O |
———–
| O |
———–
| | X
Turno do jogador. Escolha uma posicao livre: 8
X | O |
———–
| O |
———–
| X | X
Turno do computador (perfeito):
X | O |
———–
| O |
———–
O | X | X
Turno do jogador. Escolha uma posicao livre: 3
X | O | X
———–
| O |
———–
O | X | X
Turno do computador (perfeito):
X | O | X
———–
| O | O
———–
O | X | X
Turno do jogador. Escolha uma posicao livre: 4
X | O | X
———–
X | O | O
———–
O | X | X
’EMPATE’
>>>
3 Condi¸co˜es de Realiza¸c˜ao e Prazos
• Devera´ submeter um u´nico ficheiro com extensa˜o .py contendo todo o c´odigo do seu projecto. O ficheiro de c´odigo dever´a conter em coment´ario, na primeira linha, o nu´mero e o nome do aluno.
• No seu ficheiro de c´odigo n˜ao devem ser utilizados caracteres acentuados ou qualquer outro cara´cter na˜o pertencente `a tabela ASCII. Todos os testes autom´aticos falhara˜o, mesmo que os caracteres n˜ao ASCII sejam utilizados dentro de comenta´rios ou cadeias de caracteres. Programas que na˜o cumpram este requisito sera˜o penalizados em trˆes valores.
• Na˜o ´e permitida a utilizac¸˜ao de qualquer mo´dulo ou fun¸ca˜o na˜o dispon´ıvel built-in no Python 3.
• Pode, ou na˜o, haver uma discussa˜o oral do trabalho e/ou uma demonstra¸ca˜o do funcionamento do programa (ser´a decidido caso a caso).
• Lembre-se que no T´ecnico, a fraude acad´emica ´e levada muito a s´erio e que a co´pia numa prova (projectos inclu´ıdos) leva `a reprova¸ca˜o na disciplina. O corpo docente da cadeira sera´ o u´nico juiz do que se considera ou n˜ao copiar num projecto.
4 Submiss˜ao
A submiss˜ao e avalia¸ca˜o da execu¸ca˜o do projecto de FP ´e feita utilizando o sistema Mooshak . Para obter as necess´arias credenciais de acesso e poder usar o sistema devera´:
• Obter uma password para acesso ao sistema, seguindo as instru¸c˜oes na pa´gina: http://acm.tecnico.ulisboa.pt/~fpshak/cgi-bin/getpass. A password serlhe-a´ enviada para o email que tem configurado no Fenix. Se a password na˜o lhe chegar de imediato, aguarde.
• Apo´s ter recebido a sua password por email, deve efetuar o login no sistema atrav´es da pa´gina: http://acm.tecnico.ulisboa.pt/~fpshak/. Preencha os campos com a informa¸c˜ao fornecida no email.
• Utilize o bot˜ao ”Browse…”, selecione o ficheiro com extens˜ao .py contendo todo o c´odigo do seu projecto. O seu ficheiro .py deve conter a implementa¸ca˜o das fun¸co˜es pedidas no enunciado. De seguida clique no bota˜o ”Submit” para efetuar a submiss˜ao.
Aguarde (20-30 seg) para que o sistema processe a sua submiss˜ao!!!
• Quando a submiss˜ao tiver sido processada, poder´a visualizar na tabela o resultado correspondente. Receber´a no seu email um relato´rio de execu¸ca˜o com os detalhes da avalia¸ca˜o autom´atica do seu projecto podendo ver o nu´mero de testes passados/falhados.
• Para sair do sistema utilize o bota˜o ”Logout”.
Submeta o seu projecto atempadamente, dado que as restri¸c˜oes seguintes podem na˜o lhe permitir fazˆe-lo no u´ltimo momento:
• So´ podera´ efetuar uma nova submissa˜o pelo menos 15 minutos depois da submiss˜ao anterior.
• So´ sa˜o permitidas 10 submisso˜es em simultˆaneo no sistema, pelo que uma submissa˜o podera´ ser recusada se este limite for excedido .
• Na˜o pode ter submiss˜oes duplicadas, ou seja, o sistema pode recusar uma submissa˜o caso seja igual a uma das anteriores.
• Sera´ considerada para avalia¸ca˜o a u´ltima submissa˜o (mesmo que tenha pontua¸ca˜o inferior a submisso˜es anteriores). Devera´, portanto, verificar cuidadosamente que a u´ltima entrega realizada corresponde `a vers˜ao do projecto que pretende que seja avaliada. N˜ao h´a excep¸co˜es!
• Cada aluno tem direito a 10 submiss˜oes sem penaliza¸c˜ao no Mooshak. Por cada submissa˜o adicional sera˜o descontados 0.1 valores na componente de avalia¸ca˜o automa´tica.
5 Classifica¸c˜ao
A nota do projecto sera´ baseada nos seguintes aspetos:
1. Avalia¸c˜ao autom´atica (80%). A avalia¸c˜ao da correcta execu¸ca˜o sera´ feita atrav´es do sistema Mooshak. O tempo de execu¸c˜ao de cada teste esta´ limitado, bem como a memo´ria utilizada.
Existem 162 casos de teste configurados no sistema: 33 testes pu´blicos (disponibilizados na pa´gina da disciplina) valendo 0 pontos cada e 129 testes privados (n˜ao disponibilizados). Como a avalia¸ca˜o automa´tica vale 80% (equivalente a 16 valores) da nota, uma submiss˜ao obt´em a nota m´axima de 1600 pontos.
O facto de um projecto completar com sucesso os testes pu´blicos fornecidos n˜ao implica que esse projecto esteja totalmente correto, pois estes na˜o sa˜o exaustivos. E´ da responsabilidade de cada aluno garantir que o co´digo produzido esta´ de acordo com a especifica¸ca˜o do enunciado, para completar com sucesso os testes privados.
2. Avalia¸c˜ao manual (20%). Estilo de programa¸ca˜o e facilidade de leitura . Em particular, ser˜ao consideradas as seguintes componentes:
• Boas pr´aticas (1.5 valores): sera˜o considerados entre outros a clareza do co´digo, a integra¸ca˜o de conhecimento adquirido durante a UC e a criatividade das soluc¸˜oes propostas.
• Comenta´rios (1 valor): devera˜o incluir a assinatura das fun¸co˜es definidas, comenta´rios para o utilizador (docstring) e coment´arios para o programador.
• Tamanho de fun¸co˜es, duplicac¸˜ao de c´odigo e abstra¸c˜ao procedimental (1 valor)
• Escolha de nomes (0.5 valores).
6 Recomenda¸c˜oes e aspetos a evitar
As seguintes recomenda¸co˜es e aspetos correspondem a sugest˜oes para evitar maus h´abitos de trabalho (e, consequentemente, m´as notas no projecto): • Leia todo o enunciado, procurando perceber o objetivo das va´rias fun¸co˜es pedidas. Em caso de du´vida de interpreta¸ca˜o, utilize o hora´rio de du´vidas para esclarecer as suas questo˜es.
• No processo de desenvolvimento do projecto, comece por implementar as va´rias fun¸co˜es pela ordem apresentada no enunciado, seguindo as metodologias estudadas na disciplina. Ao desenvolver cada uma das fun¸co˜es pedidas, comece por perceber se pode usar alguma das anteriores.
• Para verificar a funcionalidade das suas fun¸co˜es, utilize os exemplos fornecidos como casos de teste. Tenha o cuidado de reproduzir fielmente as mensagens de erro e restantes outputs, conforme ilustrado nos v´arios exemplos.
• Na˜o pense que o projecto se pode fazer nos u´ltimos dias. Se apenas iniciar o seu trabalho neste per´ıodo ira´ ver a Lei de Murphy em funcionamento (todos os problemas sa˜o mais dif´ıceis do que parecem; tudo demora mais tempo do que n´os pensamos; e se alguma coisa puder correr mal, ela vai correr mal, na pior das alturas poss´ıveis);
• Na˜o duplique c´odigo. Se duas fun¸co˜es s˜ao muito semelhantes ´e natural que estas possam ser fundidas numa u´nica, eventualmente com mais argumentos; • Na˜o se esque¸ca que as fun¸co˜es excessivamente grandes s˜ao penalizadas no que respeita ao estilo de programa¸ca˜o;
• A atitude “vou poˆr agora o programa a correr de qualquer maneira e depois preocupo-me com o estilo” ´e totalmente errada; • Quando o programa gerar um erro, preocupe-se em descobrir qual a causa do erro. As “marteladas” no co´digo tˆem o efeito de distorcer cada vez mais o co´digo.