Laços de Repetição em coletanea

Prévia do material em texto

Laços de Repetição
 Faça um algoritmo para exibir os números 1, 4, 9, 16, 25, 36, ..., 10000.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 09.04.2012
// Contato: tiagodemelo@gmail.com
algoritmo "Serie Quadrado"
var
 n: inteiro
inicio
 n <- 1
 enquanto (n <= 100) faca
 escreval(n*n)
 n <- n + 1
 fimenquanto
fimalgoritmo
Imprimir da primeira até a décima potência dos números de 2 até 5 inclusive.
 Em c++
// Autor: Prof. Tiago Eugenio de Melo
// Data: 29.07.2010
// Contato: tiagodemelo@gmail.com
#include <stdio.h>
int main() {
	int i, j, valor;
	for (i=2;i<=5;i++) {
		valor = 1;
		for (j=1;j<=10;j++){
			valor = i * valor;
			printf("%d ", valor);
		}
		printf("\n");
	}
	return 0;
}
/ Autor: Prof. Tiago Eugenio de Melo
// Data: 08.06.2011
// Contato: tiagodemelo@gmail.com
algoritmo "Imprimir Potência"
var
 resultado: real
 i, base: inteiro
inicio
 base<-2
 repita
 i<-1
 repita
 resultado <- base ^ i
 escreval(resultado)
 i<-i+1
 ate (i>10)
 base<-base+1
 ate (base>5)
fimalgoritmo
 Criar um algoritmo que leia idade e sexo (0-masculino,1-feminino)de várias pessoas. Calcule e imprima a idade média,total de pessoas do sexo feminino com idade entre 30-45 inclusive e o número total de pessoas do sexo masculino. O algoritmo termina quando se digita 0 para idade.
 Escreva um algoritmo para ler vários números inteiros e positivos, até que seja lido um número menor que zero. Para cada número mostrar seu dobro.
 Faça um algoritmo para ler diversos caracteres informados pelo dispositivo de entrada. Depois imprima:
a) a quantidade total de letras 'A' e 'Z' informadas;
b) a quantidade de caracteres informados;
c) a quantidade de consoantes;
d) a maior letra informada (de acordo com a ordem alfabética) (considere que o usuário irá digitar todas as letras em caixa alta);
e) a quantidade de pontos de exclamação informados;
A condição de término da leitura é o caractere '#'.
 Ler vários números e informar quantos números entre 100 e 200 foram digitados. Quando o valor 0 (zero) for lido, o algoritmo deverá cessar sua execução.
/ Autor: Prof. Tiago Eugenio de Melo
// Data: 09.10.2011
// Contato: tiagodemelo@gmail.com
#include <stdio.h>
int main() {
	int valor, qtde=0;
	scanf("%d", &valor);
	while (valor!=0) {
		if ((valor>100) && (valor<200)) {
			qtde=qtde+1;
		}
		scanf("%d", &valor);
	}
	printf("Foram digitados %d valores no intervalo.", qtde);
	return 0;
}
// Autor: Prof. Tiago Eugenio de Melo
// Data: 09.10.2011
// Contato: tiagodemelo@gmail.com
#include <stdio.h>
int main() {
	int valor, qtde=0;
	do {
		scanf("%d", &valor);
		if ((valor>100) && (valor<200)) {
			qtde++;
		}
	}
	while (valor!=0);
	printf("Foram digitados %d valores no intervalo.", qtde);
	return 0;
}
 Crie um algoritmo que leia vários valores inteiros e positivos e imprima a média dos números múltiplos de 3. Considere como flag (critério de parada) um valor negativo ou nulo.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 12.04.2012
// Contato: tiagodemelo@gmail.com
algoritmo "Somatoria"
var
 num, soma, qtde: inteiro
 media: real
inicio
 soma <- 0
 qtde <- 0
 leia (num)
 enquanto (num > 0) faca
 se (num%3=0) entao
 qtde <- qtde + 1
 soma <- soma + num
 fimse
 leia (num)
 fimenquanto
 se (qtde = 0) entao
 escreva("Não foram digitados números múltiplos de 3.")
 senao
 media <- soma / qtde
 escreva("A média dos números múltiplos de 3 é", media)
 fimse
fimalgoritmo
 A série matemática Fibonacci, que possui o nome de um grande matemático do século XIII, especialista em números, é uma série na qual cada número é igual à soma dos dois números precedentes: 1 mais 1 é igual a 2, 1 mais 2 é igual a 3, 2 mais 3 é igual a 5, 3 mais 5 é igual a 8, 5 mais 8 é igual a 13, e assim por diante. A sequência de Fibonacci é muito útil aos naturalistas (botânicos, zoólogos, etc...), pois muitas coisas da natureza estão dispostas de acordo com tal série. Dados os dois primeiros números da série (1 e 1), imprimir os vinte primeiros números da sequência de Fibonacci.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 29.07.2010
// Contato: tiagodemelo@gmail.com
#include <stdio.h>
int main() {
	int anterior=1, atual=1, proximo, total=0;
	printf("%d\n", anterior);
	printf("%d\n", atual);
	while (total<=18) {
		proximo = anterior + atual;
		anterior = atual;
		atual = proximo;
		printf("%d\n", proximo);
		total++;
	}
	return 0;
}
// Autor: Prof. Tiago Eugenio de Melo
// Data: 12.11.2010
// Contato: tiagodemelo@gmail.com
algoritmo "Fibonacci"
var
 ant1, ant2, prox, i: inteiro
inicio
 ant1<-1
 ant2<-1
 escreval(ant1)
 escreval(ant2)
 para i de 1 ate 18 faca
 prox <- ant1 + ant2
 escreval(prox)
 ant1 <- ant2
 ant2 <- prox
 fimpara
fimalgoritmo
Escreva um algoritmo que imprima o n primeiros termos da série de Fibonacci. O valor de n será digitado pelo usuário.
 Escreva um algoritmo que leia um valor inteiro n e teste se esse valor pertence à série de Fibonacci.
 A série de Ricci difere da série de Fibonacci porque os dois primeiros termos podem ser definidos pelo usuário. Imprima os n primeiros termos da série de Ricci. O valor de n será digitado pelo usuário.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 06.06.2011
// Contato: tiagodemelo@gmail.com
algoritmo "Série de Ricci"
var
 n1, n2, n, qtde, prox: inteiro
inicio
 leia(n1, n2, n)
 escreval(n1)
 escreval(n2)
 qtde<-2
 enquanto (qtde<n) faca
 prox<-n1+n2
 escreval(prox)
 n1<-n2
 n2<-prox
 qtde<-qtde+1
 fimenquanto
