Edição atual tal como às 09h10min de 7 de dezembro de 2011

Instrutor

Professor: Tiago Semprebom
Email: tisemp@ifsc.edu.br
diretório web:: tele.sj.ifsc.edu.br/~tisemp
Atendimento paralelo: 4a feira 14:30h - 15:30h e 5a feira 14:30h - 15:30h (Lab. de Desenvolvimento de Tele)
Endereço do grupo da disciplina: http://groups.google.com/group/ifsc_prg
e-mail da disciplina: ifsc_prg@googlegroups.com

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.

Lógica de Programação

Baseado no material Lógica de Programação, de Paulo Sérgio de Moraes - uma das referências bibliográficas da disciplina.
diretório web da disciplina: diretório web da disciplina

03/08: Introdução

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

05/08: Resolução de exercícios

Resolução de exercícios de lógica

10/08: 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:

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

Guia de referência Kturtle12/08: 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 ?

17/08: Algoritmos

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

Atividade para casa

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:



Primeira iteração


Segunda iteração


Terceira iteração


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

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
}

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
}

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
}

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.

19/08: Pseudocódigo e Diagrama de Blocos (Fluxograma)Fluxogramas (páginas da apostila: 12 a 14).

Diagramas de bloco para auxiliar a descrição de algoritmos. Ajudam na compreensão do algoritmo, por poder visualizar o fluxo de execução.
Por exemplo um 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

Página de apoio (Fluxogramas):Estruturas de Programação Fluxogramas: Estruturas de decisãoPáginas da apostila: 26 a 30.Exercícios Propostos:Utilizando fluxogramas desenvolva os algoritmos para resolução dos seguintes problemas:

Elabore um diagrama de blocos que leia um número. Se positivo armazene-o em A, se for negativo, em B. No final mostrar o resultado.
Elabore um diagrama de blocos que leia um número e informe se este é par ou ímpar.
Faça um algoritmo para eleição do IFSC. Existem 3 candidatos possíveis, representados na urna por seus números partidários: 10 - Jão, 20 - Maria e 30 - Zé. O algoritmo deve solicitar o voto do eleitor e exibir o nome do candidato votado. O número indica o candidato votado, caso o número informado não exista o voto será nulo.
Construa um diagrama de blocos para ler uma variável numérica N e imprimi-la somente se a mesma for maior que 100, caso contrário imprimi-la com o valor zero.
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.
Tendo 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 (h = altura):
Para homens: (72.7*h) - 58
Para mulheres: (62.1*h) - 44.7
João Papo-de-Pescador, homem de bem, morador do Ribeirão da Ilha, comprou um microcomputador para controlar o rendimento diário de seu trabalho. Toda vez que ele traz um peso de peixes maior que o estabelecido pelo regulamento de pesca do estado de São Paulo (50 quilos) deve pagar um multa de R$ 4,00 por quilo excedente. João precisa que você faça um diagrama de blocos que leia a variável P (peso de peixes) e verifique se há excesso. Se houver, gravar na variável E (Excesso) e na variável M o valor da multa que João deverá pagar. Caso contrário mostrar tais variáveis com o conteúdo ZERO.
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.

26/08: Pseudocódigo e Diagrama de Blocos (Fluxograma)Fluxogramas: Estruturas de repetiçãoPáginas da apostila: 32 a 35.Estrutura de repetição: FOR (em português, PARA)

Esta estrutura permite criar um ciclo de repetição controlado por uma variável,, que assumirá todos os valores entre um valor inicial e um valor final, incrementando-se ou decrementando-se a si própria de um valor passo x.

Estrutura de repetição: While Do (em português, ENQUANTO FACA)

Nesta estrutura, enquanto a condição permanecer verdadeira, são executadas as declarações A e B, sendo que quando não for satisfeita sai do ciclo e continua o programa. Note que, se a condição nunca for satisfeita, nunca serão executadas as declarações do ciclo.

Estrutura de repetição: Do Until (em português, FACA ATE)

Nesta estrutura, as declarações A e B até que a condição seja satisfeita.   Neste caso, contrariamente ao anterior, as declarações serão executadas pelo menos uma vez. Note que, que algumas linguagens como a C e C++, a condição é invertida e as declarações são executadas enquanto a condição for verdadeira, (Do While).

Exercícios Propostos:Utilizando fluxogramas desenvolva os algoritmos para resolução dos seguintes problemas:

Faça um algoritmo que determine o maior entre N números. A condição de parada é a entrada de um valor 0, ou seja, o algoritmo deve ficar calculando o maior até que a entrada seja igual a 0 (ZERO).
Faça um algoritmo que conte de 1 a 100 e a cada múltiplo de 10 emita uma mensagem: Múltiplo de 10.
Faça uma Programa que receba um número inteiro, calcule e imprima a tabuada desse número.
Uma grande firma deseja saber qual é o empregado mais recente e qual é o mais antigo. Desenvolver um algoritmo para ler um número indeterminado de informações (máximo de 300) contendo o número do empregado e o número de meses de trabalho deste empregado e imprimir o mais recente e o mais antigo. Obs.: A última informação contém os dois números iguais a zero. Não existem dois empregados admitidos no mesmo mês.
Escreva um algoritmo em fluxograma que imprima todos os números inteiros do intervalo fechado de 1 a 100.
Escreva uma Programa que receba a idade de 10 pessoas, calcule e imprima a quantidade de pessoas maiores de idade (maiores de 18 anos).

Atividade em sala (teste surpresa, nem tão surpresa assim ;)

Atividade deve ser realizada em sala de aula e os exercícios entregues ao professor.
Elabore os algoritmos solicitados utilizando Pseudocódigo e Diagrama de Blocos (fluxogramas).
Fique à vontade para consultar o material de aula, inclusive os exercícios já realizados por você.
Não faça plágio de seu colega, faça o seus exercícios. Além de antiético, você perde o conceito da atividade.

Ler as notas da 1a. e 2a. avaliações de um aluno. Calcular a média aritmética simples e escrever uma mensagem que diga se o aluno foi ou não aprovado (considerar que nota igual ou maior que 6 o aluno é aprovado). Escrever também a média calculada.
A jornada de trabalho semanal de um funcionário é de 40 horas. O funcionário que trabalhar mais de 40 horas receberá hora extra, cujo cálculo é o valor da hora regular com um acréscimo de 50%. Escreva um algoritmo que leia o número de horas trabalhadas em um mês, o salário por hora e escreva o salário total do funcionário, que deverá ser acrescido das horas extras, caso tenham sido trabalhadas (considere que o mês possua 4 semanas exatas).
Ler dois valores e imprimir uma das três mensagens a seguir:
Números iguais, caso os números sejam iguais
Primeiro é maior, caso o primeiro seja maior que o segundo;
Segundo maior, caso o segundo seja maior que o primeiro.
Ler 10 valores e escrever quantos desses valores lidos estão no intervalo [10,20] (incluindo os valores 10 e 20 no intervalo) e quantos deles estão fora deste intervalo.
Faça um algoritmo para ler o código e o preço de 15 produtos, calcular e escrever:
O maior preço lido
A média aritmética dos preços dos produtos

31/08: Lógica de Programação

Resolução de exercícios
Vetores

02/09: Lógica de ProgramaçãoExercícios de lógica de programação utilizando vetoresExercícios Propostos (Vetores)Utilizando diagrama de blocos (fluxogramas) desenvolva algoritmos para os problemas descritos.

Escreva um algoritmo que permita a leitura dos nomes de 10 pessoas e armazene os nomes lidos em um vetor. Após isto, o algoritmo deve permitir a leitura de mais 1 nome qualquer de pessoa e depois escrever a mensagem ACHEI, se o nome estiver entre os 10 nomes lidos anteriormente (guardados no vetor), ou NÃO ACHEI caso contrário.
Escreva um algoritmo que permita a leitura das notas de uma turma de 20 alunos. Calcular a média da turma e contar quantos alunos obtiveram nota acima desta média calculada. Escrever a média da turma e o resultado da contagem.
Ler um vetor de 20 posições (aceitar somente números positivos). Escrever a seguir o valor do maior elemento do vetor e a respectiva posição que ele ocupa no vetor.
Ler um vetor A de 10 números. Após, ler mais um número e guardar em uma variável X. Armazenar em um vetor M o resultado de cada elemento de A multiplicado pelo valor X. Logo após, imprimir o vetor M.
Faça um algoritmo para ler 20 números e armazenar em um vetor. Após a leitura total dos 20 números, o algoritmo deve escrever esses 20 números lidos na ordem inversa.

Entrega dos exercícios

Em dupla, por e-mail (tisemp@ifsc.edu.br) em formato digital (ferramenta DIA ou equivalente)
Entrega até 06/09/2011 (terça-feira)

07/09: Feriado NacionalIndependência do Brasil ;)09/09: PortugolAdoção do Portugol IDE como ferramenta didática.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.

Faça o download do Portugol.
Descompacte-o com o seguinte comando: tar xzf portugol23.tar.gz

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

Copie esse arquivo para poder ver fluxogramas coloridos, e grave-o no memso diretório onde está o Portugol.
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:

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

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

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

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.

14/09: Constantes e VariáveisVariá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
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.

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

16/09: 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 do Polígono (Wagner)

inicio
//variáveis
real lado<-0
inteiro N<-3
texto unidade <- "cm"

   Escrever "Digite o valor dos lados(em cm): "
   ler lado
   Escrever "Quantos lados possui o seu poligono?(deve ser maior que 2)", "\nResp.: "
   ler N
   Escrever "O perimetro do seu poligono é: ", lado*N , " cm"
fim

</syntaxhighlight>

Solução do exercício da área do triângulo (Anna Luiza)


inicio

   real base <- 0.0 , altura <- 0.0
   
   escrever "Insira a altura: "
   ler altura
   escrever "Insira a medida da base: "
   ler base
   escrever "A área do triângulo é: " , ( altura * base ) / 2

fim
</syntaxhighlight>

Solução do exercício de conversão de temperatura (Bruno)


Inicio
real fah<-0.0, cent<-0.0
Escrever "Digite a temperatura em Fahrenheit: "
ler fah
cent<- (fah-32)*5/9
Escrever "A temperatura em graus Centigrados é de: ", cent, "ºC"
fim
</syntaxhighlight>

Solução do exercício das poltronas no cinema (Cleber):


inicio

   // variaveis
   inteiro ncadeira <- 0 , fila <- 0 , cadeira <- 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

Escreva um algoritmo que calcule a raiz de uma equação de 1o grau.
Escreva um algoritmo que calcule as raízes de uma equação de 2o grau. Assuma que existam duas raízes reais
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.
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

21/09: 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 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.

23/09: Exercícios estruturas de decisãoTeste surpresa (Estruturas de decisão):

Faça um programa que leia um número e então informe se ele é par ou ímpar.
Um radar de trânsito faz a medição de velocidade de veículos e, dependendo do valor, calcula a multa a ser aplicada. Em uma determinada via esse radar foi configurado da seguinte forma:
Se a velocidade for maior que 80 km/h, a multa é de R$ 360.
Se a velocidade for maior que 60 km/h, a multa é de R$ 180.
Se a velocidade for menor ou igual a 60 km/h, não há multa.
Escreva um algoritmo que calcule a multa de acordo com a velocidade de um veículo.
Faça um algoritmo que leia três números do teclado, e mostre o maior e menor números.
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 ? Escreva um  algoritmo  que faça o teste de risco de paciente cardíaco de um paciente, conforme descrito acima.

Exercícios extras: entrega até dia 27/09

Exercícios devem ser enviados para o e-mail do professor até o dia 27/09
Entrega individual. Não copie exercícios de seu colega. Plágio não será aceito.

Um estudo sobre sensibilidade de pessoas a temperaturas da água identificou que a maioria das pessoas considera fria a água com temperaturas abaixo de 25 graus, morna entre 25 e 30 graus, e quente acima de 30 graus. Escreva um algoritmo que mostre as palavras "fria", "morna" ou "quente" dependendo da temperatura da água que for informada.
Em uma rede de computadores, o firewall restringe o acesso a Internet dependendo do horário e do tipo de usuário que faz o acesso. Os tipos de usuário abaixo têm as seguintes restrições:
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.
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 (8:00 às 18:00)
Diretoria: sem restrições a sites
Faça um algoritmo para fazer a divisão de dois números reais. Antes de dividi-los deve ser feito um teste de validade. Caso não seja possível dividi-los, deve ser mostrada uma mensagem de erro. Se for possível, deve-se mostrar o resultado da divisão.
Faça um jogo de par ou ímpar, em que o jogador aposta contra o computador. O jogador deve digitar um número entre 0 e 5 e optar entre par ou ímpar. O computador deve sortear um número também entre 0 e 5. Se a paridade da soma dos números do jogador e do computador for a mesma que o jogador optou, então ele ganha a partida, senão o computador vence.
Escreva um algoritmo para identificar se há, dentre três palavras lidas do teclado, ao menos duas palavras distintas que pertençam ao conjunto {azul, preto, vermelho}. Exemplos:
Se o usuário digitar verde, preto, vermelho, o programa deve mostrar na tela verdadeiro
Se o usuário digitar verde, preto, preto, o programa deve mostrar na tela falso
Se o usuário digitar azul, preto, azul, o programa deve mostrar na tela verdadeiro

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

28/09: Estruturas de decisãoEngenharia de Telecomunicações: início de oferta 2012-1

O curso de Engenharia de Telecomunicações começa a ser ofertado em 2012-1 no Instituto Federal de Santa Catarina, campus São José. Mais informações sobre o ingresso acesse: portal do ingresso. Trata-se de um curso gratuito e com duração de 5 anos. O atual curso superior de tecnologia em Telecomunicações recebeu o conceito máximo (5) na avaliação do MEC.
Parabéns à todos os envolvidos na concepção desse projeto. Sucesso aos futuros Engenheiros de Telecomunicações, formados pelo IFSC, Campus São José.
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

Faça um algoritmo que converta um número de 1 a 7 para o respectivo dia da semana (ex: 1 = domingo, 2 = 2a feira, e assim por diante).
Faça uma calculadora com as quatro operações aritméticas. Sua calculadora deve ler (nesta ordem) o primeiro número, a operação aritmética (que deve ser informada usando o símbolo da respectiva operação: +, -, * ou /), e depois o segundo número. Ao final, seu algoritmo deve mostrar o resultado, ou uma mensagem de erro se a operação não for possível de realizar (ex: divisão por zero).
A previsão do tempo na costa brasileira pode ser feita de forma aproximada usando-se um barômetro e um termômetro. Uma estimativa com boa chance de acerto se baseia na tabela abaixo: 


Faça um algoritmo que forneça uma estimativa da previsão do tempo, usando essa tabela.
Faça um algoritmo que mostre qual o último dia de um determinado mês informado pelo teclado. Caso seja informado o mês 2 (fevereiro), seu algoritmo deve identificar se é 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):
De 4 em 4 anos é ano bissexto.
De 100 em 100 anos não é ano bissexto.
De 400 em 400 anos é ano bissexto.
Prevalecem as últimas regras sobre as primeiras.
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.
Escreva um programa que leia cinco números do teclado e mostre os dois maiores números.
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é".
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

30/09: 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

Escreva um  algoritmo que mostre a tabuada de um número fornecido pelo teclado. Esse número deve estar entre 1 e 10.
Modifique o exemplo da média para que a quantidade de números a serem lidos seja previamente informada pelo teclado.
Modifique novamente o exemplo da média para que ela funcione para um quantidade de números desconhecida de antemão. Quer dizer, o algoritmo deve ler os números para calcular a média, mas não sabe quantos números existem (e isto não pode ser informado pelo teclado).
Modifique o exemplo da senha para que o usuário tenha somente três tentativas permitidas para digitar a senha correta. caso ao final as três senhas estejam erradas, o algoritmo deve informar que a conta foi bloqueada.
Escreva um algoritmo que leia até 10 números do teclado, e informe ao final qual o maior e o menor deles.
Escreva um algoritmo que teste se um número informado pelo teclado é primo.

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

07/10: Estruturas de repetiçãoVariá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:
 $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 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/10: Estruturas de repetição (Lista de exercícios para o Feriado :p)Entrega por e-mail (tisemp@ifsc.edu.br) até o dia 12/10 (quarta-feira)

Escreva um algoritmo que leia 5 números do teclado, e depois mostre-os em ordem inversa à que foi digitada.
Escreva um algoritmo que leia dois vetores de 5 números, e depois mostre se os vetores são iguais.
Escreva um algoritmo que leia um palavra do teclado e depois procure-a numa lista de palavras preexistente. Essa lista deve ser implementada usando um vetor.
Escreva um algoritmo que leia 5 números, e mostre-os em ordem crescente.
Modifique o algoritmo anterior para mostrá-los em ordem decrescente.
Em um  jogo de bingo devem-se contar quantos números de uma aposta foram sorteados no bingo. Faça um algoritmo que, dados os números sorteados e uma aposta, conta quantos números apostados forma sorteados.

14/10: 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;

14/10: Lista complementar, 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 resposta):"
     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>

19/10: 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:21/10: Vista da avaliação de Lógica de ProgramaçãoDesenvolvimento e correção dos exercícios propostos na avaliação.21/10: Linguagem C

Introdução a linguagem C
Primeiros Programas
Compilador Gcc

Para provocar: Teach Yourself Programming in Ten Years
Apostila adotada: Curso de Linguagem C - Engenharia Elétrica -  UFMG

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:

Faça o download do instalador. Salve-o em algum subdiretório.
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

Aceite as opções de instalação sugeridas pelo instalador.
Ao final da instalação, o Netbeans 6.8 estará acessível pelo menu Aplicativos -> Programação.
Sempre que for escrever um novo programa com o Netbeans, crie um novo projeto (ver menu Arquivo->Novo Projeto). Selecione um projeto do tipo "Aplicativo C/C++".

Compilando o primeiro programaO 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:
Inicio
  inteiro x, y
 
  Escrever "Digite um numero: ",
  Ler x
  Escrever "Digite outro numero: ",
  Ler y
  Escrever "Soma = ", x+y
Fim

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

26/10: Introdução linguagem C

Aulas 1 e 2 - curso de C UFMG
Curso de Linguagem C - Engenharia Elétrica -  UFMG

28/10: Feriado: dia do servidor público



MURAL DE AVISOS E OPORTUNIDADES DA ÁREA DE TELECOMUNICAÇÕES

Conceitos

Conceitos avaliação Lógica de Programação  clique aqui

31/10: Aula 3Operadores lógicos e aritméticos02/11: Feriado: todos os santos (finados)04/11: Aula 4Estruturas de Controle de fluxo09/11: Aula 4

Estruturas de decisão
Switch

11/11: Aula 4

Estruturas de repetição
for, while, do

16/11: Aula 523/11: Aula 7 (Funções)

Material de aula Prof. Marcelo funções
Texto introdutório sobre funções na linguagem C

Escopo de variáveisTexto obtido de: Uso de funções em C

Por escopo de uma variável entende-se o bloco de código onde esta variável é válida. Com base nisto, temos as seguintes afirmações:

As variáveis valem no bloco que são definidas;
As variáveis definidas  dentro de uma função recebem o nome de variáveis locais
As variáveis declaradas fora de qualquer função são chamadas de variáveis globais
Os parâmetros formais de uma função (também conhecidos como argumentos da função) valem também somente dentro da função;
Uma variável definida dentro de uma função não é acessível em outras funções, MESMO QUE ESSAS VARIÁVEIS TENHAM NOMES IDÊNTICOS.

Variáveis locais

No trecho de código a seguir tem-se um exemplo com funções e variáveis com nomes iguais.

#include <stdio.h>

void FUNC1() {
   int B;

   B = -100;
   printf("Valor de B dentro da função FUNC1: %d\n", B);
}

void FUNC2() {
   int B;

   B = -200;
   printf("Valor de B dentro da função FUNC2: %d\n", B);
}

void main() {
   int B;

   B = 10;
   printf("Valor de B: %d\n", B);
   B = 20;
   FUNC1();
   printf("Valor de B: %d\n", B);
   B = 30;
   FUNC2();
   printf("Valor de B: %d\n", B);
}

O resultado de sua execução deve ser:

Valor de B: 10
Valor de B dentro da função FUNC1: -100
Valor de B: 20
Valor de B dentro da função FUNC2: -200
Valor de B: 30

Variáveis globais

O seguinte exemplo mostra o mesmo programa, porém fazendo com que a variável B seja global:

#include <stdio.h>

// Declaração da variável global B
int B;

void FUNC1() {
   B = -100;
   printf("Valor de B dentro da função FUNC1: %d\n", B);
}

void FUNC2() {
   B = -200;
   printf("Valor de B dentro da função FUNC2: %d\n", B);
}

void main() {
   B = 10;
   printf("Valor de B: %d\n", B);
   B = 20;
   FUNC1();
   printf("Valor de B: %d\n", B);
   B = 30;
   FUNC2();
   printf("Valor de B: %d\n", B);
}

O resultado de sua execução deve ser:

Valor de B: 10
Valor de B dentro da função FUNC1: -100
Valor de B: -100
Valor de B dentro da função FUNC2: -200
Valor de B: -200

E se existir um variável local  com mesmo nome que uma global ? nesse caso, a variável local vai esconder a sua homônima global:

#include <stdio.h>

// Declaração da variável global B
int B;

void FUNC1() {
   //  no escopo desta função, esta variável local vai esconder a variável global B! 
   int B; 

   B = -100;
   printf("Valor de B dentro da função FUNC1: %d\n", B);
}

void FUNC2() {
   B = -200;
   printf("Valor de B dentro da função FUNC2: %d\n", B);
}

void main() {
   B = 10;
   printf("Valor de B: %d\n", B);
   B = 20;
   FUNC1();
   printf("Valor de B: %d\n", B);
   B = 30;
   FUNC2();
   printf("Valor de B: %d\n", B);
}

O resultado de sua execução deve ser:

Valor de B: 10
Valor de B dentro da função FUNC1: -100
Valor de B: 20
Valor de B dentro da função FUNC2: -200
Valor de B: -200

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

Para fixar

Escreva  o programa para mostrar a tabuada de um  número lido do teclado. #include <stdlib.h>
#include <stdio.h>

/*
 * 
 */
int main(int argc, char** argv) {

    int numero, c;

    printf("Numero: ");
    scanf("%d", &numero);

    c = 1;
    while (c < 11) {
        printf("%d X %d = %d\n", numero, c, numero*c);
        c++;
    }

    return (EXIT_SUCCESS);
}

Reescreva o programa anterior, mas usando uma função para mostrar a tabuada. #include <stdio.h>

int tabuada(int num) {
    int c = 1;
    while (c < 11) {
        printf("%d X %d = %d\n", num, c, num*c);
        c++;
    }

}
int main(int argc, char** argv) {

    int numero, c;

    printf("Numero: ");
    scanf("%d", &numero);

    tabuada(numero);
    
    return (EXIT_SUCCESS);
}

Modifique o programa anterior para mostrar a tabuada de todos os números entre 1 e 10. Obs: não modifique a função tabuada!
Escreva um  programa para ler 10 números do teclado, e em seguida mostrar o maior e o menor número.
Reescreva o programa anterior, mas criando as função "maior" e "menor", que retornam o maior e menor número de um vetor de tamanho arbitrário.

30/11: O Jogo: Batalha Naval

Para referência:

apostila online sobre linguagem C.
Descrição do jogo de Batalha Naval clássico

Etapas de desenvolvimento:

Desenha 1 onda
Desenha 1 linha de ondas
Desenha 1 matriz de tamanho fixo de ondas
Desenha 1 matriz de tamanho variável de ondas (o usuário informa as dimensões)
Mapeia 1 barco: latitude e longitude (vetor)
Desenha o mar com 1 barco
Mapeia 10 barcos: latitude e longitude (matriz)
Desenha os 10 barcos
Mapeia 10 barcos: latitude, longitude e se já foi atingido
Pede ao usuário atirar
Se o barco foi atingido, desenhar um X
Ao final (todo os barcos atingidos): informar o usuário que venceu em 'n' movimentos

