PRG-2011-1-sobral

Introdução à Programação - 2011-1

Informações gerais

Professor: Marcelo Maia Sobral
Email: msobral@gmail.com
Skype: mm-sobral
Lista de email (forum): prg-ifsc@googlegroups.com
Atendimento paralelo: 4a feira 10:00 - 11:30 h, 5a feira 8:00 - 9:30 h e 13:30 - 15:30 h (no Laboratório de Desenvolvimento de Tele)
Reavaliação (recuperação): no final do semestre
IMPORTANTE: o direito de recuperar uma avaliação em que se faltou somente existe mediante justificativa reconhecida pela coordenação. Assim, deve-se protocolar a justificativa no prazo de 48 horas, contando da data e horário da avaliação, e aguardar o parecer da coordenação. O não cumprimento desse procedimento implica a impossibilidade de fazer a recuperação, e assim a reprovação na disciplina.

• Plano da disciplina
• Ementa e bibliografia

Softwares

Será usado como plataforma de estudo o sistema operacional Ubuntu Linux 10.04 LTS ou posterior. Para obtê-lo há essas opções:

1. Trazer um CD-R virgem para que eu faça a cópia aqui no IFSC
2. Fazer o download por conta própria (aprox. 700 MB)
3. Usar uma máquina virtual do VirtualBox já preparada por mim (menos recomendado, pois o Linux roda mais lento)
   • Trazer um DVD-R ou pendrive com ao menos 4 GB livres.
   • Instalar o VirtualBox em seu computador para executar a máquina virtual

ATENÇÃO: é muito importante que se providencie o quanto antes a instalação do Ubuntu em seu computador. Sem ele você não poderá fazer os exercícios sugeridos, o que atrapalhará seu aproveitamento na disciplina ! O bom andamento do estudo depende muito de não deixar acumular o conteúdo e os exercícios. Acostume a criar uma rotina de estudo, procurando resolver os problemas apresentados e procurando o professor (ou contatando-o por email) para tirar dúvidas.

Referências adicionais

• Diário de aula do Prof. Tiago Semprebom
• Antiga página da disciplina (2009-2)
• Valle, Odilson Tadeu. Gerência de Redes. IFSC - Unidade São José. 2009. (ver capítulos 1 a 9)
• Ubuntu Documentation
• Guia Foca Linux (iniciante)
• Apostila sobre Lógica de Programação
• Demais referências contidas na página principal de SOP.

Aulas

16/03: Introdução

Apresentação da disciplina: plano de ensino, avaliação, abordagem pedagógica.

Assunto: Lógica de programação

Referências auxiliares:

• Apostila auxiliar, escrita pelo prof. Paulo Sérgio de Moraes.
• Ver transparências.

Um primeiro algoritmo

Videos sobre algoritmos:

• Resolvendo o cubo de Rubik (cubo mágico)
  • Cópia desse vídeo aqui no Ifsc
• Outro algoritmo ...

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:

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 ?

Leitura adicional

• História dos algoritmos
• Uma definição de algoritmos na Wikipedia

17/03: Algoritmos

Para criar algoritmos, deve-se primeiro entender o que são instruções e sequências lógicas;

O jogo LightBot mostra de uma forma divertida como criar pequenos algoritmos. Nesse jogo o robô deve se movimentar de acordo com uma sequência de instruções elementares definidas pelo jogador. Apesar de sua simplicidade, ele pode se tornar bastante desafiador ! Até que fase desse jogo você consegue chegar ?

Desenhando figuras geométricas

1. Scratch é um software educacional para ajudar no ensino de matemática, geometria e introdução à programação. Com ele pequenos programas podem ser escritos de foram visual, com instruções representadas por blocos que se encaixam como Lego. Ele possibilita fazer desenhos facilmente, seguindo um programa com instruções de desenho. Use-o para desenhar estas figuras:
   • triângulo equilátero
   • triângulo isósceles
   • quadrado
   • hexágono
   • quadrado com vértices interligados
   • Um círculo

• Agora tente algo mais avançado:
  • Desenhe um triângulo equilátero, porém perguntando na tela qual o tamanho do lado.
  • repita o desenho do triângulo, porém fazendo-o lentamente: espere 1 segundo após desenhar cada lado do triângulo.
  • Faça com que um pequeno traço se movimente de um lado a outro do palco.
  • Faça com que um pequeno traço se movimente em círculo indefinidamente.
  • Faça com que uma bola role pela horizontal. Insira quatro raios na bola para ajudar no efeito visual de movimento.

Atividade para casa

Faça as figuras geométricas indicadas na aula !

23/03: Começando os primeiros algoritmos ...

Algoritmo é uma sequência lógica de instruções, a qual possui um início e um fim.

Sequência lógica é uma sequência correta de instruções capaz de gerar o resultado esperado.

A escrita ou projeto de algoritmos se faz com:

• Estruturas de controle: comandos que modificam uma sequência de instruções
• Estruturas de dados: dados (valores) usados e modificados durante a execução do algoritmo.

Para introduzir esses conceitos, nada melhor que um pequeno projeto ...

Projeto: um jogo muito simples

Você conhece o jogo clássico Space Invaders ?

Pros padrões atuais esse é um jogo muito simples. Você conseguiria reproduzi-lo, mesmo que simplificado, no Scratch ? Ele poderia começar assim:

1. O robô se movimenta na horizontal, comandado pelas teclas seta pra direita e seta pra esquerda.
2. O helicóptero se movimenta de um lado a outro constantemente, refletindo nas bordas.
3. Ao teclar espaço, um tiro sai do robô em direção ao topo do palco
4. Se o tiro acertar o helicóptero, o jogo termina.

