PRG-2011-1-tiago

De MediaWiki do Campus São José
Ir para: navegação, pesquisa

Índice

Instrutor

Professor: Tiago Semprebom
Email: tisemp@ifsc.edu.br
Atendimento paralelo: 4a feira 14:30h - 15:30h e 5a feira 14:30h - 15:30h (Lab. de Desenvolvimento de Tele)

Lógica de Programação

16/03: Introdução

  • Tópicos: instrução, sequência, problemas do dia a dia.
  • Páginas da apostila: 4 a 7.

17/03: Resolução de exercícios

  • Resolução de exercícios propostos aos alunos na aula do dia 06/09
  • Apresentação dos trabalhos de Conclusão de Curso CST Telecomunicações (TCCII) - Auditório Campus São José

23/03: Desenvolvendo algoritmos

  • Tópicos: resolvendo problemas, linguagens e instrução disponíveis (vocabulário).
  • Páginas da apostila: 8 a 11.

Exemplificando com shell scripts:

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

Videos sobre algoritmos:

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:

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 LightBot mostra de uma forma divertida como criar pequenos algoritmos. Até que fase desse jogo você consegue chegar ?

Exercícios: desenho de figuras geométricas

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

reset forward X turnright angulo turnleft angulo </syntaxhighlight> ... escreva algoritmos para desenhar as seguintes figuras:

    • triângulo equilátero
    • triângulo isósceles
    • triângulo escaleno
    • quadrado
    • hexágono
    • octógono
    • 7 hexágonos interligados (um central e seis periféricos).

24/03: Desenvolvendo 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 ?

Lightbot.png

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

Scratch.png


  • Agora tente algo mais avançado:

Projeto: um jogo muito simples

Você conhece o jogo clássico Space Invaders ?

Spaceinvaders.jpg


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

Jogo1-scratch.gif


  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

Em nosso projeto sugerido na última aula (com data de entrega para amanhã, dia 31/03) foi necessário armazenar a posição do robô antes de disparar o tiro em direção ao helicóptero, na aula de hoje veremos o que são variáveis e para que servem.

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

Scratch-var1.png

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.

Scratch-var2.png


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


Scratch-operadores1.png


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:


Scratch-operadores2.png


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

Pong1.jpg


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:

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


Scratch-reflexao.png

31/03: Algoritmos

  1. 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:
    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)
    
    ... escreva programas para os 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


Guia de referência completo do Kturtle


Kturtle.png


Atividade para casa

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

Koch0.png
Primeira iteração

Koch1.png
Segunda iteração

Koch2.png
Terceira iteração

Koch3.png
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: fonte dessas figuras

Dicas para o kturtle

  1. Pode-se repetir uma sequência de instruções usando-se o comando repeat. Por exemplo, para desenhar um pentágono usando repeat:
    repeat 5 {
      forward 50
      turnleft 72
    }
    
  2. Podem-se usar variáveis para generalizar os algoritmos. Uma variável tem um identificador, que deve ser precedido do caractere $:
    $x=5
    $lado=50
    repeat $x {
      forward $lado
      turnleft 360/$x
    }
    
  3. Pode-se usar o comando ask para ler do teclado valores a serem usados no algoritmo de desenho:
    $x = ask "Quantos lados tem o polígono ?"
    $lado = ask "Qual o comprimento de cada lado ?"
    repeat $x {
      forward $lado
      turnleft 360/$x
    }
    
  4. Por fim, com o comando learn é possível criar novos comandos no kturtle. Por exemplo, para criar um comando que desenhe um triângulo:
    learn triangulo $lado {
     repeat 3 {
      forward $lado
      turnleft 120
     }
    }
    

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:

learn triangulo $lado {
 repeat 3 {
  forward $lado
  turnleft 120
 }
}
triangulo 50
triangulo 100
triangulo 100

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.

06/04: Pseudocódigo e diagrama de blocos (fluxograma)

  • Adoção do Portugol IDE como ferramenta didática.
  • Páginas da apostila: 12 a 14.

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

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.

Editor-Portugol.png

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



    ... com valores iniciais e .

    Numerosas formas na natureza apresentam essa sequência, como neste girassol (cujas flores se dispõem em uma espiral):

    Sunflower.jpg Espiral fibonacci.png FibonacciBlocks.png

    Usando o Portugol escreva um programa que mostre os 10 primeiros números dessa sequência.

