Estrutura_Para-Ate-Faca_exercicios_resolvidos

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

EXERCICIOS PARA-ATE-FACA
IMPRESSÃO DE TEXTO
Escreva um algoritmo que mostre na tela a palavra “Algoritmos” 20 vezes. As palavras devem ser mostradas uma ao lado do outra, com um espaço em branco entre elas.
algoritmo "Algoritimos 20X"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
inicio
// Seção de Comandos
para cont de 1 ate 20 faca
escreva(“ Algoritimos”)
fimpara
fimalgoritmo
Escreva um algoritmo que mostre seu nome na tela 20 vezes. Os nomes devem ser mostrados um ao lado do outro, com um espaço em branco entre eles. 
algoritmo "Meu nome"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
inicio
// Seção de Comandos 
para cont de 1 ate 20 faca
escreva(“ Willians”)
fimpara
fimalgoritmo
Escreva um algoritmo que mostre na tela a mensagem “Estou estudando estrutura de repetição” 20 vezes. As frases deverão ser mostradas uma embaixo da outra.
algoritmo "Frases"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
inicio
// Seção de Comandos 
para cont de 1 ate 20 faca
escreval(“Estou estudando estrutura de repetição”)
fimpara
fimalgoritmo
Escreva um algoritmo que mostre na tela a mensagem “Fazer exercícios é o primeiro passo para a prática profissional” 20 vezes. As frases deverão ser mostradas uma embaixo da outra.
algoritmo "Fazer exercicio"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
inicio
// Seção de Comandos
para cont de 1 ate 20 faca
	escreval(“Fazer exercícios é o primeiro passo para a prática profissional”)
fimpara
fimalgoritmo
REPETIÇÃO DE EXECUÇÃO DE PROGRAMAS
Escreva um algoritmo que repita 5 vezes a seguinte função: ler um número do teclado, calcular o quadrado desse número e mostrar o resultado na tela para o usuário.
algoritmo "Quadrado"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
numero,quadrado:inteiro
inicio
// Seção de Comandos
para cont de 1 ate 5 faca
escreval(“Digite um numero inteiro”)
leia(numero)
quadrado<-numero*numero
escreval(“O quadrado de: ”, numero, “ é :”,quadrado)
fimpara
fimalgoritmo
Escreva um algoritmo que repita 5 vezes a seguinte função: ler dois números do teclado, somar os 2 números e mostrar na tela o resultado para o usuário. 
algoritmo "somar 2 numeros"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
n1,n2,soma:real
inicio
// Seção de Comandos 
para cont de 1 ate 5 faca
escreval(“Digite o primeiro numero inteiro”)
leia(n1)
escreval(“Digite o segundo numero inteiro”)
leia(n2)
soma<-n1+n2
escreval(“A soma de:”,n1,” + “,n2,” = “,soma)
fimpara
fimalgoritmo
 
Escreva um algoritmo que repita 5 vezes a seguinte função: ler dois números do teclado, verificar e mostrar na tela se os números são iguais ou diferentes.
algoritmo "iguais ou difrentes"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
n1,n2:real
iguais:logico
inicio
// Seção de Comandos 
para cont de 1 ate 5 faca
escreval(“digite o primeiro numero”)
leia(n1)
escreval(“digite o segundo numero”)
leia(n2)
iguais<-n1=n2
se iguais entao
escreval(“Os números digitados são iguais”)
senao
escreval(“Os números digitados são diferentes”)
			fimse
	fimpara
fimalgoritmo
Escreva um algoritmo que repita 5 vezes a seguinte função: ler um número do teclado, verificar e mostrar na tela se o número digitado é par ou impar.
algoritmo "par ou impar"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
numero:inteiro
par:logico
inicio
// Seção de Comandos 
para cont de 1 ate 5 faca
escreval(“digite um numero”)
leia(numero)
par<-((numero%2)=0)
	se par entao
		escreval(“O numero é par”)
		senao
		escreval(“O numero é impar”)
	fimse
	fimpara
fimalgoritmo
IMPRESSÃO DE NÚMEROS USANDO A VARIÁVEL CONTADORA
Escreva um algoritmo que mostre na tela os números inteiros entre 0 e 100, em ordem crescente. Os números devem ser mostrados em ordem crescente, um ao lado do outro, com um espaço em branco entre eles.
algoritmo "crescente"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
inicio
// Seção de Comandos 
para cont de 1 ate 100 faca
escreva( cont)
fimpara
fimalgoritmo
Escreva um algoritmo que mostre na tela todos os números inteiros de 0 e 100 em ordem decrescente. Os números devem ser mostrados em ordem decrescente, um ao lado do outro, com um espaço em branco entre eles.
algoritmo "decrescente"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
inicio
// Seção de Comandos
para cont de 100 ate 0 passo -1 faca
escreva( cont)
fimpara
fimalgoritmo
Escreva um algoritmo que mostre na tela apenas os números pares de 100 a 200. Os números devem ser mostrados em ordem crescente, um ao lado do outro, com um espaço em branco entre eles.
algoritmo "pares crescente"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
inicio
// Seção de Comandos
	para cont de 100 ate 200 passo 2 faca
		escreva( cont)
	fimpara
fimalgoritmo
Faça um algoritmo para mostrar na tela os números divisíveis por 3 e 5 ao mesmo tempo, de 1 a100.
algoritmo "divisíveis por 3 e 5"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
inicio
// Seção de Comandos
para cont de 1 ate 100 faca
 		se ((cont%3)=0) e ((cont%5)=0)entao
			escreval(“ O numero:”,cont,” é divisivel por 3 e 5”)
		fimse
	fimpara
fimalgoritmo
FÓRMULAS USANDO A VARIÁVEL CONTADORA
Escreva um algoritmo que mostre o quadrado de todos os números do intervalo de 1 a 100. Utilize o seguinte formato de saída de dados: O quadrado de 1 é 1. O quadrado de 2 é 4, e assim sucessivamente. O resultado deve ser uma apresentação de dados na forma de coluna.
algoritmo "quadrado"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
quadrado:inteiro
inicio
// Seção de Comandos 
para cont de 1 ate 100 faca
quadrado<-cont*cont
escreval(“ O quadrado de:”,cont,” é”,quadrado)
	fimpara