fimalgoritmo
 A série de Fetuccine difere da série de Ricci porque o termo de posição par é resultado da subtração dos dois anteriores. Os termos ímpares continuam sendo o resultado da soma dos dois elementos anteriores. Imprima os n primeiros termos da série de Fetuccine.
 Considere a série abaixo e faça o que se pede:
1, 4, 4, 2, 5, 5, 3, 6, 6, 4, 7, 7, ...
Escreva um algoritmo que seja capaz de gerar os N termos dessa série. Esse número N deve ser lido do teclado.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 07.05.2012
// Contato: tiagodemelo@gmail.com
algoritmo "Série Tripla"
var
 n, posicao, prim, seg, terc: inteiro
inicio
 posicao <- 1
 prim <- 1
 seg <- 4
 terc <- 4
 leia (n)
 repita
 se (n>=posicao) entao
 escreval(prim)
 prim<-prim+1
 posicao<-posicao+1
 fimse
 se (n>=posicao) entao
 escreval(seg)
 seg<-seg+1
 posicao<-posicao+1
 fimse
 se (n>=posicao) entao
 escreval(terc)
 terc<-terc+1
 posicao<-posicao+1
 fimse
 ate (posicao>n)
fimalgoritmo
 Reescreva o exercício anterior, mas considere que o usuário irá digitar a posição do elemento pesquisado. Portanto, não é necessário escrever todos os elementos da série, mas apenas o elemento da posição pesquisada. Por exemplo, se o usuário digitar 11, o algoritmo deve imprimir apenas o valor 7 (uma vez que esse valor corresponde ao elemento da décima primeira posição).
Solução (algoritmo): LRBuscaElementoSerieTripla.alg
 Escreva um algoritmo para calcular e escrever uma tabela de graus Celsius em função de graus Farenheit, com graus Celsius variando de 0 até 100.
Solução (algoritmo): LRConversaoTemperatura.alg
 Escreva um algoritmo que leia números digitados pelo usuário até que este digite um valor negativo. Neste momento, o algoritmo deverá apresentar o maior valor digitado.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 30.08.2010
// Contato:tiagodemelo@gmail.com
#include <stdio.h>
int main() {
	int valor, maior=0;
	scanf("%d", &valor);
	while (valor>=0) {
		if ((valor!=0) && (valor>maior))
			maior=valor;
		scanf("%d", &valor);
	}
	if (maior>0)
		printf("O maior valor digitado é %d", maior);
	else
		printf("Não foi digitado nenhum valor positivo.");
	return 0;
}
// Autor: Prof. Tiago Eugenio de Melo
// Data: 25.05.2011
// Contato: tiagodemelo@gmail.com
algoritmo "Maior Valor Positivo"
var
 num, maior: inteiro
inicio
 maior <- -1
 leia(num)
 enquanto (num>=0) faca
 se (num>maior) entao
 maior<-num
 fimse
 leia(num)
 fimenquanto
 se (maior<0) entao
 escreval("Não foi digitado um valor maior que zero.")
 senao
 escreval("O maior valor digitado é ", maior)
 fimse
fimalgoritmo
 Escreva um algoritmo para calcular e escrever o n-ésimo termo da série abaixo, onde o valor de N é será informado pelo usuário. A série é: 5, 6, 11, 12, 17, 18, 23, 24, etc. Se de N for igual a 3, deve ser impresso o valor 11. Se o valor de N for igual 5, deve ser impresso o valor 17. Se o valor de N for igual a 8, deve ser impresso o valor 24.
 Escreva um algoritmo que leia um número inteiro que seja um valor binário. Se o usuário digitar, por exemplo, o valor 1101, o algoritmo deverá apresentar na tela o valor 13. Caso o usuário digite um valor que não seja binário (com valores diferentes de 1s e 0s), o algoritmo deverá apresentar uma mensagem na tela informando tal característica.
 Ler 2 valores A e B. Se A for igual a B, devem ser lidos novos valores para A e B. Se A for menor que B, deve-se calcular e imprimir a soma dos números ímpares existentes entre A (inclusive) e B (inclusive). Se A for maior que B, deve-se calcular e imprimir a média aritmética dos múltiplos de 3 existentes entre A (inclusive) e B (inclusive). OBS: Considere que só serão informados valores inteiros positivos.
Comentários: neste exercício, deve-se observar que os valores de A e B devem ser incluídos. Se forem digitados valores iguais, o programa deve permitir que o usuário digite dois valores novamente, até que estes sejam diferentes. Não há limitação do número de vezes que o usuário poderá digitar os dois valores iguais. O exercício foi resolvido usando o comando for. Tente dar uma outra solução, mas agora utilizando apenas o comando while.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 01.09.2010
// Contato: tiagodemelo@gmail.com
#include <stdio.h>
int main() {
	int A, B, i, soma=0;
	scanf("%d", &A);
	scanf("%d", &B);
	while (A==B) {
		scanf("%d", &A);
		scanf("%d", &B);
	}
	if (A>B) {
		for (i=A;i>=B;i--) {
			if (i%3==0)
				soma=soma+i;
		}
		printf("%d", soma);
	}
	else {
		for (i=A;i<=B;i++){
			if (i%2!=0)
				soma=soma+i;
		}
		printf("%d", soma);
	}	
	return 0;
}
 Escreva um programa que leia números digitados pelo usuário e informe se são pares ou ímpares. A flag (ponto de parada) é o valor zero.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 30.08.2010
// Contato: tiagodemelo@gmail.com
#include <stdio.h>
int main() {
	int valor;
	scanf("%d", &valor);
	while (valor != 0) {
		if (valor % 2 == 0) 
			printf("%d é par.\n", valor);
		else
		scanf("%d", &valor);
	}
	return 0;
}
// Autor: Prof. Tiago Eugenio de Melo
// Data: 30.05.2011
// Contato: tiagodemelo@gmail.com
algoritmo "Testa Par Ímpar"
var
 num: inteiro
inicio
 leia (num)
 enquanto (num<>0) faca
 se (num%2=0) entao
 escreval(num, " é par.")
 senao
 escreval(num, " é ímpar.")
 fimse
 leia(num)
 fimenquanto
fimalgoritmo
 Criar um algoritmo em que leia os limites inferior e superior de um intervalo e imprima todos os números pares no intervalo aberto e o seu somatório. Suponha que os dados digitados são para um intervalo crescente, ou seja, o primeiro valor é menor que o segundo.
  Construa um programa que apresente os 100 primeiros números ímpares.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 29.07.2010
// Contato: tiagodemelo@gmail.com
// est.direcao.2k10!!
#include <stdio.h>
int main() {
	int i=1, total=0;
	while (total<5) {
		printf("%d\n", i);
		i=i+2;
		total++;
	}
	return 0;
}
 Construa um programa que apresente os 100 primeiros números de uma Progressão Aritmética, sendo lidos o primeiro termo e a razão.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 08.06.2011