O que você precisa para fazer esse jogo ?

1. Movimento do helicóptero.
2. Movimento do robô comandado pelo teclado.
3. Acionamento do tiro.
4. Detecção se o tirou acertou o helicóptero.

Mãos à obra !

24/03: Introduzindo algoritmos: variáveis e expressões

Variáveis são usadas em algoritmos para guardar dados. Dados podem ser:

• Números inteiros ou reais
• Letras ou textos
• Valores lógicos (booleanos)
• ... e outros que vocês descobrirão futuramente !

Uma variável possui um identificador, que nada mais é que seu nome. No Scratch as variáveis são criadas e podem ser modificadas com os comandos categorizados em Variáveis (comandos laranjas):

Variáveis podem ser globais ou locais:

• Globais: são visíveis e podem ser usadas por qualquer objeto do Scratch.
• Locais: são visíveis e podem ser usadas somente pelo objeto do Scratch ao qual está vinculada.

Variáveis podem ser usadas em qualquer comando que precise de um valor numérico, como por exemplo o comando para mover um certo número de passos. No exemplo abaixo, um programa faz com que um objeto desenhe um triângulo no palco, sendo que o comprimento do lado do triângulo é informado pelo usuário.

Variáveis podem ser usadas em expressões aritméticas, que realizam algum cálculo com valores numéricos. No Scratch expressões são criadas combinando-se os blocos contidos em Operadores(blocos verdes-claros):

Usando esses blocos podem-se calcular novos valores usando variáveis ou constantes. Por exemplo, um pequeno programa que desenha um polígono qualquer precisa calcular o ângulo de quina da figura dependendo de sua quantidade de lados:

Usando esses conceitos sobre variáveis e expressões, faça as atividades a seguir.

Pong

Outro jogo clássico chamado Pong mostrava uma bola que refletia em uma parede, voltando e devendo ser interceptada por uma pequena base (que funcionava como raquete) comandada pelo jogador. Se conseguir interceptá-la, a bola é refletida de novo em direção à parede oposta, continuando assim o jogo. Se falhar, o jogo termina. Esse é considerado o primeiro videogame lucrativo a ter sido criado ...

Tente fazer uma versão do Pong usando o Scratch, mas com duas pequenas modificações. Há apenas uma base, que fica no canto inferior do palco. O placar conta quantas vezes a bola tocou o chão (i.e. o jogador falhou em interceptá-la), e se chegar a 0 o jogo termina. A segunda modificação é uma aceleração gradual da bola, que deve deve aumentar de velocidade a cada 5 segundos de jogo.

Para que serão necessárias variáveis nesse jogo ?

O problema da reflexão da bola na barra

Em aula vimos que para fazer a reflexão da bola com a barra deve-se calcular o ângulo de reflexão. No caso da barra estar na horizontal, esse ângulo deve ser calculado assim:

$NovaDirecao=180^{0}-Direcao$

No Scratch isso deve ser feito combinando-se o comando "Aponte para direção" e uma expressão para calcular a nova direção. A direção atual do objeto está contida em sua variável local direção (predefinida nos comandos de Movimentos):

Uma outra versão do Pong

Em uma outra versão ainda encontrada, no canto superior há um conjunto de alvos que devem ser acertados pela bola. Quando se acertarem todos os alvos o jogo termina.

Para casa: um jogo de sinuca

Para exercitar o uso de variáveis vamos criar também um jogo de sinuca. Nesse jogo deve-se usar a bola branca para encaçapar uma outra bola colorida. As bolas se movimentam de forma natural, desacelerando gradualmente devido ao atrito com a mesa. Quando as bolas colidem, suas velocidades e direções se modificam, dependendo de seus valores anteriores e do ângulo de colisão. Quando as bolas batem nos cantos das mesas, devem ser refletidas. Como as bolas predem velocidade gradualmente, dependendo de suas velocidades iniciais e das colisões em algum momento irão fatalmente parar. As caçapas ficam nos dois cantos superiores do palco. Você notará que sem o uso de variáveis, não será possível criar esse jogo, ainda mais se quiser acrescentar mais alguns detalhes.

As tacadas se fazem com um taco representado por uma linha reta, cuja ponta sempre está colada à bola branca. A direção do taco pode ser controlada pelo mouse ou por teclas direita e esquerda. Para fazer uma tacada, deve-se pressionar a tecla seta pra baixo durante um tempo, e então soltá-la. Quanto mais tempo se pressionar essa tecla mais forte será a tacada, e assim mais veloz a bola branca vai disparar. Assim, para realizar tacadas com pouca velocidade deve-se pressionar a tecla seta pra baixo por pouco tempo, e para tacadas mais fortes, em que a bola branca dispara com grande velocidade, deve-se pressionar essa tecla por um tempo maior. Pode-se usar algum objeto e colocá-lo na lateral do palco para informar qual a potência da tacada a ser realizada.

Alguns dados serão necessários para calcular as movimentações das bolas:

• Peso de cada bola: 100 g
• Diâmetro das bolas: 8 cm
• Desaceleração das bolas devido ao atrito com a mesa: $0.1~m/s^{2}$
• Velocidade mínima de tacada: 0 m/s
• Velocidade máxima de tacada: 4 m/s

30/03: Algoritmos: Usando variáveis, expressões e estruturas de decisão

Estruturas de decisão: blocos de controle usados quando devem-se executar comandos somente se uma determinada condição for verdadeira. Por exemplo, no jogo Pong a bola deve ser refletida se tocar na barra controlada pelo jogador:

Esse tipo de estrutura de decisão se chama Se condição então faça algo. Como indica sua descrição, uma ou mais instruções serão executadas caso a condição seja verdadeira. No exemplo acima, a condição é tocando em barra, e as instruções executados caso isso seja verdade são aponte para a direção 180-direção.

No exemplo do tiro ao helicóptero, inspirado no jogo Space invaders, o jogo deveria terminar quando o tiro acertasse o alvo. Assim, as instruções para término do jogo precisavam estar dentro de uma estrutura Se condição então ..., como mostrado abaixo:

Para ilustrar o uso de Se condição então ..., e o teste de condições em geral, hoje serão feitos dois projetos:

1. A continuação do jogo Pong, em que a bola deve acertar alvos no topo da tela. Além disso, se a bola tocar no chão mais que 3 vezes o jogador perde.
   • Uma versão inicial do jogo Pong
2. Um cronômetro a ser visualizado no palco.

31/03: Algoritmos: ainda estruturas de decisão e também de repetição

Por diversas vezes criaram-se programas no Scratch em que o comportamento de um objeto corresponde a repetir uma sequência de comandos. Por exemplo, cada alvo no topo da tela no jogo Pong deve sumir quando for tocado pela bola:

Assim, ele deve sempre testar se a bola o está tocando, e quando isso acontecer ele deve desaparecer e contabilizar que há uma alvo a menos para ser acertado. Como esse teste deve ser feito repetidamente até que a bola o acerte, torna-se necessário usar uma estrutura de repetição. No caso do Scratch, usou-se o comando Sempre, que faz com que todos os comandos nele contidos sejam executados indefinidamente (no caso, até que a bola toque o alvo). Além dessa parte do programa, o teste se todos os alvos foram acertados também implica a repetição de uma sequência de comandos.

No jogo, a bola deve se movimentar pelo palco, refletindo nas paredes e sendo rebatida pela barra até que todos os alvos tenham sido acertados. Portanto, os comandos que implicam controlar seu movimento devem se repetir seguidamente até que essa condição de término seja alcançada. O comportamento da bola pode desta forma ser descrito simplificadamente pelos comandos mostrados abaixo, em que se usa a variável bananas para indicar quantos alvos faltam para serem acertados. A repetição foi obtida com o comando repita até bananas=0, e dessa forma a repetição se interrompe quando a variável bananas tiver o valor 0.

Um terceiro exemplo diz respeito à criação de um cronômetro. Uma variável pode ser decrementada uma vez por segundo, até que o cronômetro zere. Um exemplo de como fazer isso segue abaixo:

Como se vê, estruturas de repetição são muito úteis para repetir sequências de comandos. Existem estruturas de repetição incondicionais, que repetem indefinidamente (como o comando sempre do Scratch), e condicionais, que repetem enquanto determinada condição for verdadeira ou até que determinada condição se verifique (ex: comando repita até). Com elas se evita que programas sejam desnecessariamente longos ... na verdade sem elas seriam inviáveis muitos tipos de programas !

Atividade

1. Adicione o cronômetro na tela do seu jogo Pong. O cronômetro deve ser composto de dois dígitos.
2. O Pong poderia ficar mais difícil se os alvos fossem móveis e fugissem da bola. Assim, quando sentisse a bola se aproximando um alvo poderia acelerar ou reduzir sua velocidade, visando evitar uma colisão. Modifique então o Pong para que os alvos movam na horizontal de uma lado para o outro, e evitem a colisão com a bola.

06/04: Portugol

Trabalho: deve-se entregar o jogo Pong com o cronômetro, conforme especificado na última aula sobre Scratch.

'Prazo de entrega: 14/04/2011

---

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 Portugol, desenvolvido na Escola Superior de Engenharia do Instituto Politécnico de Tomar, em Portugal.

• 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.

1. Faça o download do Portugol.
2. Descompacte-o com o seguinte comando:

   tar xzf portugol23.tar.gz
   

3. Repare que existe agora um subdiretório portugol no diretório onde você o descompactou. Execute o Portugol com o seguinte comando:

   java -jar portugol/Portugol.jar
   

   Obs: você precisará ter Java instalado. Caso não o tenha, execute o comando:

   sudo apt-get install openjdk-6-jre
   

4. Copie esse arquivo para poder ver fluxogramas coloridos, e grave-o no memso diretório onde está o Portugol.
5. Veja a ajuda do Portugol, e use-a sempre que tiver dúvidas !

A tela inicial do Portugol segue abaixo, junto com um programa demonstrativo.

Exemplos de programas iniciais em Portugol:

1. Lendo um número e mostrando-o na tela em seguida:

   Inicio
     inteiro x
   
     Escrever "Digite um numero: ",
     Ler X
     Escrever "Numero digitado: ", x
   Fim
   

2. Lendo dois números, somando-os e mostrando o resultado na tela:

   Inicio
     inteiro x, y
   
     Escrever "Digite um numero: ",
     Ler x
     Escrever "Digite outro numero: ",
     Ler y
     Escrever "Soma = ", x+y
   Fim
   

   O programa abaixo é equivalente:

   Inicio
     inteiro x, y, z
   
     Escrever "Digite um numero: ",
     Ler x
     Escrever "Digite outro numero: ",
     Ler y
     z <- x + y
     Escrever "Soma = ", z
   Fim
   

Atividades