fimalgoritmo
Faça um algoritmo que mostre uma tabela de valores correspondentes entre Graus Célsius e Graus Fahrenheit. Por exemplo: 0º C = 32º F, 1º C = 33,8º F, e assim sucessivamente, até 100ºC. O resultado deve ser uma apresentação de dados na forma de coluna. Pesquise a fórmula de conversão.
algoritmo "Graus Celsius e Fahrenheit"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
conversao:real
inicio
// Seção de Comandos 
para cont de 0 ate 100 faca
conversao<-(cont*1,8+32)
escreval(cont,” Graus Celsius”,” =”,conversao,” Graus Fahrenheit”)
	fimpara
fimalgoritmo
Faça um algoritmo que mostre uma tabela de valores correspondentes entre centímetros e polegadas. Por
exemplo: 1 centímetro = 0,39 polegadas, e assim sucessivamente, até 100 centímetros. O resultado deve ser uma apresentação de dados na forma de coluna. Pesquise a fórmula de conversão.
algoritmo "Centímetro para Polegada"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
polegada:literal
conversao:real
inicio
// Seção de Comandos 
para cont de 1 ate 100 faca
polegaga<-0.39
conversao<-(cont*polegada)
escreval(cont,” centímetros é igual a:”,conversao,” polegadas)
	fimpara
fimalgoritmo
Escreva um algoritmo que mostre na tela a tabuada do número 7.
algoritmo "tabuada 7"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
sete,produto:inteiro
inicio
// Seção de Comandos
escreval(“TABUADA DO 7”)
para cont de 1 ate 10 faca
sete<-7
produto<-(sete*cont)
escreval(sete,” X”,cont,” =”,produto)
fimpara
fimalgoritmo
UTILIZAÇÃO DE DUAS VARIÁVEIS CONTADORAS AO MESMO TEMPO
Escreva um algoritmo que mostre na tela a seguinte sequencia: 1 + 2 = 3, 2 + 3 = 5, 3 + 4 = 7, e assim sucessivamente, até 10 + 11 = 21. Os números devem ser apresentados na forma de coluna.
algoritmo "soma alternada"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont1,cont2:inteiro
soma:inteiro
inicio
// Seção de Comandos
para cont1 de 1 ate 10 faca
cont2<-cont1+1
soma<-cont1+cont2
escreval(cont1,” +”,cont2,” =”,soma)
	fimpara
fimalgoritmo
Escreva um algoritmo que mostre na tela a seguinte sequencia: 1 + 10 = 11, 2 + 9 = 11, 3 + 8 = 11, e assim sucessivamente, até 10 + 1 = 11. Os números devem ser apresentados na forma de coluna.
algoritmo "subtração alternada"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont1,cont2:inteiro
soma:inteiro
inicio
// Seção de Comandos
para cont1 de 1 ate 10 faca
cont2<-11-cont1
soma<-cont1+cont2
escreval(cont1,” +”,cont2,” =”,soma)
fimpara
fimalgoritmo
Escreva um algoritmo que mostre na tela as tabuadas do 1 ao 10.
algoritmo "Tabuada"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont1,cont2:inteiro
produto:inteiro
inicio
// Seção de Comandos
para cont1 de 1 ate 10 faca
para cont2 de 1 ate 10 faca
produto<-cont2*cont1
escreval(cont1,” X”,cont2,” =”,produto)
fimpara
escreval(“”)
fimpara
fimalgoritmo
Escreva um algoritmo que mostre na tela a seguinte sequência, simulando uma tabela de 4 linhas e 4 colunas: linha 1, coluna1, linha 1, coluna2, linha 1, coluna3, linha 1, coluna4. As sequências devem ser mostradas na forma de colunas. Pular uma linha em branco entre elas.
algoritmo "Sequencia"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont1,cont2:inteiro
inicio
// Seção de Comandos
para cont1 de 1 ate 4 faca
	para cont2 de 1 ate 4 faca
escreval(“Linha”,cont1,” Coluna”,cont2)
fimpara
escreval(“”)
	fimpara 
fimalgoritmo
DETERMINAÇÃO DE SOMATÓRIOS: VARIÁVEL SOMATÓRIA COM LEITURA DE DADOS
Faça um algoritmo para ler 100 inteiros números do teclado, somar, e ao final mostrar na tela o resultado.
algoritmo "Somatorio"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont,somatorio:inteiro
numero:inteiro
inicio
// Seção de Comandos 
somatorio<-0
para cont de 1 ate 100 faca
	escreval(“Didite o”,cont,”o. Numero”)
leia(numero)
somatorio<-somatorio+numero
fimpara
escreval(“O somatório de todos os números é: ”,somatorio)
fimalgoritmo
Faça um algoritmo para ler 100 números inteiros do teclado. Faça a soma dos números digitados somente se o número for impar. Ao final mostrar na tela o resultado.
algoritmo "Somatório impares"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont,somatorio:inteiro
numero:inteiro
inicio
// Seção de Comandos 
	somatorio<-0
		para cont de 1 ate 100 faca
			escreval(“Digite o”,cont,”.o Numero”)
			leia(numero)
			se ((numero%2)=1)entao
				somatorio<-somatorio+numero
			fimse
		fimpara
escreval(“A soma dos números impares digitados é:”,somatorio)
fimalgoritmo
Suponha que 100 pessoas irão responder um questionário. Faça um algoritmo para ler 2 dados dessas pessoas: idade e número de filhos. Faça a soma dos dois dados separadamente e ao final apresente os somatórios.
algoritmo "Questionario"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
qtdanos,qtdfilhos,somatorio:inteiro
filhos,idade:inteiro
inicio
// Seção de Comandos 
qtdanos<-0
qtdfilhos<-0
	para cont de 1 ate 100 faca
		escreval(“digite sua idade”)
		leia(idade)
		escreval(“Informe quantos filhos tem”)
		leia(filhos)
			qtdanos<-qtdanos+idade
			qtdfilhos<-qtdfilhos+filhos
			somatorio<-qtdanos+qtdfilhos
	fimpara
				escreval(“A soma das idades é:”,qtdanos,”anos”)
				escreval(“A soma dos filhos é:”,qtdfilhos,”filhos”)
				escreval(“A soma das idades + a qtd de filhos é:”,somatorio)