07/04: Fluxogramas, constantes e Variáveis

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


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


Blocos de uso mais comum

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

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

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 begin_of_the_skype_highlighting 2 147 483 647 end_of_the_skype_highlighting begin_of_the_skype_highlighting 2 147 483 647 end_of_the_skype_highlighting begin_of_the_skype_highlighting 2 147 483 647 end_of_the_skype_highlighting 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.

Atividade

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

  1. Faça um algoritmo que calcule a média de quatro números, porém mostrando as casas decimais (caso existam).
  2. Escreva um algoritmo que mostre, em sequência: 9, 9^2 (ao quadrado), 9^3 (ao cubo) e a soma desses 3 números.
  3. Escreva um algoritmo que leia o nome, sobrenome e idade de uma pessoa, e escreva na tela:
    sobrenome, nome
    idade anos
    

13/04: Algoritmos

  • Exemplo de um algoritmo simples, onde após calculado os valores de entrada de um usuário, apresenta-se os valores na tela. Observe a declaração de variáveis e constantes, além dos comentários e identação do código portugol:

inicio

   //declaração das variáveis
   texto nome<-"", sobrenome<-"", endereco<-""
   inteiro ano<-0, idade<-0
   constante inteiro ano_atual <- 2010
   caracter sexo<-"X"
   //área de leitura de valores
   escrever "Informe o Nome: "
   ler nome
   escrever "Informe o Sobrenome: "
   ler sobrenome
   escrever "Informa o endereço: "
   ler endereco
   escrever "Informe o ano de nascimento: "
   ler ano
   escrever "Informe o sexo (M ou F): "
   ler sexo
   //calcula idade
   idade <- (ano_atual - ano)


   //Mostra valores
   escrever "\n ****** Dados Pessoais ******"
   escrever "\nNome Completo: ", nome, " ",sobrenome
   escrever "\nEndereço: ", endereco
   escrever "\nAno de Nascimento: ", ano
   escrever "\nIdade: ", idade
   escrever "\nSexo: ", sexo

fim </syntaxhighlight>

  • Solução do exercício das poltronas no cinema:

inicio

   // variaveis
   inteiro ncadeira <- 0 , fila <- 0 , cadeira <- 0 , calculo <- 0
   // area de leitura
   escrever "informe o número de sua cadeira:\n"
   ler ncadeira
   // area de calculo
   fila <- ( ncadeira / 20 ) + 1
   cadeira <- ( ncadeira % 20 )
   // mostrar valores
   escrever "Fila: " , fila
   escrever "\nCadeira: " , cadeira

fim </syntaxhighlight>

Desenvolvimento de algoritmos

Escreva um algoritmo utilizando a ferramenta Portugol para cada uma das questões abaixo:

1. Calcular a quantidade dinheiro gasta por um fumante. Dados: o número de anos que ele fuma, o nº de cigarros fumados por dia e o preço de uma carteira.

2. Ler dois números inteiros, x e y, e imprimir o quociente e o resto da divisão inteira entre eles.

3. Que informe a área e o volume de um cilindro.

4. Para ler dois valores reais do teclado, calcular e imprimir na tela: a) A soma destes valores b) O produto deles c) O quociente entre eles

5. Que gere o preço de um carro ao consumidor e os valores pagos pelo imposto e pelo lucro do distribuidor, sabendo o custo de fábrica do carro e que são pagos: a) de imposto: 45% sobre o custo do carro; b) de lucro do distribuidor: 12% sobre o custo do carro.

6. Ler os três coeficientes de uma equação de segundo grau e determinar suas raízes.

7. Imprimir a tabuada de qualquer número n, informado pelo usuário.

14/04: Expressões lógicas e aritméticas

Expressão aritmética: 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

Atividades

  1. Escreva um algoritmo que calcule a raiz de uma equação de 1o grau.
  2. Escreva um algoritmo que calcule as raízes de uma equação de 2o grau. Assuma que existam duas raízes reais
  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.
  4. Faça um algoritmo que converta um número decimal para sua representação binária. Assuma que o número decimal tenha até dois dígitos.
  • Resolução do exercício 2:
inicio
    real va , vb , vc , x1,delta,x2 <- 0.0
    escrever "Digite um valor para A: "
     ler va
    escrever "Digite um valor para B: "
    Ler vb
    escrever "Digite um valor para C: "
    Ler vc
    
    escrever "Sua equação é: " ,va,"x^2+",vb,"x+",vc, "=0\n"
    delta <- (vb ^ 2) - (4*va*vc)
    escrever delta ,"\n"
     x1 <- ((-vb) + (raiz(delta))) / (2*va)
    Escrever " x ' = " , x1
    x2 <- ((-vb) - (raiz(delta))) / (2*va)
    Escrever "\n x '' = " , x2
fim

16/04: Estruturas de decisão

Isso mesmo aula no sábado (das 8h:30m às 11h:30m)

Páginas da apostila: 26 a 31.

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 acima mostra a estrutura de decisão Se condição entao comandos Fimse. 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.

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

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

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

Operador Descrição Exemplo
NAO Negação baixo <- NOT (altura > 1.8)
E Conjunção aprovado <- NOT (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.

20/04: Exercícios estruturas de decisão

Atividades para serem desenvolvidas:

  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. 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.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 ? Escreva um algoritmo que faça o teste de risco de paciente cardíaco de um paciente, conforme descrito acima.

  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. 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:
    • Funcionário: apenas entre 0:00 e 7:30, entre 18:30 e 0:00, e entre 12:00 e 13:30
    • Financeiro: qualquer horário
    • 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.
  3. Modifique o algoritmo acima para adicionar a seguinte restrição:
    • Funcionário: não pode acessar sites de jornal (ex: www.rbs.com.br)
    • Financeiro: não pode acessar sites de jornal durante o expediente
    • Diretoria: sem restrições a sites
  4. 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.
  5. 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.
  6. 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

Solução Exercício 3:

inicio
    inteiro num<-0,maior<-0,menor<-0, i<-0
    constante inteiro valores<-2 //declaração da constante
    
    escrever "Digite um valor: \n"
    ler num
    maior <- num
    menor <- num
    para i de 1 até valores passo 1
        ler num
        se (num > maior) então
            maior <- num
        fimse
        se (num < menor) então 
            menor <- num
        fimse
    proximo
    escrever "O maior valor digitado é: ", maior
    escrever "\n"
    escrever "O menor valor digitado é: ", menor
fim

Solução Exercício 6:

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

21/04: Exercícios estruturas de decisão

  • Feriado Nacional - Tiradentes

27/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
                        se mes = 12 entao
                            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:
    Previsao-barometro.png

    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 4 em 4 anos é ano bissexto.
    2. De 100 em 100 anos não é ano bissexto.
    3. De 400 em 400 anos é ano bissexto.
    4. Prevalecem as últimas regras sobre as primeiras.
  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. Escreva um programa que leia cinco números do teclado e mostre os dois maiores números.
  7. 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é".
  8. 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, segue exemplo de como utilizar a função abaixo). Finalmente o algoritmo deve informar o vencedor.

Abaixo um exemplo de como utilizar a função aleatório.
A variável valor armazena um número inteiro entre 1 e 10 a cada execução do programa

inicio
    inteiro valor <- 0
    
    valor <- aleatorio()*10+1
    escrever "O valor gerado eh: ", valor
fim

04/05: Estruturas de repetição

Páginas da apostila: 32 a 35.

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

A estrutura de repetição junto com a sequência de instruções a ser repetida é comumente chamada de 'laço. Assim, no algoritmo acima 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

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

Solução do problema proposto em sala

inicio

   inteiro opcao <- 0
   real numero1 <- 0 , numero2 <- 0 , resultado <- 0
   enquanto opcao =/= 5 faz
       escrever "\n Entre com a opção desejada: 1- Adição; 2- Subtração; 3- Multiplicação; 4- Divisão , 5- Sair."
       ler opcao
       se opcao = 5 entao
           escrever "\n Você saiu com sucesso!"
       senao
           escrever "\n Lembre-se: Na subtração e na divisão a ordem dos números é importante!"
           escrever "\n Entre com o primeiro número: "
           ler numero1
           escrever "\n Entre com o segundo número: "
           ler numero2
           se opcao = 1 entao
               resultado <- ( numero1 + numero2 )
               escrever "\n A soma dos dois números é: " , resultado
           fimse
           se opcao = 2 entao
               resultado <- ( numero1 - numero2 )
               escrever "\n A subtração dos dois números é: " , resultado
           fimse
           se opcao = 3 entao
               resultado <- ( numero1 * numero2 )
               escrever "\n O produto dos dois números é: " , resultado
           fimse
           se opcao = 4 entao
               se numero2 = 0 entao
                   escrever "\n Não existe divisão por 0 (zero)."
               senao
                   resultado <- ( numero1 / numero2 )
                   escrever "\n A divisão dos dois números é: " , resultado
               fimse
           fimse
           se ( opcao =/= 1 e opcao =/= 2 ) e ( opcao =/= 3 e opcao =/= 4 ) entao
               escrever "\n Esta operação não está definida."
           fimse
       fimse
   fimenquanto
