aula_05

Prévia do material em texto

CCF 110
ALGORITMO E ESTRUTURA ALGORITMO E ESTRUTURA 
DE DADOS IDE DADOS I
Universidade Federal de Itajubá
Prof. Roberto Affonso da Costa Junior
AULA 05 – 1/2AULA 05 – 1/2
– Estrutura Condicionais
– Linguagem de Programação C
Operadores LógicosOperadores Lógicos
● Utilizados na confecção das condições
● São eles: Portugol Linguagem 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
– E e &&
– OU ou ||
– não não !
5
Estruturas de ControleEstruturas de Controle
Condicional ou de seleçãoCondicional ou de seleção
Seleções Simples:
A seleção simples é dada por if (<condição>) {...} 
onde se a <condição> for verdadeira é realizado o 
que está dentro das chaves, se for falsa, não é 
realizado nada.
6
Estruturas de ControleEstruturas de Controle
Condicional 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 ) {
 procedimento;
}
8
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”.
{declaração de variáveis}
real N
inicio
 {comandos de entrada de dados}
 leia (N)
 {processo e saída de dados}
 se N > 10
 então
 imprima (N,” maior que 10)
 fim-se
fim
INICIO
N
N, “ Maior que 10”
FIM
N > 10
F
V
9
LINGUAGEM CLINGUAGEM C
#include <stdio.h>
int main()
{
 float N;
 {comandos de entrada de dados}
 scanf (“%f”,&N)
 {processo e saída de dados}
 if (N > 10)
 {
 printf (“%.1f maior que 10”,N);
 }
}
10
Estruturas de ControleEstruturas de Controle
Condicional ou de seleçãoCondicional ou de seleção
Seleções Completa:
A seleção completa é dada por if (<condição>) 
{blocos de comandos 1} else {blocos de comandos 
2} 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.
11
Estruturas de ControleEstruturas de Controle
Condicional ou de seleçãoCondicional ou de seleção
Portugol:
se <condição> 
então 
 bloco de comandos 1
senão
 bloco de comandos 2
fim-se
Fluxograma:
<condições>
F
V
Bloco de comandos 1
Bloco de comandos 2
12
Linguagem CLinguagem C
if ( condição )
{ 
 bloco de comandos 1;
} else {
 bloco de comandos 2;
}
13
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.
{declaração de variáveis}
inteiro N
inicio
 leia (N)
 se mod (N,2) = 0
 então
 imprima (N, “ é par”)
 senão
 imprima (N,” é impar)
 fim-se
fim
INICIO
FIM
N
N, “ é par”
mod (N, 2) = 0
F
V
N, “ é impar”
14
LINGUAGEM CLINGUAGEM C
#include <stdio.h>
int main()
{
 int N;
 scanf (“%d”,&N);
 if ((N % 2) == 0)
 {
 printf (“%d é par.”, N);
 } else {
 printf ( “%d é impar.”,N);
 }
}
15
Estruturas de ControleEstruturas de Controle
Condicional 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.
16
Estruturas de ControleEstruturas de Controle
Condicional 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 2
fim-se
17
<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
18
Estruturas de ControleEstruturas de Controle
Condicional 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;
}
19
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, C
inicio
 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-se
fim
20
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”);
 }
}
21
Estruturas de ControleEstruturas de Controle
Condicional 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
22
<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
23
Estruturas de ControleEstruturas de Controle
Condicional 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)
}
24
Estruturas de ControleEstruturas de Controle
Condicional ou de seleçãoCondicional ou de seleção
OBSERVAÇÃO:
As seleções Múltiplas não aceitam variáveis 
CADEIA (STRING).
Exemplo 4Exemplo 4
● Calcular a seguinte expressão:
 
VL= 5A+B
(A−B)+ 2A
B+3A
Portugol
objetivo: Calcular uma expressão aritmética
 inteiros A, B, num1, num2, den1, den2, VL
 inicio
 imprima ( “entre com dois valores “ )
 leia ( A, B )
 num1 ← 5 A + B
 num2 ← 2 A
 den 1 ← B + 3A
 se ( den1 = 0 )
 então 
 imprima ( “expressão não calculada “ )
 imprima ( “denominador nulo” )
 senão 
 den2 ← ( A – B ) + num2 / den1
 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
 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
objetivo: calcular o conceito de um aluno frente ao gabarito 
 de uma prova
 caracter gab1, gab2, gab3, gab4, gab5
 caracter resp1, resp2, resp3, resp4, resp5
 caracter conceito
 inteiro n_questoes
 inicio
 imprima ( “entre com as 5 alternativas do gabarito” ) 
 leia ( gab1, gab2, gab3, gab4, gab5 )
 imprima ( “entre com as 5 resposta do aluno” ) 
 leia ( resp1, resp2, resp3, resp4, resp5 )
 n_questoes ← 0
 se ( gab1 = resp1 ) 
 então
 n_questoes ← n_questoes + 1
 fim_se
 se ( 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
 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
 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 )
 imprima ( “quantidade de questoes certas = “ , n_questoes )
 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 7Exemplo 7
 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 dias
Sugestão:
os valores DD, MM e AAAA devem ser fornecidos pelo 
usuário e armazenados cada um numa variável;
 PORTUGOL:
 inteiros dia, mês, ano
 inicio
 imprima ( “entre com a data de nascimento” )
leia ( dia, mes, ano )
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
 
 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_se
 fim
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 );
 }
 }
 }}
 }
 }
 }
 }
 }
 }
 }
 }
 }
 }
 }
 }
Em casa construa as duas outras versão na Em casa construa as duas outras versão na 
linguagem C.linguagem C.
Exemplo 8Exemplo 8
● 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.
 COMO FICA ESSE EXEMPLO EM 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
 
TreinamentoTreinamento
5) 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
	Slide 1
	Slide 2
	Slide 3
	Slide 4
	Slide 5
	Slide 6
	Slide 7
	Slide 8
	Slide 9
	Slide 10
	Slide 11
	Slide 12
	Slide 13
	Slide 14
	Slide 15
	Slide 16
	Slide 17
	Slide 18
	Slide 19
	Slide 20
	Slide 21
	Slide 22
	Slide 23
	Slide 24
	Slide 25
	Slide 26
	Slide 27
	Slide 28
	Slide 29
	Slide 30
	Slide 31
	Slide 32
	Slide 33
	Slide 34
	Slide 35
	Slide 36
	Slide 37
	Slide 38
	Slide 39
	Slide 40
	Slide 41
	Slide 42
	Slide 43
	Slide 44
	Slide 45
	Slide 46
	Slide 47
	Slide 48
	Slide 49
	Slide 50
	Slide 51
	Slide 52
	Slide 53
	Slide 54
	Slide 55
	Slide 56
	Slide 57
	Slide 58
	Slide 59
	Slide 60
	Slide 61
	Slide 62
	Slide 63
	Slide 64