fimalgoritmo
Faça um algoritmo para ler 100 números do teclado. Faça a soma dos números digitados, separando a soma dos valores positivos e a soma dos valores negativos, separadamente. Ao final mostre as somas parciais e o resultado da soma dos positivos com os negativos.
algoritmo "Positivos e Negativos"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
numero,positivo,negativo,somatorio:inteiro
inicio
// Seção de Comandos
positivo<-0
negativo<-0
	para cont de 1 ate 100 faca
		escreval(“Digite o”,cont,”o. Numero”)
		leia(numero)
		se numero>0 entao
			positivo<-positivo+numero
			senao
				se numero<0 entao
					negativo<-negativo+numero
				fimse
		fimse
		somatorio<-positivo+negativo
	fimpara
		escreval(“A soma dos numeros positivos é:”,positivo)
		escreval(“A soma dos números negativos é:”,negativo)
		escreval(“A soma dos positivos com os negativos é:”,somatorio)
fimalgoritmo
DETERMINAÇÃO DE SOMATÓRIOS: VARIÁVEL SOMATÓRIA UTILIZANDO A VARIÁVEL CONTADORA
Faça um algoritmo para somar os números de 1 a100 e ao final mostrar na tela o resultado. (Ex: 1 + 2 + 3 ... + 100)
algoritmo "somatorio"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
somatorio:inteiro
inicio
// Seção de Comandos
somatorio<-0
para cont de 1 ate 100 faca
somatorio<-somatorio+cont
	fimpara
		escreval(“A soma de todos os numeros é:”,somatorio) 
fimalgoritmo
Faça um algoritmo para somar os números pares de 1 a100 e ao final mostrar na tela o resultado. (Ex. 2 + 4 + 6 ... + 100)
algoritmo "somatório pares"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
somatorio:inteiro
inicio
// Seção de Comandos
somatorio<-0
para cont de 1 ate 100 faca
	se ((cont%2)=0)entao
somatorio<-somatorio+cont
		fimse
fimpara
	escreval(“A soma dos números pares é:”,somatorio)
fimalgoritmo
Faça um algoritmo para somar os números múltiplos de 5, de 1 a 100 e ao final mostrar na tela o resultado.
(Ex. 5 + 10 + 15 ... + 100)
algoritmo "somatorio múltiplos de 5"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
somatorio:inteiro
inicio
// Seção de Comandos 
	somatorio<-0
para cont de 1 ate 100 faca
		se ((cont%5)=0) entao
			somatorio<-somatorio+cont
		fimse
	fimpara
		escreval(“A soma dos números múltiplos de 5 são:”,somatorio)
fimalgoritmo
Faça um algoritmo para somar os números divisíveis por 3 e 5, de 1 a100 e ao final mostrar na tela o resultado. (Ex. 15 + 45 + ... + 100)
algoritmo "Soma dos números divisíveis por 3 e 5"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
somatorio:inteiro
inicio
// Seção de Comandos 
	somatorio<-0
	para cont de 1 ate 100 faca
		se((cont%3)=0) e ((cont%5)=0) entao
			somatorio<-somatorio+cont
		fimse
	fimpara
		escreval(“A soma dos números divisíveis por 3 e 5 são:”,somatorio)
fimalgoritmo
DETERMINAÇÃO DE SOMATÓRIOS COM VARIÁVEL SOMATÓRIA, USO DA VARIÁVEL CONTADORA E DE LEITURA DE VARIÁVEIS
Faça um algoritmo para calcular os seguintes somatórios:
 
�
algoritmo "somatorio"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
n:inteiro
somatorio:inteiro
inicio
// Seção de Comandos
	somatorio<-0
		para n de 1 ate 50 faca
			somatorio<-somatorio+2*n
fimpara
	escreval(“O somatorio de 0 a 50 fazendo 2*n é”,somatorio)
fimalgoritmo
**********************************************************************************************************************
�
algoritmo "somatorio"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
n:inteiro
somatorio:inteiro
inicio
// Seção de Comandos 
	somatorio<-0
	para n de 1 ate 50 faca
		somatorio<-somatorio+n*n
	fimpara
		escreval(“O somatorio de 0 ate 50 fazendo n*n é:”,somatorio)
fimalgoritmo
**********************************************************************************************************************
�
algoritmo "somatorio"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
n:inteiro
somatorio:real
inicio
// Seção de Comandos 
	somatorio<-0
	para n de 1 ate 50 faca
		somatorio<-somatorio+1/n
	fimpara
		escreval(“O somatorio de 0 ate 50 fazendo 1/n é:”,somatorio)
fimalgoritmo
**********************************************************************************************************************
�
algoritmo "somatorio"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
n:inteiro
somatorio:real
inicio
// Seção de Comandos 
	somatorio<-0
	para n de 1 ate 50 faca
		somatorio<-somatorio+1/(2*n)
	fimpara
		escreval(“O somatorio de 0 ate 50 fazendo 1/2*n é:”,somatorio)
fimalgoritmo
DETERMINAÇÃO DE MENOR E MAIOR
Faça um algoritmo que leia a idade de 10 pessoas e ao final mostre na tela a menor idade digitada.
algoritmo "Menor Idade"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
idade,menorIdade:inteiro
inicio
// Seção de Comandos 
	para cont de 1 ate 10 faca
		escreval(“digite a idade da”,cont,”.a pessoa”)
		leia(idade)
		se (cont=1) entao
			menorIdade<-idade
			senao
			se (idade<menorIdade) entao
				menorIdade<-idade
			fimse
		fimse
	fimpara
		escreval(“A menor idade digitada foi:”,menorIdade,”anos”)
fimalgoritmo
Faça um algoritmo que leia o salário de 10 pessoas e ao final mostre na tela o menor salário digitado.
algoritmo "menor salario"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
salario,menorSalario:real
inicio
// Seção de Comandos
	para cont de 1 ate 10 faca
		escreval(“Digite o valor do:”,cont,”.o Salário”)
		leia(salario)
			se (cont=1) entao
				menorSalario<-salario
				senao
				se (salario<menorSalario)entao
					menorSalario<-salario
				fimse
			fimse
	fimpara
		escreval(“O menor salário digitado foi:”,menorSalario,”,00 R$”)