Proposta de código que contempla:
Bibliotecas e definições
Declaração de constantes e variáveis
Uso de variáveis com mesmo nome e diferentes escopos
Vetor e matriz
Operadores lógicos e matemáticos
Expressões
E/S
Estruturas de decisão e repetição
Funções
Passagem de parâmetro por valor e por referência
Acesso a uma matriz através de um vetor linear (função iniciaJogo)
Ponteiros

Uma versão do jogo implementado:O tabuleiro

Representar o tabuleiro: etapas 1 a 4.

Etapa 1: desenhar uma onda

Conteúdos abordados:

declaraçao de variáveis
saída de dados na tela
estrutura de decisão: if

Nessa etapa se deseja mostrar o estado de uma única posição do tabuleiro. Se o estado for "água", mostra-se uma onda (símbolo ~), e se for "navio" mostra-se X.

#include <stdio.h>

int main() {
  // 0: agua
  // 1: navio
  int posicao = 1;

  if (posicao == 0) {
    printf("~");
  } else {
    printf("X");
  }
}

Usou-se uma variável inteira para representar o estado da posição do tabuleiro. O valor 0 (zero) corresponde a "água", e 1 corresponde a "navio". Para testar o valor dessa variável, e mostrar ~ ou X, precisou-se de uma estrutura de decisão do tipo se (condição) então bloco_de instruções senão outro_bloco_de_instruções. Na linguagem C isso se faz com if (condição) { bloco de instruções } else {outro bloco de instruções}.

Etapa 2: desenhar uma linha de ondas

Nessa etapa deseja-se mostrar uma linha do tabuleiro. Por exemplo, para um tabuleiro de 10 colunas, uma linha deve aparecer assim (se tiver só "água'":

~ ~ ~ ~ ~ ~ ~ ~ ~ ~

O problema é parecido com o da etapa 1, mas agora deve-se mostrar o estado de cada posição de uma linha. Foi sugerido o uso de um vetor para representar os estados das posições em uma linha. Assim, imaginando-se uma linha com 10 posições, o vetor abaixo poderia ser usado para representar seus estados:

int linha[10];

Repare na semelhança entre a declaração de um vetor em C e em Portugol. A ideia é a mesma: ao declarar o vetor deve-se informar sua capacidade (quantas posições ele possui, o que corresponde a quantos valores ele é capaz de armazenar). No exemplo acima, o vetor de inteiros linha possui 10 posições, e assim é capaz de guardar 10 números inteiros.
A tarefa da etapa 2 portanto é testar cada posição do vetor linha: se for 0 deve-se mostrar ~(água), e se for 1 deve-se mostrar X (navio).
Conteúdos abordados:

declaraçao de variáveis
saída de dados na tela
estrutura de decisão: if
estrutura de repetição: while

#include <stdio.h>

int main() {
  // 0: agua
  // 1: navio
  int linha[10] = {0,1,0,0,0,0,0,0,0,0};
  int y;

  y = 0;
  while (y < 10) {

    // Mostra ~ se posicao for agua, e X se for navio
    if (linha[y] == 0) {
      printf("~ ");
    } else {
      printf("X ");
    }

    y = y + 1;
  }

}

Equipes 2011-2

Antônio e Joseane
Julio e Deyze
Edimar e Thiago
Juliana e Marina
Daniel e Guilherme
Fabiana e Erivelto
Wagner e Edgar
Gabriel Simas e Mário
Anna e Vinicius Rodrigues
Bruno e Gabriel Cantu
Cleber

02/12: Desenvolvimento do ProjetoPonteiros em linguagem C

Ponteiros é uma característica poderosa oferecida pela linguagem C. A linguagem de programação C depende muito dos ponteiros, assim, um bom programador em C precisa dominar bem ponteiros.
Ponteiro é visto pela maior parte dos programadores  iniciantes como uma das partes mais difíceis na linguagem C, pois o conceito de ponteiros pode ser novo ou um mesmo símbolo usado para certa finalidade e usado para outra diferente, tornando mais difícil o entendimento.
Entendendo o que é um ponteiro
Um ponteiro é uma variável que guarda um endereço de memória de outra variável. Os ponteiros da linguagem C proporcionam uma forma fácil de acesso ao valor de variáveis sem referenciá-las diretamente. Um ponteiro possui tipo, por exemplo, inteiros, ponto flutuante e caracteres. O tipo do ponteiro indica que tipo é a variável para qual ele aponta.
Um ponteiro é declarado a seguinte forma:

tipo_do_ponteiro *nome_do_ponteiro

Exemplo:

int *p, *a;
char *pt, *ponteiro;

No exemplo acima foram criados quatro ponteiros, dois de tipo inteiro e dois de tipo caractere. É importante não confundir o asterisco (*), que indica que a variável é um ponteiro, com o mesmo sinal indicando uma multiplicação.
Conhecendo os operadores
Sempre é importante iniciar o ponteiro. Um ponteiro sempre é iniciado com o local na memória onde se localiza o valor da variável. Para iniciar a variável desejada como o endereço de memória, segue o exemplo:

int variavel_apontada=2;
int *ponteiro;
ponteiro=&variavel_apontada;

No exemplo foi criada uma variável e iniciada com valor 2, foi criado também um ponteiro que logo abaixo foi iniciado com o endereço da variável chamada variável_apontada.
A linguagem de programação C oferece dois operadores unitários, o operador de endereço (&) e o operador indireto (*). O operador de endereço retorna o endereço de memória onde fica localizado a variável, como foi mostrado no exemplo acima. O operador indireto retorna o valor da variável para qual o ponteiro aponta. Por exemplo:

main() {
   int var, *p;
   var=10;
   p=&var;
   printf("O valor da variavel eh: %d \n", *p);
   printf("O endereco de memoria da variavel eh: %p \n", p);
   printf("O endereco de memoria do ponteiro eh: %p \n", &p);
   *p=15;
   printf("O novo valor da variavel e': %d \n", var);
   return (0);    
}

A saída será:

O valor da variavel eh: 10
O endereco de memoria da variavel eh: 00AE4F6
O endereco de memoria do ponteiro eh: 00AE4F8
O novo valor da variavel eh: 15

No exemplo, usam-se os operadores para imprimir e aterá o valor da variável. Onde o endereço de memória varia de cada computador.
O ponteiro é usado em situações em que a passagem de valores é complicada, por isso é muito importante seu aprendizado. O conceito de ponteiro e seu uso podem, aparentemente, ser complicado, porém, não é muito difícil. O uso indevido e insensato de ponteiros pode causar sérios bugs em um programa e até comprometer todo o sistema, assim, é necessário cuidado quando se usa eles.

07/12: Desenvolvimento do ProjetoDesenhando o tabuleiro completo

Dando continuidade à visualização do tabuleiro, agora deve-se desenhá-lo por completo na tela. Quer dizer, mostrar um tabuleiro com 10 linhas e 10 colunas, seguindo a abordagem das etapas 1 e 2.

Para mostrar uma única casa do tabuleiro (etapa 1) usou-se uma variável inteira, cujo conteúdo representa o estado daquela casa (se água ou navio). Para mostrar uma linha usou-se um vetor com capacidade 10, com cada posição do vetor representando o estado da casa correspondente. Como se deve então fazer para mostrar todo o tabuleiro ?
Possível solução: usando uma matriz bidimensional para representar todas suas casas: #include <stdio.h>

int main() {
  // 0: agua
  // 1: navio
  int tabuleiro[10][10] = {{0,1,1,0,1,0,0,0,0,0}, {0,0,1,0,0,0,0,0,0,0},
                           {0,0,0,0,1,0,0,0,0,1}, {0,1,1,0,1,0,0,0,0,0},
                           {0,0,0,0,1,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0},
                           {0,1,0,0,0,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0},
                           {0,0,0,0,0,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0}};
  int linha, coluna;

  linha = 0;
  while (linha < 10) {
      coluna = 0;
      while (coluna < 10) {

        // Mostra ~ se posicao for agua, e X se for navio
        if (tabuleiro[linha][coluna] == 0) {
          printf("~ ");
        } else {
          printf("X ");
        }

        coluna = coluna + 1;
      }
      printf("\n");
      linha = linha + 1;
  }

}

Mostrar o tabuleiro na tela parece ser em si um algoritmo. Ele precisa apenas  que se informem quais os estados das casas do tabuleiro. Esse algoritmo ficaria bem se implementado em uma função. #include <stdio.h>

  // 0: agua
  // 1: navio

// Obs: a matriz "tabuleiro" foi tornada uma variável global porque é difícil
// passar uma matriz como argumento de função. Assim ela pode ser acessada
// pela função "mostra_tabuleiro".

int tabuleiro[10][10] = {{0,1,1,0,1,0,0,0,0,0}, {0,0,1,0,0,0,0,0,0,0},
                           {0,0,0,0,1,0,0,0,0,1}, {0,1,1,0,1,0,0,0,0,0},
                           {0,0,0,0,1,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0},
                           {0,1,0,0,0,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0},
                           {0,0,0,0,0,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0}};

int mostra_tabuleiro() {
  int linha, coluna;

  linha = 0;
  while (linha < 10) {
      coluna = 0;
      while (coluna < 10) {

        // Mostra ~ se posicao for agua, e X se for navio
        if (tabuleiro[linha][coluna] == 0) {
          printf("~ ");
        } else {
          printf("X ");
        }

        coluna = coluna + 1;
      }
      printf("\n");
      linha = linha + 1;
  }
}


int main() {
  mostra_tabuleiro();

}

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

09/12: Desenvolvimento do Projeto

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)

Desenvolvimento do projeto
O código abaixo faz uso da biblioteca <time.h>, necessário para cálculo do tempo transcorrido pelo jogador

#include <stdio.h>
#include <time.h>
#include <string.h>


void calcula(){ //função calcula tempo transcorrido para executar uma operação.
    
  time_t inicio, fim;
  char nome[51];

  inicio= time(NULL);
  printf("Digite seu nome: ");
  scanf("%s",nome);
  //fgets(nome, 51, stdin);
  fim= time(NULL);

  printf("%s, voce demorou %.2f segundos para digitar seu nome.\n", nome, difftime(inicio,fim)*(-1));

}

void tempo()
{
  time_t segundos, inicio;

  inicio = time(NULL); //captura tempo nesse instante
  printf("O valor lido neste instante eh %ld \n", inicio);

  segundos= time(NULL); //captura e apresenta o tempo em segundos
  printf("%ld horas desde 1 de Janeiro de 1970.\n", segundos/3600);

}

int main() {

    tempo();
    calcula();

    return 0;
}

14/12: Desenvolvimento do Projeto

Entrega do projeto
Avaliação individual (oral)

16/12: Encerramento disciplinaRecuperaçõesLinguagens de programação: tendências do mercado

Discussões sobre os tipos de linguagens de programação utilizadas atualmente no mercado e tendências
Popularidade das linguagens de programação

@@ Linha 198: / Linha 198: @@
 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.