1. Média de três números: escreva um programa para calcular a média de três números.
2. Média balanceada de três números: escreva um programa para calcular a média balanceada de três números.
3. Sequência de Fibonacci: em matemática corresponde aos números:

   1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
   

   ... que pode ser descrita pela relação de recorrência
   
   $F_{n}=F_{n-1}+F_{n-2}$
   
   ... com valores iniciais $F_{0}=1$ e $F_{1}=1$.
   
   Numerosas formas na natureza apresentam essa sequência, como neste girassol (cujas flores se dispõem em uma espiral):
   
   
   
   Usando o Portugol escreva um programa que mostre os 10 primeiros números dessa sequência.
4. 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.

13/04: Algoritmos

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:

  Inicio
    inteiro anos, dias
  
    Escrever "Quantos anos se passaram ? "
    Ler anos
    dias <- anos * 365
    Escrever "... então se passaram ", dias, " dias"
  Fim
  

  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:

  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
  

  Nesse exemplo há uma constante: diasPorAno

Variáveis e constantes devem ser declaradas antes de serem usadas (algumas poucas linguagens, como Python e 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:

  constante inteiro diasPorAno <- 365
  inteiro anos, dias
Fim

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:

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 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:

# 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)

Os resultados de expressões podem ser mostrados na tela, ou armazenados em variáveis:

# 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)

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:

segundos <- 3600*horas + 60*minutos + segundos

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:

Real x, area, lado
inteiro dias, horas

Operador	Descrição	Exemplo
+	Adição	x <- x + 1
-	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:

escrever 1 + 2 * 3
escrever (1 + 2)*3

No Portugol, existem também algumas funções úteis, como a função raiz:

r <- raiz(x^2 + y^2)

O resultado de expressões aritméticas depende dos tipos numéricos das variáveis e constantes:

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

Atividade

Para os exercícios abaixo, escreva o algoritmo no Portugol.

1. Faça um algoritmo que, usando somente duas variáveis, calcule a média de quatro números.
2. Escreva um algoritmo que calcule as raizes de uma equação de 2o grau.
3. 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.

   inicio
     inteiro h,m,s
   
     escrever "Quantos segundos mostrou o equipamento ? "
     ler s
     
     h <- s /3600
     s <- s % 3600   // s <- s - h*3600
     m <- s /60
     s <- s % 60 // s <- s - m*60
     
     escrever h, ":", m, ":", s
     
   fim
   

14/04: Variáveis e expressões

Continuação ...

Exercícios

1. 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.
2. 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):

    Nome: [sobrenome, nome]
    Idade: [idade] anos
   

3. A função exponencial $f(x)=e^{x}$ pode ser calculada por uma série de Taylor:
   $f(x)\approx 1+x+{\frac {x^{2}}{2}}+{\frac {x^{3}}{6}}+...+{\frac {x^{n}}{n!}}$
   Faça um algoritmo para calcular o valor desta função.

16/04: 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.

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:

  Se pontuacao > recorde então 
    recorde <- pontuação
  FimSe

O exemplo em Portugol acima mostra a estrutura de decisão Se condição entao comandos Fimse. O equivalente em fluxograma é:

Veja o próximo exemplo:

  Se conceito > 70 entao
    escrever 'Voce esta aprovado'
  senao
    escrever 'Desta vez não deu ... tente de novo !'
  Fimse

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 é:

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:

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

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.

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.

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

1. Faça um programa que leia um número e então informe se ele é par ou ímpar.
2. 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.
     
     Escreva um algoritmo que calcule a multa de acordo com a velocidade de um veículo.
3. Faça um algoritmo que leia três números do teclado, e mostre o maior e menor números.
4. Escreva um algoritmo que faça o teste de risco de paciente cardíaco, mostrado no início da aula.
5. 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.
6. 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
     Escreva um algoritmo que informe se um acesso foi permitido, em função do horário e do tipo de usuário.
7. 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
8. 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.
9. 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.
10. 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

inicio
  texto cor1, cor2, cor3
  inteiro cont <- 0
    
  ler cor1
  ler cor2
  ler cor3
  
  se cor1 = "preto" ou cor2 = "preto" ou cor3 = "preto" entao
    cont <- cont + 1
  fimse

  se cor1 = "azul" ou cor2 = "azul" ou cor3 = "azul" entao
    cont <- cont + 1
  fimse

  se cor1 = "vermelho" ou cor2 = "vermelho" ou cor3 = "vermelho" entao
    cont <- cont + 1
  fimse
        
  se cont > 1 entao
    escrever "verdadeiro"
  senao
    escrever "falso"
  fimse
fim

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.

Fluxograma para o algoritmo da média de trẽs números.

Blocos de uso mais comum

Bloco	Descrição	Exemplo
	Inicio do fluxograma
	Processamento
	Entrada de dados (ler do teclado)
	Saída de dados (mostrar na tela)
	Decisão (testar uma condição e bifurcar)
	Conector (juntar dos ou mais ramos do fluxograma)
	Fim

Obs: Arquivo de configuração das cores do fluxograma do Portugol.

20/04: estruturas de decisão

Há situações em que se precisa fazer um conjunto de comparações, como mostrado abaixo:

// 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

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:

// 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

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:

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

Atividades

1. 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).
2. 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).
3. 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:
   
   
   Faça um algoritmo que forneça uma estimativa da previsão do tempo usando essa tabela.
4. 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 é 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 calendário Gregoriano):
   1. De 400 em 400 anos é ano bissexto.
   2. De 100 em 100 anos não é ano bissexto.
   3. De 4 em 4 anos é ano bissexto.
      Solução vista em aula: (sem considerar anos bissextos):

27/04: Estruturas de decisão

Exercícios