fimalgoritmo
Faça um algoritmo que leia a altura de 10 pessoas e ao final mostre na tela a maior altura digitada.
algoritmo "maior altura"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
altura,maiorAltura:real
inicio
// Seção de Comandos 
	para cont de 1 ate 10 faca
		escreval(“Digite a altura da:”,cont,”.a pessoa”)
		leia(altura)
		se (cont=1) entao
			maiorAltura<-altura
			senao
			se (altura>maiorAltura) entao
				maiorAltura<-altura
			fimse
		fimse
	fimpara
		escreval(“A maior altura apresentada foi de:”,maiorAltura,” metros”)
fimalgoritmo
Faça um algoritmo que leia o peso de 10 pessoas e ao final mostre na tela o maior peso digitado.
algoritmo "maior peso"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
peso,maiorPeso:real
inicio
// Seção de Comandos 
	para cont de 1 ate 10 faca
		escreval(“Digite o peso da:”,cont,”.a pessoa”)
		leia(peso)
		se (cont=1) entao
			maiorPeso<-peso
			senao
			se (peso>maiorPeso) entao
				maiorPeso<-peso
			fimse
		fimse
	fimpara
		escreval(“O maior peso apresentado foi de:”,maiorPeso,” Kilos”)
fimalgoritmo
DETERMINAÇÃO DE QUANTIDADES
Faça um algoritmo que leia a idade de 10 pessoas e ao final mostre na tela a quantidade de pessoas com idade menor de 18 anos.
algoritmo "Quantidade de pessoas menores de 18 anos"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
idade,qtdPessoasMenores18:inteiro
inicio
// Seção de Comandos 
qtdPessoasMenores18<-0
para cont de 1 ate 10 faca
	escreval(“Digite a idade da:”,cont,”.a pessoa”)
	leia (idade)
	se (idade<18)entao
		qtdPessoasMenores18<-qtdPessoasMenores18+1
	fimse
fimpara
	escreval(“A quantidade de pessoas menores de 18 anos é:”,qtdPessoasMenores18)
fimalgoritmo
Faça um algoritmo que leia o salário de 10 pessoas e ao final mostre na tela a quantidade de pessoas com que recebem salário acima de 2 salários mínimos.
algoritmo "Acima de 2 salarios"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
salario, acimaDe2Salarios:real
qtdPessoasRecebeAcimaDe2Salarios:inteiro
inicio
// Seção de Comandos 
qtdPessoasRecebeAcimaDe2Salarios<-0
	para cont de 1 ate 10 faca
		escreval(“Digite o salário da:”,cont,”.a pessoa”)
		leia(salario)
		acimaDe2Salarios<-(678*2)+1
		se(salario>=acimaDe2Salarios)entao
			qtdPessoasRecebeAcimaDe2Salarios<- qtdPessoasRecebeAcimaDe2Salarios +1
		fimse
	fimpara
		escreval(“A quantidade de pessoas que recebem acima de 2 salarios é de:”, qtdPessoasRecebeAcimaDe2Salarios,” pessoas”)
fimalgoritmo
Faça um algoritmo que leia a altura de 10 pessoas e ao final mostre na tela a quantidades de pessoas com altura menor que 1.5 metros.
algoritmo "menor de 1.50 metros"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
altura,medida:real
qtdPessoasMenorede150Metros:inteiro
inicio
// Seção de Comandos 
	qtdPessoasMenorede150Metros <-0
	para cont de 1 ate 10 faca
		escreval(“Digite a altura da:”,cont,”.a Pessoa”)
		leia(altura)
			medida<-1.5
			se(altura<medida)entao
				qtdPessoasMenorede150Metros <- qtdPessoasMenorede150Metros+1
			fimse
	fimpara
		escreval(“A quantidade de pessoas abaixo de 1,5 metros é de:”, qtdPessoasMenorede150Metros,” pessoas”)
fimalgoritmo
Faça um algoritmo que leia sexo e o peso de 10 pessoas e ao final mostre na tela a quantidade de homens e de mulheres com peso acima de 80 quilos.
algoritmo "Homens e Mulheres acima de 80 quilos"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
Var
cont:inteiro
qtdHomensAcimaPeso,qtdMulheresAcimaPeso:inteiro
sexo:literal
peso:real
inicio
// Seção de Comandos
	qtdHomensAcimaPeso<-0
	qtdMulheresAcimaPeso<-0
	Para cont de 1 ate 10 faca
		escreval(“Digite m para masculino e f para feminino”)
		escreval(“Digite o sexo da:”,cont,”.a pessoa”)
		leia(sexo)
		escreval(“Digite o peso da:”,cont,”.a pessoa”)
		leia(peso)
		se (sexo=”m”)e(peso>80)entao
			qtdHomensAcimaPeso<-qtdHomensAcimaPeso+1
			senao
			se (sexo=”f”)e(peso>80)entao
				qtdMulheresAcimaPeso<-qtdMulheresAcimaPeso+1
			fimse
		fimse
	fimpara
		escreval(qtdHomensAcimaPeso,” Homens tem o peso acima de 80 quilos”)
		escreval(qtdMulheresAcimaPeso,” Mulheres tem o peso acima de 80 quilos”) 
fimalgoritmo
DETERMINAÇÃO DE MÉDIA
Faça um algoritmo que leia a idade de 10 pessoas e ao final calcule e mostre na tela a média das idades.
algoritmo "Media das idades"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
Var
cont,idade,somaIdade:inteiro
mediaIdade:real
inicio
// Seção de Comandos
	somaIdade<-0 
para cont de 1 ate 10 faca
		escreval(“Digite a idade da:”,cont,”.a pessoa”)
		leia(idade)
		somaIdade<-somaIdade+idade
		mediaIdade<-somaIdade/cont
	fimpara
		escreval(“A media das idade apresentadas é:”,mediaIdade,”anos”)
fimalgoritmo
Faça um algoritmo que leia o salário de 10 pessoas e ao final mostre na tela a média dos salários.
algoritmo "Media dos Salarios"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
salario,mediaSalario,somaSalario:real
inicio
// Seção de Comandos
	somaSalario<-0 