// Contato: tiagodemelo@gmail.com
algoritmo "Imprimir 100 Termos PA"
var
 an, a1, n, r: inteiro
inicio
 leia (a1, r)
 n<-1
 repita
 an <- a1 + (n-1)*r
 escreval("Posição: ", n, " - valor: ", an)
 n<-n+1
 ate (n>100)
fimalgoritmo
  Ler 10 valores e escrever quantos destes valores são negativos.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 29.07.2010
// Contato: tiagodemelo@gmail.com
#include <stdio.h>
int main() {
	int i=1, num, total=0;
	while (i<=10) {
		scanf("%d", &num);
		if (num<0)
			total++;
		i++;
	}
	printf("Foram digitados %d número(s) negativo(s).", total);
	return 0;
}
// Autor: Prof. Tiago Eugenio de Melo
// Data: 25.05.2011
// Contato: tiagodemelo@gmail.com
algoritmo "Quantidade Valores Negativos"
var
 num, qtde, i: inteiro
inicio
 i<-0
 qtde<-0
 enquanto (i<10) faca
 leia(num)
 se (num<0) entao
 qtde<-qtde+1
 fimse
 i<-i+1
 fimenquanto
 escreval("A quantidade de números negativos é ", qtde)
fimalgoritmo
 Calcular e imprimir a soma dos N primeiros números pares onde N é um número inteiro, que deve ser lido pelo teclado.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 26.05.2011
// Contato: tiagodemelo@gmail.com
algoritmo "Somatória Números Pares"
var
 n, quant, i, soma: inteiro
inicio
 quant<-0
 i<-0
 soma<-0
 leia(n)
 enquanto (quant<n) faca
 se (i%2=0) entao
 soma <- soma+i
 quant <- quant+1
 fimse
 i <- i +1
 fimenquanto
 escreval("O resultado da soma é ", soma)
fimalgoritmo
Escreva um algoritmo que lê um número e verifique se o número é real ou inteiro (considere que o usuário irá digitar apenas números positivos).
// Autor: Prof. Tiago Eugenio de Melo
// Data: 15.06.2011
// Contato: tiagodemelo@gmail.com
algoritmo "Testa Número Inteiro/Real"
var
 num, resultado: real
inicio
 leia(num)
 resultado <- num
 enquanto (resultado > 0) faca
 resultado <- resultado-1
 fimenquanto
 se (resultado=0) entao
 escreval("O número ", num, " é inteiro.")
 senao
 escreval("O número ", num, " é real.")
 fimse
fimalgoritmo
Escreva um algoritmo que receba vários números e verifique se eles são ou não quadrados perfeitos. O algoritmo termina a execução quando for digitado um número menor ou igual a 0 (um número é quadrado perfeito quando tem um número inteiro como raiz quadrada).
Escreva um algoritmo que forneça quantos números devem existir em sequência a partir do 1 (1,2,3,4,...) para que a sua soma ultrapasse a 100 o mínimo possível.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 02.09.2010
// Contato: tiagodemelo@gmail.com
#include <stdio.h>
int main() {
	int i=1, soma=0;
	while (soma<=100) {
		soma = soma + i;
		i = i + 1;
	} 
	printf("Foram %d números", i-1);
	return 0;
}
// Autor: Prof. Tiago Eugenio de Melo
// Data: 15.06.2011
// Contato: tiagodemelo@gmail.com
algoritmo "Somatória"
var
 num, soma: inteiro
inicio
 num<-1
 soma<-1
 enquanto (soma<=100) faca
 num <- num+1
 soma <- soma+num
 fimenquanto
 escreval("Foram utilizados ", num, " números.")
fimalgoritmo
Comentários: a resposta do exercício é 14, ou seja, é necessário somar 1, 2, 3, ..., e 14 para obter o valor105, que corresponde ao menor valor que ultrapassa 100. Neste exercício, não haverá entrada de dados, mas apenas processamento e saída.
 Escreva um algoritmo para repetir a leitura de um número enquanto o valor fornecido for diferente de 0. Para cada número fornecido, imprimir se ele é NEGATIVO ou POSITIVO. Quando o número 0 for fornecido a repetição deve ser encerrada sem imprimir mensagem alguma.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 26.05.2011
// Contato: tiagodemelo@gmail.com
algoritmo "Testa Positivo Negativo"
var
 num: inteiro
inicio
 leia (num)
 enquanto (num<>0) faca
 se (num>0) entao
 escreval(num, " é positivo.")
 senao
 escreval(num, " é negativo.")
 fimse
 fimenquanto
fimalgoritmo
 Escreva um algoritmo que verifique a validade de uma senha fornecida pelo usuário. A senha válida é o número 1234. Se a senha informada pelo usuário for inválida, a mensagem ACESSO NEGADO deve ser impressa e repetida a solicitação de uma nova senha até que ela seja válida. Caso contrário, deve ser impressa a mensagem ACESSO PERMITIDO junto com um número que representa quantas vezes a senha foi informada.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 26.05.2011
// Contato: tiagodemelo@gmail.com
algoritmo "Testa Senha"
var
 valor, qtde: inteiro
inicio
 leia(valor)
 qtde<-1
 enquanto (valor<>1234) faca
 escreval("ACESSO NEGADO")
 leia(valor)
 qtde<-qtde+1
 fimenquanto
 escreval("ACESSO PERMITIDO")
 escreval("O usuário digitou ", qtde, " vezes a senha.")
fimalgoritmo
 Escreva um algoritmo para verificar se um determinado número digitado pelo usuário é primo.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 29.07.2010
// Contato: tiagodemelo@gmail.com
#include <stdio.h>
int main() {
	int num, total=0, i;
	scanf("%d", &num);
	for (i=1;i<=num;i++) {
		if (num%i==0)
			total++;
	}
	if (total==2)
		printf("O número %d é primo.", num);
	else
		printf("O número %d não é primo.", num);	
	return 0;
}
algoritmo "TestarPrimo"
var
 numero, total, i: inteiro
inicio
 total<-0
 leia (numero)
 para i de 1 ate numero faca
 se (numero mod i=0) entao
 total<-total+1
 fimse
 fimpara
 se (total=2) entao
 escreva("O número ", numero, " é primo")
 senao
 escreva("O número ", numero, " não é primo")
 fimse
fimalgoritmo
 Escreva um algoritmo que determine se dois valores inteiros e positivos A e B são primos entre si (dois números inteiros são ditos primos entre si caso não exista divisor comum aos dois números, com exceção do valor 1).
