CCO 016 / COM 110 - rcosta62br.unifei.edu.br · • Faça um programa que leia um número natural e...
Transcript of CCO 016 / COM 110 - rcosta62br.unifei.edu.br · • Faça um programa que leia um número natural e...
CCO 016 / COM 110Fundamentos de Fundamentos de
ProgramaçãoProgramação
Universidade Federal de Itajubá
Prof. Roberto Affonso da Costa Junior
AULA 07AULA 07
– Comandos Sequenciais (se – senao)– Linguagem de Programação C (if – else)– Estrutura Condicionais (caso)– Linguagem de Programação C (switch)
Estrutura CondicionaisEstrutura Condicionais➢ Até agora estávamos trabalhando com algoritmos puramente sequenciais, ou seja, todas as instruções eram executadas seguindo a ordem do algoritmo (normalmente, de cima para baixo). A partir de agora começamos a estudar estruturas de seleção.
➢ Uma estrutura de seleção, como o próprio nome já diz, permite que determinadas instruções sejam executadas ou não, dependendo do resultado de uma condição (teste), ou seja, o algoritmo vai tomar decisão de um processo (leitura, processo e impressão) a ser realizado.
4
Estruturas de ControleEstruturas de ControleCondicional ou de seleçãoCondicional ou de seleção
Isto é, são testados parâmetros e, dependendo de seus valores, tomamos um caminho ou outro. As condições que são testadas num Algoritmo são do tipo lógica (booleano), portanto podem ter somente dois resultados: Verdadeiro ou Falso. Assim, a seleção de ações pode seguir, no máximo, duas alternativas: uma se a condição for verdadeira e outra se a condição testada for falsa. Existem seleções simples, compostas e múltiplas.
Operadores LógicosOperadores Lógicos
✔ Utilizados na confecção das condições
✔ São eles: Portugol Linguagem C/C++– Maior que > >– Menor que < <– Maior ou igual a >= >=– Menor ou igual a <= <=– Diferente de <> !=– Igual a = ==
Operadores RelacionaisOperadores Relacionais
✔ Complementando a confecção das condições
✔ São eles: Portugol Linguagem C/C++– E e &&– OU ou ||– não não !
Operadores RelacionaisOperadores Relacionais
A Não A
V F
F V
A B A ou B
V V V
V F V
F V V
F F F
A B A e B
V V V
V F F
F V F
F F F
TreinamentoTreinamento1) Com base nas tabelas de decisão, determine os resultados lógicos das expressões mencionadas, assinalando se são verdadeiras ou falsas. Considere para as respostas os seguintes valores: X = 1, A = 3, B = 5, C = 8 e D = 7.
a) ! (X <= 3) resp: ( )
b) ((X != 1) && ! (B > A)) resp: ( )
c) (!(B < 0) && (D > 8)) resp: ( )
d) (!(X > -2) || (C < 9)) resp: ( )
e) ((X > A) || (A > C)) resp: ( )
f) (B >= 5) resp: ( )
g) ((C < 1) && (B >= A)) resp: ( )
9
Estruturas de ControleEstruturas de ControleCondicional ou de seleçãoCondicional ou de seleção
Seleções Simples: A seleção mais simples existente é quando o único bloco
de comando (leitura, processo e/ou escreva) a ser realizado é aquele que a situação da <condição> é verdadeira. Não existe a opção falsa, ou não é necessário realizar nada neste tipo de opção. É o que chamamos de opção “default”.
10
Estruturas de ControleEstruturas de ControleCondicional ou de seleçãoCondicional ou de seleção
Portugol: se <condição> então bloco de comandos fim-se
Fluxograma:
<condições>F
V
Bloco de comandos
● Na Linguagem C:
if ( condição )
{
Blocos de comando;
}
12
EXEMPLO 1:EXEMPLO 1:Leia um número e diga se ele é “maior que 10”.Leia um número e diga se ele é “maior que 10”.
inicio {declaração de variáveis} real N {comandos de entrada de dados} imprima (“Entre com N: “) leia (N) {processo e saída de dados} se N > 10 então
imprima (N,” maior que 10) fim-sefim
INICIO
N
N, “ Maior que 10”
FIM
N > 10F
V
13
#include <stdio.h>int main(){ float N; //comandos de entrada de dados printf (“Entre com um número: “); scanf (“%f”,&N); //processo e saída de dados if (N > 10) {
printf (“%.1f maior que 10”,N); } return 0;}
Linguagem CLinguagem C
14
Estruturas de ControleEstruturas de ControleCondicional ou de seleçãoCondicional ou de seleção
Seleções Completa:
A seleção completa é dada por se...então...senão...fim-se onde se a <condição> for verdadeira é realizado o então e dentro dele os blocos de comandos 1, se for falsa, é realizado o senão e dentro dele os blocos de comandos 2.
15
Estruturas de ControleEstruturas de ControleCondicional ou de seleçãoCondicional ou de seleção
Portugol:se <condição> então bloco de comandos 1senão bloco de comandos 2fim-se
Fluxograma:
<condições>F
V
Bloco de comandos 1
Bloco de comandos 2
16
if ( condição ){ bloco de comandos 1;} else { bloco de comandos 2;}
Linguagem CLinguagem C
17
EXEMPLO 2:EXEMPLO 2:Leia um número natural e diga se ele é par ou impar.Leia um número natural e diga se ele é par ou impar.
inicio {declaração de variáveis} inteiro N Imprima (“Entre com N: “) leia (N) se resto (N,2) = 0 então imprima (N, “ é par”) senão imprima (N,” é impar) fim-sefim
INICIO
FIM
N
N, “ é par”
resto (N, 2) = 0F
V
N, “ é impar”
18
#include <stdio.h>int main(){ int N; printf (“Entre com um número inteiro: “); scanf (“%d”,&N); if ((N % 2) == 0) { printf (“%d é par.”, N); } else { printf ( “%d é impar.”,N); } return 0;}
Linguagem CLinguagem C
TreinamentoTreinamento2) Determine o resultado lógicos das expressões mencionadas, assinalando se
são verdadeiras ou falsas. Considere para as respostas os seguintes valores:X = 3 A = 1 B = 5 C = 8 D = 0
a) (! (X > 3)) b) ((X > 3) || !(B > D))c) (! (D < 0) && (C > 5)) d) (!(X > 3) || (C < 7))
3) Indique a saída dos trechos de programa em português estruturado, mostrado abaixo. Para as saídas considere os seguintes valores:
A = 0 B = 9 C = 3 D = 2a) if (!(D > 3)) { X = (A + B) * D; } else { X = (A - B) / C; } printf (“X = %d\n”, X);
b) if ((A > B) || (C <= 2)) {
X = (A + 2) * (B - 2); } else { X = (A + B) / D * (C + D); } printf (“X = %d\n”, X);
20
Operador de Seleção Operador de Seleção CompletaCompleta
• O operador de seleção completa é dados por
EXP1 ? EXP2 : EXP3;
onde EXP1 é uma expressão condicional, e EXP2 e EXP3 é um único bloco de comando para o verdadeiro e falso, respectivamente.
21
Exemplo de Operador de Exemplo de Operador de Seleção CompletaSeleção Completa
• Faça um programa que leia um número natural e diga se ele é par ou impar.
Para N = 8:8 é par.
Para N = 7:7 é impar.
#include <stdio.h>int main() {
int N;scanf ("%d",&N);((N % 2) == 0) ? printf ( "%d é par.\n", N): printf ( "%d é impar.\n",N);return 0;
}
22
Exemplo de Operador de Exemplo de Operador de Seleção CompletaSeleção Completa
• Faça um programa que leia um número natural e se for par mostre 0 e se for impar mostre 1.
Para N = 8:0
Para N = 7:1
#include <stdio.h>using namespace std;int main() {
int N, X;scanf ("%d",&N);X = ((N % 2) == 0) ? 0 : 1;printf("%d\n", X);return 0;
}
23
Estruturas de ControleEstruturas de ControleCondicional ou de seleçãoCondicional ou de seleção
Seleções Composta:
A estrutura de seleções composta também é designada como seleção aninhada e é utilizada quando estivermos fazendo várias comparações (testes) sempre com a mesma variável. Esta estrutura é chamada de aninhada porque na sua representação fica uma seleção dentro de outra seleção.
24
Estruturas de ControleEstruturas de ControleCondicional ou de seleçãoCondicional ou de seleção
Portugol:se <condição 1> então se <condição 2> então bloco de comandos 11 senão bloco de comandos 12 fim-se bloco de comandos 1
senão se <condição 3> então bloco de comandos 21 senão bloco de comandos 22 fim-se bloco de comandos 2fim-se
25
<condições 1>F
V
Bloco de comandos 1 Bloco de comandos 2
Fluxograma:
<condições 2> <condições 3>
V V
F F
Bloco de comandos 11
Bloco de comandos 12
Bloco de comandos 21
Bloco de comandos 22
26
Estruturas de ControleEstruturas de ControleCondicional ou de seleçãoCondicional ou de seleção
Linguagem C:if ( condição 1 ) { if ( condição 2 ) { bloco de comandos 11; } else { bloco de comandos 12; } bloco de comandos 1;
} else { if ( condição 3 ) { bloco de comandos 21; } else { bloco de comandos 22; } bloco de comandos 2;}
27
EXEMPLO 3:EXEMPLO 3:Montar um programa que leia Montar um programa que leia três medidas e determine se três medidas e determine se essas medidas formam um essas medidas formam um
triângulo, se formam que tipo triângulo, se formam que tipo de triângulo ele é (isósceles, de triângulo ele é (isósceles,
escaleno ou eqüilátero).escaleno ou eqüilátero).
{declaração de variáveis}real A, B, Cinicio leia (A, B, C) se (A < B + C) e (B < A + C) e (C < A + B) então se (A = B) e (B = C) então imprima(“Triângulo Eqüilátero”) senão se (A = B) ou (A = C) ou (B = C) então imprima (“Triângulo Isósceles”) senão imprima (“Triângulo escaleno”) fim-se fim-se senão imprima (“As medidas não formam um triângulo”) fim-sefim
28
EXEMPLO 3:EXEMPLO 3:Montar um programa que leia Montar um programa que leia três medidas e determine se três medidas e determine se essas medidas formam um essas medidas formam um
triângulo, se formam que tipo triângulo, se formam que tipo de triângulo ele é (isósceles, de triângulo ele é (isósceles,
escaleno ou equilátero).escaleno ou equilátero).
#include <stdio.h>int main() { float A, B, C; scanf (“%f %f %f”,&A,&B,&C); if ((A < B + C) && (B < A + C) && (C < A + B)) { if ((A == B) && (B == C)) { printf(“Triângulo Equilátero”); } else { if ((A == B) || (A == C) || (B == C)) { printf (“Triângulo Isósceles”); } else { printf (“Triângulo escaleno”); } } } else { printf (“As medidas não formam um triângulo”); } return 0;}
TreinamentoTreinamento4) Indique a saída dos trechos de programa do pedaço de fluxograma a seguir. Considerando os seguintes de valores inteiros: A = 2, B = 3, C = 5, D = 9.
X
nao (D > 5)F
V
X ← (A + B) * D X ← (A - B) / C
TreinamentoTreinamento5) Indique a saída dos trechos de programa do pedaço de fluxograma a seguir. Considerando os seguintes de valores inteiros: A = 4, B = 1, C = 0, D = 10.
X
(A > 2) .e.(B < 7)
F
V
X ← (A + 2) * (B – 2) X ← (A + B) div D * (C + D)
Exemplo 4Exemplo 4
● Calcular a seguinte expressão:
VL=5A+ B
(A−B)+2A
B+ 3A
ALGORITMO
objetivo: Calcular uma expressão aritmética
1) Definir variáveis
inteiros A, B, num1, num2, den1, den2, VL
inicio
2) Entrada dos dados
imprima ( “entre com dois valores “ )
leia ( A, B )
3) Calculo do numerador
num1 ← 5 A + B
4) Calculo do numerador do denominador
num2 ← 2 A
5) Calculo do denominador simples
den 1 ← B + 3A
6) calculo da expressao
se ( den1 = 0 )
então
imprima ( “expressão não calculada “ )
imprima ( “denominador nulo” )
senão
senão
6.1) calculo do denominador geral
den2 ← ( A – B ) + num2 / den1
6.2) calculo da expressão
se ( den2 = 0 )
então
imprima ( “expressão não calculada “ )
imprima ( “denominador nulo” )
senão
VL ← num1 / den2
imprima ( “ valor da expressao = “, VL )
fim_se
fim_se
7) mostrando os dados de entrada
imprima ( “A = “, A )
imprima ( “B = “, B )
fim
PORTUGOL
inicio
{Declaração das variáveis}
inteiros A, B, num1, num2, den1, den2, VL
{Entrada de Dados}
imprima ( “entre com dois valores “ )
leia ( A, B )
{Calculo da expressão}
num1 ← 5 A + B
num2 ← 2 A
den1 ← B + 3A
{Verificando o denominador 1}
se ( den1 = 0 )
então
imprima ( “expressão não calculada “ )
imprima ( “denominador nulo” )
senão
{Calculando o denominador 2}
den2 ← ( A – B ) + num2 / den1
{Verificando o denominador 2}
se ( den2 = 0 )
então
imprima ( “expressão não calculada “ )
imprima ( “denominador nulo” )
senão {Calculando e imprimindo o Valor da operação} VL ← num1 / den2
imprima ( “ valor da expressao = “, VL )
fim_se
fim_se imprima ( “A = “, A ) imprima ( “B = “, B )
fim
Linguagem C
#include <stdio.h>
int main ()
{
int A, B, num1, num2, den1, den2, VL;
printf ( “entre com dois valores: “ );
scanf ( “%d %d”,&A,&B );
num1 = 5 * A + B;
num2 = 2 * A;
den1 = B + 3 * A;
if ( den1 == 0 )
{
printf ( “expressão não calculada “ );
printf ( “denominador nulo” );
} else {
den2 = ( A – B ) + num2 / den1;
if ( den2 == 0 )
{
printf ( “expressão não calculada “ );
printf ( “denominador nulo” );
} else {
VL = num1 / den2 ;
printf ( “ valor da expressao = %d“, VL );
}
}
printf ( “A = %d“, A );
printf ( “B = %d“, B );
}
Exemplo 5Exemplo 5● São dados os resultados de uma prova que consta
de 5 questões, cujas respostas podem ser uma das 3 alternativas A, B ou C;
● São dados também as respostas de um aluno para esta prova.
● Desenvolva um algoritmo para calcular o desempenho deste aluno na prova segundo o seguinte critério:– Acerto de 3 ou mais questões – conceito A– Acerto de 1 ou 2 questões – conceito B– Acerto de nenhuma questão - conceito R
ALGORITMO / PORTUGOLobjetivo: calcular o conceito de um aluno frente ao gabarito
de uma prova
inicio
1) definição das variáveis
caracter gab1, gab2, gab3, gab4, gab5
caracter resp1, resp2, resp3, resp4, resp5
caracter conceito
inteiro n_questoes
2) entrada dos dados
2.1 ) dados do gabarito
imprima ( “entre com as 5 alternativas do gabarito” )
leia ( gab1, gab2, gab3, gab4, gab5 )
2.2 ) dados do aluno imprima ( “entre com as 5 resposta do aluno” ) leia ( resp1, resp2, resp3, resp4, resp5 )
3) inicializando variáveis n_questoes ← 0
4) calculando quantas questões estão certasSe ( gab1 = resp1 ) então n_questoes ← n_questoes + 1fim_seSe ( gab2 = resp2 ) então n_questoes ← n_questoes + 1
fim_se
Se ( gab3 = resp3 )
então n_questoes ← n_questoes + 1
fim_se
Se ( gab4 = resp4 )
então n_questoes ← n_questoes + 1
fim_se
Se ( gab5 = resp5 )
então n_questoes ← n_questoes + 1
fim_se
5) verificando o conceito do aluno
se ( n_questoes ≥ 3 )
então
conceito ← ‘A’
senão
se ( n_questoes > 0 )
então
conceito ← ‘B’
senão
conceito ← ‘R’
fim_se
fim_se
6) mostrando os resultados
6.1 ) dados de entrada imprima ( “gabarito: “ ) imprima ( “questao 1: “, gab1 ) imprima ( “questao 2: “, gab2 ) imprima ( “questao 3: “, gab3 ) imprima ( “questao 4: “, gab4 ) imprima ( “questao 5: “, gab5 )
imprima ( “resposta do aluno: “ ) imprima ( “resposta 1: “, resp1 ) imprima ( “resposta 2: “, resp2 ) imprima ( “resposta 3: “, resp3 ) imprima ( “resposta 4: “, resp4 ) imprima ( “resposta 5: “, resp5 )
6.2 ) quantidade de acertos
imprima ( “quantidade de questoes certas = “ ,
n_questoes )
6.3 ) conceito do aluno
imprima ( “conceito do aluno: “, conceito )
fim
LINGUAGEM C
#include <stdio.h>
int main ()
{
char gab1, gab2, gab3, gab4, gab5;
char resp1, resp2, resp3, resp4, resp5;
char conceito;
int n_questoes;
printf ( “entre com as 5 alternativas do gabarito” );
scanf ( “ %c %c %c”, &gab1, &gab2, &gab3);
scanf ( “ %c %c”, &gab4, &gab5 );
printf ( “entre com as 5 resposta do aluno” ); scanf ( “ %c %c %c ”, &resp1, &resp2, &resp3 ); scanf ( “ %c %c ”, &resp4, &resp5 );
n_questoes = 0;
if ( gab1 == resp1 ) ; {
n_questoes ++; }
if ( gab2 == resp2 ) {
n_questoes ++;
}
if ( gab3 == resp3 )
{
n_questoes ++;
}
if ( gab4 == resp4 )
{
n_questoes ++;
}
if ( gab5 == resp5 )
{
n_questoes ++;
}
if ( n_questoes >= 3 )
{
conceito = ‘A’;
} else {
if ( n_questoes > 0 )
{
conceito = ‘B’;
} else {
conceito = ‘R’;
}
}
printf ( “gabarito: \n“ ); printf ( “questao 1: %c\n“, gab1 );
printf ( “questao 2: %c\n“, gab2 ); printf ( “questao 3: %c\n“, gab3 ); printf ( “questao 4: %c\n“, gab4 ); printf ( “questao 5: %c\n“, gab5 );
printf ( “\n\nresposta do aluno:\n “ ); printf ( “resposta 1: %c\n“, resp1 ); printf ( “resposta 2: %c\n“, resp2 ); printf ( “resposta 3: %c\n“, resp3 ); printf ( “resposta 4: %c\n“, resp4 ); printf ( “resposta 5: %c\n“, resp5 );
printf ( “quantidade de questoes certas = %d\n“ , n_questoes );
printf ( “conceito do aluno: %c\n “, conceito );
}
Exemplo 6Exemplo 6 Dado a data de nascimento de uma pessoa, no formato
DD MM AAAA, fazer um programa para ler esta data e imprimi-la na forma corrente, ou seja:
DD de nome do mês ao qual MM corresponde de AAA
O programa deverá fazer a consistência dos dados de entrada. ( dia e mês )
Observação: antes de fazer o programa, faça o algoritmo do mesmo.
Exemplos: dado: 20 3 1950 saída: 20 de março de 1950
dado: 35 10 1980 saída: dia do mês não permitido
dado: 3 20 1980 saída: mês não permitido
dado: 31 4 1980 saída: mês não tem 31 diasSugestão:
os valores DD, MM e AAAA devem ser fornecidos pelo usuário e armazenados cada um numa variável;
Primeira versãoPrimeira versão
Observar nestas soluções o seguinte:● A entrada de dados é fornecida num único registro,
ou seja, dia mês ano ( isto significa utilizar-se apenas uma declaração de entrada para todas as variáveis )
● Nesta versão após conferidas as consistências da entrada dos dados, o programa inicia a conversão pedida no enunciado;
● Observe que esta tarefa só é realizada após toda a consistência dos dados tiver terminado. Por isto ela fica dentro do senão do ultimo Se da consistência.
ALGORITMO / PORTUGOLalgoritmo para imprimir de forma corrente uma data de nascimento
inicio
1) Definição das variáveisinteiro dia, mes, ano
2) Entrada de dadosimprima ( “entre com a data de nascimento” )leia ( dia, mes, ano )
3) fazendo consistência dos dados e a conversão da data
se ( dia < 1) ou ( dia > 31 ) então imprima ( “dia errado” )
senão se ( mes < 1 ) ou ( mes > 12 ) então imprima ( “mês errado” ) senão se ( ano < 0 ) ou ( ano > 2010 ) então imprima ( “verifique o ano “ ) senão
se ( mes = 1 ) então imprima ( dia, “ de janeiro de “, ano )
senão
se ( mes = 2 ) então se ( dia > 29 ) então imprima ( “mes com dias errado“ ) senão imprima ( dia, “ de fevereiro de “,
ano ) fim_se
senão
senão
se ( mes = 3 )
então
imprima ( dia, “ de março de “, ano )
senão
se ( mes = 4 )
então
se ( dia > 30 )
então
imprima ( “mes com dias errado“ )
senão
imprima ( dia, “ de abril de “, ano )
fim_se
senão
se ( mes = 5 )
então
imprima ( dia, “ de maio de “, ano )
senão
se ( mes = 6 )
então
se ( dia > 30 )
então
imprima ( “mes com dias errado“ )
senão
imprima ( dia, “ de junho de “, ano )
fim_se
senão se ( mes = 7 ) então imprima ( dia, “ de julho de “, ano )
senão
se ( mes = 8 ) então imprima ( dia, “ de agosto de “, ano ) senão
se ( mes = 9 ) então se ( dia > 30 ) então imprima ( “mes com dias errado“ ) senão imprima ( dia, “ de setembro de “, ano )
fim_se senão se ( mes = 10 ) então imprima ( dia, “ de outubro de “, ano )
senão se ( mes = 11 ) então se ( dia > 30 ) então imprima ( “mes com dias errado“ ) senão imprima ( dia, “ de novembro de “, ano )
fim_se senão se ( mes = 12 ) então imprima ( dia, “ de dezembro de “, ano ) fim_se
fim_se fim_se fim_se fim_se fim_se fim_se fim_se fim_se fim_se fim_se fim_se fim_se fim_se fim_sefim
LINGUAGEM C:
#include <stdio.h> int main () { int dia, mes, ano; printf ( “entre com a data de nascimento” );
scanf ( “%d %d %d”, &dia, &mes, &ano );
if (( dia < 1) || ( dia > 31 )) { printf ( “dia errado” );
} else { if (( mes < 1 ) || ( mes > 12 )) { printf ( “mês errado” ); } else {
if (( ano < 0 ) || ( ano > 2010 )) { printf ( “verifique o ano “ ); } else {
if ( mes == 1 ) { printf ( “%d de janeiro de %d“, dia, ano ); } else {
if ( mes == 2 ) { if ( dia > 29 ) { printf ( “mes com dias errado“ ); } else {
printf (“%d de fevereiro de %d“, dia, ano ); }
} else {
if ( mes == 3 )
{
printf ( “%d de março de %d“, dia, ano );
} else {
if ( mes == 4 )
{
if ( dia > 30 )
{
printf ( “mes com dias errado“ );
} else {
printf ( “%d de abril de %d“, dia, ano );
}
} else {
if ( mes == 5 )
{
printf ( “%d de maio de %d“, dia, ano );
} else {
if ( mes == 6 )
{
if ( dia > 30 )
{
printf ( “mes com dias errado“ );
} else {
printf ( “%d de junho de %d“, dia, ano );
}
} else {
if ( mes == 7 ) { printf ( “%d de julho de %d“, dia, ano ); } else {
if ( mes == 8 ) { printf ( “%d de agosto de %d“, dia, ano ); } else {
if ( mes == 9 ) { if ( dia > 30 ) { printf ( “mes com dias errado“ ); } eles { printf ( “%d de setembro de %d“, dia, ano )
} } else {
if ( mes == 10 ) { printf ( “%d de outubro de %d“, dia, ano );
} else { if ( mes == 11 ) { if ( dia > 30 ) { printf ( “mes com dias errado“ ); } else { printf ( “%d de novembro de %d“, dia, ano );
} } else { if ( mes == 12 ) { printf ( “%d de dezembro de %d“, dia, ano ); }
}
} } } } } } } } } } } } } }
Segunda VersãoSegunda Versão● A entrada de dados é a mesma;● Nesta versão foram criadas algumas variáveis com o
objetivo de otimizar o programa, quanto a leitura do mesmo:– Variável CHAVE– Variável MÊS_SAIDA
● A variável CHAVE é utilizada para controlar a impressão da saída, ou seja, inicialmente ela vale zero; se qualquer um erro ocorrer, tal como por exemplo, uma inconstência nos dados de entrada, esta variável passa para o valor 1; No final do programa ela é testada afim de verificar se a impressão pode ou não ocorrer.
● Diferentemente que na versão anterior, aqui o programa inicializa várias variáveis, as quais contém cada o nome do mês por extenso, as quais vão ser utilizadas nas comparações com os dados de entrada;
ALGORITMO / PORTUGOLalgoritmo para imprimir de forma corrente uma data de nascimento
inicio
1) Definição das variáveis inteiros dia, mes, ano
inteiros chave cadeia mes01, mes02, mes03, mes04, mes05, mes06, mes07,
mes08, mes09, mes10, mes11, mes12
2) Entrada de dados imprima ( “entre com a data de nascimento” ) leia ( dia, mes, ano )
3) Inicializando chave de controle da impressão chave ← 0
4) inicializando variáveis referentes ao mêsmes01 ← “ de Janeiro de ” mes02 ← “ de Fevereiro de ” mes03 ← “ de Março de ” mes04 ← “ de Abril de ”
mes05 ← “ de de Maio de ” mes06 ← “ de Junho de ” mes07 ← “ de Julho de ” mes08 ← “ de Agosto de ” mes09 ← “ de Setembro de ” mes10 ← “ de Outubro de ” mes11 ← “ de Novembro de ” mes12 ← “ de Dezembro de ”
5) fazendo consistência dos dias e meses e ano se ( dia < 1) ou ( dia > 31 )
então imprima ( “dia errado” ) chave ← 1 fim_se
se ( mes < 1 ) ou ( mes > 12 ) então imprima ( “mês errado” ) chave ← 1 fim_se se ( ano < 0 ) ou ( ano > 2010 ) então imprima ( “verifique o ano “ ) chave ← 1 fim_se
6) fazendo a conversão da datase ( mes = 1 ) então mes_sai ← mes01fim_se
se ( mes = 2 ) então mes_sai ← mes02
Se ( dia > 29 ) então
imprima ( “ mês não tem mais de 29 dias “ ) chave ← 1 fim_se
fim_se
se ( mes = 3 ) então mes_sai ← mes03 fim_se
se ( mes = 4 ) então mes_sai ← mes04
se ( dia > 30 ) então
imprima ( “ mês não tem mais de 30 dias “ ) chave ← 1 fim_se
fim_se
se ( mes = 5 ) então mes_sai ← mes05 fim_se
se ( mes = 6 ) então mes_sai ← mes06 se ( dia > 30 ) então imprima ( “ mês não tem mais de 30 dias “ ) chave ← 1 fim_se fim_se
se ( mes = 7 ) então mes_sai ← mes07 fim_se
se ( mes = 8 ) então mes_sai ← mes08 fim_se
se ( mes = 9 ) então
mes_sai ← mes09 se ( dia > 30 ) então
imprima ( “ mês não tem mais de 30 dias “ ) chave ← 1 fim_se
fim_se
se ( mes = 10 ) então
mes_sai ← mes10
fim_se
se ( mes = 11 )
então
mes_sai ← mes11
se ( dia > 30 )
então
imprima ( “ mês não tem mais de 30 dias “ )
chave ← 1
fim_se
fim_se
se ( mes = 12 )
então
mes_sai ← mes12
fim_se
7) saida do resultado
se ( chave = 0 )
entao
imprima ( dd, mês_sai, ano )
fim_se
fim
Terceira VersãoTerceira Versão● Observe que na versão anterior, para determinados meses,
aqueles que têm menos de 31 dias, o programa verifica esta possibilidade,e se o usuário entrou com a informação errada, o programa envia uma mensagem e troca a CHAVE para o valor 1;
● Deste modo, quando chegar ao final do programa e CHAVE for diferente de 1, ele imprime o valor do mês convertido;
● Ao invés de se ter um trecho igual para todos os meses onde esta verificação é feita, pode-se fazer uma única verificação conforme mostre o programa seguinte.
● Apenas o item 6) é trocado da versão anterior para esta;
6) fazendo a conversão da datase ( mes = 1 ) então mes_sai ← mes01fim_se
se ( mes = 2 ) então mes_sai ← mes02fim_se
se ( mes = 3 ) então mes_sai ← mes03fim_se
se ( mes = 4 ) então mes_sai ← mes04fim_se
se ( mes = 5 ) então mes_sai ← mes05fim_se
se ( mes = 6 ) então mes_sai ← mes06fim_se
se ( mes = 7) então mes_sai ← mes07fim_se
se ( mes = 8 ) então mes_sai ← mes08fim_se
se ( mes = 9 ) então mes_sai ← mes09fim_se
se ( mes = 10 ) então mes_sai ← mes10fim_se
se ( mes = 11 ) então mes_sai ← mes11fim_se
se ( mes = 12 ) então mes_sai ← mes12fim_se
se ( mes = 2 ) e ( dia > 29 )
então
chave ← 1
imprima ( “mês tem mais de 29 dias “ )
senão
se ( ( mes = 4 ) ou ( mes = 6 ) ou ( mes = 9 ) ou ( mes = 11 ) ) e
( dia > 30 )
então
chave ← 1
imprima ( “mês tem mais de 30 dias “ )
fim_se
fim_se
Em casa construa as duas outras versão na Em casa construa as duas outras versão na linguagem C.linguagem C.
ComentáriosComentários● Todas as versões são soluções para o problema, porém é bom
analisá-las e verificar que a primeira é a mais pobre de todas, tendo em vista que há um aninhamento muito grande de Seleções;
● A segunda versão já melhorou no sentido de que agora a saída é controlada por uma chave e foi retirada uma grande parte do aninhamento das seleções;
● A ultima versão é a mais otimizada, visto que todos os aninhamentos foram retirados, a chave de controle foi mantida e uma única verificação é responsável por decidir qual dos meses possui mais de 30 dias; além disto ela ficou com menos declarações.
Exemplo 7Exemplo 7● Dados os coeficientes de uma equação do segundo
grau, calcular as raízes reais da mesma.
● Fazer a consistência dos dados de entrada.
( verificar se é equação do segundo grau )
Se as raízes não forem reais, o programa deverá comunicar ao usuário este fato, mas não calculá-las.
Observação: antes de fazer o programa, faça o algoritmo do mesmo.
ALGORITMO equacao_segundo_graualgoritmo para calcular as raízes reais de uma equação do segundo grau
1) Definição das variáveisinteiros coef1, coef2, coef3reais delta, raiz1, raiz2
2) Entrada de dadosimprima ( “entre com os coeficientes da equação do segundo grau” )leia ( coef1, coef2, coef3)
3) mostrando os dados de entrada
imprima ( “coeficientes da equacao: “, coef1, coef2, coef3 )
4) Fazendo consistência dos dados de entrada Se ( coef1 = 0 )
então imprima ( “equação não é do segundo grau” )
senão 4.1 ) cálculo do discriminante
delta ← coef2 . coef2 – 4 coef1 . coef3
4.2 ) verificação do discriminante
se ( delta < 0 )
então
imprima ( “raízes complexas” )
senão
4.2.1) calculo das raízes reais
- coef2 + raiz ( discriminante )
raiz1 ← ------------------------------------------
2 coef1
- coef2 – raiz ( discriminante )
raiz2 ← ------------------------------------------
2 coef1
4.2.2) mostrando as raízes calculadas
imprima ( “raízes reais: “ , raiz1, raiz2 )
fim_se
fim_se
fim_algoritmo
Em casa construa a versão na linguagem C.Em casa construa a versão na linguagem C.
TreinamentoTreinamento
1)Faça um programa que leia um número e diga se ele é divisível por 2 e por 3. Use estrutura de desvio condicional simples.
2)Faça um programa que leia um número e diga se ele é divisível por 5 ou por 7. Use estrutura de desvio condicional simples.
3)Faça um programa que leia dois números e apresente-os em ordem crescente. Use estrutura de desvio condicional simples.
TreinamentoTreinamento
4)Elabore um algoritmo que dada a idade de um nadador classifica-o em uma das seguintes categorias:
infantil A = 5 - 7 anos
infantil B = 8 - 10 anos
juvenil A = 11 - 13 anos
juvenil B = 14 - 17 anos
adulto = maiores de 18 anos
99
Estruturas de ControleEstruturas de ControleCondicional ou de seleçãoCondicional ou de seleção
Seleções Múltiplas: Podemos com as seleções aninhadas criarmos múltiplas seleções, mas
existe um comando ao qual as seleções múltiplas são melhor representadas. E com isto, podemos escolher mais opções que somente verdadeira e falsa.
Portugol:caso (<variável>) <valor_variável 1>:Comandos de bloco 1 <valor_variável 2>:Comandos de bloco 2 ... <valor_variável n>:Comandos de bloco n senão: Comandos de bloco F (opcional)fim-caso
100
<variável>
Bloco de comandos F
Fluxograma:
F
Bloco de comandos 1<valor_variável 1>
<valor_variável 2> Bloco de comandos 2
<valor_variável n> Bloco de comandos n
101
Estruturas de ControleEstruturas de ControleCondicional ou de seleçãoCondicional ou de seleção
Seleções Múltiplas: Os BREAKs são para pular os casos seguintes.
LINGUAGEM C:switch ( variável ) { case <valor_variável 1> : Comandos de bloco 1; break; case <valor_variável 2> : Comandos de bloco 2; break; ... case <valor_variável n> : Comandos de bloco n; break; default: Comandos de bloco F (opcional)}
102
Estruturas de ControleEstruturas de ControleCondicional ou de seleçãoCondicional ou de seleção
OBSERVAÇÃO:
As seleções Múltiplas não aceitam variáveis CADEIA (STRING) e nem variável Real.
Exemplo 8Exemplo 8 Faça um programa que a pessoa escolha qual é a sua
Universidade pelo número dado:
1) UNIFEI
2) UFMG
3) UFU
4) Outra
Exemplo 8Exemplo 8 #include <stdio.h>
int main() {
int opcao;
printf("Escolha a sua Universidade:\n");
printf("1) UNIFEI\n");
printf("2) UFMG\n");
printf("3) UFU\n");
printf("4) Outra\n");
scanf("%d",&opcao);
Exemplo 8Exemplo 8switch(opcao) {
case 1:
printf("UNIFEI\n");
break;
case 2:
printf("UFMG\n");
break;
case 3:
printf("UFU\n");
break;
Exemplo 8Exemplo 8case 4:
printf("Outra\n");
break;
}
return 0;
}
Exemplo 9Exemplo 9 Faça um programa que escolha a letra que começa o
nome de uma fruta, conforme a lista abaixo:
a) abacaxi
b) banana
c) caju
d) Damasco
Caso o usuário digite outra letra, imprima que está errado.
Exemplo 9Exemplo 9 #include <stdio.h>
int main() {
char opcao;
printf("Escolha a primeira letra de uma fruta:\n");
printf("a) abacaxi\n");
printf("b) banana\n");
printf("c) caju\n");
printf("d) damasco\n");
scanf("%d",&opcao);
Exemplo 9Exemplo 9switch(opcao) {
case 'a':
printf("abacaxi\n");
break;
case 'b':
printf("banana\n");
break;
case 'c':
printf("caju\n");
break;
Exemplo 9Exemplo 9case 'd':
printf("damasco\n");
break;
default:
printf("Opcao errada\n");
}
return 0;
}
Exemplo 10Exemplo 10 Dado a data de nascimento de uma pessoa, no formato
DD MM AAAA, fazer um programa para ler esta data e imprimi-la na forma corrente, ou seja:
DD de nome do mês ao qual MM corresponde de AAA
O programa deverá fazer a consistência dos dados de entrada. ( dia e mês )
Observação: antes de fazer o programa, faça o algoritmo do mesmo.
Exemplos: dado: 20 3 1950 saída: 20 de março de 1950
dado: 35 10 1980 saída: dia do mês não permitido
dado: 3 20 1980 saída: mês não permitido
dado: 31 4 1980 saída: mês não tem 31 diasSugestão:Sugestão:
os valores DD, MM e AAAA devem ser fornecidos pelo usuário e armazenados cada um numa variável;
ALGORITMO / PORTUGOLalgoritmo para imprimir de forma corrente uma data de nascimento
inicio
1) Definição das variáveisinteiro dia, mes, ano
2) Entrada de dadosimprima ( “entre com a data de nascimento” )leia ( dia, mes, ano )
3) fazendo consistência dos dados e a conversão da data
se ( dia < 1) ou ( dia > 31 ) então imprima ( “dia errado” )
senão se ( mes < 1 ) ou ( mes > 12 ) então imprima ( “mês errado” ) senão se ( ano < 0 ) ou ( ano > 2010 ) então imprima ( “verifique o ano “ ) senão
caso ( mes ) 1 : imprima ( dia, “ de janeiro de “, ano ) 2 : se ( dia > 29 ) então imprima ( “mes com dias errado“ ) senão imprima ( dia, “ de fevereiro de “, ano ) fim_se 3 : imprima ( dia, “ de março de “, ano )
4 :
se ( dia > 30 )
então
imprima ( “mes com dias errado“ )
senão
imprima ( dia, “ de abril de “, ano )
fim_se
5 :
imprima ( dia, “ de maio de “, ano )
6 :
se ( dia > 30 )
então
imprima ( “mes com dias errado“ )
senão
imprima ( dia, “ de junho de “, ano )
fim_se
7 : imprima ( dia, “ de julho de “, ano )
8 : imprima ( dia, “ de agosto de “, ano )
9 : se ( dia > 30 ) então imprima ( “mes com dias errado“ ) senão imprima ( dia, “ de setembro de “, ano )
fim_se
10 : imprima ( dia, “ de outubro de “, ano )
11 : se ( dia > 30 ) então imprima ( “mes com dias errado“ ) senão imprima ( dia, “ de novembro de “, ano )
fim_se 12 : imprima ( dia, “ de dezembro de “, ano )
fim_caso
fim_se fim_se fim_sefim
LINGUAGEM C:
#include <stdio.h> int main () { int dia, mes, ano; printf ( “entre com a data de nascimento” );
scanf ( “%d %d %d”, &dia, &mes, &ano );
if (( dia < 1) || ( dia > 31 )) { printf ( “dia errado” );
} else { if (( mes < 1 ) || ( mes > 12 )) { printf ( “mês errado” ); } else { if (( ano < 0 ) || ( ano > 2010 )) { printf ( “verifique o ano “ ); } else {
switch ( mes ) { case 1 : printf ( “%d de janeiro de %d“, dia, ano ); break;
case 2 : if ( dia > 29 ) { printf ( “mes com dias errado“ ); } else { printf (“%d de fevereiro de %d“, dia, ano ); } break;
caso 3 :
printf ( “%d de março de %d“, dia, ano );
break;
caso 4 :
if ( dia > 30 )
{
printf ( “mes com dias errado“ );
} else {
printf ( “%d de abril de %d“, dia, ano );
}
break;
caso 5 :
printf ( “%d de maio de %d“, dia, ano );
break;
caso 6 :
if ( dia > 30 )
{
printf ( “mes com dias errado“ );
} else {
printf ( “%d de junho de %d“, dia, ano );
}
break;
caso 7 : printf ( “%d de julho de %d“, dia, ano );
break;
caso 8 : printf ( “%d de agosto de %d“, dia, ano );
break;
caso 9 : if ( dia > 30 ) { printf ( “mes com dias errado“ ); } else { printf ( “%d de setembro de %d“, dia, ano )
}
break;
caso 10 : printf ( “%d de outubro de %d“, dia, ano ); break;
caso 11 : if ( dia > 30 ) { printf ( “mes com dias errado“ ); } else { printf ( “%d de novembro de %d“, dia, ano );
} break; caso 12 : printf ( “%d de dezembro de %d“, dia, ano ); break; }
} } } }
1) Um vendedor necessita de um algoritmo que calcule o preço total devido por um cliente. O algoritmo deve receber o código de um produto e a quantidade comprada e calcular o preço total, usando a tabela abaixo:
Código do Produto Preço unitário
101 R$ 3,20
102 R$ 2,80
103 R$ 1,50
104 R$ 10,25
105 R$ 2,90
TreinamentoTreinamento
2) Faça um programa que entre com uma opção de 1 a 5 e diga qual o time que a pessoa torce.
a) Barcelona
b) Real Madrid
c) Juventus
d) Milan
e) Porto
TreinamentoTreinamento
131
ExercíciosExercícios
• https://www.urionlinejudge.com.br/judge/en/login
– URI 1035 a 1038, 1040 a 1052, 1061, 1828, 1837, 1847, 1929, 1933, 1960, 2057, 2059, 2235, 2313, 2670, 2717.