para cont de 1 ate 10 faca
	escreval(“Digite o salario da:”,cont,”.a pessoa”)
	leia(salario)
	somaSalario<-somaSalario+salario 
	mediaSalario<-somaSalario/cont
fimpara
	escreval(“A media dos salários Apresentados é de:”,mediaSalario)
fimalgoritmo
Faça um algoritmo que leia a altura de 10 pessoas e ao final mostre na tela a média das alturas que forem menores que 1.5 metros.
algoritmo "Media das Alturas"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont,cont2:inteiro
altura,somaAltura,mediaAltura:real
inicio
// Seção de Comandos
	somaAltura<-0
	cont2<-0
	para cont de 1 ate 10 faca
		escreval(“Digite a altura da:”,cont,”.a pessoa”)
		leia(altura)
		se (altura<1.5)entao
			cont2<-cont2+1
			somaAltura<-somaAltura+altura
			mediaAltura<-somaAltura/cont2
		fimse
	fimpara
			escreval(“A media das alturas abaixo de 1.5 metros é de:”,mediaAltura,”metros”)
 fimalgoritmo
Faça um algoritmo que leia sexo e o peso de 10 pessoas. Calcule a quantidade de homens acima de 80 quilos e das mulheres abaixo de 60. Mostre na tela a quantidade e a média dos pesos dos homens acima de 80 quilos e quantidade e a média dos pesos das mulheres abaixo de 60 quilos.
algoritmo "Qtd e Media de H e M e seus pesos"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
sexo:literal
qtdHomemAcima80Q,qtdMulherAbaixo60Q:inteiro
peso,totalPesoHomem,totalPesoMulher,mediaPesoHomem,mediaPesoMulher:real
inicio
// Seção de Comandos
	qtdHomemAcima80Q<-0
	qtdMulherAbaixo60Q<-0
	para cont de 1 ate 10 faca
		escreval(“Digite m para masculino e f para feminino”)
		escreval(“Digite o sexo da:”,cont,”.a pessoa”)
		leia(sexo)
		escreval(“Digite o peso da:”,cont,”.a pessoa”)
		leia(peso)
		se (sexo=”m”) e (peso>80) entao
			qtdHomemAcima80Q<-qtdHomemAcima80Q+1
			totalPesoHomem<-totalPesoHomem+peso
			mediaPesoHomem<-totalPesoHomem/qtdHomemAcima80Q
			senao
			se(sexo=”f”) e (peso<60) entao
qtdMulherAbaixo60Q<-qtdMulherAbaixo60Q+1
totalPesoMulher<-totalPesoMulher+peso
mediaPesoMulher<-totalPesoMulher/qtdMulherAbaixo60Q
			fimse
		fimse
	fimpara
		escreval(qtdHomemAcima80Q,” Homens tem mais de 80 Quilos”)
		escreval(“A media de peso dos Homens é de: ”,mediaPesoHomem,” Quilos”)
		escreval(“”)
		escreval(qtdMulherAbaixo60Q,” Mulheres tem menos que 60 Quilos”)
		escreval(“A media de peso das Mulheres é de:”,mediaPesoMulher, “Quilos”)
fimalgoritmo
DETERMINAÇÃO DE PORCENTAGEM
Faça um algoritmo que leia a quantidade de filhos de 10 pessoas e ao final calcule e mostre a porcentagem de pessoas com pessoas até 2 filhos.
algoritmo "Quantidade de filhos e Media das pessoas com 2 filhos"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
qtdPessoasAte2Filhos,qtdFilhos:inteiro
porcentagemPessoas2Filhos:real
inicio
// Seção de Comandos
	qtdPessoasAte2Filhos<-0 
	Para cont de 1 ate 10 faca
		escreval(“Digite a quantidade de filhos da:”,cont,”.a pessoa”)
		leia(qtdFilhos)
		se (qtdFilhos>0) e (qtdFilhos<=2) entao
			qtdPessoasAte2Filhos<-qtdPessoasAte2Filhos+1
			porcentagemPessoas2Filhos<-(qtdPessoasAte2Filhos/10)*100
		fimse
	fimpara
		escreval(porcentagemPessoas2Filhos,” % das pessoas tem até 2 filhos”)
fimalgoritmo
Faça um algoritmo que leia o ano de fabricação de 10 carros. Calcule e mostre a porcentagem de automóveis fabricados entre 1990 e 2000.
algoritmo "Ano Fabricação e porcentagem"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
ano,qtdFabricados:inteiro
porcentagemFabricados:real
inicio
// Seção de Comandos
	qtdFabricados<-0 
	para cont de 1 ate 10 faca
		escreval(“Digite o ano de fabricação do:”,cont,”.o Carro”)
		leia(ano)
		se (ano>=1990) e (ano<=2000)entao
			qtdFabricados<-qtdFabricados+1
			porcentagemFabricados<-(qtdFabricados/10)*100
		fimse
	fimpara
		escreval(porcentagemFabricados,” % dos carros foram fabricados entre 1990 e 2000”)
fimalgoritmo
Faça um algoritmo que leia o sexo e o estado civil de 10 pessoas. Calcule e mostre a porcentagem de mulheres casadas e a porcentagem de homens solteiros.
algoritmo "Estado Civil e Porcentagem"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
qtdMCas,qtdHSolt,qtdM,qtdH:inteiro
sexo,estadoCivil:literal
pctMCas,pctHSolt:real
inicio
// Seção de Comandos
	qtdMCas<-0 
	qtdHSolt<-0
	qtdM<-0
	qtdH<-0
	para cont de 1 ate 10 faca
		escreval(“Digite [ m ] para mulher e [ h ] para homem da:”,cont,”.a pessoa”)
		leia(sexo)
		escreval(“Digite [ s ] para Solteiro e [ c ] para Casado da:”,cont,”.a pessoa”)
		leia(estadoCivil)
		se (sexo=”m”)entao
			qtdM<-qtdM+1
			se (sexo=”m”)e(estadoCivil=”c”)entao
				qtdMCas<-qtdMCas+1
				senao
				se (sexo=”h”)entao
					qtdH<-qtdH+1
					se(sexo=”h”)e(estadoCivil=”s”)entao
						qtdHSolt<-qtdHSolt+1
					fimse
				fimse