// Autor: Prof. Tiago Eugenio de Melo
// Data: 17.10.2011
// Contato: tiagodemelo@gmail.com
#include <stdio.h>
int main() {
	int A, B, menor, i, flag=0;
	scanf("%d %d", &A, &B);
	if (A<B)
		menor = A;
	else
		menor = B;
	for(i=2;i<=menor;i++){
		if ((A%i==0) && (B%i==0)){
			flag=1;
			break;
		}
	}
	if (flag) 
		printf("%d e %d não são primos entre si.", A, B);
	else
		printf("%d e %d são primos entre si.", A, B); 	
	return 0;
}
// Autor: Prof. Tiago Eugenio de Melo
// Data: 22.04.2013
// Contato: tiagodemelo@gmail.com
algoritmo "Testa primos entre si"
var
 A, B, i: inteiro
 primo: logico
inicio
 primo <- verdadeiro
 i <- 2
 leia (A, B)
 enquanto (i <= B) faca
 se (B % i = 0) entao
 se (A % i = 0) entao
 primo <- falso
 fimse
 fimse
 i <- i + 1
 fimenquanto
 se (primo = verdadeiro) entao
 escreval (A, " e ", B, " são primos entre si.")
 senao
 escreval (A, " e ", B, " não são primos entre si.")
 fimse
fimalgoritmo
 Leia 100 valores. A seguir, para cada valor, mostre se o valor é primo ou não. Em caso negativo, mostre quantos divisores o número possui.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 12.11.2010
// Contato: tiagodemelo@gmail.com
algoritmo "VerificaPrimos"
var
 num, i, j, total: inteiro
inicio
 para i de 1 ate 100 faca
 total<-0
 leia (num)
 para j de 1 ate num faca
 se (num mod j = 0) entao
 total <- total + 1
 fimse
 fimpara
 se (total=2) entao
 escreval("É primo.")
 senao
 escreval("Não é primo.")
 escreval("Total de divisores é: ", total)
 fimse
 fimpara
fimalgoritmo
 Escreva um algoritmo para ler um número inteiro do usuário e exibir o maior número primo que seja menor do que o número digitado.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 06.06.2011
// Contato: tiagodemelo@gmail.com
algoritmo "Maior Primo Anterior"
var
 num, i, qtde: inteiro
 teste: logico
inicio
 teste<-verdadeiro
 leia (num)
 enquanto (teste) faca
 qtde<-0
 num<-num-1
 para i de 1 ate num faca
 se (num%i=0) entao
 qtde<-qtde+1
 fimse
 fimpara
 se (qtde=2) entao
 escreval("O número primo é ", num)
 teste<-falso
 fimse
 fimenquanto
fimalgoritmo
 Calcular e imprimir a soma dos 100 primeiros números primos.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 07.05.2012
// Contato: tiagodemelo@gmail.com
algoritmo "Soma 100 primeiros primos"
var
 n, total, qtde, soma, i: inteiro
inicio
 n<-1
 qtde<-0
 soma<-0
 repita
 total <- 0
 para i de 1 ate n faca
 se (n%i=0) entao
 total<-total+1
 fimse
 fimpara
 se (total=2) entao
 qtde <- qtde + 1
 soma <- soma + n
 fimse
 n <- n + 1
 ate (qtde=100)
 escreval ("A soma dos 100 primeiros números primos é ", soma)
fimalgoritmo
 Faça um algoritmo que leia 20 números e imprima a soma dos números cujos quadrados são menores do que 225.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 08.05.2013
// Contato: tiagodemelo@gmail.com
algoritmo "Série Quadrados"
var
 soma, num, aux: inteiro
inicio
 soma <- 0
 para aux de 1 ate 5 passo 1 faca
 leia (num)
 se ((num*num) < 225) entao
 soma <- soma + num
 fimse
 fimpara
 escreval ("A soma dos números é ", soma)
fimalgoritmo
 Fatoração é a decomposição de um número inteiro em seus números primos. Escreva um programa em C que calcule os fatores de um número digitado pelo usuário. Por exemplo, se o usuário digitar o valor 12, o programa deverá exibir os valores 2, 2 e 3. Lembrando que 2 x 2 x 3 = 12.
#include <stdio.h>
int main() {
	int divisor=2, valor;
	scanf("%d", &valor);
	while (valor!=1) {
		if (valor%divisor==0) {
			printf("%d\n", divisor);
			valor=valor/divisor;
			divisor=2;
		}
		else {
			divisor++;
		}
	}
	return 0;
}
#include <stdio.h>
int main() {
	int num, i=2, aux;
	float resto;
	scanf("%d", &num);
	aux=num;
	do {
		do {
			resto=num%i;
			if (resto==0) {
				printf("%d\n", i);
				num=num/i;
			}
		}
		while (resto==0); 
		i++;
	}
	while (i<=(aux/2));
	return 0;
}
#include <stdio.h>
int main() {
	int x, y, k;
	scanf("%d", &x);
	k=x;
	for (y=2;y<=k;y++){
		while (x%y==0) {
			printf("%d\n", y);
			x = x/y;
		}
	}
	return 0;
}
 Leia uma quantidade de valores para X indeterminadamente (parar quando o valor digitado para X for igual a zero). Para cada valor lido, mostrar se este valor é primo ou não.
 Escreva um algoritmo que leia dois números inteiros e positivos e verifique se estes números são amigáveis. Dois números são amigáveis quando a soma dos divisores de um é igual ao outro número, excluindo o próprio número. Os números 220 e 284 são exemplos de números amigáveis.
// Autor: Prof.Tiago Eugenio de Melo
// Data: 16.06.2011
// Contato: tiagodemelo@gmail.com
algoritmo "Testa Números Amigáveis"
var
 num1, num2, soma1, soma2, i: inteiro
inicio
 leia (num1, num2)
 soma1<-0
 soma2<-0
 para i de 1 ate num1-1 faca
 se (num1%i=0) entao
 soma1<-soma1+i
 fimse
 fimpara
 para i de 1 ate num2-1 faca
 se (num2%i=0) entao
 soma2<-soma2+i
 fimse
 fimpara
 se ((num1=soma2) e (num2=soma1)) entao
 escreval(num1, " e ", num2, " são amigáveis.")
 senao
 escreval(num1, " e ", num2, " não são amigáveis.")
 fimse
fimalgoritmo
 Escreva um algoritmo para encontrar todos os pares de números amigáveis entre 1 e 100000. Um par de números é amigável quando cada um deles é igual à soma dos divisores do outro, com exceção do próprio número. Os números 220 e 284 são exemplos de números amigáveis.
 Escreva um algoritmo que sorteie um número de 0 a 100 e que permita que o usuário (sem conhecer o número sorteado) tente acertar. Caso não acerte, o programa deve imprimir uma mensagem informando se o número sorteado é maior ou menor que a tentativa feita. Ao acertar o número, o algoritmo deve imprimir a quantidade de tentativas feitas.
 Escreva um algoritmo para calcular o Máximo Divisor Comum (MDC) entre dois números inteiros.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 27.07.2010