fim

</syntaxhighlight>

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. Modifique o exemplo da média para que a quantidade de números a serem lidos seja previamente informada pelo teclado.
  3. 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).
  4. 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.
  5. Escreva um algoritmo que leia até 10 números do teclado, e informe ao final qual o maior e o menor deles.
  6. Escreva um algoritmo que teste se um número informado pelo teclado é primo.

05/05: Estruturas de repetição

  • Resolução de exercícios
  • Introdução a variáveis multidimencionais

Uma pequena avaliação :-)

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.

Quando concluir o teste, chame o professor!

Boa Sorte

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 3 x 3 (3 linhas e 3 colunas) pode ser:

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

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:

... e o vetor v do exemplo:

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 M[3][2];
  inteiro v[5] <- {1, 6, 2, 18, 5}
  inteiro i, j

  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}}
  inteiro M[3][2];

Exemplo de preenchimento e impressão de matrizes não quadradas

inicio
	inteiro i,j, mat[2][4]
    
      //leitura (preenchimento da matriz)
      para i de 0 ate 1 passo 1
          para j de 0 ate 3 passo 1
              ler mat[i][j]
          proximo
      proximo
      
      //impressão da matriz
      para i de 0 ate 1 passo 1
          para j de 0 ate 3 passo 1
              escrever "O valor na linha: ",i, "Coluna: ", j, "eh: ", mat[i][j]
              escrever "\n"
          proximo
      proximo
fim

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:

  # í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], " 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


12/05: Estruturas de repetição (exercícios)

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

18/05: Revisão para avaliação de Lógica de Programação

1. Crie um programa que lê três inteiros e informa VERDADEIRO se apenas o maior deles é par ou se o menor deles é ímpar ou informa FALSO em caso contrário.

2. Desenvolva um programa que recebe do usuário o placar de um jogo de futebol (os gols de cada time) e informa se o resultado foi um empate, a vitória do primeiro time ou do segundo time.

3. Elabore um programa que recebe do usuário três cadeias de caracteres e informa VERDADEIRO se há pelo menos duas diferentes cadeias iguais aos valores 'azul', 'preto'ou 'vermelho' ou FALSO em caso contrário. Exemplos: {'azul', 'preto', 'branco'} é VERDADEIRO; {'azul', 'roxo', 'azul'} é FALSO; {'preto', vermelho', 'vermelho'} é VERDADEIRO.

4. Tendo-se como dados de entrada a altura e o sexo de uma pessoa, construa um algoritmo que calcule seu peso ideal, utilizando as seguintes fórmulas:

    • para homens: (72,7 * h) – 58;
    • para mulheres: (62,1 * h) – 44,7.

5. Escrever um algoritmo, que leia um conjunto de 23 dados, cada um, contendo o peso e o código do sexo ("F" ou "M") dos alunos de uma classe, calcule e imprima:

    • Maior e o menor peso da turma;
    • A média de peso dos homens;
    • A média de peso da turma;


19/05: Revisão Lógica de Programação, com respostas ;)

1. Desenvolver um programa que efetue a leitura de 5 elementos de uma matriz A do tipo vetor. Construir uma matriz B de mesmo tipo, observando a seguinte lei de formação: Se o valor do índice for par, o valor deverá ser multiplicado por 5, sendo ímpar deverá ser somado por 5. Ao final mostrar os conteúdos das duas matrizes.

inicio

     //declaração dos vetores A e B

