case

Capítulo IV – Comandos de
Controle de Fluxo
4.1 – Comandos compostos
4.2 – Comandos condicionais
4.3 – Expressões condicionais
4.4 – Comandos repetitivos
4.5 – Comandos de escape
4.6 – Comandos de seleção
4.7 – Introdução à metodologia top-down
expressão
e os valores
4.6 – Comandos Ade
Seleção
Escolher um de vários
caminhos alternativos,
conforme o valor da
4.6.1
– Importante estrutura
expressão
V11, V12, ... , Vnp são inteiros
ou caracteres
algoritmica
Expressão
Lista de
comandos
Lista de
comandos
Lista de
comandos
Lista de
comandos
Em C
aplainada:
switch (Expressao) {
V11, V12, ... , V1i : Lista de Comandos;
V21, V22, ... , V2j : Lista de Comandos;
......
Vn1, Vn2, ... , Vnp : Lista de Comandos;
default: Lista de Comandos;
}
switch (Expressao) {
Em C
case V11: case V12: ... case V1i:
Lista de comandos; break;
case V21: case V22: ... case V2j:
O comando break é
Lista de comandos; break;
necessário para que
.
somente uma lista de
.
comandos seja executada
case Vn1: case Vn2: ... case Vnp:
Lista de comandos; break;
default:
Lista de comandos;
switch (Expressao) {
}
V11, V12, ... , V1i : Lista de Comandos;
V21, V22, ... , V2j : Lista de Comandos;
......
Vn1, Vn2, ... , Vnp : Lista de Comandos;
default: Lista de Comandos;
Obs.: o ramo default
é opcional
}
#include <stdio.h>
Resultado para n = 5
#include <conio.h>
Tudo coopera
para seu seja
sucesso
Exemplo:
o
void main ( ) {
seguinte programa
char c; int n;
printf ("Levantar o astral? (s/n): "); c = getche();
while (c == 's' || c == 'S') {
printf ("\n\n\tDigite um numero de 1 a 7: "); scanf ("%d", &n);
switch (n) {
case 1: printf ("\n\tVoce eh inteligente"); break;
case 2: printf ("\n\tVoce eh campeao"); break;
case 3: printf ("\n\tVoce estah com tudo"); break;
case 4: printf ("\n\tSeu destino eh vencer"); break;
case 5: printf ("\n\tTudo coopera para seu sucesso"); break;
case 6: printf ("\n\tA vida sorri para voce"); break;
case 7: printf ("\n\tNada pode impedir sua vitoria"); break;
default: printf ("\n\tO numero deve ser de 1 a 7");
}
printf ("\n\nLevantar o astral? (s/n): "); c = getche ();
}
}
#include <stdio.h>
Resultado para n = 5
#include <conio.h>
TudoRetirando-se
coopera para seu sucesso
os
void main ( ) {
A vida sorri para voce
break
Nadacomandos
pode impedir sua
vitoria
char c; int n;
printf ("Levantar o astral? (s/n): "); c = getche(); O numero deve ser de 1 a 7
while (c == 's' || c == 'S') {
printf ("\n\n\tDigite um numero de 1 a 7: "); scanf ("%d", &n);
switch (n) {
case 1: printf ("\n\tVoce eh inteligente");
case 2: printf ("\n\tVoce eh campeao");
case 3: printf ("\n\tVoce estah com tudo");
case 4: printf ("\n\tSeu destino eh vencer");
case 5: printf ("\n\tTudo coopera para seu sucesso");
case 6: printf ("\n\tA vida sorri para voce");
case 7: printf ("\n\tNada pode impedir sua vitoria");
default: printf ("\n\tO numero deve ser de 1 a 7");
}
printf ("\n\nLevantar o astral? (s/n): "); c = getche ();
}
}
Fluxograma do switch sem usar break:
Expressão
Lista de
comandos
Lista de
comandos
Lista de
comandos
Lista de
comandos
Exemplo: programa para contar diversos tipos de
caracteres