fimse
		fimse
	fimpara
		pctMCas<-(qtdMCas/qtdM)*100
		pctHSolt<-(qtdHSolt/qtdH)*100
		escreval(pctMCas,” % das mulheres são casadas”)
		escreval(pctHSolt,” % dos homens são solteiros”)
fimalgoritmo
		
Faça um algoritmo que leia as notas finais de 10 alunos. Calcule e mostre a porcentagem de alunos com nota acima de 8 e a porcentagem de alunos com nota abaixo de 5.
algoritmo "notas finais e porcentagem"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
qtdAc8,qtdAb5:inteiro
nota:real
pctAc8,pctAb5:real
inicio
// Seção de Comandos 
	qtdAb5<-0
	qtdAc8<-0
	para cont de 1 ate 10 faca
		escreval(“Digite a note da:”,cont,”.a pessoa”)
		leia(nota)
		se (nota<5)entao
			qtdAb5<-qtdAb5+1
			pctAb5<-(qtdAb5/10)*100
			senao
			se (nota>8)entao
				qtdAc8<-qtdAc8+1
				pctAc8<-(qtdAc8/10)*100
			fimse
		fimse
	fimpara
		escreval(pctAb5,” % dos alunos tiraram abaixo que 5”)
		escreval(pctAc8,” % dos alunos tiraram acima que 8”)
fimalgoritmo
DETERMINAÇÃO DE FATORIAL
Escreva um algoritmo que leia um número do teclado, calcule e mostre o fatorial desse número.
algoritmo "fatorial de N"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
fat:inteiro
n:inteiro
inicio
// Seção de Comandos
	escreval(“Digite um numero”)
	leia(n)
fat<-1
	para cont de n ate 1 passo -1 faca
		fat<-fat*cont
	fimpara
		escreval(“O fatorial de: ”,n,” é:”,fat)
fimalgoritmo
Mostre a sequencia de fatoriais de 1 a 10
algoritmo "fotorial de 1 ate 10"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
fat:inteiro
inicio
// Seção de Comandos 
fat<-1
para cont de 10 ate 1 passo -1 faca
fat<-fat*cont
escreva(cont,"X")
fimpara
fimalgoritmo
Calcule a soma dos fatoriais de 1 a 5
algoritmo "Fatorial de 5"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
fat:inteiro
inicio
// Seção de Comandos 
fat<-1
para cont de 5 ate 1 passo -1 faca
	fat<-fat*cont
fimpara
	escreval(“O fatorial de 5 é: ”,fat)
fimalgoritmo
DETERMINAÇÃO DE NÚMERO PRIMO
Faça um algoritmo que mostre na tela se um número digitado pelo usuário é primo.
algoritmo "numero primo"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont: inteiro
n: inteiro
sinal: literal
inicio
// Seção de Comandos
sinal <- "V"
escreval ("digite um numero")
leia (n)
para cont de 2 ate n-1 faca
se ((n mod cont)=0) entao
sinal <- "F"
fimse
fimpara
se (sinal = "F") entao
escreval (n, " não é primo")
senao
se (sinal = "V") entao
escreval(n, " é primo")
fimse
fimse
fimalgoritmo
Mostre na tela a sequencia de números primos de 1 a 100
algoritmo "sequencia de números primos"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont1,cont2,sinal:inteiro
inicio
// Seção de Comandos 
	para cont1 de 1 ate 100 faca
		sinal<-0
		para cont2 de 1 ate cont1 faca
			se((cont1 mod cont2)=0)entao
				sinal<-sinal+1
			Fimse
		fimpara
		se(sinal<=2)entao
			escreval(cont1,” é um numero primo”)
		fimse
	fimpara
fimalgoritmo
Calcule a soma dos números primos de 1 a 100
algoritmo "soma dos primos"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont1,cont2,sinal,soma:inteiro
inicio
// Seção de Comandos 
	para cont1 de 1 ate 100 faca
		Sinal<-0
		para cont2 de 1 ate cont1 faca
			se((cont1 mod cont2)=0)entao
				sinal<-sinal+1
			fimse
		fimpara
		se(sinal=2)entao
			soma<-soma+cont1
		fimse
	fimpara
	escreval(“A soma dos números primos é:”,soma)
fimalgoritmo
TRABALHANDO COM SÉRIES
Faça um algoritmo que calcule e mostre o resultado da sequência: 32 + 62 + 92 + ... + 992
algoritmo "sequencia"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara
// Data : 02/09/2013
// Seção de Declarações 
var
cont, soma: inteiro
inicio
para cont de 32 ate 1000 faca
se ((cont mod 30) = 2) entao
 soma <- soma + cont
fimse
fimpara
escreval ("O resultada da sequência é", soma)
fimalgoritmo
Faça um algoritmo para ler um valor X e calcular Y = X+2X+3X+4X+5X+…+20X
algoritmo "Valor de Y"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont:inteiro
x,y:inteiro
inicio
// Seção de Comandos 
	escreval(“Digite um valor para X”)
	leia (x)
	y<-0
	para cont de 1 ate 20 faca
		y<- y+(x*cont)
	fimpara
		Escreval(“A soma é: ”,y)
fimalgoritmo
Faça um algoritmo para ler um valor X do teclado e Calcular Y = (x+1)+(x+2)+(x+3)+(x+4)+(x+5)+…(x+100).
algoritmo "Soma de X"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
Var
cont:inteiro
x,y:inteiro
inicio
// Seção de Comandos 
	escreval(“Digite um valor para X”)
	leia(x)
	y<-0
	para cont de 1 ate 100 faca
		y<-y+(x+cont)
	fimpara
	escreval(“A soma é: ”,y)
fimalgoritmo
CALCULO DE SÉRIES COM ALTERNÂNCIA ENTRE MAIOR E MENOR
Faça um algoritmo que calcule e mostre o resultado da sequência: 2 - 4 + 6 - ... + 100
algoritmo "Sequencia alternada"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
somaPos, somaNeg, somaTotal, cont: inteiro
inicio
somaPos <- 0
somaNeg <- 0
para cont de 2 ate 100 passo 2 faca
 		 se ((cont mod 4) = 0) entao
 			 somaNeg <- somaNeg + cont
 			 senao
 			 somaPos <- somaPos + cont
 		 fimse