inteiro i,a[5],b[5]

     //formação do vetor A
     para i de 0 ate 4 passo 1
         ler a[i]
     proximo
     
     //guarda valor na posição par
     para i de 0 ate 4 passo 2
         b[i]<-a[i]*5
     proximo
     
     //guarda valor na posição ímpar
     para i de 1 ate 4 passo 2
         b[i]<-a[i]+5
     proximo
     
     //apresenta valor B resposta
     escrever "Formação do vetor B (vetor respota):"
     escrever "\n"
     
     para i de 0 ate 4 passo 1
         escrever "O valor da posição ",i, " é: ", b[i]
         escrever "\n"
     proximo

fim </syntaxhighlight>


2. Desenvolver um programa que efetue a leitura de 5 elementos de uma matriz A do tipo vetor. No final, apresente o total da soma de todos os elementos que sejam ímpares.


inicio

   //declaração das variáveis
   inteiro a [5] , i , soma <- 0
   //entrada de dados
   para i de 0 ate 4 passo 1
       ler a [i]
   proximo
   //construindo a matriz "B"
   para i de 0 ate 4 passo 1
       se ( a [i] % 2 =/= 0 ) entao
           soma <- soma + a [ i ]
       fimse
   proximo
   //impressão dos dados
   escrever "O valor da soma dos numero ímpares é: " , soma

fim </syntaxhighlight>

3. Ler 15 elementos de uma matriz A do tipo vetor. Construir uma matriz B de mesmo tipo. Observando a seguinte lei de formação: “Todo elemento de B deverá ser o quadrado do elemento de A correspondente”.

inicio

   //declaração das variáveis
   inteiro a[15] ,b[15] ,i
   //entrada de dados
   para i de 0 ate 14 passo 1
       ler a[i]
   proximo
   //construindo a matriz "B"
   para i de 0 ate 14 passo 1
       b[i] <- a[i] * a[i]
   proximo
   //impressão dos dados
   escrever "\nMatriz A:"
   para i de 0 ate 14 passo 1
       escrever "" , a[i]
   proximo
   escrever "\nMatriz B:"
   para i de 0 ate 14 passo 1
       escrever "" , b [i]
   proximo

fim </syntaxhighlight>

4. Escreva um algoritmo que:

    • Leia uma matriz 5 x 5 de elementos reais;
    • Divida cada elemento de uma linha da matriz pelo elemento da diagonal principal desta linha;
    • Imprima a matriz assim modificada.


inicio

   //declaração das variáveis
   real a [5] [5] , b [5] [5]
   inteiro i , j
   //entrada de dados
   para i de 0 ate 4 passo 1
       para j de 0 ate 4 passo 1
           ler a [i] [j]
       proximo
   proximo
   //dividindo a linha da matriz por sua diagonal principal
   para i de 0 ate 4 passo 1
       para j de 0 ate 4 passo 1
           b [i] [j] <- ( a [i] [j] / a [i] [i] )
       proximo
   proximo
   //impressão dos dados
   escrever "\nMatriz: "
   escrever "\n"
   para i de 0 ate 4 passo 1
       escrever "\n" , a [i] [0] , " " , a [i] [1] , " " , a [i] [2] , " " , a [i] [3] , " " , a [i] [4]
   proximo
   escrever "\n\nMatriz modificada: "
   escrever "\n"
   para i de 0 ate 4 passo 1
       escrever "\n" , b [i] [0] , " " , b [i] [1] , " " , b [i] [2] , " " , b [i] [3] , " " , b [i] [4]
   proximo

fim </syntaxhighlight>


5. Elabore um algoritmo para corrigir provas de múltipla escolha. Assuma que em cada prova encontraremos os seguintes dados: RM, NOME DO ALUNO, MATÉRIA e BIMESTRE, além de 10 questões numeradas de 1 até 10 e que cada questão possui 5 alternativas identificadas pelas letras de “a” até “e”. Primeiramente, o algoritmo deve ler o gabarito e o número de provas a serem corrigidas . A seguir, os dados das provas a serem corrigidas devem ser lidas. Ainda, o algoritmo deverá calcular e escrever:

    • O RM, NOME DO ALUNO, MATÉRIA, BIMESTRE e a NOTA de cada aluno (assumindo que cada questão correta vale 1 ponto).
    • A porcentagem de aprovação, assumindo que a nota mínima para aprovação é 6.