1. 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.
2. 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.
3. Escreva um programa que leia cinco números do teclado e mostre os dois maiores números.
4. Faça um programa que leia o nome de um usuário e sua senha, e em seguida informe se o acesso foi concedido ou negado. Os usuários possíveis de entrar são "joao", "maria" e "zé".
5. Jogo de Pedra, papel e tesoura: nesse jogo cada jogador faz sua escolha, e vence aquele que escolher um objeto que seja capaz de vencer o outro:
   • Tesoura corta papel
   • Pedra quebra tesoura
   • Papel embrulha a pedra
     Faça um algoritmo que pergunte ao usuário o objeto escolhido, e em seguida faça o computador escolher o seu próprio objeto (dica: use o gerador de números aleatórios visto no jogo do par ou ímpar). Finalmente o algoritmo deve informar o vencedor.

28/04: 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:

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

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:

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

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:

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

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:

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:

  enquanto contador < NUMEROS faz  
    escrever "Avaliação ", contador, ":"
    ler m
    media <- media + m
    contador <- contador + 1
  fimEnquanto

---

Um outro exemplo ainda mais simples é mostrar na tela uma contagem numérica:

inicio
    inteiro contador
    contador <- 0

    enquanto contador < 10 faz
        escrever contador , " "
        contador <- contador + 1
    fimenquanto
fim

Ao executar esse algoritmo, tem-se como resultado:

0 1 2 3 4 5 6 7 8 9

Seu fluxograma está mostrado a seguir:

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:

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

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:

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

O fluxograma desse algoritmo segue abaixo:

Atividades

1. Escreva um algoritmo que mostre a tabuada de um número fornecido pelo teclado. Esse número deve estar entre 1 e 10.
2. Aproveite o algoritmo anterior para mostrar a tabuada de todos os números entre 1 e 10.
3. Modifique o exemplo da média para que a quantidade de números a serem lidos seja previamente informada pelo teclado.
4. 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, ...)

     inicio
         inteiro n <- 0 , n1 , n2, mmc
         
         escrever "Primeiro numero : "
         ler n1
         escrever "Segundo numero : "
         ler n2
         
         // descobre o mmc de n1 e n2
         se n1 > n2 entao
           mmc <- n1
         senao
           mmc <- n2
         fimse
         
         enquanto mmc % n1 =/= 0 OU mmc % n2 =/= 0 faz
            mmc <- mmc + 1
         fimenquanto
         
         // mostra os multiplos de mmc que sejam <= 1000
         enquanto n <= 1000 faz
             escrever "\n " , n
             n <- n + mmc
         fimenquanto
     fim
     

5. 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
6. 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

     inicio
         inteiro n1 , n2, mdc
      
         escrever "Primeiro numero : "
         ler n1
         escrever "Segundo numero : "
         ler n2
      
         // descobre o mmc de n1 e n2
         se n1 > n2 entao
           mdc <- n2
         senao
           mdc <- n1
         fimse
     
         enquanto mdc > 1 E NAO (n1 % mdc = 0 E n2 % mdc = 0) faz
            mdc <- mdc - 1
         fimenquanto
       
         escrever "MDC=", mdc
     fim
     

7. Escreva um algoritmo que leia até 10 números do teclado, e informe ao final qual o maior e o menor deles.
8. Escreva um algoritmo que teste se um número informado pelo teclado é primo.
9. Aproveite o algoritmo do ítem anterior para mostrar todos os números primos menores que 1000.
10. 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).
11. 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.
12. 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).
13. 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.
14. Faça um algoritmo para descobrir os dois maiores números dentre 6 números lidos do teclado.
15. Faça um algoritmo para converter um número entre 0 e 16777215 para sua representação em hexadecimal.
16. 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/05: Estruturas de repetição

Resolução de exercícios (continuando aula anterior).

05/05: Estruturas de repetição

Continuando a resolução de exercícios ...

Uma pequena avaliação

Resolva o seguinte problema em 15 minutos:

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.

inicio
  inteiro m1, m5, m10, m25, m50
  inteiro moeda 
  inteiro n
    
  enquanto n < 10 faz
    escrever "Moeda: "
    ler moeda
    
    escolhe moeda 
      caso 1:
        m1 <- m1 + 1
      caso 5:
        m5 <- m5 + 1
      caso 10:
        m10 <- m10 + 1
      caso 25:
        m25 <- m25 + 1
      caso 50:
        m50 <- m50 + 1
      defeito:
        escrever "Valor invalido ...\n"
        n <- n - 1
    fimescolhe
    n <- n + 1
  fimenquanto

  escrever "Moedas de 1 centavo: ", m1
  escrever "\nMoedas de 5 centavos: ", m5
  escrever "\nMoedas de 10 centavos: ", m10  
  escrever "\nMoedas de 25 centavos: ", m25
  escrever "\nMoedas de 50 centavos: ", m50
fim

11/05: Estruturas de repetição

Variáveis multidimensionais

Em matemática existem matrizes e vetores, que são variáveis multidimensionais. Por exemplo, uma matriz 2 x 2 (2 linhas e 2 colunas) pode ser:

$A={\begin{pmatrix}1&6\\3&5\end{pmatrix}}$

Vetores são matrizes unidimensionais, portanto possuem somente uma linha ou uma coluna:

$v={\begin{pmatrix}1&6&2&18&5\end{pmatrix}}$

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:

$A={\begin{pmatrix}A_{11}&A_{12}\\A_{21}&A_{22}\end{pmatrix}}$

... e o vetor v do exemplo:

$v={\begin{pmatrix}v_{1}&v_{2}&v_{3}&v_{4}&v_{5}\end{pmatrix}}$

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:

inicio
  inteiro A[2][2] <- {{1, 6}, {3, 5}}
  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

A declaração da matriz se faz como uma variável comum, porém indicando-se suas dimensões:

  inteiro A[2][2] <- {{1, 6}, {3, 5}}

Veja que 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:

  # índice 0,0
  escrever "Valor de A[0][0]: ", A[0][0], "\n"

O exemplo acima pode ser reescrito usando-se estruturas de repetição:

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

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:

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

Outro problema comum é precisar guardar um conjunto de valores, e depois ordená-los:

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

Atividades

1. Escreva um algoritmo que leia 5 números do teclado, e depois mostre-os em ordem inversa à que foi digitada.
2. Escreva um algoritmo que leia dois vetores de 5 números, e depois mostre se os vetores são iguais.
3. 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.
4. Escreva um algoritmo que leia 5 números, e mostre-os em ordem crescente.
5. Modifique o algoritmo anterior para mostrá-los em ordem decrescente.
6. 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.

12/05: 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:

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

Atividades

1. Escreva o algoritmo para comparar dois vetores, porém usando a estrutura para.
2. 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.
3. Modifique o algoritmo acima para mostrar todas as ocorrências do vetor menor dentro do maior.
4. Modifique o algoritmo do anterior para remover todas as ocorrências do vetor menor dentro do maior.
5. Resolva o problema do bingo usando a estrutura para

18/05: Revisão

...exercícios

Resolver a avaliação de 2010-2:

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.

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.

... mais algumas questões interessantes:

5) Filtro: Um programa possui 10 números inteiros em um vetor. No entanto, para a próxima etapa de processamento apenas os números entre 3 e 8 são válidos. Escreva um algoritmo que remova os números inválidos do vetor. Ao final o vetor deve conter somente os números válidos.

6) Tabuleiro: Escreva um programa que mostre o conteúdo de uma matriz 4 x 4 na tela. Essa matriz contém valores inteiros que podem ser positivos ou negativos. Ao mostrar cada valor da matriz, deve-se seguir a seguinte regra:

• Valor negativo: deve ser mostrado um espaço em branco
• Valor entre 1 e 8: mostrar o próprio valor
• Valor acima de 8: mostrar o caractere H

Além disso, a matriz deve ser mostrada com uma grade. Por exemplo, a matriz com conteúdo:

$A={\begin{pmatrix}1&6&10&-1\\3&5&-1&-1\\10&4&-1&5\\3&-1&1&-1\\\end{pmatrix}}$

... que em Portugol seria declarada assim:

inteiro A <- {{1, 6, 10, -1}, {3, 5, -1, -1}, 
              {10, 4, -1, 5}, {3, -1, 1, -1}}

... deveria ser mostrada da seguinte forma:

..| 1 | 2 | 3 | 4 |
-------------------
A | 1 | 6 | H |   |
-------------------
B | 3 | 5 |   |   |
-------------------
C | H | 4 |   | 5 |
-------------------
D | 3 |   | 1 |   |
-------------------

Quer dizer, as colunas devem ser identificadas por seus números, e as linhas devem ser identificadas pelas letras A, B,C, D.

Linguagem C: Projeto final

19/05: Introdução à linguagem C

• Baseado no Guia Básico de C.
• Para provocar: Teach Yourself Programming in Ten Years
• Apostila adotada: Curso de Linguagem C - Engenharia Elétrica - UFMG
• Ver transparências
• Alguns textos escritos por mim sobre tópicos específicos da linguagem C:
  • Strings
  • Funções
  • Entrada e saída padrão
  • Arquivos
  • Estruturas de dados

Obs: durante as aulas usaremos o 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:

1. Faça o download do instalador. Salve-o em algum subdiretório.
2. Abrindo um terminal, entre no subdiretório onde está o instalador e execute esse comando:

   bash netbeans-6.8-ml-cpp-linux.sh
   

   • Caso o instalador falhe porque não encontrou a JVM (Máquina Virtual Java), instale-a com esse comando:

     sudo apt-get install -y sun-java6-jdk
     

3. Aceite as opções de instalação sugeridas pelo instalador.
4. Ao final da instalação, o Netbeans 6.8 estará acessível pelo menu Aplicativos -> Programação.
5. 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

Obs: para compilar um programa você deve salvá-lo em um arquivo com extensão .c. Por exemplo, ao editar o exemplo abaixo, você pode gravá-lo no arquivo hello.c. Em seguida você deve compilá-lo usando o seguinte comando:

gcc hello.c -o hello

Para executá-lo, faça assim:

./hello

O arquivo que contém o programa em linguagem C se chama arquivo de código-fonte. O arquivo que contém o programa compilado se chama arquivo de código-objeto.

• O clássico Hello World!

#include <stdio.h>

int main(int argc, char *argv[])
{
	printf("Alô mundo!\n");
}

• Mostrando mensagens de na tela: puts e printf:

  #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;
  }
  

• Lendo dados do teclado: scanf

  #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;
  }
  

  • Outras formas de ler do teclado: getchar, fgets

Tipos de dados

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"; char palavra[16];
logico	qualquer tipo (valor 0 = Falso, qualquer outro valor = Verdadeiro)	int ok = 1; char teste = 0;

Comandos/funções e Estruturas de controle