fimpara
somaTotal <- somaPos - somaNeg
escreval ("O resultado da sequência é", somaTotal)
fimalgoritmo
Faça um algoritmo que calcule: 1! - 3! + 5! - 7! + ... + 81!
algoritmo "Soma Alternada"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont, cont2, fat, n, somaPos, somaNeg, somaTotal: inteiro
inicio
// Seção de Comandos
somaPos <- 0
somaNeg <- 0
n <- 1
repita
para cont de 1 ate 81 passo 2 faca
 		fat <- 1
 			 para cont2 de 1 ate cont faca
 			 fat <- fat * cont2
 			 fimpara
 				 se ((n mod 2) <> 0) entao
 				 somaPos <- somaPos + fat
 					 senao
 				 somaNeg <- somaNeg + fat
 				 fimse
 					 n <- n + 1
 	 fimpara
ate (n > 4)
somaTotal <- somaPos - somaNeg
escreval ("Resultado =", somaTotal) 
fimalgoritmo
Fazer um algoritmo que calcule e escreva a soma dos 50 primeiros termos da seguinte série de 1000 números:
algoritmo "Soma Termos"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
num, den: inteiro
sP, sN, sT: real
inicio
 num <- 1000
 para den de 1 ate 50 faca
 se ((num mod 2)) = 0 entao
 sP <- sP + (num/den)
 senao
 sN <- sN + (num/den)
 fimse
num <- num - 3
 fimpara
 sT <- sP - sN
 escreval ("Soma dos 50 primeiros termos = ", sT: 4:2)
fimalgoritmo
DESAFIOS
Faça um algoritmo para gerar os termos da seguinte P.G.: 3,9,27,81,…,. Calcule e mostre na tela a sequencia até o 100º termo.
algoritmo "semnome"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
inicio
// Seção de Comandos 
fimalgoritmo
A série de Fibonacci é formada pela sequência: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ... Escreva um algoritmo que gere a série de FIBONACCI até o N-ésimo termo, ou seja, N digitado pelo usuário.
algoritmo "semnome"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
inicio
// Seção de Comandos 
fimalgoritmo
Seja a seguinte série: 1, 4, 4, 2, 5, 5, 3, 6, 6, 4, 7, 7, ... Escreva um algoritmo em PORTUGOL que seja capaz de gerar os N termos dessa série. Esse número N deve ser lido do teclado.
algoritmo "soma alternada"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
cont1,cont2:inteiro
soma:inteiro
inicio
// Seção de Comandos
para cont1 de 1 ate 10 faca
		cont2<-cont1+1
soma<-cont1+cont2
escreval(cont1,” +”,cont2,” =”,soma)
	fimpara
fimalgoritmo
Faca um algoritimo que leia o modelo e o ano de fabricação de 10 carros. Calcule e mostre no final:
O modelo e o ano de fabricação do carro mais novo;
O modelo e o ano de fabricação do carro mais antigo;
Utilize obrigatoriamente a estrutura Para-ate-faca.
algoritmo "O mais novo e o mais antigo"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
ano, modelo, cont, maiorAno, maiorModelo, menorAno, menorModelo: inteiro
inicio
// Seção de Comandos 
para cont de 1 ate 5 faca
escreval("Digite o ano do carro")
leia (ano)
escreval ("Digite o modelo do carro")
leia (modelo)
se (cont = 1) entao
maiorAno <- ano
maiorModelo <- modelo
menorAno <- ano
menorModelo <- modelo
fimse
se (ano > maiorAno) entao
maiorAno <- ano
senao
se (ano < menorAno) entao
menorAno <- ano
fimse
fimse
se (modelo > maiorModelo) entao
maiorModelo <- modelo
senao
se (modelo < menorModelo) entao
menorModelo <- modelo
fimse
fimse
fimpara
escreval ("O ano mais novo é ano ", maiorAno, " e o modelo é ", maiorModelo)
escreval ("O mais antigo é ano ", menorAno, " e o modelo ", menorModelo)
fimalgoritmo
Faca um algoritimo que leia as 10 notas finais de uma turma de alunos de uma disciplina, calcule e mostre no final:
A media das notas entre 6 e 8
A porcentagem de alunos com notas acima de 8
Utilize obrigatoriamente a estrutura Para-ate-faca
algoritmo "Notas dos alunos"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var	
cont:inteiro
nota:real
qtdNota68,qtdNotaMais8:inteiro
somaNota68,porcentagem,mediaNota68:real
inicio
// Seção de Comandos
	qtdNota68<-0
	qtdNotaMais8<-0 
	Para cont de 1 ate 10 faca
		Escreval(“Digite a nota do:”,cont,”.o Aluno”)
		Leia(nota)
		Se(nota>5)e(nota<9)entao
			qtdNota68<-qtdNota68+1
			somaNota68<-somaNota68+nota
			senao
			se(nota>8)entao
				qtdNotaMais8<-qtdNotaMais8+1
			fimse
		fimse
	fimpara
		porcentagem<-(qtdNotaMais8/10)*100
		mediaNota68<-(somaNota68/qtdNota68)
		escreval(“A Media das notas entre 6 e 8 é de:”,mediaNota68)
		escreval(“A porcentagem de alunos que tiraram acima de 8 é de:”,porcentagem,” %”)
fimalgoritmo
Paula possui altura de 0.90cm e cresce 0.027 centimetros por ano. Ana tem 0.80cm e cresce 0.05 centimetros por ano. Construa um algoritimo que calcule iterativamente e mostre, ano a ano, o crescimento das duas e, ao final, mostre quantos anos serão necessários ate que Ana seja maior que Paula.
Utilize obrigatoriamente a estrutura Enquanto-faca
algoritmo "Crescimento"
// Função : Enquanto-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
altPaula,altAna:real
ano:inteiro
inicio
// Seção de Comandos
altPaula<-0.9
altAna<-0.8
ano<-0
enquanto altAna<=altPaula faca
	altPaula<-altPaula+0.027
	altAna<-altAna+0.05
	ano<-ano+1
	escreval("ano:",ano)
	escreval("Paula cresceu:",altPaula)
	escreval("Ana cresceu:",altana)
	escreval("")
