|
|
Linha 42: |
Linha 42: |
| = Sistemas operacionais = | | = Sistemas operacionais = |
| | | |
− | == 27/07: Apresentação == | + | == 16/03: Apresentação == |
| | | |
| Apresentação da disciplina: plano de ensino, avaliação, abordagem pedagógica. | | Apresentação da disciplina: plano de ensino, avaliação, abordagem pedagógica. |
| * [http://www.advivo.com.br/node/364056 65 anos do primeiro computador digital] | | * [http://www.advivo.com.br/node/364056 65 anos do primeiro computador digital] |
| | | |
− | == 02/08: Introdução a sistemas computacionais == | + | == 23/03: Introdução a sistemas computacionais == |
| | | |
| * Sistemas computacionais [http://www.sj.ifsc.edu.br/~msobral/SOP/slides/aula1.pdf (resumo)]: | | * Sistemas computacionais [http://www.sj.ifsc.edu.br/~msobral/SOP/slides/aula1.pdf (resumo)]: |
Linha 117: |
Linha 117: |
| * [http://www.pcworld.com/article/162866/the_10_worst_operating_systems_of_all_time.html Os 10 piores sistemas operacionais de toda a história (inglês)] | | * [http://www.pcworld.com/article/162866/the_10_worst_operating_systems_of_all_time.html Os 10 piores sistemas operacionais de toda a história (inglês)] |
| | | |
− | == 03/08: Introdução ao Linux (continuação) == | + | == 30/03: Introdução ao Linux (continuação) == |
| | | |
| *Uso básico da interface gráfica e de texto. | | *Uso básico da interface gráfica e de texto. |
Linha 156: |
Linha 156: |
| ... e veja que aparecerá um subdiretório ''sop'' com todos os arquivos do exercício lá dentro. | | ... e veja que aparecerá um subdiretório ''sop'' com todos os arquivos do exercício lá dentro. |
| | | |
− | == 09/08: Processos e memória == | + | == 06/04: Processos e memória == |
| | | |
| [http://www.sj.ifsc.edu.br/~msobral/SOP/aula1.pdf Visão geral sobre Sistemas Operacionais]: | | [http://www.sj.ifsc.edu.br/~msobral/SOP/aula1.pdf Visão geral sobre Sistemas Operacionais]: |
Linha 192: |
Linha 192: |
| <center>''Telas do monitor do Sistema</center> | | <center>''Telas do monitor do Sistema</center> |
| | | |
− | == 10/08: Sistemas de arquivos; redirecionamentos de entrada e saída padrão; pipes == | + | == 13/04: Sistemas de arquivos; redirecionamentos de entrada e saída padrão; pipes == |
| | | |
| Resolver a 1a lista de exercícios: | | Resolver a 1a lista de exercícios: |
Linha 313: |
Linha 313: |
| | | |
| | | |
− | == 16/08: Localização de arquivos == | + | == 20/04: Localização de arquivos == |
| | | |
| Uma tarefa usual em um sistema operacional é localizar arquivos. Essa procura pode ser baseada no nome ou parte do nome de arquivo, na data de criação ou última modificação, no nome do usuário ou grupo dono, ou outros atributos do arquivo. Pode ser inclusive baseada numa combinação dessas informações. Por exemplo, pode ser necessário procurar todos os arquivos de música ou video, ou então todos os programas (arquivos executáveis) que pertençam ao superusuário (usuário ''root''). Existem programas capazes de fazer tais buscas tanto no ambiente gráfico quanto no modo texto. | | Uma tarefa usual em um sistema operacional é localizar arquivos. Essa procura pode ser baseada no nome ou parte do nome de arquivo, na data de criação ou última modificação, no nome do usuário ou grupo dono, ou outros atributos do arquivo. Pode ser inclusive baseada numa combinação dessas informações. Por exemplo, pode ser necessário procurar todos os arquivos de música ou video, ou então todos os programas (arquivos executáveis) que pertençam ao superusuário (usuário ''root''). Existem programas capazes de fazer tais buscas tanto no ambiente gráfico quanto no modo texto. |
Linha 419: |
Linha 419: |
| # '''''(Desafio)''''' Em seu diretório ''home'' (pasta pessoal) existem alguns arquivos de video obtidos com sua câmera fotográfica, porém você não sabe exatamente onde estão. Além disso, esses videos são codificados na máquina fotográfica com o codec MJPG, que gera arquivos muito grandes. Se forem recodificados para XVID, os tamanhos desses videos serão reduzidos substancialmente (4 vezes ou mais). Sabendo que se pode recodificá-los no modo texto com o programa '''mencoder''' (usando-o assim: '''''mencoder''' -o novo_video.avi -oac mp3lame -ovc xvid -xvidencopts bitrate=1200 arquivo_video''), faça a busca e conversão desses videos para XVID. | | # '''''(Desafio)''''' Em seu diretório ''home'' (pasta pessoal) existem alguns arquivos de video obtidos com sua câmera fotográfica, porém você não sabe exatamente onde estão. Além disso, esses videos são codificados na máquina fotográfica com o codec MJPG, que gera arquivos muito grandes. Se forem recodificados para XVID, os tamanhos desses videos serão reduzidos substancialmente (4 vezes ou mais). Sabendo que se pode recodificá-los no modo texto com o programa '''mencoder''' (usando-o assim: '''''mencoder''' -o novo_video.avi -oac mp3lame -ovc xvid -xvidencopts bitrate=1200 arquivo_video''), faça a busca e conversão desses videos para XVID. |
| | | |
− | == 17/08: Redirecionamentos, pipes, usuários e grupos == | + | == 27/04: Redirecionamentos, pipes, usuários e grupos == |
| | | |
| Uso de redirecionamentos e pipes. Para entender a utilidade desses recursos, alguns comandos adicionais serão vistos: | | Uso de redirecionamentos e pipes. Para entender a utilidade desses recursos, alguns comandos adicionais serão vistos: |
Linha 529: |
Linha 529: |
| </syntaxhighlight> | | </syntaxhighlight> |
| | | |
− | == 23/08: Editores de texto == | + | == 04/05: Editores de texto == |
| | | |
| Ver capítulo 9 da [[Media:Gerencia_de_redes.pdf|apostila do prof. Odilson]]. | | Ver capítulo 9 da [[Media:Gerencia_de_redes.pdf|apostila do prof. Odilson]]. |
Linha 651: |
Linha 651: |
| # Salve o arquivo resultante com o nome Leiame2.txt. O arquivo resultante deve ter mais ou menos [http://www.sj.ifsc.edu.br/~msobral/SOP/roteiros/lab6/Leiame2-professor.txt este conteúdo]. | | # Salve o arquivo resultante com o nome Leiame2.txt. O arquivo resultante deve ter mais ou menos [http://www.sj.ifsc.edu.br/~msobral/SOP/roteiros/lab6/Leiame2-professor.txt este conteúdo]. |
| | | |
− | == 24/08: Compactadores de arquivos == | + | == 11/05: Compactadores de arquivos == |
| | | |
| Uma primeira forma de compactar arquivos no Linux é usando o gerenciador de arquivos ''nautilus''. Por exemplo, ra compactar um diretório deve-se selecioná-lo e em seguida chamar o ''pop-up menu'' (botão direito do mouse): | | Uma primeira forma de compactar arquivos no Linux é usando o gerenciador de arquivos ''nautilus''. Por exemplo, ra compactar um diretório deve-se selecioná-lo e em seguida chamar o ''pop-up menu'' (botão direito do mouse): |
Linha 753: |
Linha 753: |
| # Resolva a [http://www.sj.ifsc.edu.br/~msobral/SOP/prova1/prova1-rec-2009-2.tgz prova] que foi aplicada no semestre 2009.2. | | # Resolva a [http://www.sj.ifsc.edu.br/~msobral/SOP/prova1/prova1-rec-2009-2.tgz prova] que foi aplicada no semestre 2009.2. |
| | | |
− | == 30/08: Avaliação == | + | == 18/05: Avaliação == |
| | | |
| [http://www.sj.ifsc.edu.br/~msobral/SOP/tmp/prova1-2010-2.tgz Avaliação teórica e prática] | | [http://www.sj.ifsc.edu.br/~msobral/SOP/tmp/prova1-2010-2.tgz Avaliação teórica e prática] |
Linha 759: |
Linha 759: |
| = Lógica de Programação = | | = Lógica de Programação = |
| | | |
− | == 31/08: Introdução == | + | == 25/05: ??? == |
− | | |
− | '''Assuntos:''' Lógica de programação: instrução, sequência lógica, algoritmo.
| |
− | | |
− | ''Referências auxiliares:''
| |
− | * [http://wiki.sj.ifsc.edu.br/images/0/02/L%C3%B3gica_de_Programa%C3%A7%C3%A3o.pdf Apostila auxiliar], escrita pelo prof. Paulo Sérgio de Moraes.
| |
− | * Ver [http://www.sj.ifsc.edu.br/~msobral/SOP/slides/aula10.pdf transparências].
| |
− | | |
− | | |
− | [http://www.sj.ifsc.edu.br/~msobral/SOP/slides/pao.png Um primeiro algoritmo]
| |
− | | |
− | | |
− | ''Videos sobre algoritmos:''
| |
− | * [http://www.youtube.com/watch?v=k0xgjUhEG3U Outro algoritmo ...]
| |
− | * [http://www1.folha.uol.com.br/folha/videocasts/ult10038u689083.shtml Resolvendo o cubo de Rubik (cubo mágico)]
| |
− | ** [http://www.sj.ifsc.edu.br/~msobral/SOP/coisas/1285780.flv Cópia desse vídeo aqui no Ifsc]
| |
− | | |
− | '''Exemplificando com ''shell scripts'':'''
| |
− | | |
− | <syntaxhighlight lang=bash>
| |
− | #!/bin/bash
| |
− | | |
− | # Cada linha no script abaixo corresponde a uma instrução ...
| |
− | # O conjunto de instruções na ordem apresentada forma uma sequência lógica ...
| |
− | | |
− | echo Iniciando o script ...
| |
− | echo Vou procurar todos os arquivos de texto existentes neste diretório
| |
− | | |
− | find . -type f -name "*.doc" > .tmp
| |
− | find . -type f -name "*.txt" >> .tmp
| |
− | find . -type f -name "*.rtf" >> .tmp
| |
− | find . -type f -name "*.odt" >> .tmp
| |
− | | |
− | echo Os arquivos são:
| |
− | | |
− | cat .tmp
| |
− | | |
− | rm -f .tmp
| |
− | </syntaxhighlight>
| |
− | | |
− | === Problemas exemplo ===
| |
− | | |
− | '''Problema dos três recipientes'''
| |
− | | |
− | Há três recipientes com tamanhos distintos: um com 8 litros, outro com 5 litros e o terceiro com 3 litros. O recipiente com 8
| |
− | litros está completamente cheio. Deseja-se colocar 4 litros em dois recipientes. Considere que os recipientes não são graduados.
| |
− | | |
− | | |
− | '''Problema da travessia'''
| |
− |
| |
− | Um barqueiro precisa levar um saco de milho, uma galinha e uma raposa para o outro lado do rio. Porém o barco somente é capaz de levar uma coisa de cada vez (além do barqueiro). Qual a sequência de travessias necessário para atravessar o milho, a galinha e a raposa ?
| |
− | | |
− | '''Torres de Hanoi'''
| |
− | | |
− | Há três hastes. Uma das hastes serve de suporte para três discos de tamanhos diferentes. Um disco menor sempre é colocado sobre um disco maior. A figura abaixo ilustra as hastes e os discos:
| |
− | | |
− | [[imagem:Hanoi.png]]
| |
− | | |
− | Desejam-se mover os três discos para a haste da direita. Porém só pode se mover um disco por vez, e um disco maior nunca pode ficar sobre um disco menor.
| |
− | | |
− | Operação possível: '''Move''' ''disco'' para ''haste''
| |
− | | |
− | Qual a sequência de operações para mover os discos de uma haste para outra ?
| |
− | | |
− | === Atividade extra ===
| |
− | | |
− | * O jogo [http://armorgames.com/play/2205/light-bot LightBot] mostra de uma forma divertida como criar pequenos algoritmos. Até que fase desse jogo você consegue chegar ?
| |
− | | |
− | === Leitura adicional ===
| |
− | | |
− | * [http://cs-exhibitions.uni-klu.ac.at/index.php?id=193 História dos algoritmos]
| |
− | * [http://en.wikipedia.org/wiki/Algorithm Uma definição de algoritmos na Wikipedia]
| |
− | | |
− | === Conceitos da 1a avaliação ===
| |
− | | |
− | {| border="1" cellpadding="2"
| |
− | !Aluno
| |
− | !Teorica
| |
− | !Pratica
| |
− | |-
| |
− | |Fernando || A || D
| |
− | |-
| |
− | |Gabriel || D || D
| |
− | |-
| |
− | |Levi || D || D
| |
− | |-
| |
− | |Lindalvo || D || D
| |
− | |-
| |
− | |Marine || D || D
| |
− | |-
| |
− | |Mario Allan || A || B
| |
− | |-
| |
− | |Mário André || B || C
| |
− | |-
| |
− | |Mário Sérgio || C || D
| |
− | |-
| |
− | |Maykon || A || C
| |
− | |-
| |
− | |Nathany || B || D
| |
− | |-
| |
− | |Paulo Igor || A || D
| |
− | |-
| |
− | |Ricardo || C || D
| |
− | |-
| |
− | |Roberto || A || B
| |
− | |-
| |
− | |Thiago Martins || C || D
| |
− | |-
| |
− | |Thiago Ramos || C || D
| |
− | |-
| |
− | |Vinicius Kachniacz || C || C
| |
− | |-
| |
− | |Vinicius Rodrigues || A || D
| |
− | |-
| |
− | |}
| |
− | | |
− | == 06/09: Algoritmos ==
| |
− | | |
− | Ver [http://www.sj.ifsc.edu.br/~msobral/SOP/slides/aula11.pdf transparências].
| |
− | | |
− | Introdução a lógica de programação:
| |
− | * '''Algoritmos:''' sequência finita de passos que leva à execução de uma tarefa. Exemplos:
| |
− | *# [http://unesp.br/~jroberto/rubiks Como resolver o cubo de Rubik (cubo mágico)]
| |
− | *# ''Cálculo das raízes de uma equação de 2o grau (método de Baskara)''
| |
− | *# [http://www.sj.ifsc.edu.br/~msobral/SOP/slides/pao.png Receita de pão]
| |
− | *# ''Soma de dois números:'' <syntaxhighlight lang=text>
| |
− | Ler primeiro número
| |
− | Ler segundo número
| |
− | Somar os dois números lidos
| |
− | Mostrar o resultado
| |
− | </syntaxhighlight>
| |
− | * '''Programa:''' tradução de um algoritmo para uma linguagem de programação, para que possa ser executado por um computador.
| |
− | *# ''Soma de dois números em shell script:'' <syntaxhighlight lang=bash>
| |
− | #!/bin/bash
| |
− | | |
− | echo -n Entre com o primeiro numero:
| |
− | read x
| |
− | echo -n Entre com o segundo numero:
| |
− | read y
| |
− | z=$(($x + $y))
| |
− | | |
− | echo A soma de $x e $y eh $z
| |
− | </syntaxhighlight> Para executar esse programa, grave-o em um arquivo chamado ''soma.sh'' e em seguida faça o seguinte: <syntaxhighlight lang=bash>
| |
− | bash soma.sh
| |
− | </syntaxhighlight>
| |
− | *# ''Soma de dois números em Linguagem C:'' <syntaxhighlight lang=c>
| |
− | #include <stdio.h>
| |
− | | |
− | int main() {
| |
− | int x, y, r;
| |
− | | |
− | | |
− | printf("Entre com o primeiro numero: ");
| |
− | scanf("%d", &x);
| |
− | | |
− | printf("Entre com o segundo numero: ");
| |
− | scanf("%d", &y);
| |
− | | |
− | r = x + y;
| |
− | | |
− | printf("A soma de %d e %d eh %d\n", x, y, r);
| |
− | | |
− | return 0;
| |
− | }
| |
− | </syntaxhighlight> Para executar esse programa, grave-o em um arquivo chamado ''soma.c'' e em seguida faça o seguinte: <syntaxhighlight lang=bash>
| |
− | gcc -o soma soma.c
| |
− | ./soma
| |
− | </syntaxhighlight>
| |
− | *# ''Soma de dois números em Java:'' <syntaxhighlight lang=java>
| |
− | import java.util.Scanner;
| |
− | | |
− | class Soma
| |
− | {
| |
− | public static void main(String args[])
| |
− | {
| |
− | int x, y, r;
| |
− | Scanner scanner = new Scanner(System.in);
| |
− |
| |
− | System.out.print("Entre com o primeiro numero: ");
| |
− | x = scanner.nextInt();
| |
− | | |
− | System.out.print("Entre com o segundo numero: ");
| |
− | y = scanner.nextInt();
| |
− | | |
− | r = x + y;
| |
− | | |
− | System.out.println("A soma de " + x + " e " + y + " eh " + r);
| |
− | }
| |
− | }
| |
− | </syntaxhighlight>Para executar esse programa, grave-o em um arquivo chamado ''Soma.java'' e em seguida faça o seguinte: <syntaxhighlight lang=bash>
| |
− | javac Soma.java
| |
− | java Soma
| |
− | </syntaxhighlight>
| |
− | *# ''Soma de dois números em Python:'' <syntaxhighlight lang=python>
| |
− | #!/usr/bin/python
| |
− | | |
− | import sys
| |
− | | |
− | print "Entre com o primeiro numero: ",
| |
− | x = int(sys.stdin.readline())
| |
− | | |
− | print "Entre com o segundo numero: ",
| |
− | y = int(sys.stdin.readline())
| |
− | | |
− | r = x + y
| |
− | | |
− | print "A soma de", x, "e", y, "eh", r
| |
− | | |
− | sys.exit(0)
| |
− | </syntaxhighlight>Para executar esse programa, grave-o em um arquivo chamado ''soma.py'' e em seguida faça o seguinte: <syntaxhighlight lang=bash>
| |
− | python soma.py
| |
− | </syntaxhighlight>
| |
− | | |
− | Como mostrado acima, o mesmo algoritmo foi traduzido para programas em diferentes linguagens de programação. Ao serem executados, geraram o mesmo resultado.
| |
− | | |
− | === Exercícios: desenho de figuras geométricas ===
| |
− | | |
− | # Usando apenas as instruções: <syntaxhighlight lang=text>
| |
− | acendeCaneta
| |
− | apagaCaneta
| |
− | avança X
| |
− | giraDireita angulo
| |
− | giraEsquerda angulo
| |
− | fazArco X graus, raio Y
| |
− | </syntaxhighlight> escreva algoritmos para desenhar a figura entregue pelo professor. Não mostre sua figura para as outras equipes.
| |
− | # [http://edu.kde.org/kturtle/ kturtle] é um software educacional para ajudar no ensino de matemática, geometria e introdução à programação. Ele possibilita fazer desenhos facilmente, seguindo um programa com instruções de desenho. Usando as instruções: <syntaxhighlight lang=bash>
| |
− | reset (move a tartaruga para o centro da tela)
| |
− | clear (limpa a tela)
| |
− | pendown (põe a caneta no papel - acendeCaneta)
| |
− | penup (levanta a caneta - apagaCaneta)
| |
− | forward X (avança X posições)
| |
− | turnright angulo (gira pra direita)
| |
− | turnleft angulo (gira pra esquerda)
| |
− | </syntaxhighlight> ... escreva programas para os algoritmos criados no ítem anterior.<br><br>[http://docs.kde.org/stable/pt/kdeedu/kturtle/reference.html Guia de referência completo do Kturtle]
| |
− | # Usando o '''kturtle''' escreva algoritmos para desenhar as seguintes figuras:
| |
− | #* triângulo equilátero
| |
− | #* triângulo isósceles
| |
− | #* triângulo escaleno
| |
− | #* quadrado
| |
− | #* hexágono
| |
− | #* octógono
| |
− | #* quadrado com vértices interligados
| |
− | #* Um círculo
| |
− | #* 7 hexágonos interligados (um central e seis periféricos).
| |
− | #* 7 círculos interligados (um central e seis periféricos), parecendo uma flor
| |
− | # Fractais são figuras nas quais cada pedacinho é semelhante à toda figura. Um fractal bastante simples de criar é o Floco de Neve Koch, cuja criação pode ser entendida na sequência de figuras abaixo:
| |
− | | |
− | [[imagem:Koch0.png]]
| |
− | <br>''Primeira iteração''
| |
− | | |
− | [[imagem:Koch1.png]]
| |
− | <br>''Segunda iteração''
| |
− | | |
− | [[imagem:Koch2.png]]
| |
− | <br>''Terceira iteração''
| |
− | | |
− | [[imagem:Koch3.png]]
| |
− | <br>''Próximas iterações''
| |
− | | |
− | Usando o '''kturtle''' desenhe essas figuras, reproduzindo o maior número de iterações que conseguir. Você consegue descobrir uma regra para gerá-las ?
| |
− | | |
− | ''Obs: [http://pt.wikibooks.org/wiki/Matem%C3%A1tica_divertida/Fractais_e_o_infinitamente_pequeno#Fractais fonte dessas figuras]''
| |
− | | |
− | ==== Dicas para o kturtle ====
| |
− | | |
− | # Pode-se repetir uma sequência de instruções usando-se o comando ''repeat''. Por exemplo, para desenhar um pentágono usando ''repeat'': <syntaxhighlight lang=text>
| |
− | repeat 5 {
| |
− | forward 50
| |
− | turnleft 72
| |
− | }
| |
− | </syntaxhighlight>
| |
− | # Podem-se usar variáveis para generalizar os algoritmos. Uma variável tem um identificador, que deve ser precedido do caractere ''$'': <syntaxhighlight lang=text>
| |
− | $x=5
| |
− | $lado=50
| |
− | repeat $x {
| |
− | forward $lado
| |
− | turnleft 360/$x
| |
− | }
| |
− | </syntaxhighlight>
| |
− | # Pode-se usar o comando ''ask'' para ler do teclado valores a serem usados no algoritmo de desenho: <syntaxhighlight lang=text>
| |
− | $x = ask "Quantos lados tem o polígono ?"
| |
− | $lado = ask "Qual o comprimento de cada lado ?"
| |
− | repeat $x {
| |
− | forward $lado
| |
− | turnleft 360/$x
| |
− | }
| |
− | </syntaxhighlight>
| |
− | # Por fim, com o comando ''learn'' é possível criar novos comandos no ''kturtle''. Por exemplo, para criar um comando que desenhe um triângulo: <syntaxhighlight lang=text>
| |
− | learn triangulo $lado {
| |
− | repeat 3 {
| |
− | forward $lado
| |
− | turnleft 120
| |
− | }
| |
− | }
| |
− | </syntaxhighlight>
| |
− | Esse novo comando desenha um triângulo equilátero cujos lados tem comprimento dado pelo parâmetro ''$lado''. Ele poderia ser usado assim em um algoritmo: <syntaxhighlight lang=text>
| |
− | learn triangulo $lado {
| |
− | repeat 3 {
| |
− | forward $lado
| |
− | turnleft 120
| |
− | }
| |
− | }
| |
− | triangulo 50
| |
− | triangulo 100
| |
− | triangulo 100
| |
− | </syntaxhighlight>
| |
− | Nesse exemplo, três triângulos são desenhados: um com lado 50, outro com lado 100, e um terceiro com lado 150. Veja que o número escrito logo após o comando ''triangulo'' irá aparecer no lugar de ''$lado'' no algoritmo que desenha o triângulo.
| |
− | | |
− | == 13/09: Algoritmos ==
| |
− | | |
− | Sobre a [[SOP-2010-2-sobral#Exerc.C3.ADcios:_desenho_de_figuras_geom.C3.A9tricas|atividade da aula passada]]:
| |
− | * [http://www.sj.ifsc.edu.br/~msobral/SOP/exemplos/kturtle/ Algoritmos dos fractais no Kturtle]
| |
− | ----
| |
− | Os algoritmos que iremos criar serão compostos de:
| |
− | * ''Estruturas de controle:'' estruturas para controlar a sequência de execução (realização) de algoritmos:
| |
− | ** ''Decisão:'' para realizar testes de forma a decidir que sequências de instruções devem ser executadas
| |
− | ** ''Repetição:'' para repetir sequências de instruções
| |
− | * ''Estruturas de dados:'' estruturas para representar os dados a serem processados por algoritmos
| |
− | ** ''Variáveis e constantes''
| |
− | | |
− | === Portugol ===
| |
− | | |
− | As aulas de Lógica de Programação usarão um software de auxílio ao ensino de algoritmos chamado [http://orion.ipt.pt/%7Emanso/Portugol/ Portugol], desenvolvido na [http://www.dei.estt.ipt.pt/portal/ Escola Superior de Engenharia do Instituto Politécnico de Tomar], em Portugal.
| |
− | * [http://www.sj.ifsc.edu.br/~msobral/SOP/portugol.html Guia rápido de instalação e utilização do Portugol].
| |
− | | |
− | ==== Guia rápido de instalação e utilização do Portugol ====
| |
− | | |
− | Abaixo segue uma breve ajuda de como obtê-lo, instalá-lo e usá-lo. Esse guia assume que você esteja usando o Ubuntu Linux 9.04 ou superior.
| |
− | | |
− | # Faça o [http://www.sj.ifsc.edu.br/%7Emsobral/SOP/soft/portugol23.tar.gz download] do Portugol.
| |
− | # Descompacte-o com o seguinte comando: <syntaxhighlight lang=bash>
| |
− | tar xzf portugol23.tar.gz
| |
− | </syntaxhighlight>
| |
− | # Repare que existe agora um subdiretório portugol no diretório onde você o descompactou. Execute o Portugol com o seguinte comando: <syntaxhighlight lang=bash>
| |
− | java -jar portugol/Portugol.jar
| |
− | </syntaxhighlight> Obs: você precisará ter Java instalado. Caso não o tenha, execute o comando: <syntaxhighlight lang=bash>
| |
− | sudo apt-get install openjdk-6-jre
| |
− | </syntaxhighlight>
| |
− | # Copie esse [http://www.sj.ifsc.edu.br/%7Emsobral/SOP/exemplos/fluxogramas.cfg arquivo] para poder ver fluxogramas coloridos, e grave-o no memso diretório onde está o Portugol.
| |
− | # Veja a [http://www.sj.ifsc.edu.br/%7Emsobral/SOP/soft/help/index.html ajuda] do Portugol, e use-a sempre que tiver dúvidas !
| |
− | | |
− | <br>A tela inicial do Portugol segue abaixo, junto com um programa demonstrativo.<br>
| |
− | | |
− | [[Imagem:Editor-Portugol.png]]
| |
− | | |
− | Exemplos de programas iniciais em Portugol:
| |
− | | |
− | # ''Lendo um número e mostrando-o na tela em seguida:'' <syntaxhighlight lang=text>
| |
− | Inicio
| |
− | inteiro x
| |
− | | |
− | Escrever "Digite um numero: ",
| |
− | Ler X
| |
− | Escrever "Numero digitado: ", x
| |
− | Fim
| |
− | </syntaxhighlight>
| |
− | # ''Lendo dois números, somando-os e mostrando o resultado na tela:'' <syntaxhighlight lang=text>
| |
− | Inicio
| |
− | inteiro x, y
| |
− | | |
− | Escrever "Digite um numero: ",
| |
− | Ler x
| |
− | Escrever "Digite outro numero: ",
| |
− | Ler y
| |
− | Escrever "Soma = ", x+y
| |
− | Fim
| |
− | </syntaxhighlight>O programa abaixo é equivalente:<syntaxhighlight lang=text>
| |
− | Inicio
| |
− | inteiro x, y, z
| |
− | | |
− | Escrever "Digite um numero: ",
| |
− | Ler x
| |
− | Escrever "Digite outro numero: ",
| |
− | Ler y
| |
− | z <- x + y
| |
− | Escrever "Soma = ", z
| |
− | Fim
| |
− | </syntaxhighlight>
| |
− | | |
− | === Atividades ===
| |
− | | |
− | # ''Média de três números:'' escreva um programa para calcular a média de três números.
| |
− | # ''Média balanceada de três números:'' escreva um programa para calcular a média balanceada de três números.
| |
− | # ''Sequência de Fibonacci:'' em matemática corresponde aos números: <syntaxhighlight lang=text>
| |
− | 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
| |
− | </syntaxhighlight>... que pode ser descrita pela relação de recorrência <br><br><math>F_{n} = F_{n-1} + F_{n-2}</math><br><br>... com valores iniciais <math>F_{0} = 1</math> e <math>F_{1} = 1</math>.<br><br>Numerosas formas na natureza apresentam essa sequência, como neste girassol (cujas flores se dispõem em uma espiral):<br><br>[[Imagem:Sunflower.jpg]] [[Imagem:espiral_fibonacci.png]] [[Imagem:FibonacciBlocks.png]]<br><br>Usando o Portugol escreva um programa que mostre os 10 primeiros números dessa sequência.
| |
− | # ''Distância até o horizonte:'' escreva um programa que calcule a distância dos seus olhos até o horizonte. Assuma que a Terra é perfeitamente esférica, e que seu raio tem 6.378 km. Considere que você esteja no nível do mar (seus pés tocando a água do mar ;-), e que o horizonte esteja num mar perfeitamente liso. ''Dica: faça um diagrama desse problema para visualizar sua geometria, e use trigonometria para resolvê-lo.
| |
− | | |
− | == 14/09: Algoritmos ==
| |
− | | |
− | * Diagrama de blocos (fluxograma)
| |
− | * Variáveis e constantes
| |
− | | |
− | === Fluxogramas ===
| |
− | | |
− | Diagramas de bloco para auxiliar a descrição de algoritmos. Ajudam na compreensão do algoritmo, por poder visualizar o fluxo de execução.
| |
− | | |
− | | |
− | [[imagem:Fluxograma-soma.png]] Fluxograma para o algoritmo da média de trẽs números.
| |
− | | |
− | <br>
| |
− | | |
− | '''Blocos de uso mais comum'''<br>
| |
− | {| border="1" cellpadding="2"
| |
− | !Bloco
| |
− | !Descrição
| |
− | !Exemplo
| |
− | |-
| |
− | |[[Imagem:Inicio.png]]||Inicio do fluxograma||
| |
− | |-
| |
− | |[[Imagem:Processamento.png]]||Processamento||
| |
− | |-
| |
− | |[[Imagem:Entrada.png]]||Entrada de dados (ler do teclado)||
| |
− | |-
| |
− | |[[Imagem:Saida.png]]||Saída de dados (mostrar na tela)||
| |
− | |-
| |
− | |[[Imagem:Decisao.png]]||Decisão (testar uma condição e bifurcar)||[[imagem:Ex-decisao.png]]
| |
− | |-
| |
− | |[[Imagem:Conector.png]]||Conector (juntar dos ou mais ramos do fluxograma)||[[imagem:Ex-conector.png]]
| |
− | |-
| |
− | |[[Imagem:Fim.png]]||Fim||
| |
− | |}
| |
− | | |
− | Obs: [http://www.sj.ifsc.edu.br/%7Emsobral/SOP/exemplos/fluxogramas.cfg Arquivo de configuração das cores do fluxograma ] do Portugol.
| |
− | | |
− | === Variáveis e constantes ===
| |
− | | |
− | * '''Variável:''' capaz de guardar um dado a ser usado no algoritmo. Pode ser entendida como uma caixa, onde se coloca um dado e se pode consultá-lo quantas vezes for necessário. O dado pode ser modificado (substituído por outro). Exemplo em Portugol: <syntaxhighlight lang=text>
| |
− | Inicio
| |
− | inteiro anos, dias
| |
− | | |
− | Escrever "Quantos anos se passaram ? "
| |
− | Ler anos
| |
− | dias <- anos * 365
| |
− | Escrever "... então se passaram ", dias, " dias"
| |
− | Fim
| |
− | </syntaxhighlight> Nesse exemplo há duas variáveis: ''dias'' e ''anos''
| |
− | * '''Constante:''' semelhante à variável, porém o dado armazenado não pode ser modificado. Exemplo em Portugol:<syntaxhighlight lang=text>
| |
− | Inicio
| |
− | constante inteiro diasPorAno <- 365
| |
− | inteiro anos, dias
| |
− | | |
− | Escrever "Quantos anos se passaram ? "
| |
− | Ler anos
| |
− | dias <- anos * diasPorAno
| |
− | Escrever "... então se passaram ", dias, " dias"
| |
− | Fim
| |
− | </syntaxhighlight> Nesse exemplo há uma constante: ''diasPorAno''
| |
− | | |
− | <br>
| |
− | Variáveis e constantes devem ser declaradas antes de serem usadas (algumas poucas linguagens, como [http://www.python.org Python] e [http://www.perl.org Perl], não exigem isto). A declaração consiste do tipo e identificador da variável. O tipo corresponde ao tipo de valor que pode ser guardado, e o identificador é o nome da variável. No exemplo abaixo:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | constante inteiro diasPorAno <- 365
| |
− | inteiro anos, dias
| |
− | Fim
| |
− | </syntaxhighlight>
| |
− | | |
− | No exemplo acima, há duas variáveis do tipo ''inteiro'', e seus identificadores são ''dias'' e ''anos''. O tipo ''inteiro'' indica que essas variáveis podem guardar somente números inteiros.
| |
− | | |
− | '''''Tipos de variáveis e constantes no Portugol:'''''
| |
− | | |
− | {| border="1" cellpadding="2"
| |
− | !Tipo
| |
− | !Descrição
| |
− | !Exemplo
| |
− | |-
| |
− | |Inteiro||Número inteiro entre -2 147 483 648 e 2 147 483 647 || Inteiro x <- 10
| |
− | |-
| |
− | |Real||Número real entre -1.7 E 308 e 1.7 E 308 || Real y <- 10.789
| |
− | |-
| |
− | |Lógico||Valor booleano, com valores "Verdadeiro" e "Falso" || Logico ok <- Falso
| |
− | |-
| |
− | |Caracter||Um caractere da [http://pt.wikipedia.org/wiki/ASCII tabela ASCII] || Caracter letra <- "A"
| |
− | |-
| |
− | |Texto||Uma sequência de caracteres (ou ''string'') || Texto palavra <- "um teste"
| |
− | |}
| |
− | | |
− | A declaração de constantes é semelhante à de variáveis, bastanto prefixá-las com a palavra-chave ''constante''.
| |
− | | |
− | === Expressões aritméticas ===
| |
− | | |
− | Um conjunto de operações sobre variáveis, constantes e funções numéricas, e que gera um determinado resultado numérico.
| |
− | | |
− | Exemplos de expressões aritméticas: <syntaxhighlight lang=text>
| |
− | # Uma expressão que calcula quantos segundos existem em um horário do tipo horas, minutos e segundos
| |
− | 3600*horas + 60*minutos + segundos
| |
− | | |
− | # Uma expressão que calcula a velocidade instantânea, segundo um MRV
| |
− | vel_inicial + aceleracao*tempo;
| |
− | | |
− | # Uma expressão que calcula o módulo de um vetor bidimensional, que possui coordenadas x e y
| |
− | raiz(x^2 + y^2)
| |
− | </syntaxhighlight>
| |
− | | |
− | Os resultados de expressões podem ser mostrados na tela, ou armazenados em variáveis:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | # Uma expressão que calcula quantos segundos existem em um horário do tipo horas, minutos e segundos
| |
− | segundos <- 3600*horas + 60*minutos + segundos
| |
− | | |
− | # Uma expressão que calcula a velocidade instantânea, segundo um MRV
| |
− | escrever 'Velocidade no instante ', tempo, ' = ', vel_inicial + aceleracao*tempo;
| |
− | | |
− | # Uma expressão que calcula o módulo de um vetor bidimensional, que possui coordenadas x e y
| |
− | modulo <- raiz(x^2 + y^2)
| |
− | </syntaxhighlight>
| |
− | | |
− | Repare que uma expressão fica sempre do lado direito, quando atribuída a uma variável. A expressão é primeiro calculada, e em seguida seu resultado é armazenado na variável:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | segundos <- 3600*horas + 60*minutos + segundos
| |
− | </syntaxhighlight>
| |
− | | |
− | ==== Operadores aritméticos ====
| |
− | | |
− | Expressões aritméticas sao compostas por números e operadores aritméticos:
| |
− | | |
− | Obs: para os exemplos abaixo são usadas estas variáveis: <syntaxhighlight lang=text>
| |
− | Real x, area, lado
| |
− | inteiro dias, horas
| |
− | </syntaxhighlight>
| |
− | | |
− | {| border="1" cellpadding="2"
| |
− | !Operador
| |
− | !Descrição
| |
− | !Exemplo
| |
− | |-
| |
− | |<nowiki>+</nowiki>||Adição|| x <- x + 1
| |
− | |-
| |
− | |<nowiki>-</nowiki>||Subtração|| x <- x - 1
| |
− | |-
| |
− | |*||Multiplicação|| x <- x*x*x
| |
− | |-
| |
− | |/||Divisão|| dias <- horas / 24
| |
− | |-
| |
− | |%||Módulo (resto de divisão)|| horas <- horas % 24
| |
− | |-
| |
− | |^||Potenciação|| area <- lado^2
| |
− | |}
| |
− | | |
− | Precedência dos operadores (nesta ordem): ^, *, /, %, + e -
| |
− | | |
− | A precedência pode ser modificada com o uso de parênteses. Ex:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | escrever 1 + 2 * 3
| |
− | escrever (1 + 2)*3
| |
− | </syntaxhighlight>
| |
− | | |
− | No Portugol, existem também algumas [http://www.sj.ifsc.edu.br/%7Emsobral/SOP/soft/help/funcoes_biblioteca.html funções úteis], como a função '''''raiz''''': <syntaxhighlight lang=text>
| |
− | r <- raiz(x^2 + y^2)
| |
− | </syntaxhighlight>
| |
− | | |
− | O resultado de expressões aritméticas depende dos tipos numéricos das variáveis e constantes: <syntaxhighlight lang=text>
| |
− | inicio
| |
− | real x
| |
− | inteiro y
| |
− | inteiro resultadoInteiro
| |
− | real resultadoReal
| |
− |
| |
− | x <- 9
| |
− | y <- 9
| |
− |
| |
− | escrever "O resultado de uma expressão aritmética depende dos tipos das variáveis e constantes\n"
| |
− | escrever "usadas na expressão. Se forem todas inteiras, então o resultado será inteiro.\n"
| |
− | escrever "Veja este exemplo: \n"
| |
− | escrever "Variável inteira y=", y
| |
− | escrever "\nExpressão: y/2=", y/2
| |
− |
| |
− | escrever "\n\nNeste segundo exemplo, repete-se a mesma expressão, porém usando-se uma\n"
| |
− | escrever "variável real:\n"
| |
− | escrever "Variável real x=", x
| |
− | escrever "\nExpressão: x/2=", x/2
| |
− |
| |
− | x <- 4
| |
− | y <- 5
| |
− | escrever "\n\nSe as variáveis de diferentes tipos forem combinadas, o resultado da\n"
| |
− | escrever "expressão será real:\n"
| |
− | escrever "Variável real x=", x, " e inteira y=", y
| |
− | escrever "\nExpressão: (x+y)/2=", (x+y)/2
| |
− | | |
− | escrever "\n\nNo entanto, se uma expressão tiver um resultado real, mas este for\n"
| |
− | escrever "atribuÃdo a uma variável inteira, então apenas a parte inteira será guardada:\n"
| |
− | escrever "Variável real x=", x, " e inteira y=", y
| |
− | y <- (x+y)/2
| |
− | escrever "\nExpressão: y <- (x+y)/2 ... após executada, y=", y
| |
− |
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | | |
− | === Atividade ===
| |
− | | |
− | Para os exercícios abaixo, desenhe o fluxograma e escreva o algoritmo no Portugol.
| |
− | | |
− | # Faça um algoritmo que, usando somente duas variáveis, calcule a média de quatro números.
| |
− | # Escreva um algoritmo que calcule as raizes de uma equação de 2o grau.
| |
− | # Um equipamento conta o tempo desde que foi ligado. No entanto, essa contagem é feita em segundos. Faça um algoritmo que converta o valor desse contador para horas, minutos e segundos. Ex: se o contador tiver o valor 43397, o seu programa deve mostrar: 12:03:17.
| |
− | # Crie um conversor de decimal para binário (limite: 4 bits). Ex.: tendo o número 10 (decimal) de entrada, deve-se obter o número 1010 (binário) de saída.
| |
− | # Escreva um algoritmo que leia o nome, sobrenome e idade de uma pessoa, e escreva na tela (no lugar dos colchetes devem aparecer os valores lidos):<syntaxhighlight lang=text>
| |
− | Nome: [sobrenome, nome]
| |
− | Idade: [idade] anos</syntaxhighlight>
| |
− | # Crie um gerador automático de código Logo para desenhar polígonos:
| |
− | #* Ler um número do usuário.
| |
− | #* Calcular o ângulo interno.
| |
− | #* Apresentar como resultado o código [http://pt.wikipedia.org/wiki/Logo Logo] a ser inserido no programa '''kturtle'''. Ex.: se o usuário digitar o número 3, o código será de um triângulo equilátero, cuja soma dos ângulos internos é 180 - logo, cada ângulo será de 60 graus (no Logo, lembre-se que o ângulo a ser usado é o complemento de 180, conforme visto em aula). Se o usuário digitar 5 ao invés de 3, teremos um pentágono. Abaixo temos soluções para triângulo e pentágono:
| |
− | reset
| |
− | repeat 3
| |
− | {
| |
− | forward 100
| |
− | turnright 120
| |
− | }
| |
− | | |
− | reset
| |
− | repeat 5
| |
− | {
| |
− | forward 100
| |
− | turnright 72
| |
− | }
| |
− | | |
− | | |
− | | |
− | == 20/09: Estruturas de decisão ==
| |
− | | |
− | O exemplo abaixo está contido no livro ''Classification and Regression Trees'', de Leo Breiman, Jerome Friedman, Richard Olshen e Charles Stone, editora Chapman & Hall, 1984.
| |
− | | |
− | Na Universidade da California, no centro Médico de San Diego, quando um paciente com ataque cardíaco é recebido, dezenove variáveis são medidas ao longo das primeiras 24 horas. Essas incluem pressão sanguínea, idade, e 17 outras variáveis ordenadas e binárias (booleanas) que sumarizam os sintomas médicos considerados importantes indicadores da condição do paciente.
| |
− | | |
− | O objetivo de um estudo médico feito entre os anos 70 e 80 foi o desenvolvimento de um método para identificar pacientes de alto risco (que não sobreviverão ao menos 30 dias) com base nos dados obtidos nas primeiras 24 horas. O diagrama abaixo mostra uma regra de classificação que foi produzida nesse estudo. A letra F significa que não há um risco alto, e a letra G quer dizer paciente de alto risco.
| |
− | | |
− | [[imagem:Crt-decisao.png]]
| |
− | | |
− | Essa regra classifica os pacientes como F ou G dependendo de respostas do tipo sim/não a no máximo três perguntas. Como seria um algoritmo que a implementasse ?
| |
− | | |
− | ----
| |
− | | |
− | Algoritmos para resolver problemas como o exemplo acima dependem de se poder expressar a '''''tomada de decisões'''''. Deve ser possível testar '''''condições''''', como por exemplo "''a idade é maior que 62.5 anos ?''", e executar instruções dependendo do resultado do teste. Em Lógica de Programação, e em linguagens de programação em geral, isso se faz com '''''estruturas de decisão'''''.
| |
− | | |
− | '''''Estruturas de decisão''''' possibilitam que se executem diferentes sequências de instruções de um programa, dependendo de uma condição a ser avaliada. Por exemplo, um jogo poderia armazenar a maior pontuação já obtida, e verificar se foi ultrapassada ao final de cada partida:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | Se pontuacao > recorde então
| |
− | recorde <- pontuação
| |
− | FimSe
| |
− | </syntaxhighlight>
| |
− | | |
− | O exemplo em Portugol acima mostra a estrutura de decisão ''Se condição entao comandos Fimse''. O equivalente em fluxograma é:
| |
− | | |
− | [[imagem:Seentao.png]]
| |
− | | |
− | Veja o próximo exemplo:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | Se conceito > 70 entao
| |
− | escrever 'Voce esta aprovado'
| |
− | senao
| |
− | escrever 'Desta vez não deu ... tente de novo !'
| |
− | Fimse
| |
− | </syntaxhighlight>
| |
− | | |
− | O uso de ''Se condição entao comandos Senao comandos Fimse'' possibilita que se execute uma sequência de comandos se a condição for verdadeira, e outra sequência se for falsa. Seu equivalente em fluxograma é:
| |
− | | |
− | [[imagem:Seentaosenao.png]]
| |
− | | |
− | Para fazer um bom uso de estruturas de decisão deve-se primeiro conseguir identificar as condições a serem avaliadas. Condições são escritas com expressões lógicas, e estas são compostas de operadores lógicos e relacionais aplicados a variáveis e constantes.
| |
− | | |
− | === Condições ===
| |
− | | |
− | Condições representam os testes que precisam ser feitos com dados do problema. Esses testes são expressados por '''''expressões lógicas''''', cujos resultados são ''verdadeiro'' ou ''falso''. Expressões lógicas são construídas usando-se '''''operadores lógicos''''' e '''''operadores relacionais''''' para comparar e avaliar os valores de variáveis e constantes.
| |
− | | |
− | Obs: para os exemplos abaixo são usadas estas variáveis: <syntaxhighlight lang=text>
| |
− | Logico correto, multa, aprovado, barato, bombear_agua
| |
− | Logico descartar, baixo, reprovado, erro, enviado, recebido
| |
− | inteiro erros, pontuacao, preco, endereco, velocidade
| |
− | Real faltas, nivel_agua, altura
| |
− | </syntaxhighlight>
| |
− | | |
− | ==== Operadores relacionais ====
| |
− | | |
− | Operadores relacionais são usados para comparar valores, e estão listados na tabela abaixo. Cada comparação feita com esses operadores forma uma ''expressão lógica simples''. Portanto, o resultado de uma comparação é um valor lógico que pode ser ''verdadeiro'' ou ''falso''.
| |
− | | |
− | {| border="1" cellpadding="2"
| |
− | !Operador
| |
− | !Descrição
| |
− | !Exemplo
| |
− | |-
| |
− | |=||Igualdade|| correto <- (erros = 0)
| |
− | |-
| |
− | |>||Maior|| multa <- (velocidade > 80)
| |
− | |-
| |
− | |>=||Maior ou igual|| aprovado <- (pontuacao >= 70)
| |
− | |-
| |
− | |<||Menor|| barato <- (preco < 100)
| |
− | |-
| |
− | |<=||Menor ou igual|| bombear_agua <- (nivel_agua <= 0.7)
| |
− | |-
| |
− | |=/=||Diferente|| descartar <- (endereco =/= 12345)
| |
− | |}
| |
− | | |
− | ==== Operadores lógicos ====
| |
− | | |
− | Operadores lógicos são usados para combinar expressões lógicas simples, criando assim ''expressões lógicas compostas'', e estão listados na tabela abaixo.
| |
− | | |
− | {| border="1" cellpadding="2"
| |
− | !Operador
| |
− | !Descrição
| |
− | !Exemplo
| |
− | |-
| |
− | |NAO||Negação|| baixo <- NAO (altura > 1.8)
| |
− | |-
| |
− | |E||Conjunção|| aprovado <- NAO (conceito = "D") E (faltas <= 0.25)
| |
− | |-
| |
− | |OU||Disjunção|| reprovado <- (conceito = "D") OU (faltas > 0.25)
| |
− | |-
| |
− | |XOU||Disjunção exclusiva|| erro <- enviado XOU recebido
| |
− | |}
| |
− | | |
− | Precedência dos operadores (nesta ordem): NAO, E, OU e XOU
| |
− | | |
− | Lembre que a precedência pode ser modificada com o uso de parênteses.
| |
− | | |
− | === Atividades ===
| |
− | | |
− | # Faça um programa que leia um número e então informe se ele é par ou ímpar.
| |
− | # Um radar de trânsito faz a medição de velocidade de veículos e, dependendo do valor, calcula a multa a ser aplicada. Em uma determinada via esse radar foi configurado da seguinte forma:
| |
− | #* Se a velocidade for maior que 80 km/h, a multa é de R$ 360.
| |
− | #* Se a velocidade for maior que 60 km/h, a multa é de R$ 180.
| |
− | #* Se a velocidade for menor ou igual a 60 km/h, não há multa.<br><br>Escreva um algoritmo que calcule a multa de acordo com a velocidade de um veículo.
| |
− | # Faça um algoritmo que leia três números do teclado, e mostre o maior e menor números.
| |
− | # Escreva um algoritmo que faça o [[SOP-2010-2-sobral#20.2F09:_Estruturas_de_decis.C3.A3o|teste de risco de paciente cardíaco]], mostrado no início da aula.
| |
− | # Um estudo sobre sensibilidade de pessoas a temperaturas da água identificou que a maioria das pessoas considera fria a água com temperaturas abaixo de 25 graus, morna entre 25 e 30 graus, e quente acima de 30 graus. Escreva um algoritmo que mostre as palavras "fria", "morna" ou "quente" dependendo da temperatura da água que for informada.
| |
− | # Em uma rede de computadores, o ''firewall'' restringe o acesso a Internet dependendo do horário e do tipo de usuário que faz o acesso. Os tipos de usuário abaixo têm as seguintes restrições:
| |
− | #* Funcionario: apenas entre 0:00 e 7:30, entre 18:30 e 0:00, e entre 12:00 e 13:30
| |
− | #* Financeiro: qualquer horario
| |
− | #* Diretoria: qualquer horário<br>Escreva um algoritmo que informe se um acesso foi permitido, em função do horário e do tipo de usuário.
| |
− | # Modifique o algoritmo acima para adicionar a seguinte restrição:
| |
− | #* Funcionario: nao pode acessar sites de jornal (ex: www.rbs.com.br)
| |
− | #* Financeiro: nao pode acessar sites de jornal durante o expediente
| |
− | #* Diretoria: sem restrições a sites
| |
− | # Faça um algoritmo para fazer a divisão de dois números reais. Antes de dividi-los deve ser feito um teste de validade. Caso não seja possível dividi-los, deve ser mostrada uma mensagem de erro. Se for possível, deve-se mostrar o resultado da divisão.
| |
− | # Faça um jogo de par ou ímpar, em que o jogador aposta contra o computador. O jogador deve digitar um número entre 0 e 5 e optar entre par ou ímpar. O computador deve sortear um número também entre 0 e 5. Se a paridade da soma dos números do jogador e do computador for a mesma que o jogador optou, então ele ganha a partida, senão o computador vence.
| |
− | # Escreva um algoritmo para identificar se há, dentre três palavras lidas do teclado, ao menos duas palavras distintas que pertençam ao conjunto {azul, preto, vermelho}. Exemplos:
| |
− | #* Se o usuário digitar ''verde'', ''preto'', ''vermelho'', o programa deve mostrar na tela ''verdadeiro''
| |
− | #* Se o usuário digitar ''verde'', ''preto'', ''preto'', o programa deve mostrar na tela ''falso''
| |
− | #* Se o usuário digitar ''azul'', ''preto'', ''azul'', o programa deve mostrar na tela ''verdadeiro'' <br>''Solução vista em aula:''<syntaxhighlight lang=text>
| |
− | // Neste algoritmo deve-se identificar se ao menos duas palavras
| |
− | // diferentes têm os valores azul, preto ou vermelho.
| |
− | // A variável inteira "cont" conta quantas palavras diferentes
| |
− | // tem esses valores.
| |
− | | |
− | inicio
| |
− | texto p1 , p2 , p3
| |
− | inteiro cont <- 0
| |
− |
| |
− | escrever "Palavra 1: "
| |
− | ler p1
| |
− | escrever "Palavra 2: "
| |
− | ler p2
| |
− | escrever "Palavra 3: "
| |
− | ler p3
| |
− |
| |
− | // ao menos uma palavra é "azul" ?
| |
− | se p1 = "azul" OU p2 = "azul" OU p3 = "azul" entao
| |
− | cont <- 1
| |
− | fimse
| |
− | | |
− | // ao menos uma palavra é "preto" ?
| |
− | se p1 = "preto" OU p2 = "preto" OU p3 = "preto" entao
| |
− | cont <- cont + 1
| |
− | fimse
| |
− | | |
− | // ao menos uma palavra é "vermelho" ?
| |
− | se p1 = "vermelho" OU p2 = "vermelho" OU p3 = "vermelho" entao
| |
− | cont <- cont + 1
| |
− | fimse
| |
− | | |
− | // se duas ou mais palavras diferentes têm aqueles valores,
| |
− | // então mostra VERDADEIRO
| |
− | se cont > 1 entao
| |
− | escrever "VERDADEIRO"
| |
− | senao
| |
− | escrever "FALSO"
| |
− | fimse
| |
− |
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | | |
− | == 21/09: estruturas de decisão ==
| |
− | | |
− | Há situações em que se precisa fazer um conjunto de comparações, como mostrado abaixo:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | // Lê a data no formato numérico dia, mes, ano, e mostra a data no formato
| |
− | // dia, nome do mês, ano.
| |
− | Inicio
| |
− | inteiro dia, mes, ano
| |
− | texto nome_mes
| |
− | | |
− | escrever "Dia: "
| |
− | ler dia
| |
− | escrever "Mes: "
| |
− | ler mes
| |
− | escrever "Ano: "
| |
− | ler ano
| |
− | | |
− | se mes = 1 entao
| |
− | nome_mes <- "Janeiro"
| |
− | senao
| |
− | se mes = 2 entao
| |
− | nome_mes <- "Fevereiro"
| |
− | senao
| |
− | se mes = 3 entao
| |
− | nome_mes <- "Março"
| |
− | senao
| |
− | se mes = 4 entao
| |
− | nome_mes <- "Abril"
| |
− | senao
| |
− | se mes = 5 entao
| |
− | nome_mes <- "Maio"
| |
− | senao
| |
− | se mes = 6 entao
| |
− | nome_mes <- "Junho"
| |
− | senao
| |
− | se mes = 7 entao
| |
− | nome_mes <- "Julho"
| |
− | senao
| |
− | se mes = 8 entao
| |
− | nome_mes <- "Agosto"
| |
− | senao
| |
− | se mes = 9 entao
| |
− | nome_mes <- "Setembro"
| |
− | senao
| |
− | se mes = 10 entao
| |
− | nome_mes <- "Outubro"
| |
− | senao
| |
− | se mes = 11 entao
| |
− | nome_mes <- "Novembro"
| |
− | senao
| |
− | nome_mes <- "Dezembro"
| |
− | fimSe
| |
− | fimSe
| |
− | fimSe
| |
− | fimSe
| |
− | fimSe
| |
− | fimSe
| |
− | fimSe
| |
− | fimSe
| |
− | fimSe
| |
− | fimSe
| |
− | fimSe
| |
− | | |
− | escrever dia, " de ", nome_mes, " de ", ano
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | | |
− | Além de ser trabalhoso esse encadeamento de ''Se ... entao ... senao'', o algoritmo resultante fica pouco legível. Quer dizer, ele fica feio e difícil de entender.
| |
− | | |
− | Existe uma estrutura de decisão criada justamente para casos como esse, e que resulta em um algoritmo mais limpo e compreensível:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | // Lê a data no formato numérico dia, mes, ano, e mostra a data no formato
| |
− | // dia, nome do mês, ano.
| |
− | Inicio
| |
− | inteiro dia, mes, ano
| |
− | texto nome_mes
| |
− | | |
− | escrever "Dia: "
| |
− | ler dia
| |
− | escrever "Mes: "
| |
− | ler mes
| |
− | escrever "Ano: "
| |
− | ler ano
| |
− | | |
− | Escolhe mes
| |
− | caso 1:
| |
− | nome_mes <- "Janeiro"
| |
− | caso 2:
| |
− | nome_mes <- "Fevereiro"
| |
− | caso 3:
| |
− | nome_mes <- "Março"
| |
− | caso 4:
| |
− | nome_mes <- "Abril"
| |
− | caso 5:
| |
− | nome_mes <- "Maio"
| |
− | caso 6:
| |
− | nome_mes <- "Junho"
| |
− | caso 7:
| |
− | nome_mes <- "Julho"
| |
− | caso 8:
| |
− | nome_mes <- "Agosto"
| |
− | caso 9:
| |
− | nome_mes <- "Setembro"
| |
− | caso 10:
| |
− | nome_mes <- "Outubro"
| |
− | caso 11:
| |
− | nome_mes <- "Novembro"
| |
− | Defeito:
| |
− | nome_mes <- "Dezembro"
| |
− | fimEscolhe
| |
− | | |
− | escrever dia, " de ", nome_mes, " de ", ano
| |
− | fim
| |
− | </syntaxhighlight>
| |
− |
| |
− | A estrutura de decisão ''escolhe ... caso'' tem uma certa flexibilidade. No exemplo abaixo, mostra-se a possibilidade de testar mais de um valor no mesmo ''caso'':
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | inicio
| |
− | caracter sexo
| |
− | | |
− | escrever "Qual o seu sexo (f/m):"
| |
− | ler sexo
| |
− | | |
− | escrever "Olá "
| |
− | | |
− | escolhe sexo
| |
− | caso "m", "M" :
| |
− | escrever "senhor"
| |
− | caso "f","F" :
| |
− | escrever "senhorita"
| |
− | defeito :
| |
− | escrever "Sexo indefinido"
| |
− | fimescolhe
| |
− | | |
− | escrever ", benvindo ao portugol"
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | | |
− | === Atividades ===
| |
− | | |
− | # Faça um algoritmo que converta um número de 1 a 7 para o respectivo dia da semana (ex: 1 = domingo, 2 = 2a feira, e assim por diante).
| |
− | # Faça uma calculadora com as quatro operações aritméticas. Sua calculadora deve ler (nesta ordem) o primeiro número, a operação aritmética (que deve ser informada usando o símbolo da respectiva operação: +, -, * ou /), e depois o segundo número. Ao final, seu algoritmo deve mostrar o resultado, ou uma mensagem de erro se a operação não for possível de realizar (ex: divisão por zero).
| |
− | # A previsão do tempo na costa brasileira pode ser feita de forma aproximada usando-se um barômetro e um termômetro. Uma estimativa com boa chance de acerto se baseia na tabela abaixo: <br>[[imagem:Previsao-barometro.png|800px]]<br><br>Faça um algoritmo que forneça uma estimativa da previsão do tempo, usando essa tabela.
| |
− | # Faça um algoritmo que mostre qual o último dia de um determinado mês informado pelo teclado. Caso seja informado o mês 2 (fevereiro), seu algoritmo deve identificar se é [http://pt.wikipedia.org/wiki/Bissexto ano bissexto] (assim o mês tem 29 dias), ou não (mês tem 28 dias). Obs: anos bissextos são dados pelas regras (segundo o [http://pt.wikipedia.org/wiki/Calend%C3%A1rio_Gregoriano calendário Gregoriano]):
| |
− | ## De 400 em 400 anos é ano bissexto.
| |
− | ## De 100 em 100 anos não é ano bissexto.
| |
− | ## De 4 em 4 anos é ano bissexto.<br>''Solução vista em aula: (sem considerar anos bissextos):'' <syntaxhighlight lang=text>
| |
− | inicio
| |
− | texto mes
| |
− |
| |
− | escrever "Mes: "
| |
− | ler mes
| |
− |
| |
− | escolhe mes
| |
− | caso "janeiro","março", "maio", "julho", "agosto", "outubro", "dezembro":
| |
− | escrever 31
| |
− | caso "abril", "junho", "setembro", "novembro":
| |
− | escrever 30
| |
− | caso "fevereiro":
| |
− | escrever 28
| |
− | defeito:
| |
− | escrever "mes desconhecido !"
| |
− | fimEscolhe
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | | |
− | == 27/09: Estruturas de decisão ==
| |
− | | |
− | Na aula se fez a resolução de exercícios propostos.
| |
− | * jogo de par ou ímpar <syntaxhighlight lang=text>
| |
− | inicio
| |
− | inteiro numeroComputador
| |
− | inteiro numeroUsuario
| |
− | inteiro soma
| |
− | inteiro resto
| |
− | texto opcaoUsuario
| |
− |
| |
− | // sorteia um numero entre 0 e 10 para o computador
| |
− | // "aleatorio()" é uma função que gera um número real entre 0 e 1
| |
− | numeroComputador <- aleatorio()*10
| |
− |
| |
− | escrever "Escolha par ou impar: "
| |
− | ler opcaoUsuario
| |
− | | |
− | escrever "Escolha seu numero: "
| |
− | ler numeroUsuario
| |
− |
| |
− |
| |
− | escrever "Numero do computador: ", numeroComputador
| |
− | escrever "\nNumero do usuario: ", numeroUsuario
| |
− |
| |
− | // Para fazer a verificacao do vencedor, precisa antes descobrir se
| |
− | // o resultado é par ou ímpar. O resultado se obtém somando os números do
| |
− | // computador e do usuário, e é guardado na variável "soma". Já a variável
| |
− | // "resto" contém 0 se o resultado for par, ou 1 se for ímpar.
| |
− | soma <- numeroUsuario + numeroComputador
| |
− | resto <- soma % 2
| |
− |
| |
− | // Verifica quem venceu: se o resultado for par e o usuário escolheu "par", ou se
| |
− | // o resultado for ímpar e o usuário escolheu ímpar, então o usuário venceu. Caso
| |
− | // contrário o computador é o vencedor.
| |
− | // Repare como se expressa a condição para descobrir o vencedor: ela usa
| |
− | // várias condições simples combinadas com operadores lógicos E e OU.
| |
− | se (resto = 0) E (opcaoUsuario = "par") OU (resto = 1) E (opcaoUsuario = "impar") entao
| |
− | escrever "\n\nUsuario venceu :-)"
| |
− | senao
| |
− | escrever "\n\nComputador venceu :-b"
| |
− | fimSe
| |
− |
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | * leitura de três palavras e teste se ano menos duas pertencem a um conjunto: <syntaxhighlight lang=text>
| |
− | // Neste algoritmo deve-se identificar se ao menos duas palavras
| |
− | // diferentes têm os valores azul, preto ou vermelho.
| |
− | // A variável inteira "cont" conta quantas palavras diferentes
| |
− | // tem esses valores.
| |
− | | |
− | inicio
| |
− | texto p1 , p2 , p3
| |
− | inteiro cont <- 0
| |
− |
| |
− | escrever "Palavra 1: "
| |
− | ler p1
| |
− | escrever "Palavra 2: "
| |
− | ler p2
| |
− | escrever "Palavra 3: "
| |
− | ler p3
| |
− |
| |
− | // ao menos uma palavra é "azul" ?
| |
− | se p1 = "azul" OU p2 = "azul" OU p3 = "azul" entao
| |
− | cont <- 1
| |
− | fimse
| |
− | | |
− | // ao menos uma palavra é "preto" ?
| |
− | se p1 = "preto" OU p2 = "preto" OU p3 = "preto" entao
| |
− | cont <- cont + 1
| |
− | fimse
| |
− | | |
− | // ao menos uma palavra é "vermelho" ?
| |
− | se p1 = "vermelho" OU p2 = "vermelho" OU p3 = "vermelho" entao
| |
− | cont <- cont + 1
| |
− | fimse
| |
− | | |
− | // se duas ou mais palavras diferentes têm aqueles valores,
| |
− | // então mostra VERDADEIRO
| |
− | se cont > 1 entao
| |
− | escrever "VERDADEIRO"
| |
− | senao
| |
− | escrever "FALSO"
| |
− | fimse
| |
− |
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | * teste de ano bissexto, e seu uso para mostrar quantos dias tem cada mês de um determinado ano. <syntaxhighlight lang=text>
| |
− | inicio
| |
− | texto mes
| |
− | inteiro ano
| |
− |
| |
− | escrever "Mes: "
| |
− | ler mes
| |
− |
| |
− | escolhe mes
| |
− | caso "janeiro","março", "maio", "julho", "agosto", "outubro", "dezembro":
| |
− | escrever 31
| |
− | caso "abril", "junho", "setembro", "novembro":
| |
− | escrever 30
| |
− | caso "fevereiro":
| |
− | escrever "Ano: "
| |
− | ler ano
| |
− |
| |
− | se ano % 400 = 0 ou ano % 4 = 0 e ano % 100 =/= 0 entao
| |
− | escrever 29
| |
− | senao
| |
− | escrever 28
| |
− | fimse
| |
− | defeito:
| |
− | escrever "mes desconhecido !"
| |
− | fimEscolhe
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | | |
− | == 28/09: Estruturas de repetição ==
| |
− | | |
− | Alguns algoritmos vistos anteriormente possuem sequências repetitivas de instruções. Por exemplo, o algoritmo da média de quatro avaliações:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | Inicio
| |
− | real m1, m2, m3, m4
| |
− | real media
| |
− | | |
− | escrever "Avaliação 1:"
| |
− | Ler m1
| |
− | escrever "Avaliação 2:"
| |
− | Ler m2
| |
− | escrever "Avaliação 3:"
| |
− | Ler m3
| |
− | escrever "Avaliação 4:"
| |
− | Ler m4
| |
− | | |
− | media <- (m1 + m2 + m3 + m4) / 4
| |
− | | |
− | escrever "Média: ", media
| |
− | Fim
| |
− | </syntaxhighlight>
| |
− | | |
− | O algoritmo acima repete quatro vezes a sequência que lê uma nota do teclado. Porém há uma forma de expressar a repetição de sequências de instruções, usando-se o que se chama de ''estrutura de repetição''. A estrutura de repetição '''''enquanto''''' ''condição'' '''''faz''''' repete todas as instruções enquanto a condição for verdadeira. A condição é escrita como uma expressão lógica, da mesma forma que na estrutura de decisão '''''se''''' ''condição'' '''''então ... senão'''''. Veja como fica o algoritmo acima ao ser reescrito para usar essa estrutura de repetição:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | Inicio
| |
− | constante inteiro NUMEROS <- 4
| |
− | real m
| |
− | real media <- 0
| |
− | inteiro contador <- 0
| |
− | | |
− | enquanto contador < NUMEROS faz
| |
− | escrever "Avaliação ", contador, ":"
| |
− | ler m
| |
− | media <- media + m
| |
− | contador <- contador + 1
| |
− | fimEnquanto
| |
− | | |
− | escrever "Média: ", media/NUMEROS
| |
− | Fim
| |
− | </syntaxhighlight>
| |
− | | |
− | Esse algoritmo funciona somente para médias de quatro números. Porém calcular a média de qualquer quantidade de números usa a mesma lógica: ler os números, somá-los e dividir o total pela quantidade de números lidos. Por exemplo, para fazer com que ele calcule a média de 7 números é necessário escrevê-lo assim:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | Inicio
| |
− | constante inteiro NUMEROS <- 7
| |
− | real m
| |
− | real media
| |
− | inteiro contador <- 0
| |
− | | |
− | enquanto contador < NUMEROS faz
| |
− | escrever "Avaliação ", contador, ":"
| |
− | ler m
| |
− | media <- media + m
| |
− | contador <- contador + 1
| |
− | fimEnquanto
| |
− | | |
− | escrever "Média: ", media/NUMEROS
| |
− | Fim
| |
− | </syntaxhighlight>
| |
− | | |
− | Note que o algoritmo praticamente não foi modificado, pois somente se alterou o valor da constante NUMEROS.
| |
− | | |
− | Esses dois algoritmos podem também ser visualizados como fluxogramas, como mostrado na figura abaixo:
| |
− | | |
− | [[imagem:Ex-repeticao.png]]
| |
− | | |
− | A estrutura de repetição junto com a sequência de instruções a ser repetida é comumente chamada de '''laço''. No fluxograma acima o laço está destacado em vermelho, e no algoritmo em Portugol o laço aparece em:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | enquanto contador < NUMEROS faz
| |
− | escrever "Avaliação ", contador, ":"
| |
− | ler m
| |
− | media <- media + m
| |
− | contador <- contador + 1
| |
− | fimEnquanto
| |
− | </syntaxhighlight>
| |
− | | |
− | ----
| |
− | | |
− | Um outro exemplo ainda mais simples é mostrar na tela uma contagem numérica:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | inicio
| |
− | inteiro contador
| |
− | contador <- 0
| |
− | | |
− | enquanto contador < 10 faz
| |
− | escrever contador , " "
| |
− | contador <- contador + 1
| |
− | fimenquanto
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | | |
− | Ao executar esse algoritmo, tem-se como resultado:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | 0 1 2 3 4 5 6 7 8 9
| |
− | </syntaxhighlight>
| |
− | | |
− | Seu fluxograma está mostrado a seguir:
| |
− | | |
− | [[imagem:Flux-Contagem.png]]
| |
− | | |
− | | |
− | Repare no uso de uma variável auxiliar ''contador'' para controlar a quantidade de repetições. Essa é uma técnica comum para
| |
− | controlar a estrutura de repetição, e já foi usada no exemplo da média. Ela pode também ser combinada com outras condições, como mostrado abaixo:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | inicio
| |
− | inteiro contador <- 1
| |
− | caracter opcao <- "s"
| |
− |
| |
− | enquanto ((opcao = "s") ou (opcao = "S")) e contador < 11 faz
| |
− | escrever contador, "\n"
| |
− | contador <- contador + 1
| |
− |
| |
− | escrever "\nContinuar (S/N) ? "
| |
− | ler opcao
| |
− | fimenquanto
| |
− |
| |
− | escrever "Terminou com contador = " , contador
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | | |
− | Nesse exemplo se usa um laço para mostrar uma contagem de 1 a 10. Porém há a possibilidade de encerrar o algoritmo. Observe a condição para continuidade do laço: ela é verdadeira somente se ''contador < 11'' e se a variável ''opcao'' for igual a "s" ou "S".
| |
− | | |
− | Finalmente, apesar de ser comum o uso de contadores para controle do laço, pode-se usar qualquer condição para essa finalidade. Então podem existir laços que não usam contadores para controlar a quantidade de repetições, como no próximo exemplo:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | inicio
| |
− | constante texto segredo <- "secreto"
| |
− | texto senha
| |
− |
| |
− | ler senha
| |
− | enquanto senha =/= segredo faz
| |
− | escrever "Voce continua preso ! Digite a senha correta: "
| |
− | ler senha
| |
− | fimenquanto
| |
− | escrever "Voce foi liberado ..."
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | | |
− | O fluxograma desse algoritmo segue abaixo:
| |
− | | |
− | [[imagem:Flux-Senha.png]]
| |
− | | |
− | === Atividades ===
| |
− | | |
− | # Escreva um algoritmo que mostre a tabuada de um número fornecido pelo teclado. Esse número deve estar entre 1 e 10.
| |
− | # Aproveite o algoritmo anterior para mostrar a tabuada de todos os números entre 1 e 10.
| |
− | # Modifique o exemplo da média para que a quantidade de números a serem lidos seja previamente informada pelo teclado.
| |
− | # Escreva algoritmos que mostrem as seguintes sequências de números:
| |
− | #* Números pares menores que 100
| |
− | #* Números ímpares menores que 100
| |
− | #* Números pares de 100 até 4 (contagem decrescente)
| |
− | #* Múltiplos de 3 menores que 100
| |
− | #* Múltiplos de 4 e múltiplos de 5 menores que 100
| |
− | #* Múltiplos comuns menores que 1000 de dois números fornecidos pelo teclado (ex: se forem fornecidos 6 e 8, deve aparecer 24, 48, 72, ...)
| |
− | # Modifique novamente o exemplo da média para que ela funcione para um quantidade de números desconhecida de antemão. Quer dizer, o algoritmo deve ler os números para calcular a média, mas não sabe quantos números existem (e isto não pode ser informado pelo teclado).
| |
− | # Modifique o exemplo da senha para que o usuário tenha somente três tentativas permitidas para digitar a senha correta. Caso ao final as três senhas estejam erradas, o algoritmo deve informar que a conta foi bloqueada.
| |
− | # Escreva um algoritmo que leia até 10 números do teclado, e informe ao final qual o maior e o menor deles.
| |
− | # Escreva um algoritmo que teste se um número informado pelo teclado é primo.
| |
− | # Aproveite o algoritmo do ítem anterior para mostrar todos os números primos menores que 1000.
| |
− | # Usando o algoritmo de teste de número primo, faça um novo algoritmo que fatore um número. Ex: a fatoração do número 15 resulta em 3 e 5 (3 X 5), e a fatoração de 54 resulta em 2, 3, 3 e 3 (2 X 3 X 3 X 3).
| |
− | # Usando estrutura de repetição, escreva um algoritmo que converta um número de decimal para binário. Assuma um número binário com 16 bits.
| |
− | # Escreva um algoritmo para calcular o MMC (Mínimo Múltiplo Comum) de dois números. O MMC de dois números é um número que pode ser dividido por qualquer um deles sem deixar resto. Ex:
| |
− | #* MMC de 8 e 6 = 24
| |
− | #* MMC de 3 e 5 = 15
| |
− | #* MMC de 3 e 27 = 27
| |
− | # Escreva um algoritmo para calcular o MDC (Máximo Divisor Comum) de dois números. O MDC de dois números é um número capaz de dividi-los sem deixar resto. Ex:
| |
− | #* MDC de 24 e 16 = 8
| |
− | #* MDC de 5 e 3 = 1
| |
− | #* MDC de 60 e 150 = 30
| |
− | # Faça um algoritmo para descobrir os dois maiores números dentre 6 números lidos do teclado.
| |
− | # Faça um algoritmo para converter um número entre 0 e 16777215 para sua representação em hexadecimal.
| |
− | # Escreva o algoritmo para uma calculadora aritmética (operações +, -, * e /) que lê continuamente do teclado números e operadores. A calculadora deve ler continuamente uma sequência do tipo ''número operador_aritmético'', até que o operador informado seja ''='', quando então o resultado da conta deve ser mostrado na tela. Ex:
| |
− | #* 1 + 2 * 5 / 3 = 5
| |
− | #* 2 * 5 - 1 / 3 = 3
| |
− | | |
− | == 04/10: Estruturas de repetição ==
| |
− | | |
− | Resolução de exercícios
| |
− | | |
− | == 05/10: Estruturas de repetição ==
| |
− | | |
− | Resolução de exercícios
| |
− | | |
− | == 18/10: Estruturas de repetição ==
| |
− | | |
− | === Para ''variavel'' de ''inicio'' ate ''fim'' passo ''incremento'' ===
| |
− | | |
− | Há casos em que se deseja repetir uma parte de um algoritmo certo número de vezes. Para esses casos há uma estrutura mais prática que ''enquanto condição faz'':
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | inicio
| |
− | inteiro i
| |
− | inteiro v[5]
| |
− | | |
− | escrever "Digite 5 números: \n"
| |
− | | |
− | para i de 0 ate 4 passo 1
| |
− | escrever "Numero ", i, ": "
| |
− | ler v[i]
| |
− | proximo
| |
− | | |
− | escrever "\nOs numeros em ordem inversa são:\n\n"
| |
− | | |
− | para i de 4 ate 0 passo -1
| |
− | escrever "Numero ", i, ": ", v[i], "\n"
| |
− | proximo
| |
− | | |
− | fim
| |
− | </syntaxhighlight>
| |
− | | |
− | === Atividades ===
| |
− | | |
− | # Escreva o algoritmo para comparar dois vetores, porém usando a estrutura ''para''.
| |
− | # Escreva um algoritmo para procurar se um vetor menor (com menos valores) está contido em um vetor maior. Caso afirmativo, mostre a partir de que posição ele aparece. Assuma vetores de números inteiros.
| |
− | # Modifique o algoritmo acima para mostrar todas as ocorrências do vetor menor dentro do maior.
| |
− | # Modifique o algoritmo do anterior para remover todas as ocorrências do vetor menor dentro do maior.
| |
− | # Resolva o problema do bingo usando a estrutura ''para''
| |
− | | |
− | == 19/10: Estruturas de repetição ==
| |
− | | |
− | | |
− | === Variáveis multidimensionais ===
| |
− | | |
− | Em matemática existem matrizes e vetores, que são variáveis multidimensionais. Por exemplo, uma matriz 3 x 3 (3 linhas e 3 colunas) pode ser:
| |
− | | |
− | <math>A = \begin{pmatrix}
| |
− | 1 & 6 \\
| |
− | 3 & 5
| |
− | \end{pmatrix}</math>
| |
− | | |
− | Vetores são matrizes unidimensionais, portanto possuem somente uma linha ou uma coluna:
| |
− | | |
− | <math>v = \begin{pmatrix}
| |
− | 1 & 6 & 2 & 18 & 5
| |
− | \end{pmatrix}</math>
| |
− | | |
− | Cada elemento em uma matriz ou vetor é identificado pela sua posição. Por exemplo, na posição ''1, 2'' da matriz A acima está o valor 6, e na posição ''4'' do vetor ''v'' está o valor 18. Assim, a matriz A do exemplo pode ser entendida da seguinte forma:
| |
− | | |
− | <math>A = \begin{pmatrix}
| |
− | A_{11} & A_{12} \\
| |
− | A_{21} & A_{22}
| |
− | \end{pmatrix}</math>
| |
− | | |
− | ... e o vetor ''v'' do exemplo:
| |
− | | |
− | <math>v = \begin{pmatrix}
| |
− | v_{1} & v_{2} & v_{3} & v_{4} & v_{5}
| |
− | \end{pmatrix}</math>
| |
− | | |
− | Nas linguagens de programação em geral existe um conceito muito parecido, chamado de variáveis multidimensionais ou simplesmente ''matrizes'' (''arrays'' em inglẽs). Para exemplificar, no Portugol se poderiam definir a matriz ''A'' e o vetor ''v'':
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | inicio
| |
− | inteiro A[2][2] <- {{1, 6}, {3, 5}}
| |
− | inteiro M[3][2]
| |
− | inteiro v[5] <- {1, 6, 2, 18, 5}
| |
− | | |
− | escrever "Valor de A[0][0]: ", A[0][0], "\n"
| |
− | escrever "Valor de A[0][1]: ", A[0][1], "\n"
| |
− | escrever "Valor de A[1][0]: ", A[1][0], "\n"
| |
− | escrever "Valor de A[1][1]: ", A[1][1], "\n"
| |
− | | |
− | escrever "Valor de v[0]: ", v[0], "\n"
| |
− | escrever "Valor de v[1]: ", v[1], "\n"
| |
− | escrever "Valor de v[2]: ", v[2], "\n"
| |
− | escrever "Valor de v[3]: ", v[3], "\n"
| |
− | escrever "Valor de v[4]: ", v[4], "\n"
| |
− | | |
− | fim
| |
− | </syntaxhighlight>
| |
− | | |
− | A declaração da matriz se faz como uma variável comum, porém indicando-se suas dimensões:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | inteiro A[2][2] <- {{1, 6}, {3, 5}}
| |
− | inteiro M[3][2];
| |
− | </syntaxhighlight>
| |
− | | |
− | Veja que a matriz ''M'' foi declarada sem valores iniciais, porém a matriz ''A'' foi inicializada na declaração.
| |
− | | |
− | O acesso aos elementos da matriz se faz usando-se ''índices'', que funcionam como coordenadas dos elementos que se quer acessar. Os índices iniciam em ''0'':
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | # índice 0,0
| |
− | escrever "Valor de A[0][0]: ", A[0][0], "\n"
| |
− | </syntaxhighlight>
| |
− | | |
− | O exemplo acima pode ser reescrito usando-se estruturas de repetição:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | inicio
| |
− | inteiro A[2][2] <- {{1, 6}, {3, 5}}
| |
− | inteiro v[5] <- {1, 6, 2, 18, 5}
| |
− | inteiro i, j
| |
− | | |
− | enquanto i < 2 faz
| |
− | j <- 0
| |
− | enquanto j < 2 faz
| |
− | escrever "Valor do elemento de A na posição ", i, ", ", j, ": ", A[i][j], "\n"
| |
− | j <- j + 1
| |
− | fimenquanto
| |
− | i <- i + 1
| |
− | fimenquanto
| |
− | | |
− | i <- 0
| |
− | enquanto i < 5 faz
| |
− | escrever "valor de v na posição ", i, ": ", v[i], "\n"
| |
− | i <- i + 1
| |
− | fimenquanto
| |
− | | |
− | fim
| |
− | </syntaxhighlight>
| |
− | | |
− | Como se vê, matrizes e vetores casam perfeitamente com estruturas de repetição, e são úteis para a resolução de inúmeros problemas. Por exemplo, o problema de mostrar o nome do mês a partir do número do mês, feito anteriormente com ''escolhe ... caso'' pode ser feito assim com um vetor:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | inicio
| |
− | texto nome_mes[12] <- {"Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho",
| |
− | "Julho", "Agosto", "Setembro", "Outubro", "Novembro",
| |
− | "Dezembro"}
| |
− | inteiro dia, mes, ano
| |
− | | |
− | escrever "Dia: "
| |
− | ler dia
| |
− | escrever "Mes: "
| |
− | ler mes
| |
− | escrever "Ano: "
| |
− | ler ano
| |
− | | |
− | escrever dia, " de ", nome_mes[mes - 1], " de ", ano
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | | |
− | Outro problema comum é precisar guardar um conjunto de valores, e depois ordená-los:
| |
− | | |
− | <syntaxhighlight lang=text>
| |
− | inicio
| |
− | inteiro v[10]
| |
− | inteiro i
| |
− | inteiro quantidade
| |
− | | |
− | escrever "Quantos valores serão digitados (máximo = 10) ? "
| |
− | ler quantidade
| |
− | | |
− | i <- 0
| |
− | enquanto i < quantidade faz
| |
− | escrever "valor ", i, ": "
| |
− | ler v[i]
| |
− | i <- i + 1
| |
− | fimenquanto
| |
− | | |
− | // ordena os valores ...
| |
− | | |
− | escrever "valores ordenados: "
| |
− | i <- 0
| |
− | enquanto i < quantidade
| |
− | escrever v[i], " "
| |
− | i <- i + 1
| |
− | fimenquanto
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | | |
− | === Atividades ===
| |
− | | |
− | # Escreva um algoritmo que leia 5 números do teclado, e depois mostre-os em ordem inversa à que foi digitada.
| |
− | # Escreva um algoritmo que leia dois vetores de 5 números, e depois mostre se os vetores são iguais. <br><br>''Solução vista em aula:''<syntaxhighlight lang=text>
| |
− | inicio
| |
− | inteiro v1[5]
| |
− | inteiro v2[5]
| |
− | inteiro n
| |
− | | |
− | // Le os valores do primeiro vetor
| |
− | para n de 0 ate 4 passo 1
| |
− | escrever "v1[", n, "]: "
| |
− | ler v1[n]
| |
− | proximo
| |
− | | |
− | // Le os valores do segundo vetor
| |
− | para n de 0 ate 4 passo 1
| |
− | escrever "v2[", n, "]: "
| |
− | ler v1[n]
| |
− | proximo
| |
− | | |
− | // compara os dois vetores
| |
− | n <- 0
| |
− | enquanto n < 5 E v1[n] = v2[n] faz
| |
− | n <- n + 1
| |
− | fimenquanto
| |
− | | |
− | // mostra o resultado da comparação
| |
− | se n = 5 entao
| |
− | escrever "Vetores iguais"
| |
− | senao
| |
− | escrever "Vetores diferem na posicao ", n
| |
− | fimse
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | | |
− | # Escreva um algoritmo que leia um palavra do teclado e depois procure-a numa lista de palavras preexistente. Essa lista deve ser implementada usando um vetor.
| |
− | # Escreva um algoritmo que leia 5 números, e mostre-os em ordem crescente.
| |
− | # Modifique o algoritmo anterior para mostrá-los em ordem decrescente.
| |
− | # Em um jogo de bingo devem-se contar quantos números de uma aposta foram sorteados no bingo. Faça um algoritmo que, dados os números sorteados e uma aposta, conta quantos números apostados foram sorteados.
| |
− | | |
− | == 25/10: 2a avaliação ==
| |
− | | |
− | Avaliação em aula, no laboratório de Redes. Resolver usando o Portugol. Compactar os arquivos com os algoritmos e entregar para o professor.
| |
− | | |
− | Obs: para compactar:
| |
− | | |
− | <syntaxhighlight lang=bash>
| |
− | tar czf prova2-seu_nome.tgz *.alg
| |
− | </syntaxhighlight>
| |
− | | |
− | Você precisará [[SOP-2010-2-sobral#Guia_r.C3.A1pido_de_instala.C3.A7.C3.A3o_e_utiliza.C3.A7.C3.A3o_do_Portugol|instalar o Portugol]] em seu computador.
| |
− | | |
− | 1) '''Contador de moedas:''' faça um programa que leia valores de moedas e some as quantidades de tipos de moedas informadas. Por exemplo, se o usuário digitar 25, 50, 25, 5, 10, 5, o programa deve informar: ''2 moedas de 5 centavos, 1 moeda de 10 centavos, 2 moedas de 25 centavos, 1 moeda de 50 centavos''. São aceitos apenas valores de moedas de 1, 5, 10, 25 e 50 centavos. Seu programa deve ler 10 valores de moedas, e então apresentar o resultado.
| |
− | | |
− | 2) '''Calculadora de troco:''' escreva um programa que calcule o troco a ser devolvido a um cliente. O troco deve ser composto de notas de 50, 20, 10, 5, 2 ou 1 real, e também moedas de 1, 5, 10, 25 ou 50 centavos. Dê preferência ao uso de notas e moedas de maior valor. Por exemplo, se o troco a ser devolvido for ''R$ 17,75'', seu programa deve informar ''1 nota de R$ 10, 1 nota de R$ 5, 1 nota de R$ 2, 1 moeda de R$ 0,50, 1 moeda de R$ 0,25''.<syntaxhighlight lang=text>Inicio
| |
− | inteiro notas[6] <- {50,20,10,5,2,1}
| |
− | inteiro moedas[5] <- {50,25,10,5,1}
| |
− | inteiro reais, centavos
| |
− | inteiro i, aux
| |
− |
| |
− | escrever "Reais: "
| |
− | ler reais
| |
− | escrever "Centavos: "
| |
− | ler centavos
| |
− |
| |
− | para i de 0 ate 5 passo 1
| |
− | aux <- reais / notas[i]
| |
− | se aux > 0 entao
| |
− | escrever aux, " notas de R$ ", notas[i], "\n"
| |
− | reais <- reais % notas[i]
| |
− | fimse
| |
− | proximo
| |
− |
| |
− | para i de 0 ate 4 passo 1
| |
− | aux <- centavos / moedas[i]
| |
− | se aux > 0 entao
| |
− | escrever aux, " moedas de R$ 0,", moedas[i], "\n"
| |
− | centavos <- centavos % moedas[i]
| |
− | fimse
| |
− | proximo
| |
− |
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | | |
− | 3) '''Modificação de senha:''' Para modificar uma senha deve-se primeiro fornecer a senha
| |
− | atual, e então a nova senha. É necessário escrever duas vezes a nova
| |
− | senha para confirmá-la. Escreva um algoritmo que modifique uma senha
| |
− | predefinida (no seu programa ela pode estar guardada em uma variável), seguindo essa regra de mudança de senha.
| |
− | | |
− | 4) '''Nota de uma prova olímpica:''' um atleta de saltos ornamentais tem seu salto avaliado por 6 juízes. Após descartar a maior e a menor nota, calcula-se a média aritmética das notas dadas. Faça um programa que calcule a nota de um atleta.
| |
− | | |
− | === Conceitos da 2a avaliação ===
| |
− | | |
− | | |
− | ''Legenda:''
| |
− | *'''T:''' Atendeu a questão totalmente
| |
− | *'''P:''' Atendeu parcialmente
| |
− | *'''N:''' Não atendeu
| |
− | *''Sufixo +:'' apresentou uma boa solução
| |
− | *''Sufixo -:'' apresentou uma solução que não escolheu estruturas de controle mais adequadas
| |
− | | |
− | | |
− | {| border="1" cellpadding="2"
| |
− | !Aluno
| |
− | !Questão 1
| |
− | !Questão 2
| |
− | !Questão 3
| |
− | !Questão 4
| |
− | !Conceito
| |
− | |-
| |
− | |Fernando || N || N || T- ''(testes redundantes da senha atual)''|| T || C
| |
− | |-
| |
− | |Gabriel || || || || || D (ausente)
| |
− | |-
| |
− | |Levi || || || || || D (ausente)
| |
− | |-
| |
− | |Lindalvo || T ''(faltou testar se a moeda é válida)'' || N || T || T || A
| |
− | |-
| |
− | |Marcos || T- ''(faltou testar se a moeda é válida, algoritmo muito extenso ...)''|| N || T || N || C
| |
− | |-
| |
− | |Marine || T+ || T || T || N || A
| |
− | |-
| |
− | |Mario Allan || T || N || T ''(algoritmo nunca termina !)''|| N || C
| |
− | |-
| |
− | |Mário André || T ''(faltou testar se a moeda é válida)'' || T || T+ || N || A
| |
− | |-
| |
− | |Mário Sérgio || N || N || N || N || D
| |
− | |-
| |
− | |Maykon || T- ''(erro no teste de moeda válida)''|| N || T || N ''(não identificou maior e menor notas)''|| C
| |
− | |-
| |
− | |Nathany || N || N || T || T- ''(não identifica a menor nota)''|| C
| |
− | |-
| |
− | |Pamella || || || || || D (ausente)
| |
− | |-
| |
− | |Paulo Igor || T- ''(não mostra moedas de 1 centavo, lê 11 moedas)''|| N || N || N || D
| |
− | |-
| |
− | |Ricardo || N || N || P ''(não confere a senha atual)''|| N || D
| |
− | |-
| |
− | |Roberto || || || || || D (ausente)
| |
− | |-
| |
− | |Thiago Martins || || || || || D (ausente)
| |
− | |-
| |
− | |Thiago Ramos || N || N || N || N || D
| |
− | |-
| |
− | |Vinicius Kachniacz || N || N || N || N || D
| |
− | |-
| |
− | |Vinicius Rodrigues || N || N || N ''(não confere as senhas)'' || N ''(não exclui maior e menor notas)''|| D
| |
− | |-
| |
− | |}
| |
− | | |
− | = Linguagem C: Projeto final =
| |
− | | |
− | == 26/10: Introdução à linguagem C ==
| |
− | | |
− | * Baseado no [[Guia Básico de C]].
| |
− | * Para provocar: [http://norvig.com/21-days.html Teach Yourself Programming in Ten Years]
| |
− | * Apostila adotada: [http://www.ead.cpdee.ufmg.br/cursos/C/c.html Curso de Linguagem C - Engenharia Elétrica - UFMG]
| |
− | * Ver [http://www.sj.ifsc.edu.br/~msobral/SOP/slides/aula15.pdf transparências]
| |
− | * Alguns textos escritos por mim sobre tópicos específicos da linguagem C:
| |
− | ** [[SOP-strings|Strings]]
| |
− | ** [[SOP-funcoes|Funções]]
| |
− | ** [[SOP-stdio|Entrada e saída padrão]]
| |
− | ** [[SOP-arquivos|Arquivos]]
| |
− | ** [[SOP-struct|Estruturas de dados]]
| |
− | | |
− | Obs: durante as aulas usaremos o [http://www.netbeans.org NetBeans], um Ambiente Integrado de Desenvolvimento (''IDE - Integrated Development Environment''). Um IDE é um programa que auxilia o programador. Ele integra um editor de programas, um gerenciador de projetos, compilador e um depurador (''debugger'').
| |
− | | |
− | '''''Para instalar o Netbeans:'''''
| |
− | # Faça o [http://netbeans.c3sl.ufpr.br/6.8/bundles/netbeans-6.8-ml-cpp-linux.sh download do instalador]. Salve-o em algum subdiretório.
| |
− | # Abrindo um terminal, entre no subdiretório onde está o instalador e execute esse comando: <syntaxhighlight lang=bash>
| |
− | bash netbeans-6.8-ml-cpp-linux.sh
| |
− | </syntaxhighlight>
| |
− | #* Caso o instalador falhe porque não encontrou a JVM (Máquina Virtual Java), instale-a com esse comando: <syntaxhighlight lang=bash>
| |
− | sudo apt-get install -y sun-java6-jdk
| |
− | </syntaxhighlight>
| |
− | # Aceite as opções de instalação sugeridas pelo instalador.
| |
− | # Ao final da instalação, o Netbeans 6.8 estará acessível pelo menu ''Aplicativos -> Programação''.
| |
− | # Sempre que for escrever um novo programa com o Netbeans, crie um novo projeto (ver menu Arquivo->Novo Projeto). Selecione um projeto do tipo "Aplicativo C/C++".
| |
− | | |
− | === Compilando o primeiro programa ===
| |
− | * O clássico ''Hello World!''
| |
− | <syntaxhighlight lang=c n>
| |
− | #include <stdio.h>
| |
− | | |
− | int main(int argc, char *argv[])
| |
− | {
| |
− | printf("Alô mundo!\n");
| |
− | }
| |
− | </syntaxhighlight>
| |
− | | |
− | * Mostrando mensagens de na tela: [http://manpages.ubuntu.com/manpages/karmic/en/man3/puts.3.html puts] e [http://manpages.ubuntu.com/manpages/karmic/en/man3/printf.3.html printf]: <syntaxhighlight lang=c n>
| |
− | #include <stdio.h>
| |
− | | |
− | int main() {
| |
− | int n;
| |
− | | |
− | n = 5;
| |
− |
| |
− | puts("Demonstração de puts e printf");
| |
− | | |
− | printf("Valor de n: %d\n", n);
| |
− | | |
− | n = n + 1;
| |
− | | |
− | printf("Novo valor de n: %d\n", n);
| |
− | | |
− | return 0;
| |
− | }
| |
− | </syntaxhighlight>
| |
− | * Lendo dados do teclado: [http://manpages.ubuntu.com/manpages/karmic/en/man3/scanf.3.html scanf]<syntaxhighlight lang=c n>
| |
− | #include <stdio.h>
| |
− | | |
− | int main() {
| |
− | int n;
| |
− | | |
− | printf("Digite um número inteiro: ");
| |
− | | |
− | scanf("%d", &n);
| |
− | | |
− | printf("Valor digitado foi %d\n", n);
| |
− | | |
− | return 0;
| |
− | }
| |
− | </syntaxhighlight>
| |
− | ** Outras formas de ler do teclado: [http://manpages.ubuntu.com/manpages/karmic/man3/fgets.3.html getchar], [http://manpages.ubuntu.com/manpages/karmic/en/man3/fgets.3.html fgets]
| |
− | | |
− | ==== Tipos de dados ====
| |
− | {| border="1" cellpadding="2"
| |
− | !Portugol
| |
− | !C
| |
− | !Exemplo
| |
− | |-
| |
− | |inteiro||int|| int x;
| |
− | |-
| |
− | |caracter||char|| char letra;
| |
− | |-
| |
− | |real||float ou double|| float pi = 3.1416;
| |
− | |-
| |
− | |texto||char * ou vetor de char || char * mensagem = "Hello world";<br>char palavra[16];
| |
− | |-
| |
− | |logico||qualquer tipo (valor 0 = Falso, qualquer outro valor = Verdadeiro)||int ok = 1;<br>char teste = 0;
| |
− | |}
| |
− | | |
− | | |
− | ==== Comandos/funções e Estruturas de controle ====
| |
− | {| border="1" cellpadding="2"
| |
− | !Portugol
| |
− | !C
| |
− | !Exemplo
| |
− | |-
| |
− | |<syntaxhighlight lang=text>inteiro n, m
| |
− | | |
− | escrever "Ola, mundo!\n"
| |
− | escrever "valor de n: ", n, "\n"
| |
− | escrever "valor de n: ", n, ", e valor de x: ", x, "\n"
| |
− | </syntaxhighlight>||<syntaxhighlight lang=c>int n, m;
| |
− | | |
− | printf("Ola, mundo!\n");
| |
− | printf("valor de n: %d\n", n);
| |
− | printf("valor de n: %d, e valor de x: %d\n", n, x);</syntaxhighlight>||
| |
− | |-
| |
− | |<syntaxhighlight lang=text>inteiro n
| |
− | | |
− | ler n</syntaxhighlight>||<syntaxhighlight lang=c>int n;
| |
− | | |
− | scanf("%d", &n);</syntaxhighlight>||
| |
− | |-
| |
− | |<syntaxhighlight lang=text>se condição então
| |
− | //comandos
| |
− | fimse</syntaxhighlight> ||<syntaxhighlight lang=c>if (condição) {
| |
− | //comandos
| |
− | }</syntaxhighlight>||
| |
− | |-
| |
− | |<syntaxhighlight lang=text>se condição então
| |
− | //comandos
| |
− | senão
| |
− | //comandos
| |
− | fimse</syntaxhighlight> ||<syntaxhighlight lang=c>if (condição) {
| |
− | //comandos
| |
− | } else {
| |
− | //comandos
| |
− | }</syntaxhighlight> ||
| |
− | |-
| |
− | |<syntaxhighlight lang=text>escolhe expressão
| |
− | caso valor1:
| |
− | //comandos
| |
− | caso valor2:
| |
− | //comandos
| |
− | defeito:
| |
− | //comandos
| |
− | fimescolhe</syntaxhighlight>||<syntaxhighlight lang=c>switch (expressão) {
| |
− | case valor1:
| |
− | //comandos
| |
− | case valor2:
| |
− | //comandos
| |
− | default:
| |
− | //comandos
| |
− | }</syntaxhighlight>||
| |
− | |-
| |
− | |<syntaxhighlight lang=text>enquanto condição faz
| |
− | //comandos
| |
− | fimenquanto</syntaxhighlight>||<syntaxhighlight lang=c>while (condição) {
| |
− | //comandos
| |
− | }</syntaxhighlight>||
| |
− | |-
| |
− | |<syntaxhighlight lang=text>para variavel de inicio ate fim passo incremento
| |
− | //comandos
| |
− | proximo</syntaxhighlight>||<syntaxhighlight lang=c>for (variavel=inicio; variavel <= fim; variavel++) {
| |
− | //comandos
| |
− | }</syntaxhighlight>||
| |
− | |}
| |
− | | |
− | === Atividades ===
| |
− | | |
− | * Traduza para C os seguintes algoritmos Portugol:
| |
− | *# <syntaxhighlight lang=text>
| |
− | Inicio
| |
− | inteiro x, y
| |
− |
| |
− | Escrever "Digite um numero: ",
| |
− | Ler x
| |
− | Escrever "Digite outro numero: ",
| |
− | Ler y
| |
− | Escrever "Soma = ", x+y
| |
− | Fim
| |
− | </syntaxhighlight>
| |
− | *# <syntaxhighlight lang=text>
| |
− | Inicio
| |
− | inteiro x, y, z
| |
− |
| |
− | Escrever "Digite um numero: ",
| |
− | Ler x
| |
− | Escrever "Digite outro numero: ",
| |
− | Ler y
| |
− | z <- x + y
| |
− | Escrever "Soma = ", z
| |
− | Fim
| |
− | </syntaxhighlight>
| |
− | *# <syntaxhighlight lang=text>
| |
− | Inicio
| |
− | Inteiro n1, n2, n3, r
| |
− |
| |
− | Escrever "Primeiro numero: "
| |
− | ler n1
| |
− | Escrever "Segundo numero: "
| |
− | ler n2
| |
− | Escrever "Terceiro numero: "
| |
− | ler n3
| |
− |
| |
− | r <- (n1 + n2 + n3) /3
| |
− |
| |
− | Escrever "Media=", r
| |
− | Fim
| |
− | </syntaxhighlight>
| |
− | *# <syntaxhighlight lang=text>
| |
− | Inicio
| |
− | inteiro anos, dias
| |
− |
| |
− | Escrever "Quantos anos se passaram ? "
| |
− | Ler anos
| |
− | dias <- anos * 365
| |
− | Escrever "... então se passaram ", dias, " dias"
| |
− | Fim
| |
− | </syntaxhighlight>
| |
− | *# <syntaxhighlight lang=text>
| |
− | Inicio
| |
− | constante inteiro diasPorAno <- 365
| |
− | inteiro anos, dias
| |
− |
| |
− | Escrever "Quantos anos se passaram ? "
| |
− | Ler anos
| |
− | dias <- anos * diasPorAno
| |
− | Escrever "... então se passaram ", dias, " dias"
| |
− | Fim
| |
− | </syntaxhighlight>
| |
− | *# <syntaxhighlight lang=text>
| |
− | inicio
| |
− | real massa
| |
− | real forca
| |
− | real aceleracao
| |
− | constante real g <- 9.8
| |
− | constante real ac <- 0.01
| |
− |
| |
− | escrever "força: "
| |
− | ler forca
| |
− |
| |
− | escrever "massa: "
| |
− | ler massa
| |
− |
| |
− | aceleracao <- forca/massa - ac*massa*g
| |
− |
| |
− | escrever "aceleracao=", aceleracao, " m/s2"
| |
− |
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | *# <syntaxhighlight lang=text>
| |
− | inicio
| |
− | real a, b, c
| |
− | real delta
| |
− | real x1, x2
| |
− |
| |
− | escrever "Forneça os coeficientes da equação de 2o grau (formato: ax^2 + bx + c):\n"
| |
− | escrever "a="
| |
− | ler a
| |
− | escrever "b="
| |
− | ler b
| |
− | escrever "c="
| |
− | ler c
| |
− |
| |
− | delta <- b^2 - 4*a*c
| |
− | x1 <- (-b + delta^0.5)/(2*a)
| |
− | x2 <- (-b - delta^0.5)/(2*a)
| |
− |
| |
− | escrever "1a raiz=", x1
| |
− | escrever "\n2a raiz=", x2
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | *# <syntaxhighlight lang=text>
| |
− | inicio
| |
− | real x1, x2, x3, x4, x5
| |
− | real media
| |
− | real desvioPadrao
| |
− | constante inteiro N <- 5
| |
− |
| |
− | // Ler os cinco valores pelo teclado
| |
− | ler x1
| |
− | ler x2
| |
− | ler x3
| |
− | ler x4
| |
− | ler x5
| |
− |
| |
− | // Calcular a media
| |
− | media <- (x1 + x2 + x3 + x4 + x5) / N
| |
− |
| |
− | // Calcular o desvio padrao
| |
− | desvioPadrao <- (x1 - media)^2 + (x2 - media)^2 + (x3 - media)^2 + (x4 - media)^2 + (x5 - media)^2
| |
− | desvioPadrao <- (desvioPadrao / (N-1))^0.5
| |
− |
| |
− | escrever "Media=", media
| |
− | escrever "\nDesvio padrao=", desvioPadrao
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | *# <syntaxhighlight lang=text>
| |
− | inicio
| |
− | real renda
| |
− | real irpf
| |
− |
| |
− | escrever "Informe sua renda: "
| |
− | ler renda
| |
− |
| |
− | se renda < 1372.81 entao
| |
− | irpf <- 0
| |
− | senao
| |
− | se renda < 2743.25 entao
| |
− | irpf <- (renda - 205.92)*0.15
| |
− | senao
| |
− | irpf <- (renda - 548.82)*0.275
| |
− | fimSe
| |
− | fimSe
| |
− |
| |
− | escrever "Imposto devido: ", irpf
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | *# <syntaxhighlight lang=text>
| |
− | inicio
| |
− | inteiro dividendo
| |
− | inteiro divisor
| |
− | inteiro resto , quociente
| |
− | | |
− | escrever "Dividendo: "
| |
− | ler dividendo
| |
− | escrever "Divisor: "
| |
− | ler divisor
| |
− | | |
− | se divisor = 0 entao
| |
− | escrever "Nao pode dividir: divisor = 0 !!!"
| |
− | senao
| |
− | resto <- dividendo % divisor
| |
− | se resto = 0 entao
| |
− | quociente <- dividendo / divisor
| |
− | escrever dividendo , " / " , divisor , " = " , quociente
| |
− | senao
| |
− | escrever "Nao pode fazer divisao inteira"
| |
− | escrever " (resto = " , resto , ")"
| |
− | fimse
| |
− | fimse
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | *# <syntaxhighlight lang=text>
| |
− | inicio
| |
− | inteiro termometro , barometro , tempo
| |
− | | |
− | escrever "Qual a condição do termômetro: \n"
| |
− | escrever "Digite 1 para baixando , 2 para estacionário e 3 para subindo. \n"
| |
− | ler termometro
| |
− | | |
− | escrever "Informe a condição do barômetro: \n"
| |
− | escrever "Digite 1 para baixando , 2 para estacionário e 3 para subindo. \n"
| |
− | ler barometro
| |
− | | |
− | tempo <- termometro*10 + barometro
| |
− | | |
− | escolhe tempo
| |
− | caso 11:
| |
− | escrever "Chuvas abundantes e ventos de sul a sudoeste fortes"
| |
− | caso 12:
| |
− | escrever "Chuva Provavel , ventos de sul a sudeste"
| |
− | caso 13:
| |
− | escrever "Tempos Bons , ventos de sul a sudeste"
| |
− | caso 21:
| |
− | escrever "Frente quente com chuva provavel"
| |
− | caso 22:
| |
− | escrever "Tempo Incerto , ventos variaveis"
| |
− | caso 23:
| |
− | escrever "Tempos Bons , ventos do leste frescos"
| |
− | caso 31:
| |
− | escrever " Tempo instavel , aproximaçao de frente"
| |
− | caso 32:
| |
− | escrever "Tempo Mudando para bom , ventos de leste"
| |
− | caso 33:
| |
− | escrever "Tempos Bons , ventos quentes e secos"
| |
− | defeito:
| |
− | escrever "Utilize somente os algorismos de 1 a 3 para indicar as condiçoes do equipamentos"
| |
− | fimescolhe
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | *# <syntaxhighlight lang=text>
| |
− | inicio
| |
− | // coeficientes do polinomio [ax^2 + bx + c = 0 ]
| |
− | real a , b , c
| |
− |
| |
− | escrever "Forneça os coeficientes da equação de 2o grau:\n"
| |
− | escrever "a="
| |
− | ler a
| |
− | escrever "b="
| |
− | ler b
| |
− | escrever "c="
| |
− | ler c
| |
− |
| |
− | // equação do tipo [ bx + c = 0 ]
| |
− | se a = 0 entao
| |
− | escrever " não é uma equação de 2o grau !!!"
| |
− | senao
| |
− | // calcular o delta => interior da raiz
| |
− | real delta
| |
− |
| |
− | delta <- b ^ 2 - 4 * a * c
| |
− |
| |
− | // não existem raizes reais de números negativos
| |
− | se delta < 0 entao
| |
− | escrever " não tem raizes reais"
| |
− | senao
| |
− | // ----------- raiz dupla ----------------
| |
− | se delta = 0 entao
| |
− | real x1
| |
− | x1 <- -b / 2 * a
| |
− | escrever "\nraiz dupla : " , x1
| |
− | senao
| |
− | // - ---------- duas raizes ---------------
| |
− | real x1 , x2
| |
− | x1 <- ( -b + raiz ( delta ) ) / 2 * a
| |
− | x2 <- ( -b - raiz ( delta ) ) / 2 * a
| |
− | escrever "\nraiz x1 : " , x1
| |
− | escrever "\nraiz x2 : " , x2
| |
− | fimse//raiz dupla
| |
− | fimse// delta >0
| |
− | fimse// a <> 0
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | *# <syntaxhighlight lang=text>
| |
− | inicio
| |
− | inteiro num, bit
| |
− | inteiro base
| |
− |
| |
− | escrever "Este algoritmo converte um número inteiro para sua representação binária.\n"
| |
− | Escrever "O número deve estar entre 0 e 131071, e a representação binária\n"
| |
− | escrever "terá 17 bits\n\n"
| |
− | escrever "Digite o numero a ser convertido para binário: "
| |
− | ler num
| |
− | | |
− | base <- 65536
| |
− | enquanto base > 0 faz
| |
− | bit <- ( num / base ) % 2
| |
− | escrever bit, " "
| |
− | base <- base / 2
| |
− | fimenquanto
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | *# <syntaxhighlight lang=text>
| |
− | inicio
| |
− | inteiro n , fat
| |
− | ler n
| |
− | fat <- 1
| |
− | enquanto n > 1 faz
| |
− | fat <- fat * n
| |
− | n <- n - 1
| |
− | fimenquanto
| |
− |
| |
− | escrever "Fatorial=" , fat
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | *# <syntaxhighlight lang=text>
| |
− | inicio
| |
− | inteiro valor , menor , contador
| |
− | ler menor
| |
− | contador <- 9
| |
− | enquanto contador > 0 faz
| |
− | ler valor
| |
− | se valor < menor entao
| |
− | menor <- valor
| |
− | fimse
| |
− | contador <- contador - 1
| |
− | fimenquanto
| |
− | escrever "menor valor = ", menor
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | *# <syntaxhighlight lang=text>
| |
− | inicio
| |
− | inteiro numero , n , resto <- 1
| |
− | escrever "Forneçaa um número: "
| |
− | ler numero
| |
− | n <- 2
| |
− | enquanto n <= numero / 2 e resto =/= 0 faz
| |
− | resto <- numero % n
| |
− | escrever "n=" , n , ": resto=" , resto , "\n"
| |
− | n <- n + 1
| |
− | fimenquanto
| |
− |
| |
− | se resto = 0 entao
| |
− | escrever "nao primo: divisivel por " , n - 1
| |
− | senao
| |
− | escrever "primo"
| |
− | fimse
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | *# <syntaxhighlight lang=text>
| |
− | // Le 5 valores e identifica os dois maiores.
| |
− | inicio
| |
− | inteiro valor , maior1 , maior2 , contador
| |
− |
| |
− | ler valor
| |
− | maior1 <- valor
| |
− |
| |
− | ler valor
| |
− | se valor > maior1 entao
| |
− | maior2 <- maior1
| |
− | maior1 <- valor
| |
− | senao
| |
− | maior2 <- valor
| |
− | fimse
| |
− | | |
− | contador <- 3
| |
− | enquanto contador > 0 faz
| |
− | ler valor
| |
− | se valor > maior1 entao
| |
− | maior2 <- maior1
| |
− | maior1 <- valor
| |
− | senao
| |
− | se valor > maior2 entao
| |
− | maior2 <- valor
| |
− | fimse
| |
− | fimse
| |
− | contador <- contador - 1
| |
− | fimenquanto
| |
− | | |
− | escrever "maior valor = " , maior1
| |
− | escrever "\nsegundo maior valor = " , maior2
| |
− | fim
| |
− | </syntaxhighlight>
| |
− | | |
− | == 08/11: Começo do projeto ==
| |
− | | |
− | Para referência: [http://www.ead.cpdee.ufmg.br/cursos/C/c.html apostila online sobre linguagem C].
| |
− | | |
− | === O jogo: Campo Minado ===
| |
− | | |
− | O [http://pt.wikipedia.org/wiki/Campo_minado ''Campo Minado''] é um jogo clássico disponível em diferentes sistemas operacionais. Basicamente devem-se procurar as minas existentes em um campo quadriculado, perdendo-se o jogo se ''pisar'' em uma mina, e vencendo se descobrir todas as minas. O jogo oferece pistas sobre a localização das minas, e usando-se um pouco de lógica podem-se encontrá-las. Uma versão desse jogo para Linux aparece na figura a seguir .
| |
− | | |
− | [[imagem:Minas-linux.png]]
| |
− | | |
− | A cada jogada deve-se escolher uma casa do tabuleiro, optando-se por ''pisá-la'' (revelando-a) ou marcá-la como uma provável mina. Ao ''pisar'' numa casa, três ações podem ocorrer:
| |
− | # A casa contém uma mina, o que revela todas as demais minas e encerra o jogo com derrota.
| |
− | # A casa é vizinha a uma ou mais minas, e assim em seu lugar aparece o número de minas em casas vizinhas.
| |
− | # Nenhuma mina existe em casas vizinhas, então a casa aparece vazia. Além disso, todas as casas vizinhas que também não possuam minas são reveladas.
| |
− | | |
− | Ao final do jogo, a pontuação é dada pelo tempo que se levou para se descobrirem as minas. O jogo contabiliza uma lista de melhores jogadas, contendo o nome do jogador e o tempo de jogo. Melhores jogadas são aquelas com menores tempos de jogo.
| |
− | | |
− | A versão do jogo a ser desenvolvida será baseada em texto ''(mas quem quiser fazer uma versão gráfica fique à vontade !)''. Basicamente deve ser apresentado o tabuleiro, mostrando-se apenas as casas já reveladas e o tempo de jogo decorrido, e um ''prompt'' pedindo as coordenadas da próxima casa assim como o tipo de ação (se ''pisar'' na casa ou marcar a provável existência de uma mina).
| |
− | | |
− | === Etapas de desenvolvimento ===
| |
− | | |
− | * Proposta de código que contempla:
| |
− | ** Bibliotecas e definições
| |
− | ** Declaração de constantes e variáveis
| |
− | *** Uso de variáveis com mesmo nome e diferentes escopos
| |
− | *** Vetor e matriz
| |
− | ** Operadores lógicos e matemáticos
| |
− | ** Expressões
| |
− | *** E/S
| |
− | *** Estruturas de decisão e repetição
| |
− | ** Funções
| |
− | *** Passagem de parâmetro por valor e por referência
| |
− | ** Acesso a uma matriz através de um vetor linear (função <tt>iniciaJogo</tt>)
| |
− | ** Ponteiros
| |
− | | |
− | === O laço principal do jogo ... ===
| |
− | | |
− | O jogo funciona com um laço principal, que lê as coordenadas da pŕoxima casa e a ação a ser feita, e atualiza o tabuleiro apropriadamente:
| |
− | | |
− | [[imagem:Fluxo-Campo-Minado.png|400px]]
| |
− | | |
− | Note que nesse laço devem-se contabilizar quantas minas fora descobertas. Esse valor é necessário para decidir se o jogo já acabou.
| |
− | | |
− | === O tabuleiro ===
| |
− | | |
− | Representar o tabuleiro: etapas X a Y.
| |
− | | |
− | O tabuleiro do campo minado deve ser representado em formato de texto conforme a figura abaixo. Nesta figura, o tabuleiro está completamente revelado.
| |
− | | |
− | | |
− | [[imagem:Tabuleiro-Minado.png]]
| |
− | | |
− | | |
− | As colunas são identificadas por letras maiúsculas, e as linhas por números. Cada casa do tabuleiro pode conter uma mina ou um número que conta quantas minas existem em casas vizinhas. Casas já reveladas devem mostrar essa contagem de minas vizinhas, sendo que se não houver minas a casa deve ser mostrada vazia (preenchida com espaço). Casa em que se marcou a existência de uma mina deve mostrar a letra '''M'''. Por fim, casas ainda não reveladas devem ser preenchidas com o caractere '''?'''. Um tabuleiro parcialmente revelado apareceria como a figura abaixo.
| |
− | | |
− | | |
− | [[imagem:Tabuleiro-Minado2.png]]
| |
− | | |
− | | |
− | ==== Etapa 1: Modelando o tabuleiro ====
| |
− | | |
− | Conteúdos abordados:
| |
− | * [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c300.html declaração de variáveis]
| |
− | * [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c940.html saída de dados na tela]
| |
− | * [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c500.html Matrizes]
| |
− | | |
− | Deve-se nessa etapa escolher uma forma de representar o tabuleiro dentro do programa. Devem-se pensar também em como representar as casas do campo minado:
| |
− | * Como definir que uma casa possui uma mina ?
| |
− | * Como definir que uma casa está vazia ? Nesse caso, como informar a quantidade de minas em casas vizinhas ?
| |
− | * Como definir se uma casa já foi pisada ?
| |
− | | |
− | Ponto de partida para mostrar um tabuleiro na tela. O tabuleiro foi modelado como uma matriz de inteiros bidimensional.
| |
− | | |
− | <syntaxhighlight lang=c>
| |
− | #include <stdio.h>
| |
− | | |
− | int main(int argc, char** argv) {
| |
− | int tabuleiro[5][5] = { {0,0,1,1,0}, {1,1,2,0,0}, {10,1,0,0,0},
| |
− | {1,1,1,0,0}, {0,0,0,0,10} };
| |
− | int i, j;
| |
− | | |
− | //i indica a linha, j a coluna
| |
− | i = 0;
| |
− | while (i < 5) {
| |
− | // O while abaixo mostra todas as colunas da linha "i"
| |
− | j = 0;
| |
− | while (j < 5) {
| |
− | printf("%d ", tabuleiro[i][j]);
| |
− | j++;
| |
− | }
| |
− | | |
− | printf("\n");
| |
− | i++;
| |
− | }
| |
− | | |
− | return (EXIT_SUCCESS);
| |
− | }
| |
− | </syntaxhighlight>
| |
− | | |
− | Cada casa dessa matriz contém um número inteiro. Para representar o estado de cada casa do tabuleiro sugeriu-se um código numérico:
| |
− | * ''Casa com mina:'' algum número > 8
| |
− | * ''Casa sem mina:'' um número que conte quantas minas existem em casas vizinhas. Tal número estará entre 0 e 8.
| |
− | | |
− | | |
− | | |
− | == 09/11: O tabuleiro ==
| |
− | | |
− | Conteúdos abordados:
| |
− | * [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c300.html declaração de variáveis]
| |
− | * [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c530.html matrizes de números]
| |
− | * [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c940.html saída de dados na tela]
| |
− | * [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c410.html estrutura de decisão: ''if'']
| |
− | * [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c440.html estrutura de repetição: ''while'']
| |
− | | |
− | === Desenhando o tabuleiro completo ===
| |
− | | |
− | Dando continuidade à visualização do tabuleiro, agora deve-se desenhá-lo por completo na tela. Quer dizer, mostrar um tabuleiro com 10 linhas e 10 colunas, seguindo a abordagem da [[SOP-2010-2-sobral#08.2F11:_Come.C3.A7o_do_projeto|aula anterior]].
| |
− | | |
− | Para mostrar o tabuleiro, deve-se explorar o uso da função [[SOP-stdio|printf]], que serve para mostrar dados na tela.
| |
− | | |
− | === Zerando o tabuleiro ===
| |
− | | |
− | Fluxograma do algoritmo que zera o tabuleiro:
| |
− | | |
− | [[imagem:Zera-tabuleiro.png|300px]]
| |
− | | |
− | | |
− | ... e esse fluxograma traduzido para linguagem C:
| |
− | | |
− | <syntaxhighlight lang=c>
| |
− | // Zerar todas as posições do tabuleiro !
| |
− | i = 0;
| |
− | while ( i < LINHAS) {
| |
− | j = 0;
| |
− | while (j < COLUNAS) {
| |
− | tabuleiro[i][j] = 0;
| |
− | j++;
| |
− | }
| |
− | i++;
| |
− | }
| |
− | </syntaxhighlight>
| |
− | | |
− | === Colocando as minas ===
| |
− | | |
− | No tabuleiro devem ser colocadas 10 minas aleatoriamente. Isso significa que para cada uma dessas minas, devem-se gerar aleatoriamente suas coordenadas no tabuleiro. A geração de números aleatórios pode ser feita usando-se a função [http://manpages.ubuntu.com/manpages/lucid/man3/random.3.html random()]. Essa função gera um número inteiro entre 0 e 2147483647. Para usá-la no tabuleiro, pode-se fazer o seguinte:
| |
− | | |
− | <syntaxhighlight lang=c>
| |
− | #include <stdlib.h>
| |
− | | |
− | int main() {
| |
− | int x, y;
| |
− | | |
− | // gera dois números aleatórios entre 0 e 9, e guarda-os nas variáveis x e y
| |
− | x = random() % 10;
| |
− | y = random() % 10;
| |
− |
| |
− | }
| |
− | </syntaxhighlight>
| |
− | | |
− | A versão atual do jogo está assim:
| |
− | | |
− | <syntaxhighlight lang=c>
| |
− | #include <stdio.h>
| |
− | #include <stdlib.h>
| |
− | | |
− | #define MINAS 10
| |
− | #define LINHAS 10
| |
− | #define COLUNAS 10
| |
− | | |
− | #define TEM_MINA 10
| |
− | | |
− | /*
| |
− | *
| |
− | */
| |
− | int main(int argc, char** argv) {
| |
− | int tabuleiro[LINHAS][COLUNAS];
| |
− | int i, j;
| |
− | | |
− | // Zerar todas as posições do tabuleiro !
| |
− | i = 0;
| |
− | while ( i < LINHAS) {
| |
− | j = 0;
| |
− | while (j < COLUNAS) {
| |
− | tabuleiro[i][j] = 0;
| |
− | j++;
| |
− | }
| |
− | i++;
| |
− | }
| |
− |
| |
− | // Colocar as minas aqui !!!
| |
− | | |
− | //Agora mostrar o tabuleiro que foi gerado
| |
− | | |
− | //i indica a linha, j a coluna
| |
− | i = 0;
| |
− | while (i < LINHAS) {
| |
− | // O while abaixo mostra todas as colunas da linha "i"
| |
− | j = 0;
| |
− | while (j < COLUNAS) {
| |
− | if (tabuleiro[i][j] == TEM_MINA) {
| |
− | printf("* ");
| |
− | } else {
| |
− | if (tabuleiro[i][j] == 0) {
| |
− | printf(" ");
| |
− | } else {
| |
− | if ((tabuleiro[i][j] >= 1) && (tabuleiro[i][j] <= 8)) {
| |
− | printf("%d ", tabuleiro[i][j]);
| |
− | }
| |
− | }
| |
− | }
| |
− | j++;
| |
− | }
| |
− | | |
− | printf("\n");
| |
− | i++;
| |
− | }
| |
− | | |
− | return (EXIT_SUCCESS);
| |
− | }
| |
− | </syntaxhighlight>
| |
− | | |
− | === Meta desta semana ===
| |
− | | |
− | Nesta semana o seu programa deve ser capaz de:
| |
− | # Representar o tabuleiro com uma matriz de inteiros bidimensional.
| |
− | # Mostrar o tabuleiro na tela, indicando o que existe em cada casa. O tabuleiro deve ser apresentado ''enfeitado'', o que significa que deve mostrar uma grade para separar as casas e a identificação de linhas e colunas. Linhas devem ser identificadas numericamente, e colunas devem ser identificadas por letras (ex: primeira coluna=A, segunda coluna=B, ...).
| |
− | # Colocar minas aleatoriamente no tabuleiro.
| |
− | | |
− | O seu programa cumprindo as metas acima '''deve ser apresentado ao professor na próxima aula (16/11), já sendo parte da avaliação desta unidade'''.
| |
− | | |
− | == 16/11: As minas e o tabuleiro ==
| |
− | | |
− | Conteúdos abordados:
| |
− | * [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c300.html declaração de variáveis]
| |
− | * [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c940.html saída de dados na tela]
| |
− | * [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c410.html estrutura de decisão: ''if'']
| |
− | * [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c440.html estrutura de repetição: ''while'']
| |
− | | |
− | === Dúvidas sobre random() ===
| |
− | | |
− | <syntaxhighlight lang=c>
| |
− | #include <stdio.h>
| |
− | #include <stdlib.h>
| |
− | #include <sys/time.h>
| |
− | | |
− | int main() {
| |
− | int x,y,z;
| |
− | time_t t;
| |
− | | |
− | // Lê o valor do relógio
| |
− | t = time(NULL);
| |
− | | |
− | // Usa o valor do relógio como semente do gerador de números
| |
− | // pseudo-aleatórios.
| |
− | srandom(t);
| |
− | | |
− | // Sorteia três números pseudo-aleatórios
| |
− | x = random() % 10;
| |
− | y = random() % 10;
| |
− | z = random() % 10;
| |
− | | |
− | printf("x=%d, y=%d, z=%d\n", x, y, z);
| |
− | }
| |
− | </syntaxhighlight>
| |
− | === Funções ===
| |
− | | |
− | A função ''mostra_tabuleiro'' corresponde ao algoritmo para desenhar o tabuleiro na tela. O tabuleiro em si é representado pela variável ''tabuleiro'', que tem escopo global (visível em todas as funções do programa). Neste momento é bom ler um pouco mais sobre funções na linguagem C:
| |
− | * [[SOP-funcoes|Texto introdutório sobre funções na linguagem C]]
| |
− | | |
− | | |
− | | |
− | === Para fixar ===
| |
− | | |
− | # Escreva um programa para ler 10 números do teclado, e em seguida mostrar o maior e o menor número.
| |
− | # Reescreva o programa anterior, mas criando as funções "maior" e "menor", que retornam o maior e menor número de um vetor de tamanho arbitrário.
| |
− | # Faça um programa que desenhe a seguinte figura na tela (use uma função para desenhar cada linha): <syntaxhighlight lang=text>
| |
− | '
| |
− | *
| |
− | ***
| |
− | *****
| |
− | *******
| |
− | *********
| |
− | *******
| |
− | *****
| |
− | ***
| |
− | *
| |
− | </syntaxhighlight>
| |
− | # Até que ponto se poderiam usar funções para mostrar o tabuleiro ? Imagine que mostrar o tabuleiro fosse uma tarefa composta por 2 subtarefas:
| |
− | ## ''Mostrar o estado de uma casa do tabuleiro''
| |
− | ## ''Mostrar o tabuleiro completo:'' mostrar todas as casas (usa subtarefa anterior).<br>Note que essas subtarefas correspondem à sequência do projeto até o momento. Um bom exercício seria modelar a tarefa de mostrar o tabuleiro usando uma função para cada subtarefa escrita acima.
| |
− | | |
− | == 22/11: Contando minas vizinhas ==
| |
− | | |
− | === A contagem de minas ===
| |
− | | |
− | Para ajudar a visualizar o algoritmo de contagem de minas vizinhas, segue o fluxograma abaixo. As coordenadas ''(x,y)'' correspondem à casa cujas minas vizinhas se desejam contar. Veja sua semelhança com o [[SOP-2010-2-sobral#Zerando_o_tabuleiro|algoritmo para zerar o tabuleiro]].
| |
− | | |
− | [[imagem:Conta-minas.png|300px]]
| |
− | | |
− | A sugestão é por o algoritmo de contagem em uma [[SOP-funcoes|função]], e dentro do programa chamá-lo para cada casa do tabuleiro:
| |
− | | |
− | <syntaxhighlight lang=c>
| |
− | #include <stdio.h>
| |
− | #include <stdlib.h>
| |
− | | |
− | #define MINAS 10
| |
− | #define LINHAS 10
| |
− | #define COLUNAS 10
| |
− | | |
− | #define TEM_MINA 10
| |
− | | |
− | // O tabuleiro como variável global: necessário para poder ser usado e modificado por outras funções
| |
− | int tabuleiro[LINHAS][COLUNAS];
| |
− | | |
− | | |
− | // Função para contar as minas vizinhas da casa x, y
| |
− | void conta(int x, int y) {
| |
− | | |
− |
| |
− | }
| |
− | | |
− | /*
| |
− | *
| |
− | */
| |
− | int main(int argc, char** argv) {
| |
− | int i, j;
| |
− | | |
− | // Zerar todas as posições do tabuleiro !
| |
− | i = 0;
| |
− | while ( i < LINHAS) {
| |
− | j = 0;
| |
− | while (j < COLUNAS) {
| |
− | tabuleiro[i][j] = 0;
| |
− | j++;
| |
− | }
| |
− | i++;
| |
− | }
| |
− |
| |
− | // Colocar as minas aqui !!!
| |
− | | |
− | // contar as minas vizinhas de cada casa do tabuleiro
| |
− | i = 0;
| |
− | while ( i < LINHAS) {
| |
− | j = 0;
| |
− | while (j < COLUNAS) {
| |
− | // chama a função de contagem de minas, para contar as minas
| |
− | // vizinhas da casa com coordenadas i,j
| |
− | conta(i, j);
| |
− | j++;
| |
− | }
| |
− | i++;
| |
− | }
| |
− | | |
− | //Agora mostrar o tabuleiro que foi gerado
| |
− | </syntaxhighlight>
| |
− | | |
− | Obs: cuidado com o seguinte ao fazer o algoritmo de contagem de minas:
| |
− | * Casas na borda do tabuleiro possuem menos casas vizinhas (casas fora do tabuleiro devem ser ignoradas).
| |
− | * O algoritmo não pode ser aplicado em casas que contêm minas. Quer dizer, não faz sentido calcular as minas vizinhas de uma casa que tem uma mina.
| |
− | | |
− | Levando em conta as restrições acima, o algoritmo deve ficar parecido com o seguinte:
| |
− | | |
− | [[imagem:Conta-minas2.png|320px]]
| |
− | | |
− | == 23/11: Pensando no jogo completo ! ==
| |
− | | |
− | === Topicos sobre linguagem C ===
| |
− | | |
− | ==== Estrutura de repetição ''for'' ====
| |
− | | |
− | * Mais detalhes na [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c430.html apostila da UFMG]
| |
− | | |
− | A estrutura de repetição ''for'' costuma ser mais usada por programadores do que ''while''. Ao contrário de sua contraparte no Portugol (''para variavel de inicio ate fim ...''), a estrutura ''for'' possui grande flexibilidade para controle das repetições de um laço. Quer dizer, qualquer laço implementado com ''while'' pode ser também implementado com ''for''. O diferencial do ''for'' está na possibilidade de concentrar todas as instruções necessárias para controlar o laço.
| |
− | | |
− | A estrutura ''for'' pode ser declarada da seguinte forma:
| |
− | | |
− | <syntaxhighlight lang=c>
| |
− | for (inicialização; condição; atualização) {
| |
− | //comandos
| |
− | }
| |
− | </syntaxhighlight>
| |
− | | |
− | ... sendo:
| |
− | * '''inicialização:''' instruções a serem executadas no início do laço (antes da primeira repetição)
| |
− | * '''condição:''' condição (expressão lógica) para a continuidade do laço. Deve ser verdadeira para que se execute mais uma repetição.
| |
− | * '''atualização:''' instruções a serem executadas ao final de cada repetição
| |
− | | |
− | Por exemplo, para mostrar os números de 1 a 10 na tela:
| |
− | | |
− | <syntaxhighlight lang=c>
| |
− | int x;
| |
− | | |
− | for (x=1; x < 11; x++) {
| |
− | printf("x=%d\n", x);
| |
− | }
| |
− | </syntaxhighlight>
| |
− | | |
− | Veja no exemplo acima que tudo o que se precisa saber sobre o controle do laço está concentrado na declaração do ''for'':
| |
− | | |
− | <syntaxhighlight lang=c>
| |
− | for (x=1; x < 11; x++) {
| |
− | </syntaxhighlight>
| |
− | | |
− | * ''inicialização (x=1):'' o laço inicia atribuindo o valor ''1'' à variável ''x''
| |
− | * ''condição (x < 11):'' o laço continua enquanto o valor da variável ''x'' for menor que ''11''
| |
− | * ''atualização (x++):'' ao final de cada repetição, o valor da variável ''x'' é incrementado
| |
− |
| |
− | Muitas possibilidades existem para o uso de ''for''. Veja este outro exemplo:
| |
− | | |
− | <syntaxhighlight lang=c>
| |
− | char c;
| |
− | | |
− | for (c = 'A'; c < 'K'; c++) {
| |
− | printf("%c ", c);
| |
− | }
| |
− | </syntaxhighlight>
| |
− | | |
− |
| |
− | O programa do Campo Minado com o uso de ''for'' ao invés de ''while'' fica assim:
| |
− | | |
− | <syntaxhighlight lang=c>
| |
− | #include <stdio.h>
| |
− | #include <stdlib.h>
| |
− | | |
− | #define MINAS 10
| |
− | #define LINHAS 10
| |
− | #define COLUNAS 10
| |
− | | |
− | /*
| |
− | *
| |
− | */
| |
− | int tabuleiro[LINHAS][COLUNAS];
| |
− | | |
− | void conta(int x, int y) {
| |
− | | |
− | }
| |
− | | |
− | int main(int argc, char** argv) {
| |
− | int i, j;
| |
− | | |
− | // zerar todas as posições do tabuleiro !
| |
− | for (i=0; i < LINHAS; i++) {
| |
− | for (j=0; j < COLUNAS; j++) {
| |
− | tabuleiro[i][j] = 0;
| |
− | }
| |
− | }
| |
− | | |
− | // Colocar as minas aqui !!!
| |
− | | |
− | // Contar as minas vizinhas
| |
− | for (i=0; i < LINHAS; i++) {
| |
− | for (j=0; j < COLUNAS; j++) {
| |
− | conta(i,j);
| |
− | }
| |
− | }
| |
− | | |
− | //Agora mostrar o tabuleiro que foi gerado
| |
− | | |
− | //i indica a linha, j a coluna
| |
− | for (i=0; i < LINHAS; i++) {
| |
− | // O while abaixo mostra todas as colunas da linha "i"
| |
− | for (j=0; i < COLUNAS; j++) {
| |
− | if (tabuleiro[i][j] == 10) {
| |
− | printf("* ");
| |
− | } else {
| |
− | if (tabuleiro[i][j] == 0) {
| |
− | printf(" ");
| |
− | } else {
| |
− | if ((tabuleiro[i][j] >= 1) && (tabuleiro[i][j] <= 8)) {
| |
− | printf("%d ", tabuleiro[i][j]);
| |
− | }
| |
− | }
| |
− | }
| |
− | }
| |
− | printf("\n");
| |
− | }
| |
− | | |
− | return (EXIT_SUCCESS);
| |
− | }
| |
− | </syntaxhighlight>
| |
− | | |
− | ==== Condições e operadores lógicos ====
| |
− | | |
− | * Maiores detalhes na [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c360.html apostila da UFMG]
| |
− | | |
− | Obs: cada condição em linguagem C deve ser envolvida por parênteses.
| |
− | | |
− | Necessários para expressar condições a serem usadas principalmente com ''if'' e ''while''.
| |
− | | |
− | {| border="1" cellpadding="2"
| |
− | !Portugol
| |
− | !C
| |
− | !Exemplo
| |
− | |-
| |
− | |E||&&|| <syntaxhighlight lang=c>
| |
− | if ((x >= 0) && (x <= 9)) {
| |
− | printf("coordenada x é válida\n");
| |
− | }</syntaxhighlight>
| |
− | |-
| |
− | |OU||<nowiki>||</nowiki>||<syntaxhighlight lang=c>if ((x < 0) || (x > 9)) {
| |
− | printf("coordenada x é inválida\n");
| |
− | }</syntaxhighlight>
| |
− | |-
| |
− | |NAO||!||<syntaxhighlight lang=c>if (!((x < 0) || (x > 9))) {
| |
− | printf("coordenada x é válida\n");
| |
− | }</syntaxhighlight>
| |
− | |-
| |
− | |}
| |
− | | |
− | === Uma versão alternativa para a contagem de minas ===
| |
− | | |
− | A versão abaixo foi criada pela Marine e Nathany. Apesar de parecida com o [[SOP-2010-2-sobral#A_contagem_de_minas|algoritmo proposto pelo professor]], possui uma diferença importante que a torna mais eficiente.
| |
− | | |
− | [[imagem:Conta-minas-nathany-marine.png|320px]]
| |
− | | |
− | == 29/11: Pensando no jogo completo ... ==
| |
− | | |
− | * Continuando [[SOP-funcoes|funções]]: variáveis locais e globais, escopo de variáveis.
| |
− | | |
− | === Escondendo as casas não pisadas ===
| |
− | | |
− | No momento você deve já conseguir mostrar todo o tabuleiro, porém no jogo apenas as casas já pisadas devem ser reveladas. Pense em como modelar o seu tabuleiro de forma a esconder as casas ainda não pisadas.
| |
− | | |
− | Opções:
| |
− | # '''''Criar uma matriz de controle:''''' cada casa dessa nova matriz informa se a casa correspondente do tabuleiro está revelada. Por exemplo, se a casa (1,2) na matriz de controle tiver o valor 0 (zero), então a casa (1,2) do tabuleiro está escondida, e se tiver o valor 1, a casa (1,2) do tabuleiro está revelada.
| |
− | # '''''Explorar os códigos numéricos das casas:''''' os códigos numéricos das casas do tabuleiro poderiam ser estendidos para informar se uma casa está escondida ou revelada. Por exemplo, se o código de uma casa for menor do que 100, ela está escondida, caso contrário está revelada. Assim, se casa (1,2) tiver o valor 3, significa que possui 3 minas vizinhas porém ainda está escondida, e se tiver o valor 103 significa que possui 3 minas vizinhas e já está revelada.
| |
− | | |
− | == 30/11: Pensando no jogo completo ... ==
| |
− | | |
− | * Continuando [[SOP-funcoes|funções]]: variáveis locais e globais, escopo de variáveis.
| |
− | * [[SOP-stdio|Entrada de dados pelo teclado]]
| |
− | | |
− | === Organizando o programa ===
| |
− | | |
− | Nesse momento seu programa deve estar ficando comprido, e já começando a se mostrar difícil de ler. Para torná-lo organizado e compreensível, deve ser reorganizado usando [[SOP-funcoes|funções]]:
| |
− | | |
− | <syntaxhighlight lang=c>
| |
− | void inicia_tabuleiro() {
| |
− | }
| |
− | | |
− | void mostra_tabuleiro(int tudo) {
| |
− | }
| |
− | | |
− | int main() {
| |
− | // cria o tabuleiro, pondo as minas e contando as minas vizinhas de
| |
− | // cada casa
| |
− | inicia_tabuleiro();
| |
− |
| |
− | // Mostra o tabuleiro que foi criado
| |
− | // O argumento da função serve para forçar a mostrar todas as casas
| |
− | // (mesmo as escondidas), ou mostrar somente as reveladas.
| |
− | // Se for 1, mostra todas as casas.
| |
− | // Se for 0, mostra somente as reveladas.
| |
− | mostra_tabuleiro(1);
| |
− | }
| |
− | </syntaxhighlight>
| |
− | | |
− | === Retomando o laço principal do jogo ... ===
| |
− | | |
− | Como apresentado na [[SOP-2010-2-sobral#O_la.C3.A7o_principal_do_jogo_...|aula de 08/11]], o jogo funciona com um laço principal, que lê as coordenadas da casa a ser pisada ou marcada e atualiza o tabuleiro apropriadamente:
| |
− | | |
− | Note que nesse laço devem-se contabilizar quantas minas foram realmente descobertas - o que não corresponde necessariamente a quantas minas foram marcadas ... A quantidade de minas descobertas é necessária para decidir se o jogo já acabou.
| |
− | | |
− | [[imagem:Fluxo-Campo-Minado.png|400px]]
| |
− | | |
− | A leitura das coordenadas deve ser feita usando a função [[SOP-stdio#Explorando_scanf_para_ler_dados_do_teclado|scanf]].
| |
− | | |
− | === Pisando e marcando casas ===
| |
− | | |
− | O jogador pode pisar em uma casa. Ao pisar em uma casa com mina, o jogador perde e o jogo acaba. Se pisar em uma casa com minas vizinhas, o jogo revela a contagem de minas vizinhas daquela casa. Mas se a casa pisada não tiver minas vizinhas, o jogo deve revelar todas as casas vizinhas na mesma condição, até o limite de casas que possuem minas vizinhas. Na figura abaixo, pisou-se na casa que está sob o ponteiro do ''mouse''. Note que todas as casas ao redor também foram reveladas, até alcançarem-se casas que têm minas vizinhas.
| |
− | | |
− | [[imagem:Minas-pisadas.png]]
| |
− | | |
− | Pense em como ''abrir'' as casas vazias em torno da casa pisada ...
| |
− | | |
− | O jogador pode também marcar uma casa, indicando que acredita ter ali uma mina. Essa casa continua escondida, porém deve ser mostrado que possui uma bandeira, como mostrado na figura abaixo. Se o jogador descobrir todas as minas, o jogo termina com sua vitória. Como se podem representar essas bandeiras no tabuleiro ?
| |
− | | |
− | [[imagem:Casas-marcadas.png]]
| |
− | | |
− | == 06/12: Pensando no jogo completo ... ==
| |
− | | |
− | Uma vez criado o [[SOP-2010-2-sobral#Retomando_o_la.C3.A7o_principal_do_jogo_...|laço principal do jogo]], em que se lêem coordenadas de casas a serem pisadas até que o jogo termine, faltam alguns refinamentos. São eles:
| |
− | # Ao pisar numa casa que não possui minas vizinhas, devem-se abrir todas as casas adjacentes até encontrar casa que possuam minas vizinhas.
| |
− | # Devem-se contabilizar as minas descobertas (casas marcadas), pois se todas as minas tiverem sido marcadas o jogo termina com vitória do jogador.
| |
− | | |
− | === Abrindo casas que não possuem minas vizinhas ===
| |
− | | |
− | Ao se pisar em uma casa que não possui minas vizinhas, devem-se abrir recursivamente as casas adjacentes até encontrar casa com minas vizinhas. As figuras a seguir mostram como seria a abertura das casas (em vermelho a casa a ser aberta, e em hachurado as casas adjacentes):
| |
− | | |
− | [[imagem:Abre-1.png]]<br><br>
| |
− | ''Início: abrindo a casa pisada e testando as casas adjacentes''
| |
− | | |
− | | |
− | | |
− | [[imagem:Abre-2.png|300px]]<br>
| |
− | ''Aplicando a abertura de casa à cada casa adjacente''
| |
− | | |
− | | |
− | | |
− | [[imagem:Abre-3.png|300px]]<br>
| |
− | ''Novamente aplicando a abertura de casa às casas adjacentes ...''
| |
− | | |
− | | |
− | O algoritmo que faz essa abertura de casas pode ser expresso da seguinte forma (note a recorrência, quando o algoritmo chama si próprio):
| |
− | | |
− | | |
− | [[imagem:Abre-casas.png|275px]]
| |
− | | |
− | === Mostrando o tempo decorrido ===
| |
− | | |
− | Para mostrar o tempo de jogo decorrido, devem-se contabilizar quantos segundos passaram desde que o jogo começou. Assim, deve-se ler o relógio do computador no início do jogo, e a cada vez que se precisar mostrar o tempo de jogo. Para ler o relógio pode-se usar a função [http://manpages.ubuntu.com/manpages/lucid/en/man2/time.2.html time] (já usada no [[SOP-2010-2-sobral#D.C3.BAvidas_sobre_random.28.29|algoritmo para colocar minas aleatoriamente]]). A contagem de quantos segundos se passaram se resume portanto a ler o relógio e subtrair o valor do relógio lido no início do programa, como no exemplo abaixo:
| |
− | | |
− | <syntaxhighlight lang=c>
| |
− | #include <time.h>
| |
− | #include <stdio.h>
| |
− | | |
− | int main() {
| |
− | time_t inicio;
| |
− | time_t agora;
| |
− | | |
− | inicio = time(NULL);
| |
− | | |
− | // faz alguma coisa
| |
− | | |
− | agora = time(NULL);
| |
− | | |
− | printf("Já passaram %d segundos desde o inicio deste programa ...\n", agora - inicio);
| |
− | }
| |
− | </syntaxhighlight>
| |
− | | |
− | Além de contar o tempo de jogo decorrido, é necessário mostrá-lo em um formato claro para o jogador. Isso quer dizer, mostrar o tempo na forma ''"horas:minutos:segundos"'' ao invés de simplesmente a contagem de segundos. Por exemplo, se já transcorreram 143 segundos, deve-se mostrar ''"00:02:23"''. Para converter a contagem de segundos para esse formato você pode aproveitar o algoritmo de conversão de tempo proposto em um [[SOP-2010-2-sobral#Atividade_5|exercício de Lógica de Programação]]. Para formatar o horário como indicado, você pode conferir a [[SOP-stdio|explicação sobre printf]].
| |
− | | |
− | === Tópico sobre linguagem C: caracteres e strings ===
| |
− | | |
− | Caracteres (tipo de dados '''''char''''') seguem a codificação [http://pt.wikipedia.org/wiki/ASCII ASCII].
| |
− | | |
− | ''Strings'' são o equivalente ao tipo ''Texto'' do Portugol.
| |
− | | |
− | * [[SOP-strings|Strings]]: um texto introdutório
| |
− | * Ver também: [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c500.html capítulo sobre ''strings'' no curso da UFMG].
| |
− | | |
− | ==== Para fixar ====
| |
− | | |
− | # Faça um programa que mostre a tabela ASCII: cada caractere com seu correspondente código numérico.
| |
− | # Escreva um programa que leia separadamente o nome e o sobrenome de uma pessoa, e em seguida mostre-os da seguinte forma na tela: ''sobrenome, nome''.
| |
− | # Escreva um programa para resolver a questão 2 da [[SOP-2010-1-sobral#12.2F05:_2a_avalia.C3.A7.C3.A3o|2a avaliação]].
| |
− | # Escreva um programa que leia uma palavra do teclado, e em seguida mostre-a em ordem invertida.
| |
− | # Faça um programa que leia uma palavra do teclado, e em seguida converta-a para maiúsculas.
| |
− | # Faça um programa para ler uma frase do teclado, e contar quantas palavras nela existem.
| |
− | | |
− | == 07/12: Pensando no jogo completo ==
| |
− | | |
− | '''ATENÇÃO: preparar para apresentar o projeto na próxima 2a feira (13/12)'''
| |
− | | |
− | | |
− | === Tópicos em linguagem C: estruturas de dados (criação de novos tpos de dados) ===
| |
− | | |
− | * [[SOP-struct|Introdução a estruturas de dados em C]]
| |
− | * [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/cb00.html Capítulo sobre estruturas de dados no curso da UFMG]
| |
− | | |
− | == 13/12: Últimos ajustes ... ==
| |
− | | |
− | == 14/12: Apresentação ==
| |
− | | |
− | | |
− | Na próxima semana, na 3a feira (14/12), vocês deverão apresentar os projetos sobre o campo minado. A apresentação será individual, em que entrevistarei cada aluno sobre sua participação no trabalho. Assim, se na entrevista for demonstrado que o aluno teve participação ativa no desenvolvimento do programa e domina o entendimento de como ele funciona, então receberá o conceito dado ao trabalho. Se não mostrar que entende como ele funciona, então ficará com conceito D e terá que fazer a prova de recuperação.
| |
− | | |
− | Para avaliar o trabalho, irei conferir se:
| |
− | | |
− | # O jogo funciona como especificado (ver [[SOP-2010-2-sobral#Retomando_o_la.C3.A7o_principal_do_jogo_...|laço principal do jogo na Wiki]]):
| |
− | ## O tabuleiro é criado e inicializado corretamente
| |
− | ## O tabuleiro é apresentado na tela conforme especificado na wiki (linhas como números e colunas como letras, grade, casas escondidas, reveladas ou marcadas com bandeiras)
| |
− | ## O programa lê as coordenadas de casas fornecidas pelo jogador, e executa corretamente a ação solicitada (pisar ou marcar), além de conferir se as coordenadas são válidas
| |
− | ## O jogo termina se uma mina for pisada, e nesse caso revelando todas as casas do tabuleiro
| |
− | ## O jogo termina se o jogador descobrir todas as minas: se as únicas casas não reveladas forem exatamente as casas com minas que podem estar marcadas ou não com bandeiras)
| |
− | ## Se ao pisar numa casa sem minas vizinhas, as casas adjacentes são reveladas recursivamente até encontrar casas que tenham minas vizinhas.
| |
− | # O programa está organizado e estruturado com funções
| |
− | | |
− | | |
− | Ítens extras, que são opcionais e aumentarão o conceito final da disciplina se forem feitos, são:
| |
− | | |
− | * Mostrar o tempo de jogo decorrido sempre que for ler novas coordenadas do jogador ([[SOP-2010-2-sobral#Mostrando_o_tempo_decorrido|ver na wiki dicas de como fazer]])
| |
− | * Ter níveis de dificuldade do jogo:
| |
− | ** ''Fácil:'' tabuleiro 10 x 10 com 10 minas
| |
− | ** ''Médio:'' tabuleiro 15 x 15 com 15 minas
| |
− | ** ''Difícil:'' tabuleiro 20 x 20 com 30 minas
| |
− | | |
− | A prova de recuperação será dia 20/12 (2a feira), e terá ao menos quatro questões sobre programação em linguagem C a serem resolvidas em laboratório. Essa prova terá que ser resolvida iniciando às 7:30 e terminando no máximo às 10:30 h.
| |
− | | |
− | == Conceitos do projeto ==
| |
− | | |
− | {| border="1" cellpadding="2"
| |
− | !Aluno
| |
− | !Conceito
| |
− | |-
| |
− | |Fernando || C
| |
− | |-
| |
− | |Gabriel || D*
| |
− | |-
| |
− | |Levi || D*
| |
− | |-
| |
− | |Lindalvo || C
| |
− | |-
| |
− | |Marcos || A
| |
− | |-
| |
− | |Marine || D
| |
− | |-
| |
− | |Mario Allan || A
| |
− | |-
| |
− | |Mário André || A
| |
− | |-
| |
− | |Mário Sérgio || D
| |
− | |-
| |
− | |Maykon || B
| |
− | |-
| |
− | |Nathany || D
| |
− | |-
| |
− | |Paulo Igor || D*
| |
− | |-
| |
− | |Ricardo || D
| |
− | |-
| |
− | |Roberto || D*
| |
− | |-
| |
− | |Thiago Martins || D*
| |
− | |-
| |
− | |Thiago Ramos || D*
| |
− | |-
| |
− | |Vinicius Kachniacz || D*
| |
− | |-
| |
− | |Vinicius Rodrigues || D
| |
− | |-
| |
− | |}
| |
− | | |
− | ''Obs: D* = não apresentou o projeto (desistente)''
| |
− | | |
− | == 20/12: Recuperação ==
| |
− | | |
− | A prova de recuperação terá ao menos quatro questões sobre programação em linguagem C a serem resolvidas em laboratório. Essa prova terá que ser resolvida iniciando às 7:30 e terminando no máximo às 10:30 h. Essa prova será a mesma para quem precisar recuperar Lógica de Programação.
| |
− | | |
− | *[http://www.sj.ifsc.edu.br/~msobral/SOP/avaliacoes/rec-2010-2.pdf Prova de recuperação]
| |