Portugol	C	Exemplo
inteiro n, m escrever "Ola, mundo!\n" escrever "valor de n: ", n, "\n" escrever "valor de n: ", n, ", e valor de x: ", x, "\n"	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);
inteiro n ler n	int n; scanf("%d", &n);
se condição então //comandos fimse	if (condição) { //comandos }
se condição então //comandos senão //comandos fimse	if (condição) { //comandos } else { //comandos }
escolhe expressão caso valor1: //comandos caso valor2: //comandos defeito: //comandos fimescolhe	switch (expressão) { case valor1: //comandos case valor2: //comandos default: //comandos }
enquanto condição faz //comandos fimenquanto	while (condição) { //comandos }
para variavel de inicio ate fim passo incremento //comandos proximo	for (variavel=inicio; variavel <= fim; variavel++) { //comandos }

Atividades

• Traduza para C os seguintes algoritmos Portugol:

  1. Inicio
       inteiro x, y
      
       Escrever "Digite um numero: ",
       Ler x
       Escrever "Digite outro numero: ",
       Ler y
       Escrever "Soma = ", x+y
     Fim
     

  2. Inicio
       inteiro x, y, z
      
       Escrever "Digite um numero: ",
       Ler x
       Escrever "Digite outro numero: ",
       Ler y
       z <- x + y
       Escrever "Soma = ", z
     Fim
     

  3. 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
     

  4. Inicio
       inteiro anos, dias
      
       Escrever "Quantos anos se passaram ? "
       Ler anos
       dias <- anos * 365
       Escrever "... então se passaram ", dias, " dias"
     Fim
     

  5. 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
     

  6. 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
     

  7. 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
     

  8. 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
     

  9. 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
     

  10. 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
      

  11. 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
      

  12. 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
      

  13. 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
      

  14. inicio
          inteiro n , fat
          ler n
          fat <- 1
          enquanto n > 1 faz
             fat <- fat * n
             n <- n - 1         
          fimenquanto
          
          escrever "Fatorial=" , fat
      fim
      

  15. 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
      

  16. 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
      

  17. // 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
      

25/05: Avaliação

No laboratório ...

• Prova

Prova resolvida

1) Um programa em uma estação meteorológica converte os valores lidos de um higrômetro para um indicativo de umidade do ar. A tabela de conversão segue abaixo:

Valor do higrômetro	Indicativo de umidade
0 a 0.3	muito baixa
0.3 a 0.5	baixa
0.5 a 0.8	normal
0.8 a 1	alta
1	precipitação

Escreva esse programa, que deve simular a leitura do higrômetro pelo teclado e mostrar o indicativo de umidade na tela.

inicio
    real h
    
    escrever " digite um valor de 0 a 1:  " , 
    ler h
    
    se h = 1 entao
        escrever "chuva" ,
    senao
        se h <= 0.3 entao
            escrever "umidade muito baixa" ,
        senao
            se h <= 0.5 entao
                escrever "umidade baixa" ,
            senao
                se h <= 0.8 entao
                    escrever "umidade normal"
                senao
                    se h < 1 entao
                        escrever "umidade alta"
                        
                    fimse
                fimse
            fimse
        fimse
    fimse
fim

2) Um programa possui o seguinte vetor de inteiros guardado em memória:

{10,12,7,4,5,9,2,3,1,3,4,2,2,9}

Esse programa deve ler uma sequência de 4 números pelo teclado, e procurá-la dentro do vetor que está em memória. Se a sequência for encontrada, a posição em que ela inicia dentro do vetor deve ser mostrada.

inicio
  inteiro numeros[14] <- {10,12,7,4,5,9,2,3,1,3,4,2,2,9}
  inteiro v[4]
  inteiro i, j
  
  Escrever "Digite 4 numeros inteiros:"
  para i de 0 ate 3 passo 1
    ler v[i]
  proximo
  
  para j de 0 ate 10 passo 1
    i <- 0
    enquanto i < 4 E v[i] = numeros[j+i] faz
      i <- i + 1
    fimenquanto
    se i = 4 entao
      escrever "Encontrou na posicao ", j
      fim
    fimse
  proximo
  escrever "Nao encontrou em nenhuma posicao"
fim

3) Um número primo é um número divisível somente por 1 ou por si mesmo. Quer dizer, se tentar dividi-lo por qualquer valor maior que 1 e menor que esse número, o resto será diferente de zero. Exemplos de números primos são 2, 3, 5, 7 e 11. Escreva um programa que leia um número pelo teclado e informe se ele é primo.

inicio
    inteiro numero , n

    escrever "Forneça um número: "
    ler numero

    n <- 2   
    enquanto n <= numero / 2 E resto =/= 0 faz       
        resto <- numero % n
        n <- n + 1
    fimenquanto
    
    se resto = 0 entao
        escrever "nao primo: divisivel por " , n - 1
    senao
        escrever "primo"
    fimse
fim

... uma versão com uma pequena melhoria:

inicio
    inteiro numero, n, resto

    escrever "Forneça um número: "
    ler numero

    
    resto <- numero % 2
    se resto =/= 0 entao
      n <- 1
      enquanto n <= numero / 2 E resto =/= 0 faz       
          n <- n + 2
          resto <- numero % n
      fimenquanto
      
      se resto = 0 entao
          escrever "nao primo: divisivel por " , n
      senao
          escrever "primo"
      fimse
    senao
      escrever "nao primo: divisivel por 2"
    fimse
fim

4) Jogo de Pedra, papel e tesoura: nesse jogo cada jogador faz sua escolha, e vence aquele que escolher um objeto que seja capaz de vencer o outro:

* Tesoura corta papel
* Pedra quebra tesoura
* Papel embrulha a pedra

Faça um algoritmo que pergunte ao usuário o objeto escolhido, e em seguida faça o computador escolher o seu próprio objeto (dica: use o gerador de números aleatórios visto no jogo do par ou ímpar). Ao final o algoritmo deve informar o vencedor.