// Contato: tiagodemelo@gmail.com
#include <stdio.h>
int main() {
	int a, b, aux, resto;
	scanf("%d %d", &a, &b);
	if (a>b) {
		aux = a;
		a = b;
		b = aux;
	}
	resto=b%a;
	while (b%a!=0) {
		resto = b % a;
		b = a;
		a = resto;
	}
	printf("%d", a);
	return 0;
}
 Supondo que a população de um país A seja da ordem de 9.000 habitantes com uma taxa anual de crescimento de 3% e que a população de um país B seja, aproximadamente, de 20.000 habitantes com taxa anual de crescimento de 1.5%. Faça um programa que calcule e escreva o número de anos necessários para que a população do país A ultrapasse ou se iguale à população do país B, mantidas estas taxas de crescimento.
 Escreva um algoritmo que leia dois números inteiros e imprima o seu Mínimo Múltiplo Comum (MMC).
// Autor: Prof. Tiago Eugenio de Melo
// Data: 27.07.2010
// Contato: tiagodemelo@gmail.com
#include <stdio.h>
int main() {
	int a, b, aux, resto;
	scanf("%d %d", &a, &b);
	if (a>b) {
		aux = a;
		a = b;
		b = aux;
	}
	resto=b%a;
	while (b%a!=0) {
		resto = b % a;
		b = a;
		a = resto;
	}
	printf("%d", a);
	return 0;
}
COMENTáRIOS: ESSA SOLUçãO EMPREGA O CáLCULO DO MDC. EXISTEM OUTRAS MANEIRAS DE SE CALCULAR O MMC.
 Escreva um algoritmo para exibir os n primeiros múltiplos simultâneos de dois números dados.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 08.06.2011
// Contato: tiagodemelo@gmail.com
algoritmo "Exibe múltiplos simultâneos"
var
 valor1, valor2, n, qtde, i: inteiro
inicio
 qtde<-0
 i<-1
 leia (valor1, valor2, n)
 repita
 se ((i%valor1=0) e (i%valor2=0)) entao
 escreval(i)
 qtde<-qtde+1
 fimse
 i<-i+1
 ate (qtde=n)
fimalgoritmo
 Criar um algoritmo que leia um número (NUM) e então imprima os múltiplos de 3 e 5, ao mesmo tempo, no intervalo fechado de 1 a NUM.
// Autor: Prof. Tiago Eugenio de Melo
// Data: 17.10.2011
// Contato: tiagodemelo@gmail.com
#include <stdio.h>
int main() {
	int NUM, i;
	scanf("%d", &NUM);
	for (i=1;i<=NUM;i++){
		if ((i%3==0) && (i%5==0)) 
			printf("%d é divisÃvel por 3 e 5 ao mesmo tempo.\n", i);
	}
	return 0;
}
 (Prova EST/2010-2) (Prova EST/2014-1) Escreva um algoritmo que permita que o usuário digite valores inteiros e positivos. O usuário deverá digitar números até totalizar 10 valores primos. Enquanto isto não ocorrer, o usuário deverá digitar outros valores. Para cada valor primo digitado, imprima esse valor na tela. Ao final, imprima a quantidade (total) de números digitados.
Solução (algoritmo): LRContadorPrimos.alg
Solução: LRContadorPrimos.c
 Escreva um algoritmo que realize o produto de A (número inteiro) por B (número inteiro), ou seja, A * B, através de adições (somas). Esses dois valores são passados pelo usuário através do teclado.
Solução (algoritmo): LRTesta10Primos.alg
 (Prova EST/2010-2) Escreva um algoritmo que imprima uma tabela comparativa entre as temperaturas Celsius e Farenheit (de -100 até 100 graus). A impressão deve seguir o padrão abaixo:
	Celsius
	Farenheit
	-100
	-148
	-99
	-146.2
	...
	...
Após a impressão dessa tabela comparativa, imprima, se houver, as temperaturas em que os valores são iguais nas escalas Celsius e Farenheit. Quando isto ocorrer, o algoritmo deve imprimir a seguinte mensagem: “As temperaturas Celsius e Farenheit são iguais em <valor> graus.”
Solução (algoritmo): LRImprimirTabelaTemperaturas.alg
 (Prova EST/2010-2) Fatoração é a decomposição de um número inteiro em seus números primos. Escreva um programa em C que calcule os fatores de um número digitado pelo usuário. Por exemplo, se o usuário digitar o valor 12, o programa deverá exibir os valores 2, 2 e 3. Ou, se o usuário digitar o valor 30, o programa deverá exibir os valores 2, 3 e 5. Lembrando que 2 x 3 x 5 = 30.
SOLUçãO: LRDECOMPOSICAOPRIMOS.C.
 Construa um algoritmo que, dado um conjunto de valores inteiros e positivos, determine qual o menor valor do conjunto. O final do conjunto de valores é conhecido através do valor zero, que não deve ser considerado.
 Construa um algoritmo que, dado um conjunto de valores inteiros e positivos, determine qual é o menor e o maior valor do conjunto. O final do conjunto de valores é conhecido através do valor -5 , que não deve ser considerado.
 Escreva um algoritmo para calcular w = 2a + 3b + 7 para todas as possibilidades, a seguir:
Variando a de 1 até 4 com incrementos de 1.
Variando b de 0.5 até 2.5 com incrementos de 0.5.
O algoritmo deverá mostrar na tela os valores de a, b e w.
 Considere a seguinte informação: "A tem o dobro da idade que B tinha quando A tinha a idade que B tem. Quando B tiver a idade de A, somarão 81 anos." Escreva um algoritmo para calcular as idades de A e B no método da força bruta.
 Uma rainha requisitou os serviços de um monge e disse-lhe que pagaria qualquer preço. O monge, necessitando de alimentos, indagou à rainha sobre o pagamento, se poderia ser feito com grãos de trigo dispostos em um tabuleiro de xadrez (que possui 64 casas), de tal forma que o primeiro quadro deveria conter apenas um grão e os quadros subseqüentes, o dobro do quadro anterior. A rainha achou o trabalho barato e pediu que o serviço fosse executado, sem se dar conta de que seria impossível efetuar o pagamento. Faça um algoritmo para calcular o número de grãos que o monge esperava receber.
 Escreva um algoritmo para calcular e mostrar a soma de todos os números 4 do dominó.
 Em uma eleição presidencial, existem quatro candidatos. Os votos são informados através de código. Os dados utilizados para a escrutinagem obedecem à seguinte codificação:
1,2,3,4 = voto para os respectivos candidatos;
5 = voto nulo;
6 = voto em branco;
Elabore um algoritmo que calcule e escreva:
total de votos para cada candidato;
total de votos nulos;
total de votos em branco;
percentual dos votos em branco e nulos sobre o total;
situação do candidato vencedor sobre os outros dois, no caso, se ele obteve ou não mais votos que os outros dois somados;
como finalizador do conjunto de votos, tem-se o valor 0.
 Construa um algoritmo que leia um conjunto de dados contendo altura e sexo (masculino e feminino) de 50 pessoas e depois calcule e escreva:
a maior e a menor altura do grupo;
a média de altura das mulheres;
o número de homens e a diferença percentual entre estes e as mulheres.
 Calcule o imposto de renda de um grupo de contribuintes considerando que os dados de cada contribuinte, número do CPF, número de dependentes erenda mensal são valores fornecidos pelo usuário. Para cada contribuinte será feito um desconto de 5% de salário mínimo por dependente.
Os valores da alíquota para cálculo do imposto são:
	Renda líquida
	Alíquota
	até 2 salários mínimos
	isento
	2..3 salários mínimos
	5%
	3..5 salários mínimos
	10%
	5..7 salários mínimos
	15%
	acima de 7 salários mínimos
	20%
O último valor, que não será considerado, terá o CPF igual a zero. Deve ser fornecido o valor atual do salário mínimo.
 Foi realizada uma pesquisa de algumas características físicas da população de uma certa região, a qual coletou os seguintes dados referentes a cada habitante para serem analisados: - sexo (masculino ou feminino); - cor dos olhos (azuis, verdes, castanhos); - cor dos cabelos (louros, castanhos, pretos); - idade.
Faça um algoritmo que determine e escreva: - a maior idade dos habitantes; - a percentagem de indivíduos do sexo feminino cuja a idade está entre 18 e 35 anos (inclusive) e que tenham olhos verdes e cabelos louros. - final do conjunto de habitantes é reconhecido pelo valor -1 entrada como idade.
 Fulano tem 1,50 metro e cresce 2 centímetros por ano, enquanto Ciclano tem 1,10 metro e cresce 3 centímetros por ano. Construa um algoritmo que calcule e imprima quantos anos serão necessários para que Ciclano seja maior que Fulano. O algoritmo deverá exibir a altura de cada um a cada ano até que a condição exigida seja alcançada.
Solução (algoritmo): LRFulanoCiclano.alg
 Dois carros (X e Y) saem de uma mesma cidade. O carro X sai com velocidade constante de 60 Km/h e o segundo carro com velocidade constante de 90 Km/h. A seguir faça a leitura de uma distância (em quilômetros) e calcule quanto tempo leva para o carro mais veloz tomar essa distância do outro carro.
 Considerando 3 carros (X,Y e Z) que saem de uma cidade A. A seguir, considerando que o caminho a percorrer pelo carro X é de 360 Km, pelo carro Y é de 270 Km e pelo carro Z é de 310 KM, faça a leitura da velocidade dos 3 carros e mostre o tempo em horas que cada um deles levará para percorrer seu percurso.
 Realizou-se uma pesquisa para determinar o índice de mortalidade infantil em um certo período. Construa um algoritmo que leia o número de crianças nascidas no período e, depois, num número indeterminado de vezes, o sexo de uma criança morta (masculino, feminino) e o número de meses de vida da criança. Como finalizador, teremos a palavra "fim" no lugar do sexo da criança. Determine e imprima: - a porcentagem de crianças mortas no período; - a porcentagem de crianças do sexo masculino mortas no período; - a porcentagem de crianças que viveram dois anos ou menos no período.
 Um cinema que possui capacidade de 100 lugares está sempre com ocupação total. Certo dia cada espectador respondeu a um questionário, no qual constava: - sua idade; - sua opinião em relação ao filme, segundo: ótimo = ***** bom = **** regular = *** ruim = ** péssimo = * Elabore um algoritmo que, lendo estes dados, calcule e imprima: - a quantidade de respostas ótimo; - a diferença percentual entre respostas bom e regular; - a média de idade das pessoas que responderam ruim; - a percentagem de respostas péssimo e a maior idade que utilizou esta opção; - a diferença de idade entre a maior idade que respondeu ótimo e a maior idade que respondeu ruim.
 Suponha que exista um prédio sem limites de andares, ou seja, um prédio infinito, onde existam três elevadores denominados: A, B e C. Para otimizar o sistema de controle dos elevadores, foi realizado um levantamento no qual cada usuário respondia: - o elevador que utilizava com maior freqüência; - o andar ao qual se dirigia; - o período que utilizava o elevador, entre: - M = matutino; - V = vespertino; - N = noturno.
Construa um algoritmo que calcule e imprima: - qual é o andar mais alto a ser utilizado; - qual é o elevador mais freqüentado e em que horário se encontra seu maior fluxo; - qual o horário mais usado de todos e a que elevador pertence; - qual a diferença percentual entre o mais usado dos horários e o menos usado (especificando qual o menos usado); qual a percentagem sobre o total de serviços prestados do elevador de média utilização.
 Faça um algoritmo para ler um valor numérico e calcular e escrever o seu fatorial.
SOLUçãO: LRFATORIAL.C.
Solução (algoritmo): LRFatorial.alg
 Faça um algoritmo que leia um conjunto não determinado de valores para M (parar quando o valor digitado for igual a 0). Para cada valor lido, se este valor for par, mostre quantos divisores ele possui. Se for ímpar, mostre o fatorial de M.
Solução (algoritmo): LRTestaDivisoresFatorial.alg
 Escreva algoritmo que apresente todos fatoriais cujo resultado seja inferior a um dado valor que é lido pelo teclado.
Solução (algoritmo): LRIntervaloFatoriais.alg
 (Prova EST/2011-1) Escreva um algoritmo que leia um valor numérico e verifique se este número corresponde ao cálculo do fatorial de um valor. Se sim, exiba qual é esse número. Caso contrário, apresente uma mensagem informando que o valor não corresponde a um fatorial. Exemplo: se o usuário digitar 120, o algoritmo deve apresentar a mensagem informando que esse valor corresponde ao fatorial de 5, pois (5 x 4 x 3 x 2 x 1 = 120). Se o usuário digitar 100, por exemplo, o algoritmo deve apresentar uma mensagem informando que esse número não corresponde a nenhum cálculo de fatorial.