fimenquanto
	escreval("Levaram:",ano," Anos para Ana ser maior que Paula")
fimalgoritmo
Faca um algoritimo usando a estrutura Enquanto-faca, que mostre na tela o fatorial de um numero digitado pelo usuário. Utilize a função produtorio para o calculo do fatorial.
algoritmo "semnome"
// Função : Para-Ate-Faca
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
numero,produto:real
inicio
// Seção de Comandos
	Esceval(“Digite um numero”)
	Leia(numero)
	Produto<-numero
	Enquanto produto<numero faca
		Produto<-produto*numero
	Fimenquanto
		Escreval(produto)	 
fimalgoritmo
Faca um algoritimo que calcule o peso ideal para um numero indefinido de pessoas. O algoritimo deve ler a altura e o sexo da pessoa, calcular e mostre o peso ideal, utilizando as seguintes formulas:
Para homens: 72,7*altura-58
Para mulheres: 62,1*altura-44.7
Depois de mostrar o resultado do calculo, o algoritimo deve perguntar se o usuário quer que o algoritimo seja executado novamente(digitando a letra C para continuar) ou então finalizar (digitando S para sair)
Utilize obrigatoriamente a estrutura Repita-ate.
algoritmo "Peso Ideal"
// Função : Repita-Ate
// Autor : Willians Miyabara (miyabara@hotmail.com)
// Data : 22/8/2013
// Seção de Declarações
var
sexo,sinal:literal
altura,pesoIdeal:real
inicio
// Seção de Comandos
repita
escreval("digite [h] para homem e [m] para mulher")
leia(sexo)
 	escreval("digite sua altura")
 	leia(altura)
 	se(sexo="h")entao
 	pesoIdeal<-72.7*altura-58
 	senao
 	pesoIdeal<-62.1*altura-44.7
 	fimse
 	escreval("seu peso ideal é:",pesoIdeal)
 	escreval("")
 	escreval("digite [s] para sair e [c] para continurar")
 	leia(sinal)
ate(sinal="s")
fimalgoritmo
Faça um algoritimo usando a estrutura Repita-ate, que mostre na tela se um numero digitado pelo usuário é primo. Utilize uma variável FLAG para verificar se existem divisores entre 1 e o numero digitado. No caso de haver um único divisor, o algoritimo deve parar de ser executado e mostrar ao final que o numero não é primo. Caso contrario, informar que o numero digitado é primo.
algoritmo "testar se é primo"
// Função : repita - ate
// Autor : Willians Miyabara (miyabara@hotmail.com
// Data : 05/09/2013
// Seção de Declarações
var
sinal:literal
n:inteiro
flag1,flag2:inteiro
inicio
// Seção de Comandos
sinal<-"v"
repita
escreval("Digite um numero")
leia (n)
flag1<-2
flag2<-n-1
se((n mod flag1)=0)entao
se((n mod flag2)<>0)entao
sinal<-"f"
fimse
fimse
se(sinal="v")entao
escreval("é primo")
senao
escreval("não é primo")
fimse
ate (sinal="f")
fimalgoritmo
Dois ciclistas A e B estão andando em uma pista de ciclismo com 2 Km de comprimento com velocidades de 10 m/s e 15 m/s, respectivamente.
Escreva um algoritmo em PORTUGOL que determine iterativamente o tempo que levará para que esses dois ciclistas A e B se encontrem em um mesmo ponto, sabendo que eles partiram de um mesmo ponto inicial, porém em sentido contrário. O algoritmo também deve calcular o deslocamento (distância) que cada um percorreu.
Faça um algoritmo que implemente a função soma para duas variáveis numéricas inteiras lidas do teclado. O algoritmo deve executar indefinidamente ou até que o usuário digite a letra S para sair. 
	Fórmulas de conversão de temperaturas
	Conversão de
	para
	Fórmula
	Grau Celsius
	Grau Fahrenheit
	°F = °C × 1,8 + 32
	Grau Fahrenheit
	Grau Celsius
	°C = (°F − 32) / 1,8
	Grau Celsius
	kelvin
	K = °C + 273,15
	Kelvin
	Grau Celsius
	°C = K − 273,15
	Grau Celsius
	Rankine
	°R = (°C + 273,15) × 1,8
	Rankine
	Grau celsius
	°C = (°R ÷ 1,8) – 273,15
Faz assim:
1 mulher casada
1 mulher casada
1 mulher solteira
1 mulher solteira
1 mulher solteira
1 homem casado
1 homem casado
1 homem casado
1 homem casado
1 homem solteiro
As mulheres casadas tem que dar 40%
Os homens Solteiros tem que dar 20%
Ou seja: 2 mulheres casadas de 5 mulheres = 40% delas
E 1 homem solteiro de 5 homens = 20% deles
Concordam??????????
algoritmo "semnome"
// Função :
// Autor :
// Data : 01/09/2013
// Seção de Declarações 
var
cont:inteiro
mCasadas, hSolteiros, mediaHSolteiro, mediaMCasada, qtdH, qtdM:real
sexo, estadoCivil: literal
inicio
// Seção de Comandos
qtdM <- 0
qtdH <- 0
mCasadas <- 0
hSolteiros <- 0
escreval("digite H para homem e M para mulher")
escreval("digite S para solteiro e C para casado")
para cont de 1 ate 10 faca
leia (sexo)
leia (estadoCivil)
se (sexo = "H") entao
qtdH <- qtdH +1
fimse
se (sexo = "H") e (estadoCivil = "S") entao
hSolteiros <- hSolteiros +1
senao
se (sexo = "M") entao
qtdM <- qtdM +1
fimse
se (sexo = "M") e (estadoCivil = "C") entao
mCasadas <- mCasadas + 1
fimse
fimse
fimpara
mediaHSolteiro <- hSolteiros *100 / qtdH
mediaMCasada <- mCasadas *100 / qtdM
escreval("qtd homens solteiros ", mediaHSolteiro, "% ")
escreval("qtd mulheres casadas ", mediaMCasada, "% ")
fimalgoritmo
� EMBED Equation.3 ���
_949923656.unknown
_949923657.unknown
_1335360809.unknown
_949923655.unknown
_949923654.unknown