inicio
    inteiro lancecomputador , lancejogador
    logico jogadorvenceu
    
    escrever "Escolha papel (1) , pedra (2) ou tesoura (3): "
    ler lancejogador
    se lancejogador > 3 ou lancejogador < 1 entao
        escrever "Lance inválido !!! (deve digitar um número entre 1 e 3)\n\n"
    senao
        lancecomputador <- 1 + 2 * aleatorio ( )
        escrever "Computador escolheu: " , lancecomputador , "\n"
        se lancejogador = lancecomputador entao
            escrever "Empate !\n\n"
        senao
          jogadorvenceu <- falso
          escolhe lancejogador
              caso 1:
                  se lancecomputador = 2 entao
                      jogadorvenceu <- verdadeiro
                  fimse
              caso 2:
                  se lancecomputador = 3 entao
                      jogadorvenceu <- verdadeiro
                  fimse
              caso 3:
                  se lancecomputador = 1 entao
                      jogadorvenceu <- verdadeiro
                  fimse
          fimescolhe
          escrever "Vencedor: "
          se jogadorvenceu entao
              escrever "jogador\n\n"
          senao
              escrever "computador\n\n"
          fimse
      fimse
    fimse
fim

... uma outra solução:

inicio

   inteiro lancecomputador , lancejogador
   logico jogadorvenceu
   texto vencedor , opcao
   
   escrever "Jogo de Papel , Pedra e Tesoura\n\n"
   escrever "Escolha papel (1) , pedra (2) ou tesoura (3): "
   ler lancejogador
   se lancejogador > 3 ou lancejogador < 1 entao
       escrever "Lance inválido !!! (deve digitar um número entre 1 e 3)\n\n"
   senao
       lancecomputador <- 1 + 2 * aleatorio ( )
       escrever "Computador escolheu: " , lancecomputador , "\n"
       se lancejogador = lancecomputador entao
           escrever "Empate !\n\n"
       senao
           escrever "Vencedor: "
           // repare em como se determina o vencedor nesta versao do jogo: a condicao abaixo
           // é verdadeira sempre que o lance do jogador estiver uma unidade atrás do computador:
           //
           // Jogador     Computador
           //    1             2
           //    2             3
           //    3             1 (nesta última preciso considerar que a contagem é circular)
               
           se (lanceJogador%3 + 1) = lanceComputador entao
               escrever "jogador\n\n"
           senao
               escrever "computador\n\n"
           fimse
       fimse
   fimse

fim </syntaxhighlight>

5) Um programa somente pode ser usado por usuários autorizados. Os usuários e seuas senhas estão armazenados em uma tabela dentro do próprio programa. Escreva o algoritmo desse programa que pede o usuário e senha pelo teclado, consulta a tabela de usuários e depois informa se o acesso foi concedido ou negado. Os usuários e respectivas senhas estão mostrados abaixo:

Usuário	Senha
joao	tainha
maria	pirao
maneca	onibus
bilica	bilro

Obs: essa tabela pode ser modificada futuramente, então o algoritmo deve conseguir trabalhar com quaisquer usuários e senhas que ali sejam armazenados. Isso é, mesmo que essa tabela tenha seu conteúdo alterado, o algoritmo não pode ser modificado.

inicio
  texto usuarios <- {"joao", "maria", "maneca", "bilica"}
  texto senhas <- {"tainha", "pirao", "onibus", "bilro"}
  texto login, umaSenha
  inteiro i
  logico OK <- falso
  
  escrever "Usuario:"
  ler login
  
  escrever "Senha:"
  ler umaSenha
  
  enquanto i < 4 E nao OK faz
    ok <- usuarios[i] = login
    i <- i + 1
  fimenquanto

  se ok entao
    ok <- senhas[i] = umaSenha
  fimse
  
  se ok entao
    escrever "acesso concedido"
  senao
    escrever "acesso negado"
  fimse
  
fim

Conceitos

Legenda:

• T: questão correta
• P: questão parcialmente correta
• N: questão incorreta ou em branco

Aluno	Conceito	Questão 1	Questão 2	Questão 3	Questão 4	Questão 5
Alfredo	D	T (mas não da forma mais eficiente)	N	N	N	N
Ângelo	D	T (mas não da forma mais eficiente)	N	P	N	N
Beatriz	D	N	N	P (primos somente menores que 12)	N	N
Bruno da Silva	D	N (erros de sintaxe)	N	T	N (copiado de um exemplo do professor)	N
Bruno	D	N	N	N	N	N
Caroline	D	T	N	N	N	N
Danilo	B	T (mas não da forma mais eficiente)	T (mas não da forma mais eficiente)	N (idêntico ao do Gabriel)	T	T (mas não da forma mais eficiente)
Dayze	D	N	N	N	N	N
Fabiana	C	T (mas não da forma mais eficiente)	P	N	T	N
Felipe	C	T	N	N	P (computador deveria jogar)	P (funciona só pra 4 contas)
Gabriel	D	T (mas não da forma mais eficiente)	N	N (idêntico ao do Danilo)	N	P (funciona só pra 4 contas)
Grazielle	D	N	N	N	N	N
Jayson	D	N	N	N	N	P (funciona só pra 4 contas)
Juliano	C	T (mas não da forma mais eficiente)	N	N	T	P (funciona só pra 4 contas)
Leandro	D	T (mas não da forma mais eficiente)	N	N	N	N
Leonardo	D	P (condições trocadas)	N	N	P (não indica o vencedor)	N

26/05: Começo do projeto

Para referência: apostila online sobre linguagem C.