Digitar uma frase, guardando-a no buffer do teclado

Ler cada caractere da frase, classificando-o

Acrescentar 1 ao contador da classe do caractere

No final, escrever no vídeo o valor do contador de cada
classe
Classes:
1) A ou a
3) I ou i
5) U ou u
7) Y ou y
9) Dígitos decimais
2) E ou e
4) O ou o
6) W ou w
8) Consoantes
10) Outros caracteres
#include <stdio.h>
#include <stdlib.h>
/* Cabecalho e declaracoes */
int main ( ) {
char c;
int ct_a, ct_e, ct_i, ct_o, ct_u, ct_w, ct_y,
ct_cons, ct_dig, ct_outros;
/* Zerar todos os contadores */
ct_a = ct_e = ct_i = ct_o = ct_u = ct_w =
ct_y = ct_cons = ct_dig = ct_outros = 0;
/* Ler e classificar cada caractere */
printf ("Digite uma frase:\n\n\t"); scanf ("%c", &c);
while (c != '\n') {
switch (c) {
case 'a': case 'A': ct_a++; break;
case 'e': case 'E': ct_e++; break;
case 'i': case 'I': ct_i++; break;
case 'o': case 'O': ct_o++; break;
case 'u': case 'U': ct_u++; break;
case 'w': case 'W': ct_w++; break;
case 'y': case 'Y': ct_y++; break;
default:
if (c >= '0' && c <= '9') ct_dig++;
else if (c >= 'B' && c <= 'Z' || c >= 'b' && c <= 'z')
ct_cons++;
else ct_outros++;
}
scanf ("%c", &c);
}
/* Imprimir os contadores e fechar a tela*/
printf ("\nLetra A : %3d\nLetra E : %3d", ct_a, ct_e);
printf ("\nLetra I : %3d\nLetra O : %3d", ct_i, ct_o);
printf ("\nLetra U : %3d\nLetra W : %3d", ct_u, ct_w);
printf ("\nLetra Y : %3d\nConsoantes: %3d", ct_y, ct_cons);
printf ("\nDigitos : %3d\nOutros : %3d", ct_dig, ct_outros);
printf ("\n\n"); system ("pause"); return 0;
}
Resultado
Digite uma frase:
hberoçh
Letra A
:
Letra E
:
Letra I
:
Letra O
:
Letra U
:
Letra W
:
Letra Y
:
Consoantes:
Digitos
:
Outros
:
1
1
0
2
3
0
3
11
5
14
Pressione . . .
9g59y9
)_Y(HHU
3@$%UDFUYapok
Exercícios 4.6:
1. Dizer que características uma frase digitada deve ter para que
o programa do próximo slide a considere correta
#include <stdio.h>
#include <stdlib.h>
int main ( ) {
char c, erro; int c1, c2, c3, c4, c5, c6;
c1 = c2 = c3 = c4 = c5 = c6 = 0; erro = 0; printf ("Digite uma frase: ");
do {
scanf ("%c", &c);
if (c != '\n') {
switch (c) {
case ' ( ' : c1++; break ;
case ' ) ' : c2++; break ;
case ' [ ' : c3++; break ;
case ' ] ' : c4++; break ;
case ' { ' : c5++; break ;
case ' } ' : c6++; break ;
}
if (c2 > c1 | | c4 > c3 | | c6 > c5) erro = 1;
}
} while (c ! = ' \n ' && erro == 0);
if (erro == 0 && c1 == c2 && c3 == c4 && c5 == c6) printf ("Frase correta");
else printf ("Frase com erros");
printf ("\n\n"); system ("pause"); return 0;
}
Capítulo IV – Comandos de
Controle de Fluxo
4.1 – Comandos compostos
4.2 – Comandos condicionais
4.3 – Expressões condicionais
4.4 – Comandos repetitivos
4.5 – Comandos de escape
4.6 – Comandos de seleção
4.7 – Introdução à metodologia top-down
4.7 – Introdução à Metodologia Topdown
4.7.1 – Conceito

É a decomposição de uma grande tarefa numa coleção de
tarefas menores interligadas

Cada uma dessas tarefas menores pode ser decomposta da
mesma forma

No final, chega-se a uma coleção de tarefas triviais
interligadas

Cada uma delas poderá ser resolvida por um comando típico
dos algoritmos
4.7.2 – Desenvolvimento de um algoritmo para
encontrar os n primeiros números naturais primos
Método:

Por definição, 1 não é primo

Percorrer o campo dos naturais, do no 2 em diante, até
encontrar n números primos
4.7.2 – Desenvolvimento de um algoritmo para
encontrar os n primeiros números naturais primos
Método:

Para ver se um número num é primo:
A
0 1 2 3
B
num tem divisor na
região B se e somente
se tem divisor na
região A
num/2
num
Então basta procurar
divisores para num na
região A
Desenvolvimento do algoritmo por “top-down”:
1ª Etapa:
N_PrimeirosNúmerosPrimos {
Declarações
Escrever o título da tarefa;
int n;
Pedir e ler o valor de n;
Se (n <= 0) Escrever mensagem de erro;
Senão
Encontrar e Escrever os n 1os números primos;
}
N_PrimeirosNúmerosPrimos {
Escrever o título da tarefa;
Pedir e ler o valor de n;
Se (n <= 0) Escrever mensagem de erro;
Senão
Encontrar e Escrever os n 1os números primos;
}
2ª Etapa
Declarações
int n;
N_PrimeirosNúmerosPrimos {
write (“Relacao dos n primeiros numeros primos”);
write (“Digite o valor de n:”); read (n);
Se (n <= 0) Escrever mensagem de erro;
Senão
Encontrar e Escrever os n 1os números primos;
}
2ª Etapa
Declarações
int n;
N_PrimeirosNúmerosPrimos {
write (“Relacao dos n primeiros numeros primos”);
write (“Digite o valor de n:”); read (n);
Se (n <= 0) Escrever mensagem de erro;
Senão
Encontrar e Escrever os n 1os números primos;
}
2ª Etapa
Declarações
int n;
N_PrimeirosNúmerosPrimos {
write (“Relacao dos n primeiros numeros primos”);
write (“Digite o valor de n:”); read (n);
if (n <= 0) write (n, “ - valor improprio para n”);
else
Encontrar e Escrever os n 1os números primos;
}
2ª Etapa
Declarações
int n;
N_PrimeirosNúmerosPrimos {
write (“Relacao dos n primeiros numeros primos”);
write (“Digite o valor de n:”); read (n);
if (n <= 0) write (n, “ - valor improprio para n”);
else
Encontrar e Escrever os n 1os números primos;
}
2ª Etapa
Declarações
int n;
N_PrimeirosNúmerosPrimos {
2ª Etapa
write (“Relacao dos n primeiros numeros primos”);
write (“Digite o valor de n:”); read (n);
if (n <= 0) write (n, “ - valor improprio para n”);
else {
num: número a ser
num = 2; cont = 0;
testado
do {
cont: contador de
Testar se num é primo;
números primos
if (num é primo) {
encontrados
write (num); cont++;
Faltam detalhes
}
num++;
Declarações
} while (cont < n);
int n, num, cont;
}
}
Desenvolvimento de:
3ª Etapa
Testar se num é primo;
if (num é primo)
Procurar divisor para num, no intervalo [ 2, 
if (não encontrar divisor para num)
 ];
Desenvolvimento de:
4ª Etapa
Procurar divisor para num, no intervalo [ 2, 
if (não encontrar divisor para num)
div = 2;
while ((não encontrar divisor) && (div2 <= num)) {
Testar div;
if (div é divisor de num)
Encontrou divisor;
Declarações
else div++;
int n, num, cont, div;
}
if (não encontrar divisor para num)
 ];
div = 2;
while ((não encontrar divisor) && (div2 <= num)) {
Testar div;
5ª e última
if (div é divisor de num)
Etapa
Encontrou divisor;
else div++;
}
if (não encontrar divisor para num)
Declarações
int n, num, cont, div;
div = 2; achou = False;
while ((achou == False) && (div2 <= num)) {
Testar div;
5ª e última
if (div é divisor de num)
Etapa
Encontrou divisor;
else div++;
}
if (achou == False)
Declarações
int n, num, cont, div;
logic achou;
div = 2; achou = False;
while ((achou == False) && (div2 <= num)) {
Testar div;
5ª e última
if (div é divisor de num)
Etapa
Encontrou divisor;
else div++;
}
if (achou == False)
Declarações
int n, num, cont, div;
logic achou;
div = 2; achou = False;
while ((achou == False) && (div2 <= num)) {
resto = num % div;
5ª e última
if (resto == 0)
Etapa
achou = True;
else div++;
}
if (achou == False)
Copia-se este trecho no
resultado da 2ª Etapa
Declarações
int n, num, cont, div, resto;
logic achou;
N_PrimeirosNúmerosPrimos {
write (“Relacao dos n primeiros numeros primos”);
write (“Digite o valor de n:”); read (n);
if (n <= 0) write (n, “ - valor improprio para n”);
else {
num = 2; cont = 0;
do {
Testar se num é primo;
if (num é primo) {
write (num); cont++;
Faltam detalhes
}
num++;
Declarações
} while (cont < n);
int n, num, cont;
}
}
N_PrimeirosNúmerosPrimos {
int n, num, cont, div, resto; logic achou;
write (“Relacao dos n primeiros numeros primos”);
write (“Digite o valor de n:”); read (n);
if (n <= 0) write (n, “ - valor improprio para n”);
else {
num = 2; cont = 0;
do {
div = 2; achou = False;
while ((achou == False) && (div2 <= num)) {
resto = num % div;
if (resto == 0) achou = True;
else div++;
}
Obs.: todos os comandos
if (achou == False)
resolvem problemas triviais
{ write (num); cont++; }
e já podem ser traduzidos
num++;
para a Linguagem C
} while (cont < n);
}
}
#include <stdio.h>
#include <stdlib.h>
/*Declaracao do tipo e das constantes logicas */
typedef char logic;
const logic True = 1, False = 0;
/*Cabecalho e declaracoes das variaveis locais */
int main () {
int n, num, cont, div, resto; logic achou;
/*Escrita do titulo e leitura de n */
printf ("Relacao dos n primeiros numeros primos");
printf ("\n\n\tDigite o valor de n: "); scanf ("%d", &n);
printf ("\n");
/*Caso de valor improprio para n */
if (n <= 0) printf ("%d - valor improprio para n", n);
/*Caso de valor correto para n
Procura dos n primeiros numeros primos */
else {
num = 2; cont = 0;
do {
/*Procura de divisor para um numero */
div = 2; achou = False;
while ((achou == False) && (div*div <= num)) {
resto = num % div;
if (resto == 0) achou = True;
else div++;
Não será usado
}
‘for’, pois o último
/*Escrita de cada numero primo encontrado;
10 numeros em cada linha
*/
comando do
‘while’ é um ‘if ’
if (achou == False) {
printf ("%5d", num); cont++;
if (cont % 10 == 0) printf ("\n");
}
/*Preparando para testar o proximo numero,
ate que os n primeiros numeros primos sejam encontrados */
num++;
} while (cont < n);
}
/*Fechamento da tela de execucao */
printf ("\n\n"); system ("pause"); return 0;
}
Relacao dos n primeiros numeros primos
Digite o valor de n: 26
Resultado
para n = 26
2
31
73
3
37
79
5
41
83
7
43
89
11
47
97
Digite algo para encerrar:
13
53
101
17
59
19
61
23
67
29
71
4.7.3 – Desenvolvimento de um algoritmo para
encontrar os fatores primos de números lidos
Requisitos para o
programa:
FATORES PRIMOS DE NUMEROS INTEIROS
Fatorar numero? (s/n): s
Digite o numero: 504
Fatores primos de 504:

Gerar relatórios do
tipo:
2^3
3^2
7^1
2^2
3^1
29^1
2^1
3^1
5^3
Fatorar numero? (s/n): s
Digite o numero: 348
Fatores primos de 348:
Fatorar numero? (s/n): s
Digite o numero: 750
Fatores primos de 750:
Fatorar numero? (s/n): n
Pressione qualquer tecla para continuar. . .
Método: ilustrado com os fatores primos de 504, 348 e 750
504
252
2
2
348
174
2
2
750
375
2
3
126
63
2
3
87
29
3
29
125
25
5
5
21
3
1
5
5
7
7
1
1
Encontrar o próximo primo como divisor é de programação
trabalhosa
Mais fácil é testar divisores consecutivos a partir de 2
Desenvolvimento do algoritmo por “top-down”:
1ª Etapa:
FatoresPrimos {
Escrever o título da tarefa;
Perguntar se quer fatorar número;
Aguardar a resposta;
Enquanto a resposta for sim {
Perguntar qual o número;
Aguardar o número;
Fatorar o número e escrever seus fatores;
Perguntar se quer fatorar outro número;
Aguardar a resposta;
}
}
FatoresPrimos {
Escrever o título da tarefa;
Perguntar se quer fatorar número;
Aguardar a resposta;
Enquanto a resposta for sim {
Perguntar qual o número;
Aguardar o número;
Fatorar o número e escrever seus fatores;
Perguntar se quer fatorar outro número;
Aguardar a resposta;
}
}
2ª Etapa
FatoresPrimos {
write (“FATORES PRIMOS DE NUMEROS INTEIROS”);
write (“Fatorar numero? (s/n): ”);
read (resposta);
2ª Etapa
Enquanto a resposta for sim {
Perguntar qual o número;
Aguardar o número;
Fatorar o número e escrever seus fatores;
Perguntar se quer fatorar outro número;
Aguardar a resposta;
}
}
char resposta;
FatoresPrimos {
write (“FATORES PRIMOS DE NUMEROS INTEIROS”);
write (“Fatorar numero? (s/n): ”);
read (resposta);
2ª Etapa
Enquanto a resposta for sim {
Perguntar qual o número;
Aguardar o número;
Fatorar o número e escrever seus fatores;
Perguntar se quer fatorar outro número;
Aguardar a resposta;
}
}
char resposta;
FatoresPrimos {
write (“FATORES PRIMOS DE NUMEROS INTEIROS”);
write (“Fatorar numero? (s/n): ”);
read (resposta);
2ª Etapa
while (resposta == ‘s’ || resposta == ‘S’) {
Perguntar qual o número;
Aguardar o número;
Fatorar o número e escrever seus fatores;
Perguntar se quer fatorar outro número;
Aguardar a resposta;
}
}
char resposta;
FatoresPrimos {
write (“FATORES PRIMOS DE NUMEROS INTEIROS”);
write (“Fatorar numero? (s/n): ”);
read (resposta);
2ª Etapa
while (resposta == ‘s’ || resposta == ‘S’) {
Perguntar qual o número;
Aguardar o número;
Fatorar o número e escrever seus fatores;
Perguntar se quer fatorar outro número;
Aguardar a resposta;
}
}
char resposta;
FatoresPrimos {
write (“FATORES PRIMOS DE NUMEROS INTEIROS”);
write (“Fatorar numero? (s/n): ”);
read (resposta);
2ª Etapa
while (resposta == ‘s’ || resposta == ‘S’) {
write (“Digite o numero:”);
read (num);
Fatorar o número e escrever seus fatores;
write (“Fatorar numero? (s/n): ”);
read (resposta);
}
}
char resposta;
int num;
FatoresPrimos {
write (“FATORES PRIMOS DE NUMEROS INTEIROS”);
write (“Fatorar numero? (s/n): ”);
read (resposta);
2ª Etapa
while (resposta == ‘s’ || resposta == ‘S’) {
write (“Digite o numero:”);
read (num);
Fatorar o número e escrever seus fatores;
write (“Fatorar numero? (s/n): ”);
A ser desenvolvido
read (resposta);
na próxima etapa
}
}
char resposta;
int num;
Desenvolvimento de Fatorar num e escrever seus fatores:
504
252
2
2
126
aux 63
2
3
21
3
7
7
2 * 2 ≤ 504
3x
504 % 2 = 0
252 % 2 = 0
126 % 2 = 0
2x
3 * 3 ≤ 63
63 % 32 =
≠0
21 % 3 = 0
1x
4*4 > 7
7%3≠0
1
Aqui, aux
Fatores
devem
é primo
ser
procurados em
[2, 
]
3ª Etapa
504 = 23 * 32 * 71
Copiar ‘num’ numa
variável ‘aux’
Dividir ‘aux’ pelos
fatores encontrados
Desenvolvimento de Fatorar num e escrever seus fatores:
aux
348
174
2
2
2x
2 * 2 ≤ 348
348 % 2 = 0
174 % 2 = 0
87
29
3
29
1x
1x
3 * 3 ≤ 87
87 % 32 =
≠0
654 * 654 >
≤ 29
29 % 543 ≠ 0
1
Aqui, aux é primo
3ª Etapa
348 = 22 * 31 * 291
Desenvolvimento de Fatorar num e escrever seus fatores:
750
375
2
3
125
aux 25
5
5
5
5
1x
1x
2 * 2 ≤ 750
3 * 3 ≤ 375
750 % 2 = 0
375 % 32 =
≠0
54 * 54 ≤ 125
125 % 543 =
≠0
3x
25 % 5 = 0
5%5=0
1
Aqui, aux não é
primo
3ª Etapa
750 = 21 * 31 * 53
Terminada a
procura de fatores
em [2, 
 ],
se aux > 1, então
aux é um fator de
expoente 1
Desenvolvimento de Fatorar num e escrever seus fatores:
write (“Fatores primos de ”, num, “:”);
aux = num;
Procurar fatores para aux no intervalo [2, 
]
Atualizando o valor de aux, ou seja
Dividindo aux pelos fatores encontrados
Imprimindo cada fator ao lado de seu expoente
Testar se aux restante é um fator;
char resposta;
int num, aux;
3ª Etapa
write (“Fatores primos de ”, num, “:”);
aux = num;
Procurar fatores para aux no intervalo [2, 
]
Atualizando o valor de aux, ou seja
Dividindo aux pelos fatores encontrados
imprimindo cada fator ao lado de seu expoente
Testar se aux restante é um fator;
char resposta;
int num, aux;
4ª Etapa
write (“Fatores primos de ”, num, “:”);
aux = num;
fat = 2;
while (fat2 <= aux ) {
Calcular expoente de fat e atualizar aux;
se expoente de fat > 0
Escrever fat ao lado do expoente;
fat++;
}
Testar se aux restante é um fator;
char resposta;
int num, aux, fat;
4ª Etapa
write (“Fatores primos de ”, num, “:”);
aux = num;
fat = 2;
while (fat2 <= aux ) {
Calcular expoente de fat e atualizar aux;
se expoente de fat > 0
Escrever fat ao lado do expoente;
fat++;
}
Testar se aux restante é um fator;
char resposta;
int num, aux, fat;
4ª Etapa
write (“Fatores primos de ”, num, “:”);
aux = num;
fat = 2;
while (fat2 <= aux ) {
Calcular expoente de fat e atualizar aux;
se expoente de fat > 0
Escrever fat ao lado do expoente;
fat++;
}
if (aux > 1 || num == 1)
char resposta;
write (aux, “^1”);
int num, aux, fat;
4ª Etapa
write (“Fatores primos de ”, num, “:”);
5ª Etapa
aux = num;
fat = 2;
while (fat2 <= aux ) {
Calcular expoente de fat e atualizar aux;
se expoente de fat > 0
Escrever fat ao lado do expoente;
fat++;
}
if (aux > 1 || num == 1)
char resposta;
write (aux, “^1”);
int num, aux, fat;
fat = 2;
while (fat2 <= aux ) {
Calcular expoente de fat e atualizar aux;
se expoente de fat > 0
Escrever fat ao lado do expoente;
fat++;
}
5ª Etapa
char resposta;
int num, aux, fat;
fat = 2;
while (fat2 <= aux ) {
expo = 0;
while (aux % fat == 0) {
expo++;
aux /= fat;
}
if (expo > 0)
write (fat, “^”, expo);
fat++;
}
5ª Etapa
char resposta;
int num, aux, fat, expo;
FatoresPrimos {
char resposta; int num, aux, fat, expo;
write (“FATORES PRIMOS DE NUMEROS INTEIROS”);
write (“Fatorar numero? (s/n): ”); read (resposta);
while (resposta == ‘s’ || resposta == ‘S’) {
write (“Digite o numero:”); read (num);
write (“Fatores primos de ”, num, “:”);
aux = num; fat = 2;
while (fat*fat <= aux ) {
expo = 0;
while (aux % fat == 0) {
expo++; aux /= fat;
}
if (expo > 0) write (fat, “^”, expo);
fat++;
}
if (aux > 1 || num == 1) write (aux, “^1”);
write (“Fatorar numero? (s/n): ”); read (resposta);
}
}
Algoritmo
final
FatoresPrimos {
char resposta; int num, aux, fat, expo;
write (“FATORES PRIMOS DE NUMEROS INTEIROS”);
write (“Fatorar numero? (s/n): ”); read (resposta);
while (resposta == ‘s’ || resposta == ‘S’) {
Algoritmo
write (“Digite o numero:”); read (num);
final, usando
write (“Fatores primos de ”, num, “:”);
comandos for
aux = num;
for (fat = 2; fat*fat <= aux; fat++ ) {
for (expo = 0; aux % fat == 0; expo++, aux /= fat);
if (expo > 0) write (fat, “^”, expo);
}
if (aux > 1 || num == 1) write (aux, “^1”);
write (“Fatorar numero? (s/n): ”); read (resposta);
}
}
#include <stdio.h>
#include <stdlib.h>
/* Cabecalho e declaracoes
Programa
em C
*/
int main () {
char resposta, lixo; int num, aux, fat, expo;
/* Escrita do titulo da tarefa e oferecimento de servico ao operador
printf ("FATORES PRIMOS DE NUMEROS INTEIROS");
printf ("\n\nFatorar numero? (s/n): "); scanf ("%c", &resposta);
while (resposta == 's' || resposta == 'S') {
/* Solicitacao do numero a fatorar
*/
printf ("\n\tDigite o numero: "); scanf ("%d%c", &num, &lixo);
printf ("\n\tFatores primos de %d: ", num);
*/
/* Pesquisa por fatores primos no intervalo [2, sqrt(aux)]
*/
aux = num;
for (fat = 2; fat*fat <= aux; fat++) {
/* Calculo do expoente de um fator
*/
for (expo = 0; aux % fat == 0; expo++, aux /= fat);
/* Escrita de um fator ao lado de seu expoente
*/
if (expo > 0) printf ("%d^%d ", fat, expo);
}
/* Testando se o ultimo aux eh fator primo
*/
if (aux > 1 || num == 1) printf ("%d^1", aux);
/* Novo oferecimento de servico ao operador
*/
printf ("\n\nFatorar numero? (s/n): "); scanf ("%c", &resposta);
}
/* Fechamento da tela */
printf ("\n\n"); system ("pause"); return 0;
}