SOLUçãO (ALGORITMO): LRTESTAFATORIAL.ALG
 Escrever um algoritmo que leia um valor em Reais (moeda). A seguir, calcule o menor número de notas possíveis no qual o valor pode ser decomposto. As notas consideradas são de 100, 50, 20, 10, 5, 2 e 1. A seguir, mostre o valor lido e a relação de notas necessárias. Neste caso, considere que o usuário nunca irá digitar valores com centavos.
 Uma das maneiras de se conseguir a raiz quadrada de um número é subtrair do número os ímpares consecutivos a partir de 1, até que o resultado da subtração seja menor ou igual a zero. O número de vezes que se conseguir fazer a subtração é a raiz quadrada exata (resultado 0) ou aproximadamente (resultado negativo).
Ex: 16
16-1=15-3=12-5=7-7=0
raiz de 16 é 4.
Faça um algoritmo que calcule a raiz quadrada de um número digitado pelo usuário utilizando o método citado acima.
 Elabore um algoritmo que obtenha o número inteiro que mais se aproxima da raiz quadrada de um número fornecido pelo usuáro.
SOLUçãO: LRINTEIRORAIZ.C.
 Escreva um algoritmo que calcule a raiz quadrada de um número digitado pelo usuário. Não utilize a função sqrt fornecida pela linguagem C.
SOLUçãO: LRRAIZQUADRADA.C.
Comentários: o método utilizado para resolver esse exercício é o Método Babilônico. Maiores informações sobre a lógica do método pode ser encontrada em http://pt.wikipedia.org/wiki/Raiz_quadrada.
 Supondo que a população de um país A seja 90 milhões de habitantes, crescendo com uma taxa anual de 3.5% e que a população de um país B seja 140 milhões de habitantes, crescendo a uma taxa anual de 1%. Faça um algoritmo que calcule e mostre quantos anos serão necessários para que a população do país A ultrapasse a população do país B.
 Faça um algoritmo para ler dois valores inteiros. O primeiro valor digitado representa o primeiro elemento de uma progressão aritmética, e o segundo valor digitado representa a razão. Calcule e mostre os 10 elementos seguintes.
 Faça um algoritmo para ler um número menor que 1000 e calcular e mostrar todos os números ímpares maiores que o número lido e menores que 1000.
 Leia a hora inicial e a hora final de um jogo. A seguir calcule a duração do jogo, sabendo que o mesmo pode começar em um dia e terminar em outro, tendo uma duração máxima de 24 horas.
 Escreva um algoritmo que calcule a soma dos 100 primeiros números inteiros.
SOLUçãO: LRSOMA100INTEIROS.C.
 Escreva um algoritmo que calcule e mostre a soma dos número pares de 1 até 100.
 Apresente todos os números divisíveis por 5 que sejam maiores do que 0 e menores ou iguais a 200.
 Escreva um algoritmo que leia 10 valores quaisquer. A seguir, mostrequantos deles estão dentro do intervalo [10,20] e quantos estão fora do intervalo, mostrando essas informações.
 Escreva um algoritmo que leia um número e diga se este número é perfeito ou não. Um número perfeito é aquele que é igual à soma de seus divisores, excluindo o próprio número. Exemplos: 1 + 2 + 3 = 6 e 1 + 2 + 4 + 7 = 28.
SOLUçãO: LRTESTANUMEROPERFEITO.C.
Solução (algoritmo): LRNumerosPerfeitos.alg
 Fazer um programa que leia uma frase de até 50 caracteres e escreva como resultado o número de vogais, consoantes e espaços em branco existentes na frase. Lembre-se que, normalmente, espaço em branco é considerado como um caracter.
 Escreva um algoritmo que leia dois números (X e Y) e depois imprima a soma dos números ímpares entre eles.
SOLUçãO: LRSOMAIMPARESINTERVALO.ALG.
 Escrever um algoritmo que lê um valor para X e calcula e mostra os 20 primeiros termos da série:
primeiro termo: ; segundo termo:  + ; terceiro termo: ; e assim por diante.
 Faça um algoritmo para ler dois números inteiros e calcular e mostrar o valor resultante se elevarmos a base representada pelo primeiro à potência representada pelo segundo.
 Escreva um algoritmo para mostrar os números entre 1000 e 2000 que quando divididos por 11 dão resto igual a 5.
SOLUçãO: LRCONTANUMEROSESPECIFICOS.C.
 Escreva um algoritmo que calcule e escreva o valor de S:
	
	(0.11)
Solução (algoritmo): LRSomatoria100.alg
 Faça um algoritmo para calcular e mostrar a soma dos 50 primeiros elementos da série:
	
	(0.12)
Solução (algoritmo): LRSomatorio50.alg
 Prepare um algoritmo que calcule o valor de H, sendo que ele é determinado pela série
	
	(0.13)
SOLUçãO: LRSERIEH.C.
COMENTáRIOS: DEVE-SE OBSERVAR A NECESSIDADE DE CONVERTER A VARIáVEL NUM PARA O TIPO FLOAT, POIS A DIVISãO DE DOIS INTEIROS EM C éUM VALOR INTEIRO. A LINGUAGEM FAZ UMA CONVERSãO AUTOMáTICA.
 Elabore um algoritmo que determine o valor de S, onde:
	
	(0.14)
Solução (algoritmo): LRSomatorio10.alg
 Escreva um algoritmo que calcule e escreva a soma dos n primeiros termos da seguinte série:
	
	(0.15)
SOLUçãO (ALGORITMO): LRSERIEALTERNADA.ALG.
 Escreva um algoritmo para calcular uma tabela com o sen(x), com x variando de 0 a 90 graus. Utilize cinco parcelas e depois dez primeiras parcelas para calcular e faça a comparação de precisão do cálculo.
	
	(0.16)
 Escreva um algoritmo que calcule o valor aproximado de PI utilizando a fórmula abaixo:
	
	(0.17)
	
	(0.18)
Solução: LRCalculoValorPI.c
 Na Matemática, uma série é uma sequência de números que possui uma lei de formação. Faça um algortimo para calcular a soma da série abaixo, onde N é fornecido pelo usuário.
	
	(0.19)
 Escreva um algoritmo para testar se um número digitado pelo usuário é ou não defectivo. Número defectivo é aquele cuja soma dos seus divisores é menor que o próprio número. Por exemplo, 10 é um número defectivo, pois a somatória dos seus divisores (1, 2, 5) é menor que o próprio número (8<10). Já o número 12 não é defectivo, pois a somatória dos seus divisores (1, 2, 3, 4, 6) é maior que o próprio número (16>12).
 (Prova monitoria UEA/2011) Escreva um algoritmo para exibir os 10 primeiros números defectivos. Número defectivo é aquele cuja soma dos seus divisores é menor que o próprio número. Por exemplo, 10 é um número defectivo, pois a somatória dos seus divisores (1, 2, 5) é menor que o próprio número (8<10). Já o número 12 não é defectivo, pois a somatória dos seus divisores (1, 2, 3, 4, 6) é maior que o próprio número (16>12).