inicio

   //declaração das variáveis
   caracter gab [10] , resp [10]
   inteiro i , qtdprova , cont <- 0 , aprovados <- 0
   real nota <- 0
   texto rm <- "" , aluno <- "" , mat <- "" , bimestre <- ""
   
   //entrada de dados
   para i de 0 ate 9 passo 1
       escrever "Informe o gabarito da " , (i + 1) , "ª questão:"
       ler gab [i]
   proximo
   
   escrever "Informe a quantidade de provas: "
   ler qtdprova
   
   //dados das provas
   enquanto cont < qtdprova faz
       escrever "**************************************************"
       escrever "\nInforme RM: "
       ler rm
       escrever "Informe o nome do aluno: "
       ler aluno
       escrever "Informe a matéria: "
       ler mat
       escrever "Informe o bimestre: "
       ler bimestre
       //informando as respostas
       para i de 0 ate 9 passo 1
           escrever "Informe a resposta da " , (i + 1) , "ª questão:"
           ler resp [i]
       proximo
       
       //corrigindo a prova
       nota <- 0
       para i de 0 ate 9 passo 1
           se ( gab [i] = resp [i] ) entao
               nota <- nota + 1
           fimse
       proximo
       
       //informando a nota
       escrever "A nota do(a) " , aluno , " é: " , nota , "\n\n"
       
       //verificando aprovação do aluno
       se ( nota >= 6 ) entao
           aprovados <- ( aprovados + 1 )
       fimse
       cont <- ( cont + 1 )
   fimenquanto
   
   //imprimindo valores
   escrever "\n**************************************************"
   escrever "\nA quantidade de aprovados é: " , aprovados

fim </syntaxhighlight>

25/05: Avaliação de Lógica de Programação

Dicas para a avaliação (vale a pena revisar conceitos):

    • Números primos
    • Fatorial
    • MDC: Máximo Divisor Comum
    • MMC: Mínimo Múltiplo Comum
    • Cálculo para série de Fibonacci

Conceitos Avaliação de Lógica:

ATENÇÃO: 20-22 de 1a Semana de Telecomunicações

Participem da 1a Semana de Telecomunicações IFSC, Campus São José

Chamada da 1a Semana de Telecomunicações do IFSC - São José clique aqui
Programação do evento: clique aqui

25/05: Vista da avaliação de Lógica de Programação

  • Desenvolvimento e correção dos exercícios propostos na avaliação.

26/05: Linguagem C

    • Introdução a linguagem C
    • Primeiros Programas
    • Compilador Gcc

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

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

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
      

01/06: Aulas 1 e 2

02/06: Aula 3

08/06: Aula 4

09/06: Aula 5

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char** argv) {
    int pres=0, idade=0, taq=0;
    
    puts("Responda da seguinte forma: 1 (sim) e 0 (não)\n");
    
    printf("Sua pressão está acima de 91? ");
    scanf("%d",&pres);
    if (pres == 1){
        printf("Sua idade é superior a 62 anos? ");
        scanf("%d",&idade);
        if (idade == 1){
            printf("Sente taquicardia ?");
            scanf("%d",&taq);
            if(taq == 1){
                 printf("Alto Risco!!!\n");
            }else{
                printf("Sem Risco!!!\n");
            }
        }else{
            printf("Sem Risco!!!\n");
        }
        
    }else{
           printf("Sem Risco!!!\n");
        }

    return (EXIT_SUCCESS);
}

15/06: Aula 7

16/06: Programação em linguagem C

20/06 e 22/06 - 1a Semana de Telecomunicações

Participem da 1a Semana de Telecomunicações IFSC, Campus São José

Chamada 1 Semana de Telecomunicações IFSC clique aqui
Programação do evento: clique aqui

23/06: Feriado Nacional

29/06: Revisão para avaliação linguagem C

  • Resolução de exercícios

A função random()

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

30/06: Prova Final - Linguagem C

  • Estruturas de repetição
  • Estruturas de decisão
  • Vetores e Strings (funções de manipulação de strings)
  • Structs e Funções (passagem de parâmetros - argumentos)

Conceitos

Conceitos avaliação programação C clique aqui

06/07: Avaliação de recuperação

Conceitos avaliação Recuperação programação C clique aqui

07/07: Aula 6 e 9 (encerramento disciplina)