-==19/08: Pseudocódigo e diagrama de blocos (fluxograma)==
+==19/08: Pseudocódigo e Diagrama de Blocos (Fluxograma)==
-* Adoção do [http://www.dei.estt.ipt.pt/portugol/node/33 Portugol IDE] como ferramenta didática.
+* Fluxogramas (páginas da apostila: 12 a 14).
-*  Páginas da apostila: 12 a 14.
-=== Portugol ===
+Diagramas de bloco para auxiliar a descrição de algoritmos. Ajudam na compreensão do algoritmo, por poder visualizar o fluxo de execução.
-As aulas de Lógica de Programação usarão um software de auxílio ao ensino de algoritmos chamado [http://orion.ipt.pt/%7Emanso/Portugol/ Portugol], desenvolvido na [http://www.dei.estt.ipt.pt/portal/ Escola Superior de Engenharia do Instituto Politécnico de Tomar], em Portugal.
+Por exemplo um fluxograma para o algoritmo da média de três números:
-* [http://www.sj.ifsc.edu.br/~msobral/SOP/portugol.html Guia rápido de instalação e utilização do Portugol].
-==== Guia rápido de instalação e utilização do Portugol ====
+[[imagem:Fluxograma-soma.png]].
-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.
+<br>
-# Faça o [http://www.sj.ifsc.edu.br/%7Emsobral/SOP/soft/portugol23.tar.gz download] do Portugol.
+'''Blocos de uso mais comum'''<br>
-# Descompacte-o com o seguinte comando: <syntaxhighlight lang=bash>
+{| border="1" cellpadding="2"
-tar xzf portugol23.tar.gz
+ !Bloco
-</syntaxhighlight>
+ !Descrição
-# Repare que existe agora um subdiretório portugol no diretório onde você o descompactou. Execute o Portugol com o seguinte comando: <syntaxhighlight lang=bash>
+ !Exemplo
-java -jar portugol/Portugol.jar
+ |-
-</syntaxhighlight> Obs: você precisará ter Java instalado. Caso não o tenha, execute o comando: <syntaxhighlight lang=bash>
+ |[[Imagem:Inicio.png]]||Inicio do fluxograma||
-sudo apt-get install openjdk-6-jre
+ |-
-</syntaxhighlight>
+ |[[Imagem:Processamento.png]]||Processamento||
-# Copie esse [http://tele.sj.ifsc.edu.br/~tisemp/SOP/fluxogramas.cfg arquivo] para poder ver fluxogramas coloridos, e grave-o no memso diretório onde está o Portugol.
+ |-
-# Veja a [http://www.sj.ifsc.edu.br/%7Emsobral/SOP/soft/help/index.html ajuda] do Portugol, e use-a sempre que tiver dúvidas !
+ |[[Imagem:Entrada.png]]||Entrada de dados (ler do teclado)||
+ |-
+ |[[Imagem:Saida.png]]||Saída de dados (mostrar na tela)||
+ |-
+ |[[Imagem:Decisao.png]]||Decisão (testar uma condição e bifurcar)||[[imagem:Ex-decisao.png]]
+ |-
+ |[[Imagem:Conector.png]]||Conector (juntar dos ou mais ramos do fluxograma)||[[imagem:Ex-conector.png]]
+ |-
+ |[[Imagem:Fim.png]]||Fim||
+|}
-<br>A tela inicial do Portugol segue abaixo, junto com um programa demonstrativo.<br>
+===Página de apoio (Fluxogramas):===
+* [http://www.prof2000.pt/users/famaral/ig/tlp/estruturas.htm Estruturas de Programação ]
-[[Imagem:Editor-Portugol.png]]
+=== Fluxogramas: Estruturas de decisão===
+* Páginas da apostila: 26 a 30.
-Exemplos de programas iniciais em Portugol:
+===Exercícios Propostos:===
+* Utilizando fluxogramas desenvolva os algoritmos para resolução dos seguintes problemas:
-# ''Lendo um número e mostrando-o na tela em seguida:'' <syntaxhighlight lang=text>
+# Elabore um diagrama de blocos que leia um número. Se positivo armazene-o em A, se for negativo, em B. No final mostrar o resultado.
-Inicio
+# Elabore um diagrama de blocos que leia um número e informe se este é par ou ímpar.
-  inteiro x
+# Faça um algoritmo para eleição do IFSC. Existem 3 candidatos possíveis, representados na urna por seus números partidários: 10 - Jão, 20 - Maria e 30 - Zé. O algoritmo deve solicitar o voto do eleitor e exibir o nome do candidato votado. O número indica o candidato votado, caso o número informado não exista o voto será nulo.
+# Construa um diagrama de blocos para ler uma variável numérica N e imprimi-la somente se a mesma for maior que 100, caso contrário imprimi-la com o valor zero.
+# 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.
+# Tendo 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 (h = altura):
+#* Para homens: (72.7*h) - 58
+#* Para mulheres: (62.1*h) - 44.7
+# João Papo-de-Pescador, homem de bem, morador do Ribeirão da Ilha, comprou um microcomputador para controlar o rendimento diário de seu trabalho. Toda vez que ele traz um peso de peixes maior que o estabelecido pelo regulamento de pesca do estado de São Paulo (50 quilos) deve pagar um multa de R$ 4,00 por quilo excedente. João precisa que você faça um diagrama de blocos que leia a variável P (peso de peixes) e verifique se há excesso. Se houver, gravar na variável E (Excesso) e na variável M o valor da multa que João deverá pagar. Caso contrário mostrar tais variáveis com o conteúdo ZERO.
+# 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.
-  Escrever "Digite um numero: ",
+==26/08: Pseudocódigo e Diagrama de Blocos (Fluxograma)==
-  Ler X
-  Escrever "Numero digitado: ", x
-Fim
-</syntaxhighlight>
-# ''Lendo dois números, somando-os e mostrando o resultado na tela:'' <syntaxhighlight lang=text>
-Inicio
-  inteiro x, y
-  Escrever "Digite um numero: ",
+=== Fluxogramas: Estruturas de repetição===
-  Ler x
+* Páginas da apostila: 32 a 35.
-  Escrever "Digite outro numero: ",
-  Ler y
-  Escrever "Soma = ", x+y
-Fim
-</syntaxhighlight>O programa abaixo é equivalente:<syntaxhighlight lang=text>
-Inicio
-  inteiro x, y, z
-  Escrever "Digite um numero: ",
+====Estrutura de repetição: FOR (em português, PARA)====
-  Ler x
+* Esta estrutura permite criar um ciclo de repetição controlado por uma variável,, que assumirá todos os valores entre um valor inicial e um valor final, incrementando-se ou decrementando-se a si própria de um valor passo x.
-  Escrever "Digite outro numero: ",
-  Ler y
-  z <- x + y
-  Escrever "Soma = ", z
-Fim
-</syntaxhighlight>
-=== Atividades ===
+[[Arquivo:estfor.gif]]
-# ''Média de três números:'' escreva um programa para calcular a média de três números. <syntaxhighlight lang=text>
+====Estrutura de repetição: While Do (em português, ENQUANTO FACA)====
-Inicio
+* Nesta estrutura, enquanto a condição permanecer verdadeira, são executadas as declarações A e B, sendo que quando não for satisfeita sai do ciclo e continua o programa. Note que, se a condição nunca for satisfeita, nunca serão executadas as declarações do ciclo.
-  Inteiro n1, n2, n3, r
-  Escrever "Primeiro numero: "
+[[Arquivo:estwhlie.gif]]
-  ler n1
-  Escrever "Segundo numero: "
-  ler n2
-  Escrever "Terceiro numero: "
-  ler n3
-   r <- (n1 + n2 + n3) /3
+====Estrutura de repetição: Do Until (em português, FACA ATE)====
+* Nesta estrutura, as declarações A e B até que a condição seja satisfeita.   Neste caso, contrariamente ao anterior, as declarações serão executadas pelo menos uma vez. Note que, que algumas linguagens como a C e C++, a condição é invertida e as declarações são executadas enquanto a condição for verdadeira, (Do While).
-  Escrever "Media=", r
+[[Arquivo:estuntil.gif]]
-Fim
-</syntaxhighlight>
-# ''Sequência de Fibonacci:'' em matemática corresponde aos números: <syntaxhighlight lang=text>
-, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
-</syntaxhighlight>... que pode ser descrita pela relação de recorrência <br><br><math>F_{n} = F_{n-1} + F_{n-2}</math><br><br>... com valores iniciais <math>F_{0} = 1</math> e <math>F_{1} = 1</math>.<br><br>Numerosas formas na natureza apresentam essa sequência, como neste girassol (cujas flores se dispõem em uma espiral):<br><br>[[Imagem:Sunflower.jpg]]  [[Imagem:espiral_fibonacci.png]] [[Imagem:FibonacciBlocks.png]]<br><br>Usando o Portugol escreva um programa que mostre os 10 primeiros números dessa sequência.
-==07/04: Constantes e Variáveis==
+===Exercícios Propostos:===
+* Utilizando fluxogramas desenvolva os algoritmos para resolução dos seguintes problemas:
+# Faça um algoritmo que determine o maior entre N números. A condição de parada é a entrada de um valor 0, ou seja, o algoritmo deve ficar calculando o maior até que a entrada seja igual a 0 (ZERO).
+# Faça um algoritmo que conte de 1 a 100 e a cada múltiplo de 10 emita uma mensagem: Múltiplo de 10.
+# Faça uma Programa que receba um número inteiro, calcule e imprima a tabuada desse número.
+# Uma grande firma deseja saber qual é o empregado mais recente e qual é o mais antigo. Desenvolver um algoritmo para ler um número indeterminado de informações (máximo de 300) contendo o número do empregado e o número de meses de trabalho deste empregado e imprimir o mais recente e o mais antigo. Obs.: A última informação contém os dois números iguais a zero. Não existem dois empregados admitidos no mesmo mês.
+# Escreva um algoritmo em fluxograma que imprima todos os números inteiros do intervalo fechado de 1 a 100.
+# Escreva uma Programa que receba a idade de 10 pessoas, calcule e imprima a quantidade de pessoas maiores de idade (maiores de 18 anos).
-=== Variáveis e constantes ===
+===Atividade em sala (teste surpresa, nem tão surpresa assim ;)===
-* '''Variável:''' capaz de guardar um dado a ser usado no algoritmo. Pode ser entendida como uma caixa, onde se coloca um dado e se pode consultá-lo quantas vezes for necessário. O dado pode ser modificado (substituído por outro). Exemplo em Portugol: <syntaxhighlight lang=text>
+* Atividade deve ser realizada em sala de aula e os exercícios entregues ao professor.
-Inicio
+* Elabore os algoritmos solicitados utilizando Pseudocódigo e Diagrama de Blocos (fluxogramas).
-  inteiro anos, dias
+* Fique à vontade para consultar o material de aula, inclusive os exercícios já realizados por você.
+* Não faça plágio de seu colega, faça o seus exercícios. Além de antiético, você perde o conceito da atividade.
-  Escrever "Quantos anos se passaram ? "
+# Ler as notas da 1a. e 2a. avaliações de um aluno. Calcular a média aritmética simples e escrever uma mensagem que diga se o aluno foi ou não aprovado (considerar que nota igual ou maior que 6 o aluno é aprovado). Escrever também a média calculada.
-  Ler anos
+# A jornada de trabalho semanal de um funcionário é de 40 horas. O funcionário que trabalhar mais de 40 horas receberá hora extra, cujo cálculo é o valor da hora regular com um acréscimo de 50%. Escreva um algoritmo que leia o número de horas trabalhadas em um mês, o salário por hora e escreva o salário total do funcionário, que deverá ser acrescido das horas extras, caso tenham sido trabalhadas (considere que o mês possua 4 semanas exatas).
-  dias <- anos * 365
+# Ler dois valores e imprimir uma das três mensagens a seguir:
-  Escrever "... então se passaram ", dias, " dias"
+#* '''Números iguais''', caso os números sejam iguais
-Fim
+#* '''Primeiro é maior''', caso o primeiro seja maior que o segundo;
-</syntaxhighlight> Nesse exemplo há duas variáveis: ''dias'' e ''anos''
+#* '''Segundo maior''', caso o segundo seja maior que o primeiro.
-* '''Constante:''' semelhante à variável, porém o dado armazenado não pode ser modificado. Exemplo em Portugol:<syntaxhighlight lang=text>
+# Ler 10 valores e escrever quantos desses valores lidos estão no intervalo [10,20] (incluindo os valores 10 e 20 no intervalo) e quantos deles estão fora deste intervalo.
-Inicio
+# Faça um algoritmo para ler o código e o preço de 15 produtos, calcular e escrever:
-  constante inteiro diasPorAno <- 365
+#* O maior preço lido
-  inteiro anos, dias
+#* A média aritmética dos preços dos produtos
-  Escrever "Quantos anos se passaram ? "
+==31/08: Lógica de Programação==
-  Ler anos
+* Resolução de exercícios
-  dias <- anos * diasPorAno
+* Vetores
-  Escrever "... então se passaram ", dias, " dias"
-Fim
-</syntaxhighlight> Nesse exemplo há uma constante: ''diasPorAno''
-<br>
+==02/09: Lógica de Programação==
-Variáveis e constantes devem ser declaradas antes de serem usadas (algumas poucas linguagens, como [http://www.python.org Python] e [http://www.perl.org Perl], não exigem isto). A declaração consiste do tipo e identificador da variável. O tipo corresponde ao tipo de valor que pode ser guardado, e o identificador é o nome da variável. No exemplo abaixo:
+* Exercícios de lógica de programação utilizando vetores
-<syntaxhighlight lang=text>
+===Exercícios Propostos (Vetores)===
-  constante inteiro diasPorAno <- 365
+* Utilizando diagrama de blocos (fluxogramas) desenvolva algoritmos para os problemas descritos.
-  inteiro anos, dias
-Fim
-</syntaxhighlight>
-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.
+# Escreva um algoritmo que permita a leitura dos nomes de 10 pessoas e armazene os nomes lidos em um vetor. Após isto, o algoritmo deve permitir a leitura de mais 1 nome qualquer de pessoa e depois escrever a mensagem ACHEI, se o nome estiver entre os 10 nomes lidos anteriormente (guardados no vetor), ou NÃO ACHEI caso contrário.
+# Escreva um algoritmo que permita a leitura das notas de uma turma de 20 alunos. Calcular a média da turma e contar quantos alunos obtiveram nota acima desta média calculada. Escrever a média da turma e o resultado da contagem.
+#  Ler um vetor de 20 posições (aceitar somente números positivos). Escrever a seguir o valor do maior elemento do vetor e a respectiva posição que ele ocupa no vetor.
+# Ler um vetor A de 10 números. Após, ler mais um número e guardar em uma variável X. Armazenar em um vetor M o resultado de cada elemento de A multiplicado pelo valor X. Logo após, imprimir o vetor M.
+# Faça um algoritmo para ler 20 números e armazenar em um vetor. Após a leitura total dos 20 números, o algoritmo deve escrever esses 20 números lidos na ordem inversa.
-'''''Tipos de variáveis e constantes no Portugol:'''''
+===Entrega dos exercícios===
+* Em dupla, por '''e-mail (tisemp@ifsc.edu.br)''' em formato digital (ferramenta DIA ou equivalente)
+* Entrega até '''06/09/2011''' (terça-feira)
+==07/09: Feriado Nacional==
+* Independência do Brasil ;)
-{| border="1" cellpadding="2"
+==09/09: Portugol==
- !Tipo
+* Adoção do [http://www.dei.estt.ipt.pt/portugol/node/33 Portugol IDE] como ferramenta didática.
- !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 [http://pt.wikipedia.org/wiki/ASCII tabela ASCII] || Caracter letra <- "A"
- |-
- |Texto||Uma sequência de caracteres (ou ''string'') || Texto palavra <- "um teste"
-|}
-A declaração de constantes é semelhante à de variáveis, bastanto prefixá-las com a palavra-chave ''constante''.
+=== Portugol ===
+As aulas de Lógica de Programação usarão um software de auxílio ao ensino de algoritmos chamado [http://orion.ipt.pt/%7Emanso/Portugol/ Portugol], desenvolvido na [http://www.dei.estt.ipt.pt/portal/ Escola Superior de Engenharia do Instituto Politécnico de Tomar], em Portugal.
+* [http://www.sj.ifsc.edu.br/~msobral/SOP/portugol.html Guia rápido de instalação e utilização do Portugol].
-=== Atividade ===
+==== Guia rápido de instalação e utilização do Portugol ====
-Para os exercícios abaixo, desenhe o fluxograma e escreva o algoritmo no Portugol.
+Abaixo segue uma breve ajuda de como obtê-lo, instalá-lo e usá-lo. Esse guia assume que você esteja usando o Ubuntu Linux 9.04 ou superior.
-# Faça um algoritmo que calcule a média de quatro números, porém mostrando as casas decimais (caso existam).
+# Faça o [http://www.sj.ifsc.edu.br/%7Emsobral/SOP/soft/portugol23.tar.gz download] do Portugol.
-# Escreva um algoritmo que mostre, em sequência: 9, 9^2 (ao quadrado), 9^3 (ao cubo) e a soma desses 3 números.
+# Descompacte-o com o seguinte comando: <syntaxhighlight lang=bash>
-# Escreva um algoritmo que leia o nome, sobrenome e idade de uma pessoa, e escreva na tela: <syntaxhighlight lang=text>
+tar xzf portugol23.tar.gz
-sobrenome, nome
+</syntaxhighlight>
-idade anos
+# Repare que existe agora um subdiretório portugol no diretório onde você o descompactou. Execute o Portugol com o seguinte comando: <syntaxhighlight lang=bash>
+java -jar portugol/Portugol.jar
+</syntaxhighlight> Obs: você precisará ter Java instalado. Caso não o tenha, execute o comando: <syntaxhighlight lang=bash>
+sudo apt-get install openjdk-6-jre
 </syntaxhighlight>
+# Copie esse [http://tele.sj.ifsc.edu.br/~tisemp/SOP/fluxogramas.cfg arquivo] para poder ver fluxogramas coloridos, e grave-o no memso diretório onde está o Portugol.
+# Veja a [http://www.sj.ifsc.edu.br/%7Emsobral/SOP/soft/help/index.html ajuda] do Portugol, e use-a sempre que tiver dúvidas !
-==13/04: Algoritmos==
+<br>A tela inicial do Portugol segue abaixo, junto com um programa demonstrativo.<br>
-* 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:
+[[Imagem:Editor-Portugol.png]]
+Exemplos de programas iniciais em Portugol:
-<code>
+# ''Lendo um número e mostrando-o na tela em seguida:'' <syntaxhighlight lang=text>
-inicio
+Inicio
-    //declaração das variáveis
+  inteiro x
-    texto nome<-"", sobrenome<-"", endereco<-""
-    inteiro ano<-0, idade<-0
-    constante inteiro ano_atual <- 2010
-    caracter sexo<-"X"
-    //área de leitura de valores
+  Escrever "Digite um numero: ",
-    escrever "Informe o Nome: "
+  Ler X
-    ler nome
+  Escrever "Numero digitado: ", x
-    escrever "Informe o Sobrenome: "
+Fim
-    ler sobrenome
+</syntaxhighlight>
-    escrever "Informa o endereço: "
+# ''Lendo dois números, somando-os e mostrando o resultado na tela:'' <syntaxhighlight lang=text>
-    ler endereco
+Inicio
-    escrever "Informe o ano de nascimento: "
+  inteiro x, y
-    ler ano
-    escrever "Informe o sexo (M ou F): "
-    ler sexo
-    //calcula idade
+  Escrever "Digite um numero: ",
-    idade <- (ano_atual - ano)
+  Ler x
+  Escrever "Digite outro numero: ",
+  Ler y
+  Escrever "Soma = ", x+y
+Fim
+</syntaxhighlight>O programa abaixo é equivalente:<syntaxhighlight lang=text>
+Inicio
+  inteiro x, y, z
+  Escrever "Digite um numero: ",
-    //Mostra valores
+  Ler x
-    escrever "\n ****** Dados Pessoais ******"
+  Escrever "Digite outro numero: ",
+  Ler y
-    escrever "\nNome Completo: ", nome, " ",sobrenome
+  z <- x + y
-    escrever "\nEndereço: ", endereco
+  Escrever "Soma = ", z
-    escrever "\nAno de Nascimento: ", ano
+Fim
-    escrever "\nIdade: ", idade
-    escrever "\nSexo: ", sexo
-fim
 </syntaxhighlight>
-* Solução do exercício das poltronas no cinema:
+=== Atividades ===
-<code>
+# ''Média de três números:'' escreva um programa para calcular a média de três números. <syntaxhighlight lang=text>
-inicio
+Inicio
-    // variaveis
+  Inteiro n1, n2, n3, r
-    inteiro ncadeira <- 0 , fila <- 0 , cadeira <- 0 , calculo <- 0
-    // area de leitura
+  Escrever "Primeiro numero: "
-    escrever "informe o número de sua cadeira:\n"
+  ler n1
-    ler ncadeira
+  Escrever "Segundo numero: "
+  ler n2
+  Escrever "Terceiro numero: "
+  ler n3
-    // area de calculo
+  r <- (n1 + n2 + n3) /3
-    fila <- ( ncadeira / 20 ) + 1
-    cadeira <- ( ncadeira % 20 )
-    // mostrar valores
+  Escrever "Media=", r
-    escrever "Fila: " , fila
+Fim
-    escrever "\nCadeira: " , cadeira
-fim
 </syntaxhighlight>
+# ''Sequência de Fibonacci:'' em matemática corresponde aos números: <syntaxhighlight lang=text>
+, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
+</syntaxhighlight>... que pode ser descrita pela relação de recorrência <br><br><math>F_{n} = F_{n-1} + F_{n-2}</math><br><br>... com valores iniciais <math>F_{0} = 1</math> e <math>F_{1} = 1</math>.<br><br>Numerosas formas na natureza apresentam essa sequência, como neste girassol (cujas flores se dispõem em uma espiral):<br><br>[[Imagem:Sunflower.jpg]]  [[Imagem:espiral_fibonacci.png]] [[Imagem:FibonacciBlocks.png]]<br><br>Usando o Portugol escreva um programa que mostre os 10 primeiros números dessa sequência.
-===Desenvolvimento de algoritmos===
+==14/09: Constantes e Variáveis==
-Escreva um algoritmo utilizando a ferramenta Portugol para cada uma das questões abaixo:
+=== Variáveis e constantes ===
-. 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.
+* '''Variável:''' capaz de guardar um dado a ser usado no algoritmo. Pode ser entendida como uma caixa, onde se coloca um dado e se pode consultá-lo quantas vezes for necessário. O dado pode ser modificado (substituído por outro). Exemplo em Portugol: <syntaxhighlight lang=text>
+Inicio
+  inteiro anos, dias
-. Ler dois números inteiros, x e y, e imprimir o quociente e o resto da divisão inteira entre eles.
+  Escrever "Quantos anos se passaram ? "
+  Ler anos
+  dias <- anos * 365
+  Escrever "... então se passaram ", dias, " dias"
+Fim
+</syntaxhighlight> Nesse exemplo há duas variáveis: ''dias'' e ''anos''
+* '''Constante:''' semelhante à variável, porém o dado armazenado não pode ser modificado. Exemplo em Portugol:<syntaxhighlight lang=text>
+Inicio
+  constante inteiro diasPorAno <- 365
+  inteiro anos, dias
-. Que informe a área e o volume de um cilindro.
+  Escrever "Quantos anos se passaram ? "
+  Ler anos
+  dias <- anos * diasPorAno
+  Escrever "... então se passaram ", dias, " dias"
+Fim
+</syntaxhighlight> Nesse exemplo há uma constante: ''diasPorAno''
-. Para ler dois valores reais do teclado, calcular e imprimir na tela:
+<br>
-a) A soma destes valores b) O produto deles c) O quociente entre eles
+Variáveis e constantes devem ser declaradas antes de serem usadas (algumas poucas linguagens, como [http://www.python.org Python] e [http://www.perl.org Perl], não exigem isto). A declaração consiste do tipo e identificador da variável. O tipo corresponde ao tipo de valor que pode ser guardado, e o identificador é o nome da variável. No exemplo abaixo:
-. 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:
+<syntaxhighlight lang=text>
-a) de imposto: 45% sobre o custo do carro;
+  constante inteiro diasPorAno <- 365
-b) de lucro do distribuidor: 12% sobre o custo do carro.
+  inteiro anos, dias
+Fim
+</syntaxhighlight>
-. Ler os três coeficientes de uma equação de segundo grau e determinar suas raízes.
+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.
-. Imprimir a tabuada de qualquer número n, informado pelo usuário.
+'''''Tipos de variáveis e constantes no Portugol:'''''
-==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.
+{| border="1" cellpadding="2"
+ !Tipo
+ !Descrição
+ !Exemplo
+ |-
+ |Inteiro||Número inteiro entre -2 147 483 648 e 2 147 483 647 || Inteiro x <- 10
+ |-
+ |Real||Número real entre -1.7 E 308 e 1.7 E 308 || Real y <- 10.789
+ |-
+ |Lógico||Valor booleano, com valores "Verdadeiro" e "Falso" || Logico ok <- Falso
+ |-
+ |Caracter||Um caractere da [http://pt.wikipedia.org/wiki/ASCII tabela ASCII] || Caracter letra <- "A"
+ |-
+ |Texto||Uma sequência de caracteres (ou ''string'') || Texto palavra <- "um teste"
+|}
-Exemplos de expressões aritméticas: <syntaxhighlight lang=text>
+A declaração de constantes é semelhante à de variáveis, bastanto prefixá-las com a palavra-chave ''constante''.
-# Uma expressão que calcula quantos segundos existem em um horário do tipo horas, minutos e segundos
-*horas + 60*minutos + segundos
-# Uma expressão que calcula a velocidade instantânea, segundo um MRV
+=== Atividade ===
-vel_inicial + aceleracao*tempo;
-# Uma expressão que calcula o módulo de um vetor bidimensional, que possui coordenadas x e y
+Para os exercícios abaixo, desenhe o fluxograma e escreva o algoritmo no Portugol.
-raiz(x^2 + y^2)
-</syntaxhighlight>
-Os resultados de expressões podem ser mostrados na tela, ou armazenados em variáveis:
+# Faça um algoritmo que calcule a média de quatro números, porém mostrando as casas decimais (caso existam).
+# Escreva um algoritmo que mostre, em sequência: 9, 9^2 (ao quadrado), 9^3 (ao cubo) e a soma desses 3 números.
-<syntaxhighlight lang=text>
+# Escreva um algoritmo que leia o nome, sobrenome e idade de uma pessoa, e escreva na tela: <syntaxhighlight lang=text>
-# Uma expressão que calcula quantos segundos existem em um horário do tipo horas, minutos e segundos
+sobrenome, nome
-segundos <- 3600*horas + 60*minutos + segundos
+idade anos
-# Uma expressão que calcula a velocidade instantânea, segundo um MRV
-escrever 'Velocidade no instante ', tempo, ' = ', vel_inicial + aceleracao*tempo;
-# Uma expressão que calcula o módulo de um vetor bidimensional, que possui coordenadas x e y
-modulo <- raiz(x^2 + y^2)
 </syntaxhighlight>
-Repare que uma expressão fica sempre do lado direito, quando atribuída a uma variável. A expressão é primeiro calculada, e em seguida seu resultado é armazenado na variável:
+==16/09: Algoritmos==
-<syntaxhighlight lang=text>
+* 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:
-segundos <- 3600*horas + 60*minutos + segundos
-</syntaxhighlight>
-=== Operadores aritméticos ===
+<code>
+inicio
+    //declaração das variáveis
+    texto nome<-"", sobrenome<-"", endereco<-""
+    inteiro ano<-0, idade<-0
+    constante inteiro ano_atual <- 2010
+    caracter sexo<-"X"
-Expressões aritméticas sao compostas por números e operadores aritméticos:
+    //área de leitura de valores
+    escrever "Informe o Nome: "
-Obs: para os exemplos abaixo são usadas estas variáveis: <syntaxhighlight lang=text>
+    ler nome
-Real x, area, lado
+    escrever "Informe o Sobrenome: "
-inteiro dias, horas
+    ler sobrenome
-</syntaxhighlight>
+    escrever "Informa o endereço: "
+    ler endereco
+    escrever "Informe o ano de nascimento: "
+    ler ano
+    escrever "Informe o sexo (M ou F): "
+    ler sexo
-{| border="1" cellpadding="2"
+    //calcula idade
- !Operador
+    idade <- (ano_atual - ano)
- !Descrição
- !Exemplo
- |-
- |<nowiki>+</nowiki>||Adição|| x <- x + 1
- |-
- |<nowiki>-</nowiki>||Subtração|| x <- x - 1
- |-
- |*||Multiplicação|| x <- x*x*x
- |-
- |/||Divisão|| dias <- horas / 24
- |-
- |%||Módulo (resto de divisão)|| horas <- horas % 24
- |-
- |^||Potenciação|| area <- lado^2
-|}
-Precedência dos operadores (nesta ordem): ^, *, /, %, + e -
-A precedência pode ser modificada com o uso de parênteses. Ex:
+    //Mostra valores
+    escrever "\n ****** Dados Pessoais ******"
-<syntaxhighlight lang=text>
+    escrever "\nNome Completo: ", nome, " ",sobrenome
-escrever 1 + 2 * 3
+    escrever "\nEndereço: ", endereco
-escrever (1 + 2)*3
+    escrever "\nAno de Nascimento: ", ano
+    escrever "\nIdade: ", idade
+    escrever "\nSexo: ", sexo
+fim
 </syntaxhighlight>
-No Portugol, existem também algumas [http://www.sj.ifsc.edu.br/%7Emsobral/SOP/soft/help/funcoes_biblioteca.html funções úteis], como a função '''''raiz''''': <syntaxhighlight lang=text>
+* Solução do exercício do Polígono (Wagner)
-r <- raiz(x^2 + y^2)
+<code>
+ inicio
+ //variáveis
+ real lado<-0
+ inteiro N<-3
+ texto unidade <- "cm"
+    Escrever "Digite o valor dos lados(em cm): "
+    ler lado
+    Escrever "Quantos lados possui o seu poligono?(deve ser maior que 2)", "\nResp.: "
+    ler N
+    Escrever "O perimetro do seu poligono é: ", lado*N , " cm"
+ fim
 </syntaxhighlight>
-O resultado de expressões aritméticas depende dos tipos numéricos das variáveis e constantes: <syntaxhighlight lang=text>
+* Solução do exercício da área do triângulo (Anna Luiza)
+<code>
 inicio
-  real x
+    real base <- 0.0 , altura <- 0.0
-  inteiro y
-  inteiro resultadoInteiro
+    escrever "Insira a altura: "
-  real resultadoReal
+    ler altura
+    escrever "Insira a medida da base: "
-  x <- 9
+    ler base
-  y <- 9
+    escrever "A área do triângulo é: " , ( altura * base ) / 2
+fim
-  escrever "O resultado de uma expressÃ£o aritmética depende dos tipos das variá¡veis e constantes\n"
+</syntaxhighlight>
-  escrever "usadas na expressão. Se forem todas inteiras, então o resultado será inteiro.\n"
-  escrever "Veja este exemplo: \n"
+* Solução do exercício de conversão de temperatura (Bruno)
-  escrever "Variável inteira y=", y
+<code>
-  escrever "\nExpressão: y/2=", y/2
+Inicio
-  escrever "\n\nNeste segundo exemplo, repete-se a mesma expressão, porém usando-se uma\n"
+real fah<-0.0, cent<-0.0
-  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 "Digite a temperatura em Fahrenheit: "
-  escrever "atribuído a uma variável inteira, então apenas a parte inteira será guardada:\n"
+ler fah
-  escrever "Variável real x=", x, " e inteira y=", y
+cent<- (fah-32)*5/9
-  y <- (x+y)/2
+Escrever "A temperatura em graus Centigrados é de: ", cent, "ºC"
-  escrever "\nExpressão: y <- (x+y)/2 ... após executada, y=", y
 fim
 </syntaxhighlight>
-=== Atividades ===
+* Solução do exercício das poltronas no cinema (Cleber):
-# Escreva um algoritmo que calcule a raiz de uma equação de 1o grau.
+<code>
-# Escreva um algoritmo que calcule as raízes de uma equação de 2o grau. Assuma que existam duas raízes reais
-# 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.
-# 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:
-<syntaxhighlight lang=text>
 inicio
-     real va , vb , vc , x1,delta,x2 <- 0.0
+     // variaveis
-    escrever "Digite um valor para A: "
+     inteiro ncadeira <- 0 , fila <- 0 , cadeira <- 0
-     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
-</syntaxhighlight>
-==16/04: Estruturas de decisão==
+    // area de leitura
+    escrever "informe o número de sua cadeira:\n"
+    ler ncadeira
-==Isso mesmo aula no sábado (das 8h:30m às 11h:30m)==
+    // area de calculo
+    fila <- ( ncadeira / 20 ) + 1
+    cadeira <- ( ncadeira % 20 )
-Páginas da apostila: 26 a 31.
+    // mostrar valores
+    escrever "Fila: " , fila
+    escrever "\nCadeira: " , cadeira
+fim
+</syntaxhighlight>
-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:
+===Desenvolvimento de algoritmos===
-<syntaxhighlight lang=text>
+Escreva um algoritmo utilizando a ferramenta Portugol para cada uma das questões abaixo:
-  Se pontuacao > recorde então
-    recorde <- pontuação
-  FimSe
-</syntaxhighlight>
-O exemplo acima mostra a estrutura de decisão ''Se condição entao comandos Fimse''. Veja o próximo exemplo:
+. 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.
-<syntaxhighlight lang=text>
+. Ler dois números inteiros, x e y, e imprimir o quociente e o resto da divisão inteira entre eles.
-  Se conceito > 70 entao
-    escrever 'Voce esta aprovado'
-  senao
-    escrever 'Desta vez não deu ... tente de novo !'
-  Fimse
-</syntaxhighlight>
-O uso de ''Se condição entao comandos Senao comandos Fimse'' possibilita que se execute uma sequência de comandos se a condição for verdadeira, e outra sequência se for falsa.
+. Que informe a área e o volume de um cilindro.
-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.
+. 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
-=== Condições ===
+. 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;
-Obs: para os exemplos abaixo são usadas estas variáveis: <syntaxhighlight lang=text>
+b) de lucro do distribuidor: 12% sobre o custo do carro.
-Logico correto, multa, aprovado, barato, bombear_agua
-Logico descartar, baixo, reprovado, erro, enviado, recebido
+. Ler os três coeficientes de uma equação de segundo grau e determinar suas raízes.
-inteiro erros, pontuacao, preco, endereco, velocidade
-Real faltas, nivel_agua, altura
-</syntaxhighlight>
-''Operadores relacionais''
+. Imprimir a tabuada de qualquer número n, informado pelo usuário.
-{| border="1" cellpadding="2"
- !Operador
- !Descrição
- !Exemplo
- |-
- |=||Igualdade|| correto <- (erros = 0)
- |-
- |>||Maior|| multa <- (velocidade > 80)
- |-
- |>=||Maior ou igual|| aprovado <- (pontuacao >= 70)
- |-
- |<||Menor|| barato <- (preco < 100)
- |-
- |<=||Menor ou igual|| bombear_agua <- (nivel_agua <= 0.7)
- |-
- |=/=||Diferente|| descartar <- (endereco =/= 12345)
-|}
+==14/04: Expressões lógicas e aritméticas==
-''Operadores lógicos''
+'''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.
-{| border="1" cellpadding="2"
- !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
+Exemplos de expressões aritméticas: <syntaxhighlight lang=text>
+# Uma expressão que calcula quantos segundos existem em um horário do tipo horas, minutos e segundos
+*horas + 60*minutos + segundos
-Lembre que a precedência pode ser modificada com o uso de parênteses.
+# Uma expressão que calcula a velocidade instantânea, segundo um MRV
+vel_inicial + aceleracao*tempo;
-==20/04: Exercícios estruturas de decisão==
+# Uma expressão que calcula o módulo de um vetor bidimensional, que possui coordenadas x e y
+raiz(x^2 + y^2)
+</syntaxhighlight>
-===Atividades para serem desenvolvidas:===
+Os resultados de expressões podem ser mostrados na tela, ou armazenados em variáveis:
-# Faça um programa que leia um número e então informe se ele é par ou ímpar.
+<syntaxhighlight lang=text>
-# 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:
+# Uma expressão que calcula quantos segundos existem em um horário do tipo horas, minutos e segundos
-#* Se a velocidade for maior que 80 km/h, a multa é de R$ 360.
+segundos <- 3600*horas + 60*minutos + segundos
-#* Se a velocidade for maior que 60 km/h, a multa é de R$ 180.
-#* Se a velocidade for menor ou igual a 60 km/h, não há multa.<br><br>Escreva um algoritmo que calcule a multa de acordo com a velocidade de um veículo.
+# Uma expressão que calcula a velocidade instantânea, segundo um MRV
-# Faça um algoritmo que leia três números do teclado, e mostre o maior e menor números.
+escrever 'Velocidade no instante ', tempo, ' = ', vel_inicial + aceleracao*tempo;
-#O objetivo  de um  estudo médico feito entre os anos 70 e 80 foi o desenvolvimento de um método para identificar pacientes de alto risco (que não sobreviverão ao menos 30 dias) com  base nos dados obtidos nas primeiras 24 horas. O diagrama abaixo mostra uma regra de classificação que foi produzida nesse estudo. A letra F  significa que não há um risco alto, e a letra G quer dizer paciente de alto risco.[[imagem:Crt-decisao.png]]
-Essa regra classifica os pacientes como F ou G dependendo de respostas do tipo sim/não a no máximo três perguntas. Como  seria um algoritmo que a implementasse ? Escreva um  algoritmo  que faça o teste de risco de paciente cardíaco de um paciente, conforme descrito acima.
+# Uma expressão que calcula o módulo de um vetor bidimensional, que possui coordenadas x e y
-# 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.
+modulo <- raiz(x^2 + y^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:
+</syntaxhighlight>
-#* 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<br>Escreva um algoritmo que informe se um acesso foi permitido, em função do horário e do tipo de usuário.
-# Modifique o algoritmo acima para adicionar a seguinte restrição:
-#* 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
-# Faça um algoritmo para fazer a divisão de dois números reais. Antes de dividi-los deve ser feito um teste de validade. Caso não seja possível dividi-los, deve ser mostrada uma mensagem de erro. Se for possível, deve-se mostrar o resultado da divisão.
-# Faça um jogo de par ou ímpar, em que o jogador aposta contra o computador. O jogador deve digitar um número entre 0 e 5 e optar entre par ou ímpar. O computador deve sortear um número também entre 0 e 5. Se a paridade da soma dos números do jogador e do computador for a mesma que o jogador optou, então ele ganha a partida, senão o computador vence.
-# Escreva um algoritmo para identificar se há, dentre três palavras lidas do teclado, ao menos duas palavras distintas que pertençam ao conjunto {azul, preto, vermelho}. Exemplos:
-#* Se o usuário digitar ''verde'', ''preto'', ''vermelho'', o programa deve mostrar na tela ''verdadeiro''
-#* Se o usuário digitar ''verde'', ''preto'', ''preto'', o programa deve mostrar na tela ''falso''
-#* Se o usuário digitar ''azul'', ''preto'', ''azul'', o programa deve mostrar na tela ''verdadeiro''
-===Solução Exercício 3:===
+Repare que uma expressão fica sempre do lado direito, quando atribuída a uma variável. A expressão é primeiro calculada, e em seguida seu resultado é armazenado na variável:
 <syntaxhighlight lang=text>
-inicio
+segundos <- 3600*horas + 60*minutos + segundos
-    inteiro num<-0,maior<-0,menor<-0, i<-0
+</syntaxhighlight>
-    constante inteiro valores<-2 //declaração da constante
+=== Operadores aritméticos ===
-    escrever "Digite um valor: \n"
-    ler num
+Expressões aritméticas sao compostas por números e operadores aritméticos:
-    maior <- num
-    menor <- num
+Obs: para os exemplos abaixo são usadas estas variáveis: <syntaxhighlight lang=text>
-    para i de 1 até valores passo 1
+Real x, area, lado
-        ler num
+inteiro dias, horas
-        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
 </syntaxhighlight>
-===Solução Exercício 6:===
+{| border="1" cellpadding="2"
-<syntaxhighlight lang=text>
+ !Operador
-inicio
+ !Descrição
-  texto cor1, cor2, cor3
+ !Exemplo
-  inteiro cont <- 0
+ |-
+ |<nowiki>+</nowiki>||Adição|| x <- x + 1
-  ler cor1
+ |-
-  ler cor2
+ |<nowiki>-</nowiki>||Subtração|| x <- x - 1
-  ler cor3
+ |-
+ |*||Multiplicação|| x <- x*x*x
-  se cor1 = "preto" ou cor2 = "preto" ou cor3 = "preto" entao
+ |-
-    cont <- cont + 1
+ |/||Divisão|| dias <- horas / 24
-  fimse
+ |-
+ |%||Módulo (resto de divisão)|| horas <- horas % 24
+ |-
+ |^||Potenciação|| area <- lado^2
+|}
+Precedência dos operadores (nesta ordem): ^, *, /, %, + e -
-  se cor1 = "azul" ou cor2 = "azul" ou cor3 = "azul" entao
+A precedência pode ser modificada com o uso de parênteses. Ex:
-    cont <- cont + 1
-  fimse
-  se cor1 = "vermelho" ou cor2 = "vermelho" ou cor3 = "vermelho" entao
+<syntaxhighlight lang=text>
-    cont <- cont + 1
+escrever 1 + 2 * 3
-  fimse
+escrever (1 + 2)*3
-  se cont > 1 entao
-    escrever "verdadeiro"
-  senao
-    escrever "falso"
-  fimse
-fim
 </syntaxhighlight>
-==21/04: Exercícios estruturas de decisão==
+No Portugol, existem também algumas [http://www.sj.ifsc.edu.br/%7Emsobral/SOP/soft/help/funcoes_biblioteca.html funções úteis], como a função '''''raiz''''': <syntaxhighlight lang=text>
-* Feriado Nacional - Tiradentes
+r <- raiz(x^2 + y^2)
+</syntaxhighlight>
-==27/04: Estruturas de decisão==
+O resultado de expressões aritméticas depende dos tipos numéricos das variáveis e constantes: <syntaxhighlight lang=text>
+inicio
-Há situações em que se precisa fazer um conjunto de comparações, como mostrado abaixo:
+  real x
+  inteiro y
-<syntaxhighlight lang=text>
+  inteiro resultadoInteiro
-// Lê a data no formato numérico dia, mes, ano, e mostra a data no formato
+  real resultadoReal
-// dia, nome do mês, ano.
-Inicio
+  x <- 9
-   inteiro dia, mes, ano
+  y <- 9
-   texto nome_mes
+  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 "Dia: "
+   escrever "\n\nNo entanto, se uma expressão tiver um resultado real, mas este for\n"
-   ler dia
+   escrever "atribuído a uma variável inteira, então apenas a parte inteira será guardada:\n"
-   escrever "Mes: "
+   escrever "Variável real x=", x, " e inteira y=", y
-   ler mes
+   y <- (x+y)/2
-   escrever "Ano: "
+   escrever "\nExpressão: y <- (x+y)/2 ... após executada, y=", y
-   ler ano
+fim
+</syntaxhighlight>
+=== Atividades ===
+# Escreva um algoritmo que calcule a raiz de uma equação de 1o grau.
+# Escreva um algoritmo que calcule as raízes de uma equação de 2o grau. Assuma que existam duas raízes reais
+# 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.
+# 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:
-  se mes = 1 entao
+<syntaxhighlight lang=text>
-     nome_mes <- "Janeiro"
+inicio
-  senao
+     real va , vb , vc , x1,delta,x2 <- 0.0
-     se mes = 2 entao
+    escrever "Digite um valor para A: "
-      nome_mes <- "Fevereiro"
+     ler va
-     senao
+     escrever "Digite um valor para B: "
-      se mes = 3 entao
+     Ler vb
-        nome_mes <- "Março"
+    escrever "Digite um valor para C: "
-      senao
+    Ler vc
-        se mes = 4 entao
-          nome_mes <- "Abril"
+    escrever "Sua equação é: " ,va,"x^2+",vb,"x+",vc, "=0\n"
-        senao
+    delta <- (vb ^ 2) - (4*va*vc)
-          se mes = 5 entao
+    escrever delta ,"\n"
-            nome_mes <- "Maio"
+     x1 <- ((-vb) + (raiz(delta))) / (2*va)
-          senao
+    Escrever " x ' = " , x1
-            se mes = 6 entao
+    x2 <- ((-vb) - (raiz(delta))) / (2*va)
-              nome_mes <- "Junho"
+    Escrever "\n x '' = " , x2
-            senao
+fim
-              se mes = 7 entao
+</syntaxhighlight>
-                nome_mes <- "Julho"
-              senao
+==21/09: Estruturas de decisão==
-                se mes = 8 entao
-                  nome_mes <- "Agosto"
+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:
-               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
+<syntaxhighlight lang=text>
-fim
+   Se pontuacao > recorde então
+    recorde <- pontuação
+  FimSe
 </syntaxhighlight>
-Além de ser trabalhoso esse encadeamento de ''Se ... entao ... senao'', o algoritmo resultante fica pouco legível. Quer dizer, ele fica feio e difícil de entender.
+O exemplo acima mostra a estrutura de decisão ''Se condição entao comandos Fimse''. Veja o próximo exemplo:
-Existe uma estrutura de decisão criada justamente para casos como esse, e que resulta em um algoritmo mais limpo e compreensível:
 <syntaxhighlight lang=text>
-// Lê a data no formato numérico dia, mes, ano, e mostra a data no formato
+  Se conceito > 70 entao
-// dia, nome do mês, ano.
+    escrever 'Voce esta aprovado'
-Inicio
+  senao
-  inteiro dia, mes, ano
+    escrever 'Desta vez não deu ... tente de novo !'
-  texto nome_mes
+  Fimse
+</syntaxhighlight>
+O uso de ''Se condição entao comandos Senao comandos Fimse'' possibilita que se execute uma sequência de comandos se a condição for verdadeira, e outra sequência se for falsa.
+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.
-  escrever "Dia: "
+=== Condições ===
-  ler dia
-  escrever "Mes: "
-  ler mes
-  escrever "Ano: "
-  ler ano
-  Escolhe mes
+Obs: para os exemplos abaixo são usadas estas variáveis: <syntaxhighlight lang=text>
-    caso 1:
+Logico correto, multa, aprovado, barato, bombear_agua
-      nome_mes <- "Janeiro"
+Logico descartar, baixo, reprovado, erro, enviado, recebido
-    caso 2:
+inteiro erros, pontuacao, preco, endereco, velocidade
-      nome_mes <- "Fevereiro"
+Real faltas, nivel_agua, altura
-    caso 3:
-      nome_mes <- "Março"
-    caso 4:
-      nome_mes <- "Abril"
-    caso 5:
-      nome_mes <- "Maio"
-    caso 6:
-      nome_mes <- "Junho"
-    caso 7:
-      nome_mes <- "Julho"
-    caso 8:
-      nome_mes <- "Agosto"
-    caso 9:
-      nome_mes <- "Setembro"
-    caso 10:
-      nome_mes <- "Outubro"
-    caso 11:
-      nome_mes <- "Novembro"
-    Defeito:
-      nome_mes <- "Dezembro"
-  fimEscolhe
-  escrever dia, " de ", nome_mes, " de ", ano
-fim
 </syntaxhighlight>
-A estrutura de decisão ''escolhe ... caso'' tem uma certa flexibilidade. No exemplo abaixo, mostra-se a possibilidade de testar mais de um valor no mesmo ''caso'':
+''Operadores relacionais''
+{| border="1" cellpadding="2"
-<syntaxhighlight lang=text>
+ !Operador
-inicio
+ !Descrição
-  caracter sexo
+ !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)
+|}
-  escrever "Qual o seu sexo (f/m):"
-  ler sexo
-  escrever "Olá "
+''Operadores lógicos''
+{| border="1" cellpadding="2"
+ !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
+|}
-  escolhe sexo
+Precedência dos operadores (nesta ordem): NAO, E, OU e XOU
-    caso "m", "M" :
-      escrever "senhor"
+Lembre que a precedência pode ser modificada com o uso de parênteses.
-    caso "f","F" :
-      escrever "senhorita"
+==23/09: Exercícios estruturas de decisão==
-    defeito :
+===Teste surpresa (Estruturas de decisão):===
-      escrever "Sexo indefinido"
-  fimescolhe
+# Faça um programa que leia um número e então informe se ele é par ou ímpar.
+# Um radar de trânsito faz a medição de velocidade de veículos e, dependendo do valor, calcula a multa a ser aplicada. Em uma determinada via esse radar foi configurado da seguinte forma:
+#* Se a velocidade for maior que 80 km/h, a multa é de R$ 360.
+#* Se a velocidade for maior que 60 km/h, a multa é de R$ 180.
+#* Se a velocidade for menor ou igual a 60 km/h, não há multa.<br>Escreva um algoritmo que calcule a multa de acordo com a velocidade de um veículo.
+# Faça um algoritmo que leia três números do teclado, e mostre o maior e menor números.
+# 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.
-  escrever ", benvindo ao portugol"
+[[imagem:Crt-decisao.png]]
-fim
-</syntaxhighlight>
-=== Atividades ===
+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.
+===Exercícios extras: entrega até dia 27/09===
+* Exercícios devem ser enviados para o e-mail do professor até o dia 27/09
+* Entrega individual. Não copie exercícios de seu colega. Plágio não será aceito.
-# Faça um algoritmo que converta um número de 1 a 7 para o respectivo dia da semana (ex: 1 = domingo, 2 = 2a feira, e assim por diante).
-# Faça uma calculadora com as quatro operações aritméticas. Sua calculadora deve ler (nesta ordem) o primeiro número, a operação aritmética (que deve ser informada usando o símbolo da respectiva operação: +, -, * ou /), e depois o segundo número. Ao final, seu algoritmo deve mostrar o resultado, ou uma mensagem de erro se a operação não for possível de realizar (ex: divisão por zero).
-# A previsão do tempo na costa brasileira pode ser feita de forma aproximada usando-se um barômetro e um termômetro. Uma estimativa com boa chance de acerto se baseia na tabela abaixo: <br>[[imagem:Previsao-barometro.png|800px]]<br><br>Faça um algoritmo que forneça uma estimativa da previsão do tempo, usando essa tabela.
-# Faça um algoritmo que mostre qual o último dia de um determinado mês informado pelo teclado. Caso seja informado o mês 2 (fevereiro), seu algoritmo deve identificar se é 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):
-## De 4 em 4 anos é ano bissexto.
-## De 100 em 100 anos não é ano bissexto.
-## De 400 em 400 anos é ano bissexto.
-## Prevalecem as últimas regras sobre as primeiras.
 # 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.
-# Escreva um programa que leia cinco números do teclado e mostre os dois maiores números.
+# 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:
-# 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é".
+#* Funcionário: apenas entre 0:00 e 7:30, entre 18:30 e 0:00, e entre 12:00 e 13:30
-# 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:
+#* Financeiro: qualquer horário
-#* Tesoura corta papel
+#* Diretoria: qualquer horário<br>Escreva um algoritmo que informe se um acesso foi permitido, em função do horário e do tipo de usuário.
-#* Pedra quebra tesoura
+# Modifique o algoritmo acima para adicionar a seguinte restrição:
-#* Papel embrulha a pedra<br>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.
+#* 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 (8:00 às 18:00)
+#* Diretoria: sem restrições a sites
+# Faça um algoritmo para fazer a divisão de dois números reais. Antes de dividi-los deve ser feito um teste de validade. Caso não seja possível dividi-los, deve ser mostrada uma mensagem de erro. Se for possível, deve-se mostrar o resultado da divisão.
+# Faça um jogo de par ou ímpar, em que o jogador aposta contra o computador. O jogador deve digitar um número entre 0 e 5 e optar entre par ou ímpar. O computador deve sortear um número também entre 0 e 5. Se a paridade da soma dos números do jogador e do computador for a mesma que o jogador optou, então ele ganha a partida, senão o computador vence.
+# Escreva um algoritmo para identificar se há, dentre três palavras lidas do teclado, ao menos duas palavras distintas que pertençam ao conjunto {azul, preto, vermelho}. Exemplos:
+#* Se o usuário digitar ''verde'', ''preto'', ''vermelho'', o programa deve mostrar na tela ''verdadeiro''
+#* Se o usuário digitar ''verde'', ''preto'', ''preto'', o programa deve mostrar na tela ''falso''
+#* Se o usuário digitar ''azul'', ''preto'', ''azul'', o programa deve mostrar na tela ''verdadeiro''
+===Solução Exercício 3:===
-'''Abaixo um exemplo de como utilizar a função aleatório'''.<br> A variável '''valor''' armazena um número inteiro entre 1 e 10 a cada execução do programa
 <syntaxhighlight lang=text>
 inicio
-     inteiro valor <- 0
+     inteiro num<-0,maior<-0,menor<-0, i<-0
+    constante inteiro valores<-2 //declaração da constante
-     valor <- aleatorio()*10+1
+     escrever "Digite um valor: \n"
-     escrever "O valor gerado eh: ", valor
+    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
 </syntaxhighlight>
-==04/05: Estruturas de repetição==
+===Solução Exercício 6:===
+<syntaxhighlight lang=text>
+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
-Páginas da apostila: 32 a 35.
+  se cor1 = "azul" ou cor2 = "azul" ou cor3 = "azul" entao
+    cont <- cont + 1
+  fimse
-Alguns algoritmos vistos anteriormente possuem sequências repetitivas de instruções. Por exemplo, o algoritmo da média de quatro avaliações:
+  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
+</syntaxhighlight>
-<syntaxhighlight lang=text>
+==28/09: Estruturas de decisão==
-Inicio
-  real m1, m2, m3, m4
-  real media
-  escrever 'Avaliação 1:'
+===Engenharia de Telecomunicações: início de oferta 2012-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
+O curso de Engenharia de Telecomunicações começa a ser ofertado em 2012-1 no Instituto Federal de Santa Catarina, campus São José. Mais informações sobre o ingresso acesse: [http://ingresso.ifsc.edu.br portal do ingresso]. Trata-se de um curso gratuito e com duração de 5 anos. O atual curso superior de tecnologia em Telecomunicações recebeu o conceito máximo (5) na avaliação do MEC.
-  escrever 'Média: ', media
+Parabéns à todos os envolvidos na concepção desse projeto. Sucesso aos futuros Engenheiros de Telecomunicações, formados pelo IFSC, Campus São José.
-Fim
-</syntaxhighlight>
-O algoritmo acima repete quatro vezes a sequência que lê uma nota do teclado. Porém há uma forma de expressar a repetição de sequências de instruções, usando-se o que se chama de ''estrutura de repetição''. A estrutura de repetição '''''enquanto''''' ''condição'' '''''faz''''' repete todas as instruções enquanto a condição for verdadeira. A condição é escrita como uma expressão lógica, da mesma forma que na estrutura de decisão '''''se''''' ''condição'' '''''então ... senão'''''. Veja como fica o algoritmo acima ao ser reescrito para usar essa estrutura de repetição:
+Há situações em que se precisa fazer um conjunto de comparações, como mostrado abaixo:
 <syntaxhighlight lang=text>
+// Lê a data no formato numérico dia, mes, ano, e mostra a data no formato
+// dia, nome do mês, ano.
 Inicio
-   constante inteiro NUMEROS <- 4
+   inteiro dia, mes, ano
-   real m
+   texto nome_mes
-  real media
-  inteiro contador <- 0
-   enquanto contador < NUMEROS faz
+   escrever "Dia: "
-    escrever 'Avaliação ', contador, ':'
+  ler dia
-    ler m
+  escrever "Mes: "
-    media <- media + m
+  ler mes
-    contador <- contador + 1
+  escrever "Ano: "
-   fimEnquanto
+   ler ano
-   escrever 'Média: ', media/NUMEROS
+   se mes = 1 entao
-Fim
+    nome_mes <- "Janeiro"
-</syntaxhighlight>
+  senao
+    se mes = 2 entao
-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:
+      nome_mes <- "Fevereiro"
+    senao
-<syntaxhighlight lang=text>
+      se mes = 3 entao
-Inicio
+        nome_mes <- "Março"
-  constante inteiro NUMEROS <- 7
+      senao
-  real m
+        se mes = 4 entao
-  real media
+          nome_mes <- "Abril"
-  inteiro contador <- 0
+        senao
+          se mes = 5 entao
-  enquanto contador < NUMEROS faz
+            nome_mes <- "Maio"
-    escrever 'Avaliação ', contador, ':'
+          senao
-    ler m
+            se mes = 6 entao
-    media <- media + m
+              nome_mes <- "Junho"
-    contador <- contador + 1
+            senao
-   fimEnquanto
+              se mes = 7 entao
+                nome_mes <- "Julho"
-   escrever 'Média: ', media/NUMEROS
+              senao
-Fim
+                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
 </syntaxhighlight>
-Note que o algoritmo praticamente não foi modificado, pois somente se alterou o valor da constante NUMEROS.
+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.
-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:
+Existe uma estrutura de decisão criada justamente para casos como esse, e que resulta em um algoritmo mais limpo e compreensível:
 <syntaxhighlight lang=text>
-  enquanto contador < NUMEROS faz
+// Lê a data no formato numérico dia, mes, ano, e mostra a data no formato
-    escrever 'Avaliação ', contador, ':'
+// dia, nome do mês, ano.
-    ler m
+Inicio
-    media <- media + m
+  inteiro dia, mes, ano
-    contador <- contador + 1
+   texto nome_mes
-   fimEnquanto
-</syntaxhighlight>
-----
+  escrever "Dia: "
+  ler dia
+  escrever "Mes: "
+  ler mes
+  escrever "Ano: "
+  ler ano
-Um outro exemplo ainda mais simples é mostrar na tela uma contagem numérica:
+  Escolhe mes
+    caso 1:
-<syntaxhighlight lang=text>
+      nome_mes <- "Janeiro"
-inicio
+    caso 2:
-     inteiro contador
+      nome_mes <- "Fevereiro"
-     contador <- 0
+    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
-    enquanto contador < 10 faz
+  escrever dia, " de ", nome_mes, " de ", ano
-        escrever contador , " "
-        contador <- contador + 1
-    fimenquanto
 fim
 </syntaxhighlight>
-Ao executar esse algoritmo, tem-se como resultado:
+A estrutura de decisão ''escolhe ... caso'' tem uma certa flexibilidade. No exemplo abaixo, mostra-se a possibilidade de testar mais de um valor no mesmo ''caso'':
 <syntaxhighlight lang=text>
-1 2 3 4 5 6 7 8 9
+inicio
-</syntaxhighlight>
+  caracter sexo
+  escrever "Qual o seu sexo (f/m):"
+  ler sexo
+  escrever "Olá "
-Repare no uso de uma variável auxiliar ''contador'' para controlar a quantidade de repetições. Essa é uma técnica comum para
+  escolhe sexo
-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:
+    caso "m", "M" :
+      escrever "senhor"
+    caso "f","F" :
+      escrever "senhorita"
+    defeito :
+      escrever "Sexo indefinido"
+  fimescolhe
-<syntaxhighlight lang=text>
+  escrever ", benvindo ao portugol"
-inicio
-    inteiro contador <- 1
-    caracter opcao <- "s"
-    enquanto ((opcao = "s") ou (opcao = "S")) e contador < 11 faz
-        escrever contador, "\n"
-        contador <- contador + 1
-        escrever "\nContinuar (S/N) ? "
-        ler opcao
-    fimenquanto
-    escrever "Terminou com contador = " , contador
 fim
 </syntaxhighlight>
-Nesse exemplo se usa um laço para mostrar uma contagem de 1 a 10. Porém há a possibilidade de encerrar o algoritmo. Observe a condição para continuidade do laço: ela é verdadeira somente se ''contador < 11'' e se a variável ''opcao'' for igual a "s" ou "S".
+=== Atividades ===
-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:
+# Faça um algoritmo que converta um número de 1 a 7 para o respectivo dia da semana (ex: 1 = domingo, 2 = 2a feira, e assim por diante).
+# Faça uma calculadora com as quatro operações aritméticas. Sua calculadora deve ler (nesta ordem) o primeiro número, a operação aritmética (que deve ser informada usando o símbolo da respectiva operação: +, -, * ou /), e depois o segundo número. Ao final, seu algoritmo deve mostrar o resultado, ou uma mensagem de erro se a operação não for possível de realizar (ex: divisão por zero).
+# A previsão do tempo na costa brasileira pode ser feita de forma aproximada usando-se um barômetro e um termômetro. Uma estimativa com boa chance de acerto se baseia na tabela abaixo: <br>[[imagem:Previsao-barometro.png|800px]]<br><br>Faça um algoritmo que forneça uma estimativa da previsão do tempo, usando essa tabela.
+# Faça um algoritmo que mostre qual o último dia de um determinado mês informado pelo teclado. Caso seja informado o mês 2 (fevereiro), seu algoritmo deve identificar se é 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):
+## De 4 em 4 anos é ano bissexto.
+## De 100 em 100 anos não é ano bissexto.
+## De 400 em 400 anos é ano bissexto.
+## Prevalecem as últimas regras sobre as primeiras.
+# 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.
+# Escreva um programa que leia cinco números do teclado e mostre os dois maiores números.
+# 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é".
+# 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<br>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'''.<br> A variável '''valor''' armazena um número inteiro entre 1 e 10 a cada execução do programa
 <syntaxhighlight lang=text>
 inicio
-     constante texto segredo <- "secreto"
+     inteiro valor <- 0
-    texto senha
-     ler senha
+     valor <- aleatorio()*10+1
-     enquanto senha =/= segredo faz
+     escrever "O valor gerado eh: ", valor
-        escrever "Voce continua preso ! Digite a senha correta: "
-        ler senha
-    fimenquanto
-    escrever "Voce foi liberado ..."
 fim
 </syntaxhighlight>
-=== Solução do problema proposto em sala===
+==30/09: Estruturas de repetição==
-<code>
+Páginas da apostila: 32 a 35.
-inicio
-    inteiro opcao <- 0
+Alguns algoritmos vistos anteriormente possuem sequências repetitivas de instruções. Por exemplo, o algoritmo da média de quatro avaliações:
-    real numero1 <- 0 , numero2 <- 0 , resultado <- 0
-    enquanto opcao =/= 5 faz
+<syntaxhighlight lang=text>
-        escrever "\n Entre com a opção desejada: 1- Adição; 2- Subtração; 3- Multiplicação; 4- Divisão , 5- Sair."
+Inicio
-        ler opcao
+  real m1, m2, m3, m4
-        se opcao = 5 entao
+  real media
-            escrever "\n Você saiu com sucesso!"
-        senao
+  escrever 'Avaliação 1:'
-            escrever "\n Lembre-se: Na subtração e na divisão a ordem dos números é importante!"
+  Ler m1
-            escrever "\n Entre com o primeiro número: "
+  escrever 'Avaliação 2:'
-            ler numero1
+  Ler m2
-            escrever "\n Entre com o segundo número: "
+  escrever 'Avaliação 3:'
-            ler numero2
+  Ler m3
-            se opcao = 1 entao
+  escrever 'Avaliação 4:'
-                resultado <- ( numero1 + numero2 )
+  Ler m4
-                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 ===
+  media <- (m1 + m2 + m3 + m4) / 4
-# Escreva um  algoritmo que mostre a tabuada de um número fornecido pelo teclado. Esse número deve estar entre 1 e 10.
+  escrever 'Média: ', media
-# Modifique o exemplo da média para que a quantidade de números a serem lidos seja previamente informada pelo teclado.
+Fim
-# 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).
+</syntaxhighlight>
-# Modifique o exemplo da senha para que o usuário tenha somente três tentativas permitidas para digitar a senha correta. caso ao final as três senhas estejam erradas, o algoritmo deve informar que a conta foi bloqueada.
-# Escreva um algoritmo que leia até 10 números do teclado, e informe ao final qual o maior e o menor deles.
-# Escreva um algoritmo que teste se um número informado pelo teclado é primo.
-==05/05: Estruturas de repetição==
+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:
-* Resolução de exercícios
-* Introdução a variáveis multidimencionais
-=== Uma pequena avaliação :-)===
+<syntaxhighlight lang=text>
+Inicio
+  constante inteiro NUMEROS <- 4
+  real m
+  real media
+  inteiro contador <- 0
-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. <br>
+  enquanto contador < NUMEROS faz
+    escrever 'Avaliação ', contador, ':'
+    ler m
+    media <- media + m
+    contador <- contador + 1
+  fimEnquanto
-Quando concluir o teste, chame o professor!<br>
+  escrever 'Média: ', media/NUMEROS
+Fim
+</syntaxhighlight>
-Boa Sorte
+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:
-==11/05: Estruturas de repetição==
+<syntaxhighlight lang=text>
+Inicio
+  constante inteiro NUMEROS <- 7
+  real m
+  real media
+  inteiro contador <- 0
-=== Variáveis multidimensionais ===
+  enquanto contador < NUMEROS faz
+    escrever 'Avaliação ', contador, ':'
+    ler m
+    media <- media + m
+    contador <- contador + 1
+  fimEnquanto
-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:
+  escrever 'Média: ', media/NUMEROS
+Fim
+</syntaxhighlight>
-<math>A = \begin{pmatrix}
+Note que o algoritmo praticamente não foi modificado, pois somente se alterou o valor da constante NUMEROS.
-& 6 \\
-& 5
-\end{pmatrix}</math>
-Vetores são matrizes unidimensionais, portanto possuem somente uma linha ou uma coluna:
+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:
-<math>v = \begin{pmatrix}
+<syntaxhighlight lang=text>
-& 6 & 2 & 18 & 5
+  enquanto contador < NUMEROS faz
-\end{pmatrix}</math>
+    escrever 'Avaliação ', contador, ':'
+    ler m
+    media <- media + m
+    contador <- contador + 1
+  fimEnquanto
+</syntaxhighlight>
-Cada elemento em uma matriz ou vetor é identificado pela sua posição. Por exemplo, na posição ''1, 2'' da matriz A acima está o valor 6, e na posição ''4'' do vetor ''v'' está o valor 18. Assim, a matriz A do exemplo pode ser entendida da seguinte forma:
+----
-<math>A = \begin{pmatrix}
+Um outro exemplo ainda mais simples é mostrar na tela uma contagem numérica:
-A_{11} & A_{12} \\
-A_{21} & A_{22}
-\end{pmatrix}</math>
-... e o vetor ''v'' do exemplo:
+<syntaxhighlight lang=text>
+inicio
+    inteiro contador
+    contador <- 0
-<math>v = \begin{pmatrix}
+    enquanto contador < 10 faz
-v_{1} & v_{2} & v_{3} & v_{4} & v_{5}
+        escrever contador , " "
-\end{pmatrix}</math>
+        contador <- contador + 1
+    fimenquanto
+fim
+</syntaxhighlight>
-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'':
+Ao executar esse algoritmo, tem-se como resultado:
 <syntaxhighlight lang=text>
-inicio
+1 2 3 4 5 6 7 8 9
-  inteiro A[2][2] <- {{1, 6}, {3, 5}}
+</syntaxhighlight>
-  inteiro M[3][2];
-  inteiro v[5] <- {1, 6, 2, 18, 5}
+Repare no uso de uma variável auxiliar ''contador'' para controlar a quantidade de repetições. Essa é uma técnica comum para
-  inteiro i, j
+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:
-  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"
+<syntaxhighlight lang=text>
+inicio
+    inteiro contador <- 1
+    caracter opcao <- "s"
+    enquanto ((opcao = "s") ou (opcao = "S")) e contador < 11 faz
+        escrever contador, "\n"
+        contador <- contador + 1
+        escrever "\nContinuar (S/N) ? "
+        ler opcao
+    fimenquanto
+    escrever "Terminou com contador = " , contador
 fim
 </syntaxhighlight>
-A declaração da matriz se faz como uma variável comum, porém indicando-se suas dimensões:
+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".
-<syntaxhighlight lang=text>
+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:
-  inteiro A[2][2] <- {{1, 6}, {3, 5}}
-  inteiro M[3][2];
-</syntaxhighlight>
-Exemplo de preenchimento e impressão de matrizes não quadradas
 <syntaxhighlight lang=text>
 inicio
-	inteiro i,j, mat[2][4]
+    constante texto segredo <- "secreto"
+    texto senha
-      //leitura (preenchimento da matriz)
+    ler senha
-      para i de 0 ate 1 passo 1
+    enquanto senha =/= segredo faz
-          para j de 0 ate 3 passo 1
+        escrever "Voce continua preso ! Digite a senha correta: "
-              ler mat[i][j]
+        ler senha
-          proximo
+    fimenquanto
-      proximo
+    escrever "Voce foi liberado ..."
-      //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
 </syntaxhighlight>
-Veja que a matriz ''M'' foi declarada sem valores iniciais, porém a matriz ''A'' foi inicializada na declaração.
+=== Solução do problema proposto em sala===
-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'':
+<code>
-<syntaxhighlight lang=text>
-  # índice 0,0
-  escrever "Valor de A[0][0]: ", A[0][0], "\n"
-</syntaxhighlight>
-O exemplo acima pode ser reescrito usando-se estruturas de repetição:
-<syntaxhighlight lang=text>
 inicio
-  inteiro A[2][2] <- {{1, 6}, {3, 5}}
+    inteiro opcao <- 0
-  inteiro v[5] <- {1, 6, 2, 18, 5}
+    real numero1 <- 0 , numero2 <- 0 , resultado <- 0
-  inteiro i, j
+    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."
-  enquanto i < 2 faz
+        ler opcao
-    j <- 0
+        se opcao = 5 entao
-    enquanto j < 2 faz
+            escrever "\n Você saiu com sucesso!"
-       escrever "Valor do elemento de A na posição ", i, ", ", j, ": ", A[i][j], "\n"
+        senao
-       j <- j + 1
+            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
-    i <- i + 1
+ fim
-  fimenquanto
+</syntaxhighlight>
-  i <- 0
+=== Atividades ===
-  enquanto i < 5 faz
-    escrever "valor de v na posição ", i, ": ", v[i], "\n"
-    i <- i + 1
-  fimenquanto
-fim
+# Escreva um  algoritmo que mostre a tabuada de um número fornecido pelo teclado. Esse número deve estar entre 1 e 10.
-</syntaxhighlight>
+# Modifique o exemplo da média para que a quantidade de números a serem lidos seja previamente informada pelo teclado.
+# Modifique novamente o exemplo da média para que ela funcione para um quantidade de números desconhecida de antemão. Quer dizer, o algoritmo deve ler os números para calcular a média, mas não sabe quantos números existem (e isto não pode ser informado pelo teclado).
+# Modifique o exemplo da senha para que o usuário tenha somente três tentativas permitidas para digitar a senha correta. caso ao final as três senhas estejam erradas, o algoritmo deve informar que a conta foi bloqueada.
+# Escreva um algoritmo que leia até 10 números do teclado, e informe ao final qual o maior e o menor deles.
+# Escreva um algoritmo que teste se um número informado pelo teclado é primo.
-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:
+==05/10: Estruturas de repetição==
+* Resolução de exercícios
+* Introdução a variáveis multidimencionais
-<syntaxhighlight lang=text>
+=== Uma pequena avaliação :-)===
-inicio
-  texto nome_mes[12] <- {"Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto", "Setembro",
-                         "Outubro", "Novembro, "Dezembro"}
-  inteiro dia, mes, ano
-  escrever "Dia: "
+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. <br>
-  ler dia
-  escrever "Mes: "
-  ler mes
-  escrever "Ano: "
-  ler ano
-  escrever dia, " de ", nome_mes[mes], " de ", ano
+Quando concluir o teste, chame o professor!<br>
-fim
-</syntaxhighlight>
+Boa Sorte
-Outro problema comum é precisar guardar um conjunto de valores, e depois ordená-los:
+==07/10: Estruturas de repetição==
-<syntaxhighlight lang=text>
+=== Variáveis multidimensionais ===
-inicio
-  inteiro v[10]
-  inteiro i
-  inteiro quantidade
-  escrever "Quantos valores serão digitados (máximo = 10) ? "
+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:
-  ler quantidade
-  i <- 0
+<math>A = \begin{pmatrix}
-  enquanto i < quantidade faz
+& 6 \\
-    escrever "valor ", i, ": "
+& 5
-    ler v[i]
+\end{pmatrix}</math>
-    i <- i + 1
-  fimenquanto
-  // ordena os valores ...
+Vetores são matrizes unidimensionais, portanto possuem somente uma linha ou uma coluna:
-  escrever "valores ordenados: "
+<math>v = \begin{pmatrix}
-  i <- 0
+& 6 & 2 & 18 & 5
-  enquanto i < quantidade
+\end{pmatrix}</math>
-    escrever v[i], " "
-    i <- i + 1
-  fimenquanto
-fim
-</syntaxhighlight>
+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:
-==12/05: Estruturas de repetição (exercícios)==
+<math>A = \begin{pmatrix}
+A_{11} & A_{12} \\
+A_{21} & A_{22}
+\end{pmatrix}</math>
-# Escreva um algoritmo que leia 5 números do teclado, e depois mostre-os em ordem inversa à que foi digitada.
+... e o vetor ''v'' do exemplo:
-# Escreva um algoritmo que leia dois vetores de 5 números, e depois mostre se os vetores são iguais.
-# Escreva um algoritmo que leia um palavra do teclado e depois procure-a numa lista de palavras preexistente. Essa lista deve ser implementada usando um vetor.
-# Escreva um algoritmo que leia 5 números, e mostre-os em ordem crescente.
-# Modifique o algoritmo anterior para mostrá-los em ordem decrescente.
-# Em um  jogo de bingo devem-se contar quantos números de uma aposta foram sorteados no bingo. Faça um algoritmo que, dados os números sorteados e uma aposta, conta quantos números apostados forma sorteados.
-== 18/05: Revisão para avaliação de Lógica de Programação ==
+<math>v = \begin{pmatrix}
+v_{1} & v_{2} & v_{3} & v_{4} & v_{5}
+\end{pmatrix}</math>
-. 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.
+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'':
-. 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.
+<syntaxhighlight lang=text>
+inicio
+  inteiro A[2][2] <- {{1, 6}, {3, 5}}
+  inteiro M[3][2];
+  inteiro v[5] <- {1, 6, 2, 18, 5}
+  inteiro i, j
-. 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.
+  escrever "Valor de A[0][0]: ", A[0][0], "\n"
+  escrever "Valor de A[0][1]: ", A[0][1], "\n"
+  escrever "Valor de A[1][0]: ", A[1][0], "\n"
+  escrever "Valor de A[1][1]: ", A[1][1], "\n"
+  escrever "Valor de v[0]: ", v[0], "\n"
+  escrever "Valor de v[1]: ", v[1], "\n"
+  escrever "Valor de v[2]: ", v[2], "\n"
+  escrever "Valor de v[3]: ", v[3], "\n"
+  escrever "Valor de v[4]: ", v[4], "\n"
+fim
+</syntaxhighlight>
+A declaração da matriz se faz como uma variável comum, porém indicando-se suas dimensões:
-. 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:
+<syntaxhighlight lang=text>
-#* para homens: (72,7 * h) – 58;
+  inteiro A[2][2] <- {{1, 6}, {3, 5}}
-#* para mulheres: (62,1 * h) – 44,7.
+  inteiro M[3][2];
+</syntaxhighlight>
-. 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:
+Exemplo de preenchimento e impressão de matrizes não quadradas
-#* Maior e o menor peso da turma;
-#* A média de peso dos homens;
-#* A média de peso da turma;
-<!--
-Solução proposta pelo Manfred Ex. 1
-<code>
+<syntaxhighlight lang=text>
 inicio
-    inteiro n1 <- 0 , n2 <- 0 , n3 <- 0 , maior <- 0 , menor <- 0
+	inteiro i,j, mat[2][4]
-    escrever "Digite o primeiro número: "
-    ler n1
+      //leitura (preenchimento da matriz)
-    escrever "Digite o segundo número: "
+      para i de 0 ate 1 passo 1
-    ler n2
+          para j de 0 ate 3 passo 1
-    escrever "Digite o terceiro número: "
+              ler mat[i][j]
-    ler n3
+          proximo
-    maior <- n1
+      proximo
-    se ( n2 > maior ) entao
-        maior <- n2
+      //impressão da matriz
-    fimse
+      para i de 0 ate 1 passo 1
-    se ( n3 > maior ) entao
+          para j de 0 ate 3 passo 1
-        maior <- n3
+              escrever "O valor na linha: ",i, "Coluna: ", j, "eh: ", mat[i][j]
-    fimse
+              escrever "\n"
-    menor <- n1
+          proximo
-    se ( n2 < menor ) entao
+      proximo
-        menor <- n2
+fim
-    fimse
+</syntaxhighlight>
-    se ( n3 < menor ) entao
-        menor <- n3
+Veja que a matriz ''M'' foi declarada sem valores iniciais, porém a matriz ''A'' foi inicializada na declaração.
-    fimse
-    se ( maior % 2 ) = 0 ou ( menor % 2 ) =/= 0 entao
+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'':
-        escrever "Verdadeiro"
-    senao
+<syntaxhighlight lang=text>
-        escrever "Falso"
+  # índice 0,0
-    fimse
+  escrever "Valor de A[0][0]: ", A[0][0], "\n"
-fim
 </syntaxhighlight>
--->
-<!--
+O exemplo acima pode ser reescrito usando-se estruturas de repetição:
-Proposta do Luiz para exercício 5
 <syntaxhighlight lang=text>
 inicio
-    //declaração das variaveis
+  inteiro A[2][2] <- {{1, 6}, {3, 5}}
-    real peso [ 5 ] <- 0 , menor <- 0 , maior <- 0 , pesom <- 0 , pesot <- 0
+  inteiro v[5] <- {1, 6, 2, 18, 5}
-    inteiro i , cont <- 0
+  inteiro i, j
-     caracter sexo [ 5 ]
-    //entrada de dados
+  enquanto i < 2 faz
-    para i de 0 ate 4 passo 1
+    j <- 0
-        escrever "Informe o peso do " , ( i + 1 ) , "º aluno: "
+     enquanto j < 2 faz
-        ler peso [ i ]
+       escrever "Valor do elemento de A na posição ", i, ", ", j, ": ", A[i][j], "\n"
-        escrever "Informe o código do sexo do " , ( i + 1 ) , "º aluno (Masculino= M; Feminino= F): "
+       j <- j + 1
-        ler sexo [ i ]
+     fimenquanto
-        escrever "\n"
+     i <- i + 1
-    proximo
+  fimenquanto
-    //testando o maior e menor peso
-    maior <- peso [ 1 ]
+  i <- 0
-     menor <- peso [ 1 ]
+  enquanto i < 5 faz
-     para i de 0 ate 4 passo 1
+     escrever "valor de v na posição ", i, ": ", v[i], "\n"
-        se ( peso [ i ] > maior ) entao
+     i <- i + 1
-            maior <- peso [ i ]
+  fimenquanto
-        fimse
-        se ( peso [ i ] < menor ) entao
+fim
-            menor <- peso [ i ]
+</syntaxhighlight>
-        fimse
-     proximo
-    //calculando a media de peso dos homens
-    para i de 0 ate 4 passo 1
-        se ( sexo [ i ] = "M" ) ou ( sexo [ i ] = "m" ) entao
-            pesom <- ( pesom + peso [ i ] )
-            cont <- ( cont + 1 )
-        fimse
-    proximo
-     //calculando a media de peso da turma
-    para i de 0 ate 4 passo 1
-        pesot <- ( peso [ i ] + pesot )
-    proximo
-    //impressão dos dados
-    escrever "\nO maior peso é: " , maior , "\nO menor peso é: " , menor
-    escrever "\nA média de peso dos homens é: " , ( pesom / cont )
-    escrever "\nA média de peso da turma é: " , ( pesot / 5 )
-fim
-</syntaxhighlight>
--->
-== 19/05: Revisão Lógica de Programação, com respostas ;) ==
+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:
-. 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.
+<syntaxhighlight lang=text>
+inicio
+  texto nome_mes[12] <- {"Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto", "Setembro",
+                         "Outubro", "Novembro, "Dezembro"}
+  inteiro dia, mes, ano
-<code>
+  escrever "Dia: "
-inicio
+  ler dia
-      //declaração dos vetores A e B
+  escrever "Mes: "
-	inteiro i,a[5],b[5]
+  ler mes
+  escrever "Ano: "
-      //formação do vetor A
+  ler ano
-      para i de 0 ate 4 passo 1
-          ler a[i]
+  escrever dia, " de ", nome_mes[mes], " de ", ano
-      proximo
+fim
+</syntaxhighlight>
-      //guarda valor na posição par
-      para i de 0 ate 4 passo 2
+Outro problema comum é precisar guardar um conjunto de valores, e depois ordená-los:
-          b[i]<-a[i]*5
-      proximo
+<syntaxhighlight lang=text>
+inicio
-      //guarda valor na posição ímpar
+  inteiro v[10]
-      para i de 1 ate 4 passo 2
+  inteiro i
-          b[i]<-a[i]+5
+  inteiro quantidade
-      proximo
+  escrever "Quantos valores serão digitados (máximo = 10) ? "
-      //apresenta valor B resposta
+  ler quantidade
-      escrever "Formação do vetor B (vetor respota):"
-      escrever "\n"
+  i <- 0
+  enquanto i < quantidade faz
-      para i de 0 ate 4 passo 1
+    escrever "valor ", i, ": "
-          escrever "O valor da posição ",i, " é: ", b[i]
+    ler v[i]
-          escrever "\n"
+    i <- i + 1
-      proximo
+  fimenquanto
+  // ordena os valores ...
+  escrever "valores ordenados: "
+  i <- 0
+  enquanto i < quantidade
+    escrever v[i], " "
+    i <- i + 1
+  fimenquanto
 fim
 </syntaxhighlight>
+==12/10: Estruturas de repetição (Lista de exercícios para o Feriado :p)==
+===Entrega por e-mail ([[tisemp@ifsc.edu.br]]) até o dia 12/10 (quarta-feira)===
+# Escreva um algoritmo que leia 5 números do teclado, e depois mostre-os em ordem inversa à que foi digitada.
+# Escreva um algoritmo que leia dois vetores de 5 números, e depois mostre se os vetores são iguais.
+# Escreva um algoritmo que leia um palavra do teclado e depois procure-a numa lista de palavras preexistente. Essa lista deve ser implementada usando um vetor.
+# Escreva um algoritmo que leia 5 números, e mostre-os em ordem crescente.
+# Modifique o algoritmo anterior para mostrá-los em ordem decrescente.
+# Em um  jogo de bingo devem-se contar quantos números de uma aposta foram sorteados no bingo. Faça um algoritmo que, dados os números sorteados e uma aposta, conta quantos números apostados forma sorteados.
+== 14/10: Revisão para avaliação de Lógica de Programação ==
+. 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.
+. 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.
+. 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.
+. 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.
+. 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;
 <!--
-Solução para o exercício 1:
+Solução proposta pelo Manfred Ex. 1
 <code>
 inicio
-	 real matrizA[10], matrizB[10]
+    inteiro n1 <- 0 , n2 <- 0 , n3 <- 0 , maior <- 0 , menor <- 0
-           inteiro i<-0
+    escrever "Digite o primeiro número: "
-           escrever "\n Construa a matriz A."
+    ler n1
-           enquanto i <= 9 faz
+    escrever "Digite o segundo número: "
-               escrever  "\n Entre com a posição ", i
+    ler n2
-               ler matrizA[i]
+    escrever "Digite o terceiro número: "
-               i <- i+1
+    ler n3
-           fimEnquanto
+    maior <- n1
-           i <- 0
+    se ( n2 > maior ) entao
-           enquanto i <= 9 faz
+        maior <- n2
-               escrever matrizA[i], " "
+    fimse
-               i <- i+1
+    se ( n3 > maior ) entao
-           fimEnquanto
+        maior <- n3
-           escrever "\n "
+    fimse
-           i <- 0
+    menor <- n1
-           enquanto i <= 9 faz
+    se ( n2 < menor ) entao
-               matrizB[i] <- ((matrizA[i])*5)
+        menor <- n2
-               matrizB[i+1] <- ((matrizA[i+1])+5)
+    fimse
-               i <- i+2
+    se ( n3 < menor ) entao
-           fimEnquanto
+        menor <- n3
-           i <- 0
+    fimse
-           escrever "\n A matriz B será: "
+    se ( maior % 2 ) = 0 ou ( menor % 2 ) =/= 0 entao
-           enquanto i <= 9 faz
+        escrever "Verdadeiro"
-               escrever matrizB[i], "   "
+    senao
-               i <- i+1
+        escrever "Falso"
-           fimenquanto
+    fimse
 fim
 </syntaxhighlight>
 -->
-. 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.
+<!--
+Proposta do Luiz para exercício 5
+<syntaxhighlight lang=text>
-<code>
 inicio
-     //declaração das variáveis
+     //declaração das variaveis
-     inteiro a [5] , i , soma <- 0
+     real peso [ 5 ] <- 0 , menor <- 0 , maior <- 0 , pesom <- 0 , pesot <- 0
+    inteiro i , cont <- 0
+    caracter sexo [ 5 ]
      //entrada de dados
      para i de 0 ate 4 passo 1
-         ler a [i]
+        escrever "Informe o peso do " , ( i + 1 ) , "º aluno: "
+        ler peso [ i ]
+        escrever "Informe o código do sexo do " , ( i + 1 ) , "º aluno (Masculino= M; Feminino= F): "
+         ler sexo [ i ]
+        escrever "\n"
      proximo
-     //construindo a matriz "B"
+     //testando o maior e menor peso
+    maior <- peso [ 1 ]
+    menor <- peso [ 1 ]
      para i de 0 ate 4 passo 1
-         se ( a [i] % 2 =/= 0 ) entao
+         se ( peso [ i ] > maior ) entao
-             soma <- soma + a [ i ]
+            maior <- peso [ i ]
+        fimse
+        se ( peso [ i ] < menor ) entao
+            menor <- peso [ i ]
+        fimse
+    proximo
+    //calculando a media de peso dos homens
+    para i de 0 ate 4 passo 1
+        se ( sexo [ i ] = "M" ) ou ( sexo [ i ] = "m" ) entao
+             pesom <- ( pesom + peso [ i ] )
+            cont <- ( cont + 1 )
          fimse
+    proximo
+    //calculando a media de peso da turma
+    para i de 0 ate 4 passo 1
+        pesot <- ( peso [ i ] + pesot )
      proximo
      //impressão dos dados
-     escrever "O valor da soma dos numero ímpares é: " , soma
+     escrever "\nO maior peso é: " , maior , "\nO menor peso é: " , menor
+    escrever "\nA média de peso dos homens é: " , ( pesom / cont )
+    escrever "\nA média de peso da turma é: " , ( pesot / 5 )
 fim
 </syntaxhighlight>
+-->
-. 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”.
+== 14/10: Lista complementar, com respostas ;) ==
+. 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.
 <code>
 inicio
-    //declaração das variáveis
+      //declaração dos vetores A e B
-    inteiro a[15] ,b[15] ,i
+	inteiro i,a[5],b[5]
-     //entrada de dados
-    para i de 0 ate 14 passo 1
+      //formação do vetor A
-        ler a[i]
+      para i de 0 ate 4 passo 1
-    proximo
+          ler a[i]
-    //construindo a matriz "B"
+      proximo
-    para i de 0 ate 14 passo 1
-        b[i] <- a[i] * a[i]
+      //guarda valor na posição par
-    proximo
+      para i de 0 ate 4 passo 2
-    //impressão dos dados
+          b[i]<-a[i]*5
-    escrever "\nMatriz A:"
+      proximo
-    para i de 0 ate 14 passo 1
-        escrever "" , a[i]
+      //guarda valor na posição ímpar
-    proximo
+      para i de 1 ate 4 passo 2
-    escrever "\nMatriz B:"
+          b[i]<-a[i]+5
-    para i de 0 ate 14 passo 1
+      proximo
-        escrever "" , b [i]
-    proximo
+      //apresenta valor B resposta
+      escrever "Formação do vetor B (vetor resposta):"
+      escrever "\n"
+      para i de 0 ate 4 passo 1
+          escrever "O valor da posição ",i, " é: ", b[i]
+          escrever "\n"
+      proximo
 fim
 </syntaxhighlight>
-. Escreva um algoritmo que:
+<!--
-#*Leia uma matriz 5 x 5 de elementos reais;
+Solução para o exercício 1:
-#* Divida cada elemento de uma linha da matriz pelo elemento da diagonal principal desta linha;
-#* Imprima a matriz assim modificada.
 <code>
 inicio
-    //declaração das variáveis
+	 real matrizA[10], matrizB[10]
-    real a [5] [5] , b [5] [5]
+           inteiro i<-0
-    inteiro i , j
+           escrever "\n Construa a matriz A."
-    //entrada de dados
+           enquanto i <= 9 faz
-    para i de 0 ate 4 passo 1
+               escrever  "\n Entre com a posição ", i
-        para j de 0 ate 4 passo 1
+               ler matrizA[i]
-            ler a [i] [j]
+               i <- i+1
-        proximo
+           fimEnquanto
-     proximo
+           i <- 0
-     //dividindo a linha da matriz por sua diagonal principal
+           enquanto i <= 9 faz
+               escrever matrizA[i], " "
+               i <- i+1
+           fimEnquanto
+           escrever "\n "
+           i <- 0
+           enquanto i <= 9 faz
+               matrizB[i] <- ((matrizA[i])*5)
+               matrizB[i+1] <- ((matrizA[i+1])+5)
+               i <- i+2
+           fimEnquanto
+           i <- 0
+           escrever "\n A matriz B será: "
+           enquanto i <= 9 faz
+               escrever matrizB[i], "   "
+               i <- i+1
+           fimenquanto
+fim
+</syntaxhighlight>
+-->
+. 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.
+<code>
+inicio
+     //declaração das variáveis
+    inteiro a [5] , i , soma <- 0
+     //entrada de dados
      para i de 0 ate 4 passo 1
-         para j de 0 ate 4 passo 1
+         ler a [i]
-            b [i] [j] <- ( a [i] [j] / a [i] [i] )
+    proximo
-         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 "\nMatriz: "
+     escrever "O valor da soma dos numero ímpares é: " , soma
-    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>
+. 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”.
-. 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.
 <code>
 inicio
      //declaração das variáveis
-     caracter gab [10] , resp [10]
+     inteiro a[15] ,b[15] ,i
-    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
+     para i de 0 ate 14 passo 1
-         escrever "Informe o gabarito da " , (i + 1) , "ª questão:"
+         ler a[i]
-         ler gab [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
-    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==
+. 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.
-Dicas para a avaliação (vale a pena revisar conceitos):
+<code>
-#* Números primos
+inicio
-#* Fatorial
+    //declaração das variáveis
-#* MDC: Máximo Divisor Comum
+    real a [5] [5] , b [5] [5]
-#* MMC: Mínimo Múltiplo Comum
+    inteiro i , j
-#* Cálculo para série de Fibonacci
+    //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>
-===Conceitos Avaliação de Lógica:===
+. 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:
-==ATENÇÃO: 20-22 de 1a Semana de Telecomunicações==
+* 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.
-===Participem da 1a Semana de Telecomunicações IFSC, Campus São José ===
+<code>
+inicio
-Chamada da 1a Semana de Telecomunicações do IFSC - São José [http://www.sj.ifsc.edu.br/~tisemp/SOP/semana_tele.pdf clique aqui]<br>
+    //declaração das variáveis
-Programação do evento: [http://www.sj.ifsc.edu.br/~tisemp/SOP/SemanaTelecom.odt clique aqui] <br>
+    caracter gab [10] , resp [10]
+    inteiro i , qtdprova , cont <- 0 , aprovados <- 0
-==25/05: Vista da avaliação de Lógica de Programação ==
+    real nota <- 0
+    texto rm <- "" , aluno <- "" , mat <- "" , bimestre <- ""
-* Desenvolvimento e correção dos exercícios propostos na avaliação.
+    //entrada de dados
-== 26/05: Linguagem C ==
+    para i de 0 ate 9 passo 1
+        escrever "Informe o gabarito da " , (i + 1) , "ª questão:"
-#* Introdução a linguagem C
+        ler gab [i]
-#* Primeiros Programas
+    proximo
-#* Compilador Gcc
+    escrever "Informe a quantidade de provas: "
-* Para provocar: [http://norvig.com/21-days.html Teach Yourself Programming in Ten Years]
+    ler qtdprova
-* Apostila adotada: [http://www.ead.cpdee.ufmg.br/cursos/C/c.html Curso de Linguagem C - Engenharia Elétrica -  UFMG]
+    //dados das provas
-Obs: durante as aulas usaremos o [http://www.netbeans.org NetBeans], um Ambiente Integrado de Desenvolvimento (''IDE - Integrated Development Environment''). Um IDE é um programa que auxilia o programador. Ele integra um  editor de programas, um gerenciador de projetos, compilador e um depurador (''debugger'').
+    enquanto cont < qtdprova faz
+        escrever "**************************************************"
-'''''Para instalar o Netbeans:'''''
+        escrever "\nInforme RM: "
-# Faça o [http://netbeans.c3sl.ufpr.br/6.8/bundles/netbeans-6.8-ml-cpp-linux.sh download do instalador]. Salve-o em algum subdiretório.
+        ler rm
-# Abrindo um terminal, entre no subdiretório onde está o instalador e execute esse comando: <syntaxhighlight lang=bash>
+        escrever "Informe o nome do aluno: "
-bash netbeans-6.8-ml-cpp-linux.sh
+        ler aluno
-</syntaxhighlight>
+        escrever "Informe a matéria: "
-#* Caso o instalador falhe porque não encontrou a JVM (Máquina Virtual Java), instale-a com esse comando: <syntaxhighlight lang=bash>
+        ler mat
-sudo apt-get install -y sun-java6-jdk
+        escrever "Informe o bimestre: "
-</syntaxhighlight>
+        ler bimestre
-# Aceite as opções de instalação sugeridas pelo instalador.
+        //informando as respostas
-# Ao final da instalação, o Netbeans 6.8 estará acessível pelo menu ''Aplicativos -> Programação''.
+        para i de 0 ate 9 passo 1
-# 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++".
+            escrever "Informe a resposta da " , (i + 1) , "ª questão:"
+            ler resp [i]
-=== Compilando o primeiro programa ===
+        proximo
-* O clássico ''Hello World!''
-<syntaxhighlight lang=c n>
+        //corrigindo a prova
-#include <stdio.h>
+        nota <- 0
+        para i de 0 ate 9 passo 1
-int main(int argc, char *argv[])
+            se ( gab [i] = resp [i] ) entao
-{
+                nota <- nota + 1
-	printf("Alô mundo!\n");
+            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>
-* Mostrando mensagens de na tela: [http://manpages.ubuntu.com/manpages/karmic/en/man3/puts.3.html puts] e [http://manpages.ubuntu.com/manpages/karmic/en/man3/printf.3.html printf]: <syntaxhighlight lang=c n>
+== 19/10: Avaliação de Lógica de Programação==
-#include <stdio.h>
-int main() {
+Dicas para a avaliação (vale a pena revisar conceitos):
-  int n;
+* Números primos
+* Fatorial
+* MDC: Máximo Divisor Comum
+* MMC: Mínimo Múltiplo Comum
+* Cálculo para série de Fibonacci
-  n = 5;
+===Conceitos Avaliação de Lógica:===
-  puts("Demonstração de puts e printf");
-  printf("Valor de n: %d\n", n);
+==21/10: Vista da avaliação de Lógica de Programação ==
-  n = n + 1;
+* Desenvolvimento e correção dos exercícios propostos na avaliação.
-  printf("Novo valor de n: %d\n", n);
+== 21/10: Linguagem C ==
-  return 0;
+* Introdução a linguagem C
-}
+* Primeiros Programas
-</syntaxhighlight>
+* Compilador Gcc
-* Lendo dados do teclado: [http://manpages.ubuntu.com/manpages/karmic/en/man3/scanf.3.html scanf]<syntaxhighlight lang=c n>
-#include <stdio.h>
-int main() {
+* Para provocar: [http://norvig.com/21-days.html Teach Yourself Programming in Ten Years]
-  int n;
+* Apostila adotada: [http://www.ead.cpdee.ufmg.br/cursos/C/c.html Curso de Linguagem C - Engenharia Elétrica -  UFMG]
-  printf("Digite um número inteiro: ");
+Obs: durante as aulas usaremos o [http://www.netbeans.org NetBeans], um Ambiente Integrado de Desenvolvimento (''IDE - Integrated Development Environment''). Um IDE é um programa que auxilia o programador. Ele integra um  editor de programas, um gerenciador de projetos, compilador e um depurador (''debugger'').
-  scanf("%d", &n);
+'''''Para instalar o Netbeans:'''''
+# Faça o [http://netbeans.c3sl.ufpr.br/6.8/bundles/netbeans-6.8-ml-cpp-linux.sh download do instalador]. Salve-o em algum subdiretório.
-  printf("Valor digitado foi %d\n", n);
+# Abrindo um terminal, entre no subdiretório onde está o instalador e execute esse comando: <syntaxhighlight lang=bash>
+bash netbeans-6.8-ml-cpp-linux.sh
-  return 0;
-}
 </syntaxhighlight>
-** Outras formas de ler do teclado: [http://manpages.ubuntu.com/manpages/karmic/man3/fgets.3.html getchar],  [http://manpages.ubuntu.com/manpages/karmic/en/man3/fgets.3.html fgets]
+#* Caso o instalador falhe porque não encontrou a JVM (Máquina Virtual Java), instale-a com esse comando: <syntaxhighlight lang=bash>
+sudo apt-get install -y sun-java6-jdk
+</syntaxhighlight>
+# Aceite as opções de instalação sugeridas pelo instalador.
+# Ao final da instalação, o Netbeans 6.8 estará acessível pelo menu ''Aplicativos -> Programação''.
+# Sempre que for escrever um novo programa com o Netbeans, crie um novo projeto (ver menu Arquivo->Novo Projeto). Selecione um projeto do tipo "Aplicativo C/C++".
-==== Tipos de dados ====
+=== Compilando o primeiro programa ===
-{| border="1" cellpadding="2"
+* O clássico ''Hello World!''
- !Portugol
+<syntaxhighlight lang=c n>
- !C
+#include <stdio.h>
- !Exemplo
- |-
- |inteiro||int|| int x;
- |-
- |caracter||char|| char letra;
- |-
- |real||float ou double|| float pi = 3.1416;
- |-
- |texto||char * ou vetor de char || char * mensagem = "Hello world";<br>char palavra[16];
- |-
- |logico||qualquer tipo (valor 0 = Falso, qualquer outro valor = Verdadeiro)||int ok = 1;<br>char teste = 0;
-|}
+int main(int argc, char *argv[])
+{
+	printf("Alô mundo!\n");
+}
+</syntaxhighlight>
+* Mostrando mensagens de na tela: [http://manpages.ubuntu.com/manpages/karmic/en/man3/puts.3.html puts] e [http://manpages.ubuntu.com/manpages/karmic/en/man3/printf.3.html printf]: <syntaxhighlight lang=c n>
+#include <stdio.h>
-==== Comandos/funções e Estruturas de controle ====
+int main() {
-{| border="1" cellpadding="2"
+  int n;
- !Portugol
- !C
- !Exemplo
- |-
- |<syntaxhighlight lang=text>inteiro n, m
-escrever "Ola, mundo!\n"
-escrever "valor de n: ", n, "\n"
-escrever "valor de n: ", n, ", e valor de x: ", x, "\n"
-</syntaxhighlight>||<syntaxhighlight lang=c>int n, m;
-printf("Ola, mundo!\n");
+  n = 5;
-printf("valor de n: %d\n", n);
-printf("valor de n: %d, e valor de x: %d\n", n, x);</syntaxhighlight>||
+  puts("Demonstração de puts e printf");
- |-
- |<syntaxhighlight lang=text>inteiro n
-ler n</syntaxhighlight>||<syntaxhighlight lang=c>int n;
+  printf("Valor de n: %d\n", n);
-scanf("%d", &n);</syntaxhighlight>||
+  n = n + 1;
- |-
- |<syntaxhighlight lang=text>se condição então
+  printf("Novo valor de n: %d\n", n);
-//comandos
-fimse</syntaxhighlight> ||<syntaxhighlight lang=c>if (condição) {
+  return 0;
-//comandos
+}
-}</syntaxhighlight>||
+</syntaxhighlight>
- |-
+* Lendo dados do teclado: [http://manpages.ubuntu.com/manpages/karmic/en/man3/scanf.3.html scanf]<syntaxhighlight lang=c n>
- |<syntaxhighlight lang=text>se condição então
+#include <stdio.h>
-   //comandos
-senão
+int main() {
-   //comandos
+  int n;
-fimse</syntaxhighlight> ||<syntaxhighlight lang=c>if (condição) {
- //comandos
+  printf("Digite um número inteiro: ");
-} else {
- //comandos
+   scanf("%d", &n);
-}</syntaxhighlight> ||
- |-
+   printf("Valor digitado foi %d\n", n);
- |<syntaxhighlight lang=text>escolhe expressão
-  caso valor1:
+  return 0;
-    //comandos
+}
-  caso valor2:
+</syntaxhighlight>
-    //comandos
+** Outras formas de ler do teclado: [http://manpages.ubuntu.com/manpages/karmic/man3/fgets.3.html getchar],  [http://manpages.ubuntu.com/manpages/karmic/en/man3/fgets.3.html fgets]
-  defeito:
-    //comandos
+==== Tipos de dados ====
-fimescolhe</syntaxhighlight>||<syntaxhighlight lang=c>switch (expressão) {
+{| border="1" cellpadding="2"
-  case valor1:
+ !Portugol
-    //comandos
+ !C
-  case valor2:
+ !Exemplo
-    //comandos
-  default:
-    //comandos
-}</syntaxhighlight>||
   |-
-  |<syntaxhighlight lang=text>enquanto condição faz
+  |inteiro||int|| int x;
-//comandos
+ |-
-fimenquanto</syntaxhighlight>||<syntaxhighlight lang=c>while (condição) {
+ |caracter||char|| char letra;
-  //comandos
+ |-
-}</syntaxhighlight>||
+ |real||float ou double|| float pi = 3.1416;
+ |-
+ |texto||char * ou vetor de char || char * mensagem = "Hello world";<br>char palavra[16];
   |-
-  |<syntaxhighlight lang=text>para variavel de inicio ate fim passo incremento
+  |logico||qualquer tipo (valor 0 = Falso, qualquer outro valor = Verdadeiro)||int ok = 1;<br>char teste = 0;
-//comandos
-proximo</syntaxhighlight>||<syntaxhighlight lang=c>for (variavel=inicio; variavel <= fim; variavel++) {
-//comandos
-}</syntaxhighlight>||
 |}
-=== Atividades ===
-* Traduza para C os seguintes algoritmos Portugol:
+==== Comandos/funções e Estruturas de controle ====
-*# <syntaxhighlight lang=text>
+{| border="1" cellpadding="2"
-Inicio
+ !Portugol
-  inteiro x, y
+ !C
+ !Exemplo
-  Escrever "Digite um numero: ",
+ |-
-  Ler x
+ |<syntaxhighlight lang=text>inteiro n, m
-  Escrever "Digite outro numero: ",
-  Ler y
+escrever "Ola, mundo!\n"
-  Escrever "Soma = ", x+y
+escrever "valor de n: ", n, "\n"
-Fim
+escrever "valor de n: ", n, ", e valor de x: ", x, "\n"
-</syntaxhighlight>
+</syntaxhighlight>||<syntaxhighlight lang=c>int n, m;
-*# <syntaxhighlight lang=text>
-Inicio
+printf("Ola, mundo!\n");
-  inteiro x, y, z
+printf("valor de n: %d\n", n);
+printf("valor de n: %d, e valor de x: %d\n", n, x);</syntaxhighlight>||
-  Escrever "Digite um numero: ",
+ |-
-  Ler x
+ |<syntaxhighlight lang=text>inteiro n
-  Escrever "Digite outro numero: ",
-  Ler y
+ler n</syntaxhighlight>||<syntaxhighlight lang=c>int n;
-  z <- x + y
-  Escrever "Soma = ", z
+scanf("%d", &n);</syntaxhighlight>||
-Fim
+ |-
-</syntaxhighlight>
+ |<syntaxhighlight lang=text>se condição então
-*# <syntaxhighlight lang=text>
+//comandos
-Inicio
+fimse</syntaxhighlight> ||<syntaxhighlight lang=c>if (condição) {
-   Inteiro n1, n2, n3, r
+//comandos
+}</syntaxhighlight>||
-   Escrever "Primeiro numero: "
+ |-
-   ler n1
+ |<syntaxhighlight lang=text>se condição então
-   Escrever "Segundo numero: "
+  //comandos
-   ler n2
+senão
-   Escrever "Terceiro numero: "
+   //comandos
-   ler n3
+fimse</syntaxhighlight> ||<syntaxhighlight lang=c>if (condição) {
+ //comandos
-  r <- (n1 + n2 + n3) /3
+} else {
+ //comandos
-  Escrever "Media=", r
+}</syntaxhighlight> ||
-Fim
+ |-
-</syntaxhighlight>
+  |<syntaxhighlight lang=text>escolhe expressão
-*# <syntaxhighlight lang=text>
+   caso valor1:
-Inicio
+    //comandos
-  inteiro anos, dias
+   caso valor2:
+    //comandos
-  Escrever "Quantos anos se passaram ? "
+   defeito:
-  Ler anos
+    //comandos
-  dias <- anos * 365
+fimescolhe</syntaxhighlight>||<syntaxhighlight lang=c>switch (expressão) {
-  Escrever "... então se passaram ", dias, " dias"
+   case valor1:
-Fim
+    //comandos
-</syntaxhighlight>
+   case valor2:
-*# <syntaxhighlight lang=text>
+    //comandos
-Inicio
+   default:
-   constante inteiro diasPorAno <- 365
+    //comandos
-  inteiro anos, dias
+}</syntaxhighlight>||
+  |-
+ |<syntaxhighlight lang=text>enquanto condição faz
+//comandos
+fimenquanto</syntaxhighlight>||<syntaxhighlight lang=c>while (condição) {
+  //comandos
+}</syntaxhighlight>||
+  |-
+ |<syntaxhighlight lang=text>para variavel de inicio ate fim passo incremento
+//comandos
+proximo</syntaxhighlight>||<syntaxhighlight lang=c>for (variavel=inicio; variavel <= fim; variavel++) {
+//comandos
+}</syntaxhighlight>||
+|}
+=== Atividades ===
+* Traduza para C os seguintes algoritmos Portugol:
+*# <syntaxhighlight lang=text>
+Inicio
+   inteiro x, y
-   Escrever "Quantos anos se passaram ? "
+   Escrever "Digite um numero: ",
-   Ler anos
+   Ler x
-   dias <- anos * diasPorAno
+   Escrever "Digite outro numero: ",
-   Escrever "... então se passaram ", dias, " dias"
+  Ler y
+   Escrever "Soma = ", x+y
 Fim
 </syntaxhighlight>
 *# <syntaxhighlight lang=text>
-inicio
+Inicio
-   real massa
+   inteiro x, y, z
-  real forca
-  real aceleracao
+   Escrever "Digite um numero: ",
-   constante real g <- 9.8
+   Ler x
-  constante real ac <- 0.01
+   Escrever "Digite outro numero: ",
+   Ler y
-  escrever "força: "
+   z <- x + y
-   ler forca
+   Escrever "Soma = ", z
+Fim
-   escrever "massa: "
-   ler massa
-  aceleracao <- forca/massa - ac*massa*g
-   escrever "aceleracao=", aceleracao, " m/s2"
-fim
 </syntaxhighlight>
 *# <syntaxhighlight lang=text>
-inicio
+Inicio
-   real a, b, c
+   Inteiro n1, n2, n3, r
-  real delta
-  real x1, x2
+   Escrever "Primeiro numero: "
+   ler n1
-   escrever "Forneça os coeficientes da equação de 2o grau (formato: ax^2 + bx + c):\n"
+   Escrever "Segundo numero: "
-  escrever "a="
+   ler n2
-   ler a
+   Escrever "Terceiro numero: "
-   escrever "b="
+   ler n3
-   ler b
-   escrever "c="
+   r <- (n1 + n2 + n3) /3
-   ler c
+   Escrever "Media=", r
-   delta <- b^2 - 4*a*c
+Fim
-  x1 <- (-b + delta^0.5)/(2*a)
-  x2 <- (-b - delta^0.5)/(2*a)
-  escrever "1a raiz=", x1
-   escrever "\n2a raiz=", x2
-fim
 </syntaxhighlight>
 *# <syntaxhighlight lang=text>
-inicio
+Inicio
-      real x1, x2, x3, x4, x5
+  inteiro anos, dias
-      real media
-      real desvioPadrao
+  Escrever "Quantos anos se passaram ? "
-      constante inteiro N <- 5
+  Ler anos
+  dias <- anos * 365
-      // Ler os cinco valores pelo teclado
+  Escrever "... então se passaram ", dias, " dias"
-      ler x1
+Fim
-      ler x2
-      ler x3
-      ler x4
-      ler x5
-      // Calcular a media
-      media <- (x1 + x2 + x3 + x4 + x5) / N
-      // Calcular o desvio padrao
-      desvioPadrao <- (x1 - media)^2 + (x2 - media)^2 + (x3 - media)^2 + (x4 - media)^2 + (x5 - media)^2
-      desvioPadrao <- (desvioPadrao / (N-1))^0.5
-      escrever "Media=", media
-      escrever "\nDesvio padrao=", desvioPadrao
-fim
 </syntaxhighlight>
 *# <syntaxhighlight lang=text>
-inicio
+Inicio
-      real renda
+  constante inteiro diasPorAno <- 365
-      real irpf
+  inteiro anos, dias
-      escrever "Informe sua renda: "
+  Escrever "Quantos anos se passaram ? "
-      ler renda
+  Ler anos
+  dias <- anos * diasPorAno
-      se renda < 1372.81 entao
+  Escrever "... então se passaram ", dias, " dias"
-        irpf <- 0
+Fim
-      senao
-        se renda < 2743.25 entao
-          irpf <- (renda - 205.92)*0.15
-        senao
-          irpf <- (renda - 548.82)*0.275
-        fimSe
-      fimSe
-      escrever "Imposto devido: ", irpf
-fim
 </syntaxhighlight>
 *# <syntaxhighlight lang=text>
 inicio
-    inteiro dividendo
+  real massa
-    inteiro divisor
+  real forca
-    inteiro resto , quociente
+  real aceleracao
+  constante real g <- 9.8
-    escrever "Dividendo: "
+  constante real ac <- 0.01
-    ler dividendo
-    escrever "Divisor: "
+  escrever "força: "
-    ler divisor
+  ler forca
-    se divisor = 0 entao
+  escrever "massa: "
-        escrever "Nao pode dividir: divisor = 0 !!!"
+  ler massa
-    senao
-        resto <- dividendo % divisor
+  aceleracao <- forca/massa - ac*massa*g
-        se resto = 0 entao
-            quociente <- dividendo / divisor
+  escrever "aceleracao=", aceleracao, " m/s2"
-            escrever dividendo , " / " , divisor , " = " , quociente
-        senao
+fim
-            escrever "Nao pode fazer divisao inteira"
+</syntaxhighlight>
-            escrever " (resto = " , resto , ")"
+*# <syntaxhighlight lang=text>
-        fimse
+inicio
-    fimse
+  real a, b, c
+  real delta
+  real x1, x2
+  escrever "Forneça os coeficientes da equação de 2o grau (formato: ax^2 + bx + c):\n"
+  escrever "a="
+  ler a
+  escrever "b="
+  ler b
+  escrever "c="
+  ler c
+  delta <- b^2 - 4*a*c
+  x1 <- (-b + delta^0.5)/(2*a)
+  x2 <- (-b - delta^0.5)/(2*a)
+  escrever "1a raiz=", x1
+  escrever "\n2a raiz=", x2
 fim
 </syntaxhighlight>
 *# <syntaxhighlight lang=text>
 inicio
-    inteiro termometro , barometro , tempo
+      real x1, x2, x3, x4, x5
+      real media
-    escrever "Qual a condição do termômetro: \n"
+      real desvioPadrao
-    escrever "Digite 1 para baixando , 2 para estacionário e 3 para subindo. \n"
+      constante inteiro N <- 5
-    ler termometro
+      // Ler os cinco valores pelo teclado
-    escrever "Informe a condição do barômetro: \n"
+      ler x1
-    escrever "Digite 1 para baixando , 2 para estacionário e 3 para subindo. \n"
+      ler x2
-    ler barometro
+      ler x3
+      ler x4
-    tempo <- termometro*10 + barometro
+      ler x5
-    escolhe tempo
+      // Calcular a media
-        caso 11:
+      media <- (x1 + x2 + x3 + x4 + x5) / N
-            escrever "Chuvas abundantes e ventos de sul a sudoeste fortes"
-        caso 12:
+      // Calcular o desvio padrao
-            escrever "Chuva Provavel , ventos de sul a sudeste"
+      desvioPadrao <- (x1 - media)^2 + (x2 - media)^2 + (x3 - media)^2 + (x4 - media)^2 + (x5 - media)^2
-        caso 13:
+      desvioPadrao <- (desvioPadrao / (N-1))^0.5
-            escrever "Tempos Bons , ventos de sul a sudeste"
-        caso 21:
+      escrever "Media=", media
-            escrever "Frente quente com chuva provavel"
+      escrever "\nDesvio padrao=", desvioPadrao
-        caso 22:
-            escrever "Tempo Incerto , ventos variaveis"
-        caso 23:
-            escrever "Tempos Bons , ventos do leste frescos"
-        caso 31:
-            escrever " Tempo instavel , aproximaÃ§ao de frente"
-        caso 32:
-            escrever "Tempo Mudando para bom , ventos de leste"
-        caso 33:
-            escrever "Tempos Bons , ventos quentes e secos"
-        defeito:
-            escrever "Utilize somente os algorismos de 1 a 3 para indicar as condiÃ§oes do equipamentos"
-    fimescolhe
 fim
 </syntaxhighlight>
 *# <syntaxhighlight lang=text>
 inicio
-    // coeficientes do polinomio  [ax^2 + bx + c = 0 ]
+      real renda
-    real a , b , c
+      real irpf
-    escrever "Forneça os coeficientes da equação de 2o grau:\n"
+      escrever "Informe sua renda: "
-    escrever "a="
+      ler renda
-    ler a
-    escrever "b="
+      se renda < 1372.81 entao
-    ler b
+         irpf <- 0
-    escrever "c="
+      senao
-    ler c
+         se renda < 2743.25 entao
+          irpf <- (renda - 205.92)*0.15
-    // 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  ----------------
+          irpf <- (renda - 548.82)*0.275
-            se delta = 0 entao
+        fimSe
-                real x1
+      fimSe
-                x1 <- -b / 2 * a
-                escrever "\nraiz dupla : " , x1
+      escrever "Imposto devido: ", irpf
-            senao
+fim
-                // - ---------- duas raizes ---------------
+</syntaxhighlight>
-                real x1 , x2
-                x1 <- ( -b + raiz ( delta ) ) / 2 * a
-                x2 <- ( -b - raiz ( delta ) ) / 2 * a
-                escrever "\nraiz x1 : " , x1
-                escrever "\nraiz x2 : " , x2
-            fimse//raiz dupla
-        fimse// delta >0
-    fimse// a <> 0
-fim
-</syntaxhighlight>
 *# <syntaxhighlight lang=text>
 inicio
-     inteiro num, bit
+     inteiro dividendo
-     inteiro base
+     inteiro divisor
+     inteiro resto , quociente
-     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
+     escrever "Dividendo: "
-    enquanto base > 0 faz
+    ler dividendo
-        bit <- ( num / base ) % 2
+    escrever "Divisor: "
-         escrever bit, " "
+    ler divisor
-         base <- base / 2
-     fimenquanto
+    se divisor = 0 entao
+        escrever "Nao pode dividir: divisor = 0 !!!"
+    senao
+        resto <- dividendo % divisor
+        se resto = 0 entao
+            quociente <- dividendo / divisor
+            escrever dividendo , " / " , divisor , " = " , quociente
+         senao
+            escrever "Nao pode fazer divisao inteira"
+            escrever " (resto = " , resto , ")"
+         fimse
+     fimse
 fim
 </syntaxhighlight>
 *# <syntaxhighlight lang=text>
 inicio
-     inteiro n , fat
+     inteiro termometro , barometro , tempo
-     ler n
-     fat <- 1
+    escrever "Qual a condição do termômetro: \n"
-     enquanto n > 1 faz
+    escrever "Digite 1 para baixando , 2 para estacionário e 3 para subindo. \n"
-       fat <- fat * n
+     ler termometro
-       n <- n - 1
-    fimenquanto
+    escrever "Informe a condição do barômetro: \n"
+     escrever "Digite 1 para baixando , 2 para estacionário e 3 para subindo. \n"
-    escrever "Fatorial=" , fat
+     ler barometro
+    tempo <- termometro*10 + barometro
+    escolhe tempo
+        caso 11:
+            escrever "Chuvas abundantes e ventos de sul a sudoeste fortes"
+        caso 12:
+            escrever "Chuva Provavel , ventos de sul a sudeste"
+        caso 13:
+            escrever "Tempos Bons , ventos de sul a sudeste"
+        caso 21:
+            escrever "Frente quente com chuva provavel"
+        caso 22:
+            escrever "Tempo Incerto , ventos variaveis"
+        caso 23:
+            escrever "Tempos Bons , ventos do leste frescos"
+         caso 31:
+            escrever " Tempo instavel , aproximaÃ§ao de frente"
+        caso 32:
+            escrever "Tempo Mudando para bom , ventos de leste"
+        caso 33:
+            escrever "Tempos Bons , ventos quentes e secos"
+        defeito:
+            escrever "Utilize somente os algorismos de 1 a 3 para indicar as condiÃ§oes do equipamentos"
+    fimescolhe
 fim
 </syntaxhighlight>
 *# <syntaxhighlight lang=text>
 inicio
-     inteiro valor , menor , contador
+     // coeficientes do polinomio  [ax^2 + bx + c = 0 ]
-    ler menor
+    real a , b , c
-    contador <- 9
-    enquanto contador > 0 faz
-        ler valor
-        se valor < menor entao
-            menor <- valor
-        fimse
-        contador <- contador - 1
-    fimenquanto
-    escrever "menor valor = ", menor
-fim
-</syntaxhighlight>
-*# <syntaxhighlight lang=text>
-inicio
-    inteiro numero , n , resto <- 1
-    escrever "Forneçaa um número: "
-    ler numero
-    n <- 2
-    enquanto n <= numero / 2 e resto =/= 0 faz
-        resto <- numero % n
-        escrever "n=" , n , ": resto=" , resto , "\n"
-        n <- n + 1
-    fimenquanto
-     se resto = 0 entao
+     escrever "Forneça os coeficientes da equação de 2o grau:\n"
-        escrever "nao primo: divisivel por " , n - 1
+     escrever "a="
-     senao
+     ler a
-        escrever "primo"
+    escrever "b="
-     fimse
+    ler b
-fim
+    escrever "c="
-</syntaxhighlight>
+     ler c
-*# <syntaxhighlight lang=text>
-// Le 5 valores e identifica os dois maiores.
-inicio
-     inteiro valor , maior1 , maior2 , contador
-     ler valor
+     // equação do tipo [ bx + c = 0 ]
-     maior1 <- valor
+     se a = 0 entao
+        escrever " não é uma equação de 2o grau !!!"
+    senao
+        // calcular o delta => interior da raiz
+        real delta
+        delta <- b ^ 2 - 4 * a * c
+        // não existem raizes  reais de números negativos
+        se delta < 0 entao
+            escrever " não tem raizes reais"
+        senao
+            // -----------  raiz dupla  ----------------
+            se delta = 0 entao
+                real x1
+                x1 <- -b / 2 * a
+                escrever "\nraiz dupla : " , x1
+            senao
+                // - ---------- duas raizes ---------------
+                real x1 , x2
+                x1 <- ( -b + raiz ( delta ) ) / 2 * a
+                x2 <- ( -b - raiz ( delta ) ) / 2 * a
+                escrever "\nraiz x1 : " , x1
+                escrever "\nraiz x2 : " , x2
+            fimse//raiz dupla
+        fimse// delta >0
+    fimse// a <> 0
+fim
+</syntaxhighlight>
+*# <syntaxhighlight lang=text>
+inicio
+    inteiro num, bit
+    inteiro base
-     ler valor
+    escrever "Este algoritmo converte um número inteiro para sua representação binária.\n"
+    Escrever "O número deve estar entre 0 e 131071, e a representação binária\n"
+    escrever "terá 17 bits\n\n"
+    escrever "Digite o numero a ser convertido para binário: "
+    ler num
+    base <- 65536
+    enquanto base > 0 faz
+        bit <- ( num / base ) % 2
+        escrever bit, " "
+        base <- base / 2
+    fimenquanto
+fim
+</syntaxhighlight>
+*# <syntaxhighlight lang=text>
+inicio
+    inteiro n , fat
+    ler n
+    fat <- 1
+    enquanto n > 1 faz
+       fat <- fat * n
+       n <- n - 1
+    fimenquanto
+    escrever "Fatorial=" , fat
+fim
+</syntaxhighlight>
+*# <syntaxhighlight lang=text>
+inicio
+    inteiro valor , menor , contador
+    ler menor
+    contador <- 9
+    enquanto contador > 0 faz
+        ler valor
+        se valor < menor entao
+            menor <- valor
+        fimse
+        contador <- contador - 1
+    fimenquanto
+    escrever "menor valor = ", menor
+fim
+</syntaxhighlight>
+*# <syntaxhighlight lang=text>
+inicio
+    inteiro numero , n , resto <- 1
+    escrever "Forneçaa um número: "
+    ler numero
+    n <- 2
+    enquanto n <= numero / 2 e resto =/= 0 faz
+        resto <- numero % n
+        escrever "n=" , n , ": resto=" , resto , "\n"
+        n <- n + 1
+    fimenquanto
+    se resto = 0 entao
+        escrever "nao primo: divisivel por " , n - 1
+    senao
+        escrever "primo"
+    fimse
+fim
+</syntaxhighlight>
+*# <syntaxhighlight lang=text>
+// Le 5 valores e identifica os dois maiores.
+inicio
+    inteiro valor , maior1 , maior2 , contador
+    ler valor
+    maior1 <- valor
+     ler valor
      se valor > maior1 entao
        maior2 <- maior1
        maior1 <- valor
      senao
        maior2 <- valor
      fimse
+    contador <- 3
+    enquanto contador > 0 faz
+        ler valor
+        se valor > maior1 entao
+            maior2 <- maior1
+            maior1 <- valor
+        senao
+            se valor > maior2 entao
+                maior2 <- valor
+            fimse
+        fimse
+        contador <- contador - 1
+    fimenquanto
+    escrever "maior valor = " , maior1
+    escrever "\nsegundo maior valor = " , maior2
+fim
+</syntaxhighlight>
+== 26/10: Introdução linguagem C==
+* Aulas 1 e 2 - curso de C UFMG
+* [http://www.ead.cpdee.ufmg.br/cursos/C/c.html Curso de Linguagem C - Engenharia Elétrica -  UFMG]
+==28/10: Feriado: dia do servidor público==
+{{DivulgueEngtelecom}}
+===Conceitos===
+Conceitos avaliação Lógica de Programação  [http://tele.sj.ifsc.edu.br/~tisemp/SOP/conceitos.pdf clique aqui]
+==31/10: Aula 3==
+* Operadores lógicos e aritméticos
+==02/11: Feriado: todos os santos (finados)==
+== 04/11: Aula 4==
+* Estruturas de Controle de fluxo
+== 09/11: Aula 4==
+* Estruturas de decisão
+** Switch
+== 11/11: Aula 4==
+* Estruturas de repetição
+** for, while, do
+== 16/11: Aula 5==
+== 23/11: Aula 7 (Funções)==
+* Material de aula Prof. Marcelo [http://wiki.sj.ifsc.edu.br/index.php/SOP-funcoes funções]
+* [[SOP-funcoes|Texto introdutório sobre funções na linguagem C]]
+==== Escopo de variáveis ====
+* Texto obtido de: [http://www.inf.pucrs.br/~pinho/LaproI/Funcoes/AulaDeFuncoes.htm Uso de funções em C]
+Por escopo de uma variável entende-se o bloco de código onde esta variável é válida. Com base nisto, temos as seguintes afirmações:
+* As variáveis valem no bloco que são definidas;
+* As variáveis definidas  dentro de uma função recebem o nome de '''''variáveis locais'''''
+* As variáveis declaradas fora de qualquer função são chamadas de '''''variáveis globais'''''
+* Os parâmetros formais de uma função (também conhecidos como ''argumentos da função'') valem também somente dentro da função;
+* Uma variável definida dentro de uma função não é acessível em outras funções, MESMO QUE ESSAS VARIÁVEIS TENHAM NOMES IDÊNTICOS.
+===== Variáveis locais =====
+No trecho de código a seguir tem-se um exemplo com funções e variáveis com nomes iguais.
+<syntaxhighlight lang=c>
+#include <stdio.h>
+void FUNC1() {
+   int B;
+   B = -100;
+   printf("Valor de B dentro da função FUNC1: %d\n", B);
+}
+void FUNC2() {
+   int B;
+   B = -200;
+   printf("Valor de B dentro da função FUNC2: %d\n", B);
+}
+void main() {
+   int B;
+   B = 10;
+   printf("Valor de B: %d\n", B);
+   B = 20;
+   FUNC1();
+   printf("Valor de B: %d\n", B);
+   B = 30;
+   FUNC2();
+   printf("Valor de B: %d\n", B);
+}
+</syntaxhighlight>
+O resultado de sua execução deve ser:
+<syntaxhighlight lang=text>
+Valor de B: 10
+Valor de B dentro da função FUNC1: -100
+Valor de B: 20
+Valor de B dentro da função FUNC2: -200
+Valor de B: 30
+</syntaxhighlight>
+===== Variáveis globais =====
+O seguinte exemplo mostra o mesmo programa, porém fazendo com que a variável B seja global:
+<syntaxhighlight lang=c>
+#include <stdio.h>
+// Declaração da variável global B
+int B;
+void FUNC1() {
+   B = -100;
+   printf("Valor de B dentro da função FUNC1: %d\n", B);
+}
+void FUNC2() {
+   B = -200;
+   printf("Valor de B dentro da função FUNC2: %d\n", B);
+}
+void main() {
+   B = 10;
+   printf("Valor de B: %d\n", B);
+   B = 20;
+   FUNC1();
+   printf("Valor de B: %d\n", B);
+   B = 30;
+   FUNC2();
+   printf("Valor de B: %d\n", B);
+}
+</syntaxhighlight>
+O resultado de sua execução deve ser:
+<syntaxhighlight lang=text>
+Valor de B: 10
+Valor de B dentro da função FUNC1: -100
+Valor de B: -100
+Valor de B dentro da função FUNC2: -200
+Valor de B: -200
+</syntaxhighlight>
+E se existir um variável local  com mesmo nome que uma global ? nesse caso, a variável local vai ''esconder'' a sua homônima global:
+<syntaxhighlight lang=c>
+#include <stdio.h>
+// Declaração da variável global B
+int B;
+void FUNC1() {
+   //  no escopo desta função, esta variável local vai esconder a variável global B!
+   int B;
+   B = -100;
+   printf("Valor de B dentro da função FUNC1: %d\n", B);
+}
+void FUNC2() {
+   B = -200;
+   printf("Valor de B dentro da função FUNC2: %d\n", B);
+}
+void main() {
+   B = 10;
+   printf("Valor de B: %d\n", B);
+   B = 20;
+   FUNC1();
+   printf("Valor de B: %d\n", B);
+   B = 30;
+   FUNC2();
+   printf("Valor de B: %d\n", B);
+}
+</syntaxhighlight>
+O resultado de sua execução deve ser:
+<syntaxhighlight lang=text>
+Valor de B: 10
+Valor de B dentro da função FUNC1: -100
+Valor de B: 20
+Valor de B dentro da função FUNC2: -200
+Valor de B: -200
+</syntaxhighlight>
+<syntaxhighlight lang=c>
+#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);
+}
+</syntaxhighlight>
+=== Para fixar ===
+# Escreva  o programa para mostrar a tabuada de um  número lido do teclado. <syntaxhighlight lang=c>
+#include <stdlib.h>
+#include <stdio.h>
+/*
+ *
+ */
+int main(int argc, char** argv) {
+    int numero, c;
+    printf("Numero: ");
+    scanf("%d", &numero);
+    c = 1;
+    while (c < 11) {
+        printf("%d X %d = %d\n", numero, c, numero*c);
+        c++;
+    }
+    return (EXIT_SUCCESS);
+}
+</syntaxhighlight>
+# Reescreva o programa anterior, mas usando uma função para mostrar a tabuada. <syntaxhighlight lang=c>
+#include <stdio.h>
+int tabuada(int num) {
+    int c = 1;
+    while (c < 11) {
+        printf("%d X %d = %d\n", num, c, num*c);
+        c++;
+    }
+}
+int main(int argc, char** argv) {
+    int numero, c;
+    printf("Numero: ");
+    scanf("%d", &numero);
+    tabuada(numero);
+    return (EXIT_SUCCESS);
+}
+</syntaxhighlight>
+# Modifique o programa anterior para mostrar a tabuada de todos os números entre 1 e 10. Obs: não modifique a função tabuada!
+# Escreva um  programa para ler 10 números do teclado, e em seguida mostrar o maior e o menor número.
+# Reescreva o programa anterior, mas criando as função "maior" e "menor", que retornam o maior e menor número de um vetor de tamanho arbitrário.
+==30/11: O Jogo: Batalha Naval ==
+Para referência:
+* [http://www.ead.cpdee.ufmg.br/cursos/C/c.html apostila online sobre linguagem C].
+* [http://zamorim.com/jogos/papel/batalha-naval-regras.html Descrição do jogo de Batalha Naval clássico]
+* Etapas de desenvolvimento:
+#Desenha 1 onda
+#Desenha 1 linha de ondas
+#Desenha 1 matriz de tamanho fixo de ondas
+#Desenha 1 matriz de tamanho variável de ondas (o usuário informa as dimensões)
+#Mapeia 1 barco: latitude e longitude (vetor)
+#Desenha o mar com 1 barco
+#Mapeia 10 barcos: latitude e longitude (matriz)
+#Desenha os 10 barcos
+#Mapeia 10 barcos: latitude, longitude e se já foi atingido
+#Pede ao usuário atirar
+#Se o barco foi atingido, desenhar um X
+#Ao final (todo os barcos atingidos): informar o usuário que venceu em 'n' movimentos
+* Proposta de código que contempla:
+** Bibliotecas e definições
+** Declaração de constantes e variáveis
+*** Uso de variáveis com mesmo nome e diferentes escopos
+*** Vetor e matriz
+** Operadores lógicos e matemáticos
+** Expressões
+*** E/S
+*** Estruturas de decisão e repetição
+** Funções
+*** Passagem de parâmetro por valor e por referência
+** Acesso a uma matriz através de um vetor linear (função <tt>iniciaJogo</tt>)
+** Ponteiros
+* Uma versão do jogo implementado:
+<!--
+<syntaxhighlight lang=c>
+#include <stdio.h>
+#define QTDE_BARCOS 2
+int iniciaJogo(int *barcos, int *tiros, int *atingidos)
+{
+	int barco;
+	for(barco=0; barco<QTDE_BARCOS; barco++)
+	{
+		printf("\nBarco número %d:\n", barco + 1); // O primeiro barco é o de no. zero :-)
+		printf("Informe a latitude do barco: ");
+		scanf("%d", barcos + 3*barco);	// end. inicial (barcos)
+										// + qtde. objetos por linha
+										// * linhas
+										// + coluna (1o. elemento)
+		printf("Informe a longitude do barco: ");
+		scanf("%d", barcos + 3*barco + 1);	// end. inicial (barcos)
+											// + qtde. objetos por linha
+											// * linhas
+											// + coluna (2o. elemento)
+		*(barcos + 3*barco + 2) = 0;	// endereço inicial (barcos)
+										// + qtde. objetos por linha
+										// * linhas
+										// + coluna (3o. elemento)
+	}
+	*tiros = 0;
+	*atingidos = 0;
+}
+char desenhaPonto(int linha, int coluna, int barcos[QTDE_BARCOS][3])
+{
+	int barco;
+	for (barco=0; barco<QTDE_BARCOS; barco++)
+	{
+		if (linha==barcos[barco][0] & coluna==barcos[barco][1])
+		{
+			if (barcos[barco][2] == 1)
+			{
+				return 'X';
+			}
+		}
+	}
+	return '~';
+}
+desenhaMar(int linhas, int colunas, char onda, int barcos[QTDE_BARCOS][3])
+{
+	int linha;
+	int coluna;
+	int barco;
+	int tinhaBarco;
+	for (linha=1; linha<linhas; linha++)
+	{
+		for (coluna=1; coluna<colunas; coluna++)
+		{
+			printf("%c", desenhaPonto(linha, coluna, barcos));
+		}
+		printf("\n");
+	}
+}
+int seVenceu(int barcos[QTDE_BARCOS][3])
+{
+	int barco;
+	int atingidos = 0;
+	for (barco=0; barco<QTDE_BARCOS; barco++)
+	{
+		if (barcos[barco][2] == 1)
+			atingidos++;
+	}
+	return atingidos;
+}
+int main(int argc, char* argv[])
+{
+	const char onda= '~';
+	int barcos[QTDE_BARCOS][3];
+	int latitude;
+	int longitude;
+	int barco;
+	int tiros;
+	int atingidos;
+	if (argc < 3)
+	{
+		printf("Use: %s (qtde. de linhas) (qtde. de colunas).\n", argv[0]);
+		return -1;
+	}
+	// Inicia o jogo
+	iniciaJogo(&barcos, &tiros, &atingidos);
+	// Estrutura principal de repetição: vai atirando sem parar... :-P
+	while (1)
+	{
+		// Limpa a tela
+		system("clear");
+		// Desenha o mar
+		desenhaMar(atoi(argv[1]), atoi(argv[2]), onda, barcos);
+		atingidos = seVenceu(barcos);
+		if (atingidos == QTDE_BARCOS)
+		{
+			printf("\nParabéns! Venceu o jogo com %d tiros!\n", tiros);
+			return 0;
+		}
+		else
+		{
+			printf("\nTiros: %d\n", tiros);
+			printf("Alvos atingidos: %d.\n", atingidos);
+			printf("\nDigite latitude e longitude:\n");
+			printf("- Latitude: ");
+			scanf("%d", &latitude);
+			printf("- Longitude: ");
+			scanf("%d", &longitude);
+			for (barco=0; barco<QTDE_BARCOS; barco++)
+			{
+				if (latitude == barcos[barco][0] & longitude == barcos[barco][1])
+				{
+					barcos[barco][2] = 1;
+					atingidos++;
+				}
+			}
+			tiros++;
+		}
+	}
+}
+</syntaxhighlight>
+-->
+=== O tabuleiro ===
+Representar o tabuleiro: etapas 1 a 4.
+==== Etapa 1: desenhar uma onda ====
+Conteúdos abordados:
+* [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c300.html declaraçao de variáveis]
+* [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c940.html saída de dados na tela]
+* [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c410.html estrutura de decisão: ''if'']
+Nessa etapa se deseja mostrar o estado de uma única posição do tabuleiro. Se o estado for "água", mostra-se uma onda (símbolo ''~''), e se for "navio" mostra-se ''X''.
+<syntaxhighlight lang=c>
+#include <stdio.h>
+int main() {
+  // 0: agua
+  // 1: navio
+  int posicao = 1;
+  if (posicao == 0) {
+    printf("~");
+  } else {
+    printf("X");
+  }
+}
+</syntaxhighlight>
+Usou-se uma variável inteira para representar o estado da posição do tabuleiro. O valor 0 (zero) corresponde a "água", e 1 corresponde a "navio". Para testar o valor dessa variável, e mostrar ''~'' ou ''X'', precisou-se de uma estrutura de decisão do tipo '''''se''' (condição) '''então''' bloco_de instruções '''senão''' outro_bloco_de_instruções''. Na linguagem C isso se faz com '''''if''' (condição) { bloco de instruções } '''else''' {outro bloco de instruções}''.
+==== Etapa 2: desenhar uma linha de ondas ====
+Nessa etapa deseja-se mostrar uma linha do tabuleiro. Por exemplo, para um tabuleiro de 10 colunas, uma linha deve aparecer assim (se tiver só "água'":
+ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
+O problema é parecido com o da etapa 1, mas agora deve-se mostrar o estado de cada posição de uma linha. Foi sugerido o uso de um vetor para representar os estados das posições em uma linha. Assim, imaginando-se uma linha com 10 posições, o vetor abaixo poderia ser usado para representar seus estados:
+<syntaxhighlight lang=c>
+int linha[10];
+</syntaxhighlight>
+Repare na semelhança entre a declaração de um vetor em C e em Portugol. A ideia é a mesma: ao declarar o vetor deve-se informar sua capacidade (quantas posições ele possui, o que corresponde a quantos valores ele é capaz de armazenar). No exemplo acima, o vetor de inteiros ''linha'' possui 10 posições, e assim é capaz de guardar 10 números inteiros.
+A tarefa da etapa 2 portanto é testar cada posição do vetor ''linha'': se for 0 deve-se mostrar ''~''(água), e se for 1 deve-se mostrar ''X'' (navio).
+Conteúdos abordados:
+* [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c300.html declaraçao de variáveis]
+* [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c940.html saída de dados na tela]
+* [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c410.html estrutura de decisão: ''if'']
+* [http://www.ead.cpdee.ufmg.br/cursos/C/aulas/c440.html estrutura de repetição: ''while'']
+<syntaxhighlight lang=c>
+#include <stdio.h>
+int main() {
+  // 0: agua
+  // 1: navio
+  int linha[10] = {0,1,0,0,0,0,0,0,0,0};
+  int y;
+  y = 0;
+  while (y < 10) {
+    // Mostra ~ se posicao for agua, e X se for navio
+    if (linha[y] == 0) {
+      printf("~ ");
+    } else {
+      printf("X ");
+    }
+    y = y + 1;
+  }
+}
+</syntaxhighlight>
+===Equipes 2011-2===
+* Antônio e Joseane
+* Julio e Deyze
+* Edimar e Thiago
+* Juliana e Marina
+* Daniel e Guilherme
+* Fabiana e Erivelto
+* Wagner e Edgar
+* Gabriel Simas e Mário
+* Anna e Vinicius Rodrigues
+* Bruno e Gabriel Cantu
+* Cleber
+== 02/12: Desenvolvimento do Projeto==
+===Ponteiros em linguagem C===
+Ponteiros é uma característica poderosa oferecida pela linguagem C. A linguagem de programação C depende muito dos ponteiros, assim, um bom programador em C precisa dominar bem ponteiros.
+Ponteiro é visto pela maior parte dos programadores  iniciantes como uma das partes mais difíceis na linguagem C, pois o conceito de ponteiros pode ser novo ou um mesmo símbolo usado para certa finalidade e usado para outra diferente, tornando mais difícil o entendimento.
+Entendendo o que é um ponteiro
+Um ponteiro é uma variável que guarda um endereço de memória de outra variável. Os ponteiros da linguagem C proporcionam uma forma fácil de acesso ao valor de variáveis sem referenciá-las diretamente. Um ponteiro possui tipo, por exemplo, inteiros, ponto flutuante e caracteres. O tipo do ponteiro indica que tipo é a variável para qual ele aponta.
+Um ponteiro é declarado a seguinte forma:
+<syntaxhighlight lang=text>
+tipo_do_ponteiro *nome_do_ponteiro
+</syntaxhighlight>
+Exemplo:
+<syntaxhighlight lang=c>
+int *p, *a;
+char *pt, *ponteiro;
+</syntaxhighlight>
+No exemplo acima foram criados quatro ponteiros, dois de tipo inteiro e dois de tipo caractere. É importante não confundir o asterisco (*), que indica que a variável é um ponteiro, com o mesmo sinal indicando uma multiplicação.
+Conhecendo os operadores
+Sempre é importante iniciar o ponteiro. Um ponteiro sempre é iniciado com o local na memória onde se localiza o valor da variável. Para iniciar a variável desejada como o endereço de memória, segue o exemplo:
+<syntaxhighlight lang=c>
+int variavel_apontada=2;
+int *ponteiro;
+ponteiro=&variavel_apontada;
+</syntaxhighlight>
+No exemplo foi criada uma variável e iniciada com valor 2, foi criado também um ponteiro que logo abaixo foi iniciado com o endereço da variável chamada variável_apontada.
+A linguagem de programação C oferece dois operadores unitários, o operador de endereço (&) e o operador indireto (*). O operador de endereço retorna o endereço de memória onde fica localizado a variável, como foi mostrado no exemplo acima. O operador indireto retorna o valor da variável para qual o ponteiro aponta. Por exemplo:
+<syntaxhighlight lang=c>
+main() {
+   int var, *p;
+   var=10;
+   p=&var;
+   printf("O valor da variavel eh: %d \n", *p);
+   printf("O endereco de memoria da variavel eh: %p \n", p);
+   printf("O endereco de memoria do ponteiro eh: %p \n", &p);
+   *p=15;
+   printf("O novo valor da variavel e': %d \n", var);
+   return (0);
+}
+</syntaxhighlight>
+A saída será:
+<syntaxhighlight lang=text>
+O valor da variavel eh: 10
+O endereco de memoria da variavel eh: 00AE4F6
+O endereco de memoria do ponteiro eh: 00AE4F8
+O novo valor da variavel eh: 15
+</syntaxhighlight>
+No exemplo, usam-se os operadores para imprimir e aterá o valor da variável. Onde o endereço de memória varia de cada computador.
+O ponteiro é usado em situações em que a passagem de valores é complicada, por isso é muito importante seu aprendizado. O conceito de ponteiro e seu uso podem, aparentemente, ser complicado, porém, não é muito difícil. O uso indevido e insensato de ponteiros pode causar sérios bugs em um programa e até comprometer todo o sistema, assim, é necessário cuidado quando se usa eles.
+== 07/12: Desenvolvimento do Projeto==
+=== Desenhando o tabuleiro completo ===
+Dando continuidade à visualização do tabuleiro, agora deve-se desenhá-lo por completo na tela. Quer dizer, mostrar um tabuleiro com 10 linhas e 10 colunas, seguindo a abordagem das etapas 1 e 2.
+* Para mostrar uma única casa do tabuleiro (etapa 1) usou-se uma variável inteira, cujo conteúdo representa o estado daquela casa (se água ou navio). Para mostrar uma linha usou-se um vetor com capacidade 10, com cada posição do vetor representando o estado da casa correspondente. Como se deve então fazer para mostrar todo o tabuleiro ?<br>''Possível solução: usando uma matriz bidimensional para representar todas suas casas:'' <syntaxhighlight lang=c>
+#include <stdio.h>
+int main() {
+  // 0: agua
+  // 1: navio
+  int tabuleiro[10][10] = {{0,1,1,0,1,0,0,0,0,0}, {0,0,1,0,0,0,0,0,0,0},
+                           {0,0,0,0,1,0,0,0,0,1}, {0,1,1,0,1,0,0,0,0,0},
+                           {0,0,0,0,1,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0},
+                           {0,1,0,0,0,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0},
+                           {0,0,0,0,0,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0}};
+  int linha, coluna;
+  linha = 0;
+  while (linha < 10) {
+      coluna = 0;
+      while (coluna < 10) {
+        // Mostra ~ se posicao for agua, e X se for navio
+        if (tabuleiro[linha][coluna] == 0) {
+          printf("~ ");
+        } else {
+          printf("X ");
+        }
+        coluna = coluna + 1;
+      }
+      printf("\n");
+      linha = linha + 1;
+  }
+}
+</syntaxhighlight>
+* Mostrar o tabuleiro na tela parece ser em si um algoritmo. Ele precisa apenas  que se informem quais os estados das casas do tabuleiro. Esse algoritmo ficaria bem se implementado em uma [http://wiki.sj.cefetsc.edu.br/wiki/index.php/SOP-funcoes função]. <syntaxhighlight lang=c>
+#include <stdio.h>
+  // 0: agua
+  // 1: navio
+// Obs: a matriz "tabuleiro" foi tornada uma variável global porque é difícil
+// passar uma matriz como argumento de função. Assim ela pode ser acessada
+// pela função "mostra_tabuleiro".
+int tabuleiro[10][10] = {{0,1,1,0,1,0,0,0,0,0}, {0,0,1,0,0,0,0,0,0,0},
+                           {0,0,0,0,1,0,0,0,0,1}, {0,1,1,0,1,0,0,0,0,0},
+                           {0,0,0,0,1,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0},
+                           {0,1,0,0,0,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0},
+                           {0,0,0,0,0,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0}};
+int mostra_tabuleiro() {
+  int linha, coluna;
+  linha = 0;
+  while (linha < 10) {
+      coluna = 0;
+      while (coluna < 10) {
+        // Mostra ~ se posicao for agua, e X se for navio
+        if (tabuleiro[linha][coluna] == 0) {
+          printf("~ ");
+        } else {
+          printf("X ");
+        }
+        coluna = coluna + 1;
+      }
+      printf("\n");
+      linha = linha + 1;
+  }
+}
+int main() {
+  mostra_tabuleiro();
+}
+</syntaxhighlight>
+=== A função random() ===
+<syntaxhighlight lang=c>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+int main() {
+  int x,y,z;
+  time_t t;
+  // Lê o valor do relógio
+  t = time(NULL);
+  // Usa o valor do relógio como semente do gerador de números
+  // pseudo-aleatórios.
+  srandom(t);
+  // Sorteia três números pseudo-aleatórios
+  x = random() % 10;
+  y = random() % 10;
+  z = random() % 10;
+  printf("x=%d, y=%d, z=%d\n", x, y, z);
+}
+</syntaxhighlight>
+== 09/12: Desenvolvimento do Projeto==
+* 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)
+* Desenvolvimento do projeto
+* O código abaixo faz uso da biblioteca <time.h>, necessário para cálculo do tempo transcorrido pelo jogador
+<syntaxhighlight lang=c>
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+void calcula(){ //função calcula tempo transcorrido para executar uma operação.
+  time_t inicio, fim;
+  char nome[51];
+  inicio= time(NULL);
+  printf("Digite seu nome: ");
+  scanf("%s",nome);
+  //fgets(nome, 51, stdin);
+  fim= time(NULL);
+  printf("%s, voce demorou %.2f segundos para digitar seu nome.\n", nome, difftime(inicio,fim)*(-1));
+}
+void tempo()
+{
+  time_t segundos, inicio;
-    contador <- 3
+  inicio = time(NULL); //captura tempo nesse instante
-    enquanto contador > 0 faz
+  printf("O valor lido neste instante eh %ld \n", inicio);
-        ler valor
-        se valor > maior1 entao
-            maior2 <- maior1
-            maior1 <- valor
-        senao
-            se valor > maior2 entao
-                maior2 <- valor
-            fimse
-        fimse
-        contador <- contador - 1
-    fimenquanto
-    escrever "maior valor = " , maior1
-    escrever "\nsegundo maior valor = " , maior2
-fim
-</syntaxhighlight>
-== 01/06: Aulas 1 e 2==
-* Conceitos avaliação de lógica de programação [http://tele.sj.ifsc.edu.br/~tisemp/SOP/avaliacoes/conceitos_logica.pdf clique aqui]
-* Aulas 1 e 2 - curso de C UFMG
-* [http://www.ead.cpdee.ufmg.br/cursos/C/c.html Curso de Linguagem C - Engenharia Elétrica -  UFMG]
-* '''Curso C/C++ ACATE (Grátis)''' [http://www.acate.com.br/index.asp?dep=7&pg=6964 clique aqui]
-== 02/06: Aula 3==
-== 08/06: Aula 4==
-== 09/06: Aula 5==
-<syntaxhighlight lang=c>
-#include <stdio.h>
-#include <stdlib.h>
-int main(int argc, char** argv) {
+  segundos= time(NULL); //captura e apresenta o tempo em segundos
-    int pres=0, idade=0, taq=0;
+  printf("%ld horas desde 1 de Janeiro de 1970.\n", segundos/3600);
-    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);
 }
-</syntaxhighlight>
-== 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 [http://www.sj.ifsc.edu.br/~tisemp/SOP/semana_tele.pdf clique aqui]<br>
-Programação do evento: [http://www.sj.ifsc.edu.br/~tisemp/SOP/SemanaTelecom.odt clique aqui] <br>
-==23/06: Feriado Nacional==
-* Aproveitando o feriado para resolver alguns [http://www.sj.ifsc.edu.br/~tisemp/SOP/exercicios_resp.pdf exercícios de Programação em linguagem C]
-* Corpus Christi
-== 29/06: Revisão para avaliação linguagem C==
-* Resolução de exercícios
-=== A função random() ===
-<syntaxhighlight lang=c>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/time.h>
 int main() {
-  int x,y,z;
-  time_t t;
-  // Lê o valor do relógio
+    tempo();
-  t = time(NULL);
+    calcula();
-  // Usa o valor do relógio como semente do gerador de números
+    return 0;
-  // pseudo-aleatórios.
-  srandom(t);
-  // Sorteia três números pseudo-aleatórios
-  x = random() % 10;
-  y = random() % 10;
-  z = random() % 10;
-  printf("x=%d, y=%d, z=%d\n", x, y, z);
 }
 </syntaxhighlight>
-== 30/06: Prova Final - Linguagem C==
+== 14/12: Desenvolvimento do Projeto==
-* Estruturas de repetição
+* Entrega do projeto
-* Estruturas de decisão
+* Avaliação individual (oral)
-* 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 [http://tele.sj.ifsc.edu.br/~tisemp/SOP/conceitos_av2.pdf clique aqui]
-== 06/07: Avaliação de recuperação==
-Conceitos avaliação Recuperação programação C [http://tele.sj.ifsc.edu.br/~tisemp/SOP/conceitos_rec.pdf clique aqui]
-== 07/07: Aula 6 e 9 (encerramento disciplina) ==
+== 16/12: Encerramento disciplina ==
-* Encerramento disciplina
+* Recuperações
+===Linguagens de programação: tendências do mercado===
 * Discussões sobre os tipos de linguagens de programação utilizadas atualmente no mercado e tendências
 * [http://langpop.com/ Popularidade das linguagens de programação]

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

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"

Operador	Descrição	Exemplo
+	Adição	x <- x + 1
-	Subtração	x <- x - 1
*	Multiplicação	x <- xxx
/	Divisão	dias <- horas / 24
%	Módulo (resto de divisão)	horas <- horas % 24
^	Potenciação	area <- lado^2

Operador	Descrição	Exemplo
=	Igualdade	correto <- (erros = 0)
>	Maior	multa <- (velocidade > 80)
>=	Maior ou igual	aprovado <- (pontuacao >= 70)
<	Menor	barato <- (preco < 100)
<=	Menor ou igual	bombear_agua <- (nivel_agua <= 0.7)
=/=	Diferente	descartar <- (endereco =/= 12345)

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

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;

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 }

Mudanças entre as edições de "PRG-2011-2-tiago"

Edição atual tal como às 09h10min de 7 de dezembro de 2011

Instrutor

Lógica de Programação

03/08: Introdução

05/08: Resolução de exercícios

10/08: Desenvolvendo algoritmos

Problemas exemplo

Atividade extra

Exercícios: desenho de figuras geométricas

12/08: Desenvolvendo algoritmos

17/08: Algoritmos

Atividade para casa

Dicas para o kturtle

19/08: Pseudocódigo e Diagrama de Blocos (Fluxograma)

Página de apoio (Fluxogramas):

Fluxogramas: Estruturas de decisão

Exercícios Propostos:

26/08: Pseudocódigo e Diagrama de Blocos (Fluxograma)

Fluxogramas: Estruturas de repetição

Estrutura de repetição: FOR (em português, PARA)

Estrutura de repetição: While Do (em português, ENQUANTO FACA)

Estrutura de repetição: Do Until (em português, FACA ATE)

Exercícios Propostos:

Atividade em sala (teste surpresa, nem tão surpresa assim ;)

31/08: Lógica de Programação

02/09: Lógica de Programação

Exercícios Propostos (Vetores)

Entrega dos exercícios

07/09: Feriado Nacional

09/09: Portugol

Portugol

Guia rápido de instalação e utilização do Portugol

Atividades

14/09: Constantes e Variáveis

Variáveis e constantes

Atividade

16/09: Algoritmos

Desenvolvimento de algoritmos

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

Operadores aritméticos

Atividades

21/09: Estruturas de decisão

Condições

23/09: Exercícios estruturas de decisão

Teste surpresa (Estruturas de decisão):

Exercícios extras: entrega até dia 27/09

Solução Exercício 3:

Solução Exercício 6:

28/09: Estruturas de decisão

Engenharia de Telecomunicações: início de oferta 2012-1

Atividades

30/09: Estruturas de repetição

Solução do problema proposto em sala

Atividades

05/10: Estruturas de repetição

Uma pequena avaliação :-)

07/10: Estruturas de repetição

Variáveis multidimensionais

12/10: Estruturas de repetição (Lista de exercícios para o Feriado :p)

Entrega por e-mail (tisemp@ifsc.edu.br) até o dia 12/10 (quarta-feira)

14/10: Revisão para avaliação de Lógica de Programação

14/10: Lista complementar, com respostas ;)

19/10: Avaliação de Lógica de Programação

Conceitos Avaliação de Lógica:

21/10: Vista da avaliação de Lógica de Programação

21/10: Linguagem C

Compilando o primeiro programa

Tipos de dados

Comandos/funções e Estruturas de controle

Atividades

26/10: Introdução linguagem C

28/10: Feriado: dia do servidor público

Conceitos

31/10: Aula 3

02/11: Feriado: todos os santos (finados)

04/11: Aula 4

09/11: Aula 4

11/11: Aula 4

16/11: Aula 5