SOLUçãO (ALGORITMO): LRNUMEROSDEFECTIVOS.ALG
 Escrever um algoritmo que mostra os números primos entre 100 e 200, bem como a soma destes números.
SOLUçãO (ALGORITMO): LREXIBESOMA100PRIMOS.ALG
 Mostre o que será impresso pelos algoritmos abaixo:
a)
algoritmo "teste"
var
 X,I:inteiro
inicio
 I<-1
 Enquanto( I<20) faca
 X<- quad(I)
 escreva(I,X);
 I<-I+2
 escreva("Passei por aqui!")
 fimenquanto
 escreva("Ufa, cheguei aqui")
fimalgoritmo
b)
algoritmo "teste"
var
 X,Y:inteiro
Inicio
 X<-0
 Y<-30
 enquanto (X<10) faca
 X<-X+1
 Y<-Y-1
 fimenquanto
 escrever(X)
 escrever(Y)
fimalgoritmo
 Escreva um algoritmo que lê um valor N inteiro e positivo e que calcula e escreve o valor da constante matemática e, onde:
	
	(0.20)
SOLUçãO (ALGORITMO): LRCALCULOCONSTANTEE.ALG
 Em uma competição de saltos ornamentais 6 (seis) juízes informam notas reais variando de 0 a 10. Para se calcular a nota final do atleta deve-se excluir a maior e a menor nota dos juízes e então a nota final será calculada pela média aritmética das 4 (quatro) notas restantes. Faça um algoritmo para ler a quantidade de atletas para os quais serão calculadas a nota final de cada atleta. Considere que para cada atleta deve ser informado além das notas o seu número de competidor (inteiro positivo). O algoritmo deverá imprimir o número de cada atleta e sua respectiva nota final, da seguinte forma:
A nota final do atleta x é igual a y.
Onde: x representa o número de cada atleta e y representa a nota final de cada atleta.
OBS: A mensagem de saída deve ser apresentada uma embaixo da outra.
SOLUçãO (ALGORITMO): LRCALCULONOTASATLETAS.ALG
 Escreva um algoritmo em que o usuário irá digitar valores numéricos até que seja digitado um valor primo. Quando o usuário digitar um número primo, o algoritmo deve encerrar a execução e deve apresentar uma mensagem informando a quantidade de números digitados (incluindo o próprio número primo). A mensagem deve seguir o formato: “Foram digitados <total> números.”.
SOLUçãO (ALGORITMO): LRCONTADORNUMEROS.ALG
 (Prova EST/2011-3) Escreva um programa em C que leia uma quantidade indeterminada de valores inteiros e positivos (a leitura será interrompida quando o usuário digitar zero). Para cada valor lido, o programa deverá exibir uma mensagem informando se este número é ou não primo. Ao final da execução, o programa deverá exibir a quantidade de números primos que foram digitados.
SOLUçãO: LRCONTADORPRIMOS.C.
 (Prova EST/2012-1) Um número excessivo ou abundante é aquele cuja soma dos seus divisores (excluído o próprio número) é maior do que ele mesmo. Por exemplo, o número 12 é abundante, pois se somarmos os seus divisores (1, 2, 3, 4 e 6) obteremos o valor 16 e este é maior do que o próprio número. Já o número 10 não é excessivo, pois a somatória dos seus divisores (1, 2 e 5) é menor do que 10. Escreva um algoritmo que permita a leitura de um valor a partir do teclado e imprima uma mensagem informando se o número digitado é ou não excessivo.
SOLUçãO (ALGORITMO): LRNUMEROSABUNDANTES.ALG
 (Prova EST/2012-2) Escreva um programa em C que leia uma quantidade indeterminada de números inteiros e informe a média dos números pares lidos. O programa interrompe quando entramos com um número menor que 1.
SOLUçãO: LRCONTAPARES.C.
 (Prova EST/2013-1) Gottfried Wilhelm von Leibniz, utilizando-se da série de Taylor, criou uma fórmula que gera o valor de pi. Escreva um algoritmo que, utilizando a série descrita abaixo, imprima o valor de pi. A quantidade de parcelas será informada pelo usuário. Vale observar que quanto maior for o número de parcelas maior será a precisão de pi.
	
	Figure: Série para cálculo de pi.
SOLUçãO (ALGORITMO): LRSERIEPI.ALG
 (Prova EST/2013-1) Escreva um algoritmo que leia um valor numérico e um símbolo. Caso o símbolo seja um dos valores relacionados abaixo, efetue a operação correspondente. Se o usuário digitar um símbolo inválido, apresente a seguinte mensagem: “<valor digitado> não corresponde a uma opção válida”. Utilize o comando escolha na seleção da operação.
	p
	Testar se o número digitado é um número perfeito, ou seja, se o número é igual à soma de seus divisores (excluído o próprio número). Exemplo: 6 (1 + 2 + 3).
	i
	Testar se o número digitado é um número levemente imperfeito, ou seja, se o número é igual à somade seus divisores menos a unidade (excluído o próprio número). Exemplos: 4 (1 + 2 = 4 – 1) ou 8 (1 + 2 + 4 = 8 – 1).
SOLUçãO (ALGORITMO): LRESCOLHANUMPERFEITOS.ALG
 (Prova UEA/2013.2) Escreva um programa em C que imprima os quinhentos primeiros termos da série abaixo:
Série: 2, 7, 3, 4, 21, 12, 8, 63, 48, 16, 189, 192, 32, 567, 768, …
Dica: os três primeiros números da série são 2, 7 e 3. Os próximos números são multiplicados por 2, 3 e 4, respectivamente. Assim, obteve-se depois 4, 21 e 12. Novamente multiplica-se por 2, 3 e 4, obtendo-se 8, 63 e 48.
SOLUçãO1: LRGERASERIEESPECIAL.C.
SOLUçãO2: LRGERASERIEESPECIAL2.C.
 Escreva um programa em C que imprima a série abaixo.
Série: 2, 7, 3, 4, 21, 12, 8, 63, 48, 16, 189, 192, 32, 567, 768, …
O usuário digitará a quantidade de números que deverão aparecer na tela.
Dica: os três primeiros números da série são 2, 7 e 3. Os próximos números são multiplicados por 2, 3 e 4, respectivamente. Assim, obteve-se depois 4, 21 e 12. Novamente multiplica-se por 2, 3 e 4, obtendo-se 8, 63 e 48.
   
Next: Vetores e matrizes Up: livro Previous: Comandos Condicionais
Tiago Eugenio de Melo 2014-03-31