Introdução algoritmo
-
Upload
wendel-da-silva-santana -
Category
Documents
-
view
34 -
download
0
Transcript of Introdução algoritmo
Introdução
A maioria das pessoas que querem aprender a programar começam de maneira errada.
Arrumam um compilador ou ambiente de programação e já vão metendo a mão na massa.
Esta é a maneira mais frustrante de aprender a programar. Logo, logo estas pessoas vão
esbarrar em obstáculos que só serão transpostos com a análise cuidadosa do problema e
com a construção de um algoritmo. A lógica de programação e a construção de algoritmos
são conhecimentos fundamentais para programar. Construído o algoritmo, você pode, então,
codificar seu programa em qualquer linguagem.
"Conte-me e eu esqueço
Mostre-me e eu lembro
Deixe-me fazer e eu aprendo"
Confúcio
Isto é verdade. E baseado nisto é que você deve assimilar as regras básicas da construção de
algoritmos e cair em campo para fazer os exercícios. Não olhe as respostas antes. Queime os
neurônios e tente até a cabeça doer. No final confira com as respostas. Porém, lembro que
muitas vezes um problema pode ser resolvido de várias maneiras. A solução mostrada aqui é
apenas uma delas.
Caso você já conheça alguma linguagem de programação, é interessante codificar suas
soluções.
O que é um algoritmo
Basicamente, um algoritmo é um conjunto de passos a serem seguidos para a resolução de
um problema.
Digamos que você quer que o seu programa calcule a média aritmética entre quatro notas.
Para resolver este problema você poderia dar as seguintes ordens ao computador:
1. Receba as quatro notas do usuário;
2. Calcule a soma destas quatro notas;
3. Divida o resultado desta soma por quatro.
Simples não ???
Porém existem algumas regras e convenções que facilitam a nossa vida e nos ajudam a
resolver problemas mais complexos.
Sentimos dificuldade em organizar nossos pensamentos e fazer o algoritmo. Para melhorar
isso devemos treinar, fazer muitos algoritmos e com o passar do tempo ficaremos com o
raciocínio bem flexível.
Após feito o algoritmo você pode codificar seu programa em qualquer linguagem,
observando, é lógico, as possibilidades e limitações da linguagem.
Existem várias formas de representar um algoritmo. Aqui utilizarei uma representação em
forma de texto. Creio que esta representação facilita na hora da codificação devido a
semelhança entre ela e a sintaxe das diversas linguagens.
Tipos de dados
Basicamente existem quatro de tipos de dados. São eles: inteiro, real, caracter e lógico.
Inteiro representa todo e qualquer número que pertença ao conjunto dos números inteiros.
Na prática são os números positivos e negativos sem partes decimais. Exemplos: 2; -4; 145; -
354.
Real representa todo e qualquer número que pertença ao conjunto dos números reais. Na
prática são os números positivos e negativos que tem parte decimal. Exemplos: 3,545; -2,6; 0,157.
Caracter é qualquer dado composto por um conjunto de caracteres alfanuméricos. Os caracteres
alfanuméricos são os números, as letras e os caracteres especiais (!,@,#,$,%, etc...). Exemplos: 3d;
valor1; nome.
Lógico é um tipo de dado que só pode assumir dois valores.
Constantes e variáveis
Constante, como o nome indica, é um dado que não sofre nenhuma variação durante todo
o algoritmo.
As constantes do tipo caracter sempre devem ser colocadas entre aspas ( " ). Exemplo: "Isto
é uma constante caracter".
Convencionaremos que constantes do tipo lógico poderão assumir um dos seguintes valores:
verdadeiro (V), ou falso(F).
Variável, como o nome indica, é um dado que tem a possibilidade de variar, ou seja, ter
seu valor alterado durante a execução do algoritmo.
As variáveis do tipo caracter sempre devem ser colocadas entre aspas ( " ). Exemplo: "Isto é
uma variável caracter".
Convencionaremos que variáveis do tipo lógico poderão assumir um dos seguintes valores:
verdadeiro (V), ou falso(F).
Nomeando constantes e variáveis
Para nomear constantes e variáveis devemos obedecer as seguintes regras:
1. Os nomes devem começar por um caractere alfabético;
2. Podem ser constituídos de caracteres alfabéticos ou numéricos;
3. Não devem conter caracteres especiais;
4. Não devem ser utilizados nomes reservados da linguagem de programação que se
vai usar.
Exemplos:
1. Nomes válidos: delta, X, BC4R, K7, notas, media, ABC, PI, ICMS.
2. Nomes inválidos: 5X, E(13), A:B, X-Y, Nota/2, AWq*, P&AA
Como regra de estilo eu costumo não utilizar acentuação, usar apenas letras maiúsculas para
nomear as constantes e apenas letras minúsculas para nomear as variáveis. Mas, como gosto
não se discute, fique livre para adotar estas regras ou não.
Declaração de variáveis
As variáveis devem ser declaradas antes do seu uso no algoritmo. Declarar uma variável é
definir seu tipo e seu nome. Para a declaração de variáveis usaremos a seguinte sintaxe:
TIPO DE DADO: VARIÁVEL1, VARIÁVEL2, ....., VARIÁVELn;
Exemplos:
inteiro: x;
caracter: nome, endereco, data;
real: PI, preco;
lógico: resposta, opcao;
A declaração das variáveis deve estar no início do algoritmo.
Duas variáveis não devem ter o mesmo nome.
Operadores aritméticos
Operadores aritméticos são os sinais que representam as operações básicas da matemática.
OPERADOR FUNÇÃO EXEMPLO
+ Adição 2 + 3, nr1 + nr1
- Subtração 5 - 3, b - c
* Multiplicação 12 * 4, x * y
/ Divisão 10 / 2, x / y3
% Resto da divisão9 % 4 resulta em 1
27 % 5 resulta em 2
pot (x,y)Potenciação.
Significa x elevado a ypot(3,2)
raiz(x) Raiz quadrada de x raiz(25)
Prioridade das operações:
1. Parênteses mais internos
2. pot, raiz
3. *, /, %
4. +, -
Dentro da mesma prioridade as operações são executadas da esquerda para a direita.
Para alterar a prioridade utilize parênteses.
Operadores relacionais
Operadores relacionais são sinais utilizados para realizar comparações entre dois valores de
mesmo tipo.
Os valores comparados podem ser constantes, variáveis ou expressões aritméticas.
OPERADOR FUNÇÃO EXEMPLO
= igual a 5 = 5, x = y
> maior que 8 > 4, x > y
< menor que 1 < 5, x < y
>= maior ou igual a 11 >= 5, x >= y
<= menor ou igual a 2 <= 5, x <= y
!= diferente de 34 != 5, a != b
O resultado obtido sempre será um valor lógico. Por exemplo, analisando a operação a + b
= c, o resultado será verdadeiro se o valor da expressão aritmética a + b for igual ao
conteúdo da variável c. Caso o resultado da expressão a + b seja diferente de c o resultado
será falso.
Exemplos:
a) 2 * 4 = 24 /3 resultado V, pois 2 * 4 = 8 e 24 / 3 = 8;
b) (14 resto 4) < 1 resutaldo F, pois 14 resto 4 = 2 e 2 não é menor que 1;
c) (2 +(8 resto 7)) >= 3 resultado V, pois 2 + (8 resto 7) = 2 + 1 = 3 e 3 é maior ou igual a 3.
Operadores lógicos
Os operadores lógicos são sinais usados para montar operações relacionais compostas. São
eles: não, e e ou
Exemplo: (notafinal >= 7,0) e (prestacao = V)
O resultado da operação acima será V se a variável "notafinal" for maior ou igual a 7,0 e a
variável lógica "prestacao" for igual a V.
Prioridade de execução entre os operadores lógicos
1. não
2. e, ou
Prioridade de execução entre todos os operadores
1° parênteses mais internos
2°operadores aritméticos
3° operadores relacionais
4° operadores lógicos
Comando de atribuição
Este comando atribui um valor a uma constante ou variável. O valor deve ser compatível com
o tipo de dado da constante ou variável, ou seja, para uma constante ou variável inteira deve
ser atribuído um valor inteiro; para uma constante ou variável real deve ser atribuído um
valor real; o mesmo ocorrendo com o tipo caracter e o lógico.
Sintaxe: VARIÁVEL <== VALOR;
VALOR pode ser um valor propriamente dito ou uma expressão.
Exemplos:
x <== 34;
notafinal <== ((nota1+nota2+nota3)/3);
LIGADO <== V;
preco <== 25,15;
Comandos para entrada e saída de dados
Para a entrada de dados adotaremos o comando ler, cuja finalidade é receber os dados que
serão processados. Sua sintaxe é:
ler (VARIÁVEL1, VARIÁVEL2, ..., VARIÁVELn);
Para a saída de dados utilizaremos o comando imprimir, cuja finalidade é exibir os dados
processados. Sua sintaxe é:
imprimir (VARIÁVEL1, VARIÁVEL2, ..., VARIÁVELn);
Você pode exibir texto juntamente com as variáveis. Para isso coloque o texto entre aspas
( " ). Exemplo:
imprimir ("Seu nome é :", nome);
Inserindo comentários
A fim de dar ao seu algoritmo um entendimento melhor por parte de outros leitores, ou até
para você mesmo, você deve sempre comentá-lo. Para inserir um comentário utilizaremos os
comando /* (barra e asterisco) e */(asterisco e barra). O que vier escrito entre estes dois
comandos deve ser interpretado como comentário e não haverá ação alguma por parte do
programa. Exemplo:
preco precobruto + IMPOSTO;
/* o IMPOSTO acima deve seguir a alíquota do ICMS. */
imprimir ("O preço do produto é", preco);
A linha do meio do trecho de algoritmo acima não dá nenhuma ordem pois é apenas um
comentário.
Blocos de instruções
Um bloco de instruções é um conjunto de comandos com uma função definida. O algoritmo é
formado de um ou mais blocos de instruções. O bloco de instruções também define os limites
para o conhecimento de constantes e variáveis. Uma constante ou variável definida em um
bloco só será conhecida dentro deste.
Para delimitar um bloco utilizamos os comandos início e fim. Exemplo:
início
inteiro: nota1, nota2; /* declaração das variáveis * /
imprimir ("Entre com a primeira nota :");
ler (nota1);
imprimir ("Entre com a segunda nota :");
ler (nota2);
imprimir ("A soma das duas notas é ", (nota1+nota2));
fim
Estrutura básica de um algoritmo
O algoritmo como um todo é um bloco de instruções, então deve ser delimitado pelos
comandos início e fim.
As constantes e variáveis devem ser declaradas no início.
Os comandos são executados sequencialmente de cima para baixo e da esquerda para a
direita, assim, devem ser escritos nesta sequência.
Cada comando deve terminar com ; (ponto-e-vírgula).
Abaixo segue um modelo da estrutura básica de um algoritmo:
início
/* declaração das constantes e variáveis*/
inteiro: var1, var2;
real: var3;
caracter: nome;
/* comandos */
comando 1;
comando 2;
comando 3;
..........
..........
..........
comando n;
fim
Observe que os comandos delimitados por início e fim estão avançados de dois espaços.
Isto será muito utilizado pois facilita o entendimento do algoritmo.
Primeiros algoritmos
Abaixo seguem três algoritmos. Como você está iniciando (é o que suponho) analise-os com
cuidado para entender a coisa.
Média aritmética entre quatro notas
início
/* Declaração das variáveis */
real: nota1, nota2, nota3, nota4, soma, media;
/* Comandos * /
/* Entrada de dados */
imprimir ("Entre com a primeira nota :");
ler (nota1);
imprimir ("Entre com a segunda nota :");
ler (nota2);
imprimir ("Entre com a terceira nota :");
ler (nota3);
imprimir ("Entre com a quarta nota :");
ler (nota4);
/* Processamento */
soma <== (nota1 + nota2 + nota3 + nota4 );
media <== soma / 4 ;
/* Saída de dados */
imprimir ("A média aritmética é ", media);
fim
Observe o uso dos comentários para tornar o algoritmo mais legível.
Cálculo da área de um quadrado
início
real: lado, area;
imprimir ("Entre com a medida do lado do quadrado :");
ler (lado);
area <== lado * lado;
imprimir ("A área do quadrado é ", area);
fim
Cálculo de juros
início
real: preco, taxa, juros, total;
imprimir ("Entre com o preço :");
ler (preco);
imprimir ("Qual a taxa de juros (%)?");
ler (taxa);
juros <== preco * (taxa / 100);
total <== preco + juros;
imprimir ("O total a pagar é ", total);
fim
Desvio condicional
A estrutura de desvio condicional deve ser utilizada quando nos deparamos com a seguinte
situação:
1. Queremos que uma condição seja analisada;
2. Caso esta condição seja verdadeira, um comando será executado;
3. Caso esta condição seja falsa, outro comando será executado.
Sua sintaxe é:
se CONDIÇÃO
COMANDO1;
senão
COMANDO2;
fimse;
Se CONDIÇÃO for verdadeira, COMANDO1 será executado. Se CONDIÇÃO for falsa,
COMANDO2 será executado.
Tanto COMANDO1 como COMANDO2 podem constituir um bloco de instruções. Quando isso
acontecer você deve delimitar o bloco com os comandos "início" e "fim".
Você pode aninhar mais de uma estrutura "se" e analisar mais de uma condição:
se CONDIÇÃO1
COMANDO1;
senão se CONDIÇÃO2
COMANDO2;
senão
COMANDO3;
fimse;
Cuidado quando usar isto para não deixar o algoritmo ruim de compreender. Às vezes,
escolhendo outro tipo de estrutura conseguimos o mesmo efeito com um algoritmo mais
legível.
Exemplo demonstrativo: algoritmo que recebe a idade do usuário e verifica se o mesmo tem
mais de 21 anos:
início
inteiro: idade;
imprimir ("Entre com sua idade :");
ler (idade);
se (idade >=21)
imprimir ("Você é de maior !!!");
senão
imprimir ("Você é de menor !!!");
fimse;
fim
Múltipla escolha
Esta estrutura analisa o valor de uma variável e, de acordo com este valor, executa
determinado comando. Sua sintaxe é:
escolha VARIÁVEL
caso VALOR1: COMANDO1;
caso VALOR2: COMANDO2;
caso VALOR3: COMANDO3;
..............................................
caso contrário: COMANDO4;
fimescolha;
Na sintaxe acima, caso o valor de VARIÁVEL seja igual a VALOR1, COMANDO1 será
executado. Caso seja igual a VALOR2, COMANDO2 será executado, e assim por diante. Se
VARIÁVEL não coincidir com nenhum valor, o COMANDO4 será executado.
Como na estrutura de desvio condicional, os COMANDOS podem constituir blocos com mais
de um comando. Quando isso acontecer, não esqueça de delimitar o bloco.
Exemplo demonstrativo: Este algoritmo exibe um menu de formas de pagamento, analisa
qual foi a forma escolhida e exibe uma mensagem relativa ao desconto.
início
inteiro: opcao;
imprimir ("Forma de pagamento");
imprimir ("-------------------------------------");
imprimir ("1. A vista em dinheiro.");
imprimir ("2. Cheque para trinta dias.");
imprimir ("3. Em duas vezes.");
imprimir ("4. Em três vezes.");
imprimir ("5. Em quatro vezes.");
imprimir ("6. A partir de cinco vezes.");
imprimir ("--------------------------------------");
imprimir ("Entre com sua opção :");
ler (opcao);
escolha opcao:
caso 1: imprimir ("Desconto de 20%.");
caso 2: imprimir ("Preço de a vista.");
caso 3: imprimir ("Preço de a vista.");
caso 4: imprimir ("Preço de a vista.");
caso 5: imprimir ("Juros de 5%.");
caso 6:
início
imprimir ("Juros de 3% ao mês");
imprimir ("Sujeito a mudança de acordo a financeira.";
fim;
caso contrário: imprimir ("Opção inválida !!!");
fimescolha;
fim
Repetição com teste inicial
Esta estrutura permite repetir um trecho de algoritmo diversas vezes. O fluxo de execução é
controlado por um teste feito antes da execução:
enquanto CONDIÇÃO faça
COMANDO1;
COMANDO2;
...........................
...........................
...........................
COMANDOn;
fimenquanto;
Quando CONDIÇÃO for falso os COMANDOS serão abandonados e o algoritmo passará para o
próximo comando após o "fimenquanto". Se já da primeira vez o resultado é falso, os
COMANDOS não são executados nenhuma vez, o que representa a característica principal
desse modelo de repetição.
Exemplo demonstrativo: algoritmo que calcula a média aritmética de uma quantidade
indeterminada de números.
início
inteiro: contador; /*contará quantos números são passados para o programa*/
real: acumulador; /*acumulará a soma dos números passados*/
real: media; /*armazenará o resultado da média aritmética*/
real: numero;/*armazenará os números e controlará o encerramento do programa*/
/*Inicialização das variáveis. É uma boa regra de estilo sempre inicializar (atribuir algum
valor) as variáveis
antes de usá-las. Algumas linguagens exigem isso.*/
contador <== 1;
acumulador <== 0;
media <== 0;
numero <== 0;
enquanto (numero >= 0) faça
imprimir ("Entre com um número (-1 para encerrar) :");
ler (numero);
se (numero >=0) /*só computa o número se este for maior ou igual a zero*/
acumulador <== acumulador + numero;
contador <== contador + 1;
fimse;
fimenquanto;
media <== acumulador / contador;
imprimir ("A média aritmética é", media);
fim
Repetição com teste final
Esta estrutura também permite repetir um trecho de algoritmo diversas vezes, porém o fluxo
é controlado por um teste feito no final da execução.
faça
COMANDO1;
COMANDO2;
...........................
...........................
...........................
COMANDOn;
enquanto CONDIÇÃO;
Observe que os COMANDOS são executados pelo menos uma vez, independente da
CONDIÇÃO. Isto acontece porque a condição é avaliada após a execução dos comandos, o
que representa a característica principal desta estrutura.
Exemplo demonstrativo: algoritmo que calcula a média aritmética de uma quantidade
indeterminada de números.
início
inteiro: contador; /*contará quantos números são passados para o programa*/
real: acumulador; /*acumulará a soma dos números passados*/
real: media; /*armazenará o resultado da média aritmética*/
real: numero;/*armazenará os números e controlará o encerramento do programa*/
/*Inicialização das variáveis. É uma boa regra de estilo sempre inicializar (atribuir algum
valor) as variáveis
antes de usá-las. Algumas linguagens exigem isso.*/
contador <== 1;
acumulador <== 0;
media <== 0;
numero <== 0;
faça
imprimir ("Entre com um número (-1 para encerrar) :");
ler (numero);
se (numero >=0) /*só computa o número se este for maior ou igual a zero*/
acumulador <== acumulador + numero;
contador <== contador + 1;
fimse;
enquanto (numero >= 0);
media <== acumulador / contador;
imprimir ("A média aritmética é", media);
fim
Repetição controlada
Esta estrutura permite repetir um trecho de algoritmo um número específico de vezes. Sua
sintaxe é:
para contador de inicio até fim incremento nr faça
COMANDO1;
COMANDO2;
...........................
...........................
...........................
COMANDOn;
fimpara;
onde:
"contador" é a variável de controle;
"inicio" é o valor inicial de "contador";
"fim" é o valor final de "contador";
"nr" é o valor segundo o qual "contador" será incrementado a cada execução.
Exemplo demonstrativo: algoritmo que imprime os números até 500
início
inteiro: contador
para contador de 1 até 500 incremento 1 faça
imprimir (contador, " - ");
fimpara;
fim
Exercícios
1. Construa um algoritmo que receba a idade do usuário e verifique se ele tem mais de
21 anos.
2. Construa um algoritmo que receba três números inteiros e verifique qual o maior.
3. Construa um algoritmo que calcule o peso ideal de uma pessoa. Dados de entrada:
altura e sexo. Fórmulas para cálculo do peso:
peso ideal de homem = (72,7 x altura) - 58
peso ideal da mulher = (62,1 x altura) - 44,7
4. Construa um algoritmo que receba o código de um produto e o classifique de acordo
com a tabela abaixo:
CÓDIGO CLASSIFICAÇÃO
1 Alimento não-perecível
2 a 4 Alimento perecível
5 e 6 Vestuário
7 Higiene pessoal
8 a 15 Limpeza e utensílios domésticos
Qualquer outro código Inválido
5. Construa um algoritmo que leia uma quantidade indeterminada de números inteiros
positivos e identifique qual foi o maior número digitado. O final da série de números
digitada deve ser indicada pela entrada de -1.
6. Construa um algoritmo que leia três valores inteiros e os imprima em ordem
cresecente.
7. Construa um algoritmo que receba um número inteiro e verifique se o mesmo é
primo.
8. Dada a fórmula: H = 1 + !/2 + 1/3 + 1/4 + ..... + 1/N . Construa um algoritmo que
calcule o número H, dado o número inteiro N.
9. Construa um algoritmo que calcule o fatorial de um número N inteiro e positivo (N!).
Saiba que:
N! = 1 x 2 x 3 .... x (N -1) x N
0! = 1
10. A série de Fibonacci é formada pela seguinte sequência: 1,1,2,3,5,8,13,21,34,55....
Construa um algoritmo que gere a série de Fibonacci até o vigésimo termo.
11. Construa um algoritmo que leia cinco números inteiros e identifique o maior e o
menor.
12. Construa um algoritmo que imprima a tabela de equivalência de graus Fahrenheit
para centígrados. Os limites são de 50 a 70 graus Fahrenheit com intervalo de 1
grau.
Fórmula: C = 5/9 (F -32)
13. Uma rainha requisitou os serviços de um monge, o qual exigiu o pagamento em
grãos de trigo da seguinte maneira: os grãos de trigo seriam dispostos em um
tabuleiro de xadrez, de tal forma que a primeira casa do tabuleiro tivesse um grão, e
as casas seguintes o dobro da anterior. Construa um algoritmo que calcule quantos
grãos de trigo a Rainha deverá pagar ao monge.
14. Construa um algoritmo que apure uma eleição com três candidatos. O algoritmo deve
realizar as seguintes tarefas:
- Calcular o total de votos para cada candidato;
- Calcular a quantidade de votos nulos;
- Calcular a quantidade de votos em branco;
- Calcular o percentual de votos em branco e nulos em relação ao total.
- A votação deve obedecer as seguintes convenções:
1,2,3 => votos dos candidatos
4 => votos em branco
5 => votos nulos
0 => encerramento da apuração
15. José tem 1,50 m e cresce 2 centímetros por ano. Pedro tem 1,10 m e cresce 3
centímetros por ano. Construa um algoritmo que calcule em quantos anos Pedro será
maior que José.
Solução aos exercícios
1. início
inteiro: idade;
imprimir("Qual a sua idade ?");
ler(idade);
se(idade>=21)
imprimir("Você é de maior !!!.");
senão
imprimir("Você é de menor !!!.");
fimse;
fim
2. início
inteiro nr1, nr2, n3;
imprimir("Entre com o primeiro número :");
ler(nr1);
imprimir("Entre com o segundo número :");
ler(nr2);
imprimir("Entre com o terceiro número :");
ler(nr3);
se(nr1 > nr2)
se(nr2 > nr3)
imprimir("O ", nr1, " é o maior.");
senão se(nr1 > nr3)
imprimir("O", nr1, "é o maior.");
senão
imprimir("O", nr3, "é o maior.");
fimse;
senão se(nr2 > nr3)
imprimir("O", nr2, "é o maior.");
senão
imprimir("O", nr3, "é o maior.");
fimse;
fim
3. início
inteiro: sexo;
real: peso, altura;
imprimir("Sexo (1. Homem 2. Mulher) :");
ler(sexo);
se((sexo<1) ou (sexo>2)) /* analisa se escolha de sexo é válida */
imprimir("Opção de sexo inválida !!!");
senão
início
imprimir("Qual sua altura ?");
ler(altura);
se (sexo = 1) /* usuário é homem */
peso <== (72,7 * altura) -58;
senão /* usuário é mulher */
peso <== (62,1 * altura) - 44,7;
fimse;
imprimir("Seu peso ideal é ", peso);
fim;
fimse;
fim
4. início
inteiro: cod;
imprimir("Código do Produto :");
ler(cod);
escolha cod
caso 1: escreva ("Alimento não perecível.");
caso 2,3,4: escreva ("Alimento perecível.");
caso 5,6: escreva ("Vestuário");
caso 7: escreva ("Higiene pessoal");
caso 8,9,10,11,12,13,14,15; escreva ("Limpeza e utensílios domésticos.");
caso contrário: escreva ("Opção inválida.");
fimescolha;
fim
5. início
inteiro: nr, maior;
maior <== 0;
faça
imprimir("Entre com um número inteiro positivo (-1 para terminar) :");
ler(nr);
se(nr > maior )
maior <== nr;
fimse;
enquanto(nr >= 0);
imprimir("O maior é ", maior);
fim
6. início
int nr1,nr2,nr3;
imprimir("Entre com o primeiro número :");
ler(nr1);
imprimir("Entre com o segundo número :");
ler(nr2);
imprimir("Entre com o terceiro número :");
ler(nr3);
se(nr1 > n2)
se(nr1 > nr3)
se(nr2 > nr3)
imprimir("Números em ordem crescente :",nr3,nr2,nr1);
senão
imprimir("Números em ordem crescente :",nr2,nr3,n1);
fimse;
senão
imprimir("Números em ordem crescente :",nr2,nr1,nr3;
fimse;
senão se(nr1 > nr3)
imprimir("Números em ordem crescente :",nr3,nr1,n2);
senão se(nr2 > nr3)
imprimir("Números em ordem crescente :",nr1,nr3,n2);
senão
imprimir("Números em ordem crescente :",nr1,nr2,n3);
fimse;
fim
7. início
int numero,contador,resto,indicador;
indicador <== 0; /* variável que indicará se o número é primo ou não */
/* caso ela seja igual a 0 (zero) o número será primo */
imprimir("Entre com o número :");
ler(numero);
para contador de 2 até (numero-1) incremento 1 faça
início
resto = numero % contador;
se(resto == 0)
indicador <== 1;
fimse;
fimpara;
se(numero == 2)
imprimir("O número 2 não é primo.");
/* Analisa se "numero" é 2 pois, caso isto aconteça, o laço "para" */
/* não é executado e "indicador" terá valor 0(zero), indicando, */
/ * assim, que 2 é primo. O que não é verdade. */
senão se(indicador == 0) /* Analise da variável "indicador" */
imprimir("O número ", numero, " é primo.");
senão
imprimir("O número ", numero, " não é primo.");
fimse;
fim
8. início
real: h,n,contador;
h <== 0;
imprimir("H = 1 + ½ + 1/3 + ¼ + ... + 1/N");
imprimir("Entre com o valor de N :");
ler(n);
para contador de 1 até n incremento 1 faça
h = h + 1/contador;
fimpara;
imprimir("H = ", h);
fim
9. início
inteiro: nr,contador,fatorial;
fatorial <== 1;
imprimir("Entre com o número :");
ler(nr);
para contador de 1 até nr incremento 1 faça
fatorial <== fatorial * contador;
fimpara;
se (nr == 0)
imprimir("Fatorial de ", nr, " = ", 1);
senão
imprimir("Fatorial de ", nr, " = ", fatorial);
fimse;
fim
10. início
inteiro: termo, termo_anterior1,termo_anterior2, contador;
imprimir("1, ");
termo_anterior1 <== 1;
termo_anterior2 <== 0;
para contador de 2 até 20 incremento 1 faça
termo <== termo_anterior1 + termo_anterior2;
imprimir("termo, ");
termo_anterior2 <== termo_anterior1;
termo_anterior1 <== termo;
fimpara;
fim
11 inicio
inteiro: nr, maior,menor,contador;
imprimir("Entre com o 1o número :");
ler(nr);
maior <== nr;
menor <== nr;
para contador de 2 até 5 incremento 1 faça
imprimir("Entre com o ", contador, "o número :");
ler(nr);
se(nr > maior)
maior <== nr;
fimse;
se(nr < menor)
menor <== nr;
fimse;
fimpara;
imprimir("O maior é ", maior.");
imprimir("O menor é ", menor.");
fim
12 início
real: cent, far;
para far de 50 até 70 incremento 1 faça
cent = 5/9(far - 32);
imprimir(far, " - ", cent);
fimpara;
fim
13 A sequência dos grão no tabuleiro será: 1, 2, 4, 8, 16, 32, ......
início
int casa,casa_ant,contador,total;
casa <== 1;
casa_ant <== 1;
total <== 1;
para contador de 2 até 64 incremento 1 faça
casa <== casa_ant * 2;
total <== total + casa;
casa_ant <== casa;
casa <== total;
fimpara;
printf("A rainha pagará ", total, " grãos de trigo ao monge.");
fim
14. início
inteiro: a,b,c,branco,nulo,total,voto;
real: percent_branco,percent_nulo;
a <== 0; /* votos do candidato 1 */
b <== 0; /* votos do candidato 2 */
c <== 0; /* votos do candidato 3 */
branco <== 0;
nulo <== 0;
total <== 0;
imprimir("Entre com seu voto :");
ler(voto):
enquanto (voto <> 0) faça
total <== total + 1;
escolha voto
caso 1: a <== a + 1;
caso 2: b <== b + 1;
caso 3: c <== c + 1;
caso 4: branco <== branco + 1;
caso 5: nulo <== nulo + 1;
fimescolha;
imprimir("Entre com seu voto :");
ler(voto);
fimenquanto;
percent_branco <== (branco * 100)/total;
percent_nulo <== (nulo * 100)/total;
imprimir("Total de votos => ",total);
imprimir("Candidato 1 => ",a, " votos.");
imprimir("Candidato 2 => ",b, " votos.");
imprimir("Candidato 3 => ",c, " votos.");
imprimir("Votos em branco => ", branco, " votos ( ", percent_branco, " % ).");
imprimir("Votos nulos => ", nulo, " votos ( ", percent_nulo, " % ).");
fim
15. início
inteiro: jose,pedro,anos;
jose <== 150;
pedro <== 110;
para anos de 1 até (pedro > jose) incremento 1 faça
jose <== jose + 2;
pedro <== pedro + 3;
fimpara;
imprimir("Levarão ", anos, "anos para Pedro ser maior que José.");
fim