📋

Unidade 3 Estruturas
condicionais

O que são estruturas condicionais? 🤔

Estruturas condicionais são blocos de código que permitem que o programa execute
diferentes ações dependendo de uma ou mais condições. Uma condição é uma
expressão lógica que pode ser verdadeira ou falsa, e geralmente envolve uma
comparação entre valores ou variáveis.
As estruturas condicionais podem ser simples, compostas ou de caso. Vamos ver
cada uma delas com mais detalhes.

✅ Operadores lógicos: São símbolos que representam operações lógicas

entre valores booleanos (verdadeiro ou falso). Os operadores lógicos mais
comuns são E, OU e NÃO. Eles são usados para criar condições
compostas que podem ser verdadeiras ou falsas dependendo dos valores
dos operandos.

Unidade 3 Estruturas condicionais 1

 ✅ Estruturas de decisão: São blocos de código que permitem executar
diferentes comandos dependendo do resultado de uma condição. As
estruturas de decisão mais comuns são SE, SENAO e ESCOLHA. Elas
são usadas para controlar o fluxo do programa e tomar decisões
baseadas em dados.

✅ Exemplos de algoritmos: São sequências de passos lógicos que

resolvem um problema específico. Os exemplos de algoritmos mostram
como usar os operadores lógicos e as estruturas de decisão em diferentes
linguagens de programação, como VisualG, Pascal e JavaScript. Eles
também mostram como identificar e corrigir erros lógicos no código.

Estrutura condicional simples 🌞

A estrutura condicional simples é aquela que tem apenas um bloco de código
associado a uma condição. Esse bloco só será executado se a condição for
verdadeira. Caso contrário, o programa segue para o próximo comando.

A estrutura condicional simples pode ser representada por um fluxograma ou por um

pseudocódigo, que são formas de descrever algoritmos de maneira visual ou
textual. Veja o exemplo abaixo:

Quadro 1
Estrutura condicional simples em fluxograma e em pseudocódigo fluxograma
pseudocódigo se (condição) então comando fimse
Nesse exemplo, o programa verifica se a condição é verdadeira. Se for, ele executa
o comando dentro do bloco. Se não for, ele ignora o bloco e segue adiante.
Por exemplo, suponha que temos uma variável chamada idade que armazena a
idade de uma pessoa. Queremos mostrar uma mensagem na tela se a pessoa for
maior de idade (ou seja, se idade >= 18 ). Podemos usar uma estrutura condicional
simples para isso:

graph LR
Start(Start)
Decision{idade >= 18}
Command1[Você é maior de idade]

Start --> Decision

Unidade 3 Estruturas condicionais 2

 Decision -->|Verdadeiro| Command1
Command1 --> End

algoritmo "exemplo intro"

var
idade: inteiro
inicio
idade <- 20
se idade >= 18 entao
escreva("Você é maior de idade")
fimse
fimalgoritmo

Nesse caso, a condição é idade >= 18 , que significa “idade maior ou igual a 18”. O
comando é Escreva("Você é maior de idade") , que significa “mostre na tela a frase
Você é maior de idade”. Como a variável idade tem o valor 20, que é maior ou igual
a 18, a condição é verdadeira e o comando é executado. Portanto, o resultado
desse algoritmo é:

Estrutura condicional composta 🌞🌙

A estrutura condicional composta é aquela que tem dois blocos de código
associados a uma condição: um para o caso da condição ser verdadeira e outro
para o caso da condição ser falsa. Assim, o programa pode executar uma ação ou
outra dependendo do resultado da condição.

A estrutura condicional composta também pode ser representada por um fluxograma

ou por um pseudocódigo. Veja o exemplo abaixo:
Quadro 2

- Estrutura condicional composta em fluxograma e em pseudocódigo fluxograma

pseudocódigo se (condição) então comando1 senao comando2 fimse

Nesse exemplo, o programa verifica se a condição é verdadeira. Se for, ele executa

o comando1 dentro do primeiro bloco. Se não for, ele executa o comando2 dentro
do segundo bloco.

Unidade 3 Estruturas condicionais 3

 Por exemplo, suponha que temos uma variável chamada nota que armazena a nota
final de um aluno. Queremos mostrar uma mensagem na tela se o aluno foi
aprovado ou reprovado, considerando que a nota mínima para aprovação é 6.
Podemos usar uma estrutura condicional composta para isso:

graph LR
Start(Inicio)
Decision{nota >= 6}
Command1[Você foi aprovado]
Command2[Você foi reprovado]

Start --> Decision

Decision -->|Verdadeiro| Command1
Command1 --> End
Decision -->|Falso| Command2
Command2 --> End

Algoritmo "exemplo intro 1"

Var
nota: real
Inicio
nota <- 7
Se nota >= 6 entao
Escreva("Você foi aprovado")
Senao
Escreva("Você foi reprovado")
FimSe
FimAlgoritmo

Nesse caso, a condição é nota >= 6 , que significa “nota maior ou igual a 6”. O
comando1 é Escreva("Você foi aprovado") , que significa “mostre na tela a frase Você

foi aprovado”. O comando2 é Escreva("Você foi reprovado") , que significa “mostre na

tela a frase Você foi reprovado”. Como a variável nota tem o valor 7.5, que é maior
ou igual a 6, a condição é verdadeira e o comando1 é executado. Portanto, o
resultado desse algoritmo é:
Você foi aprovado

Unidade 3 Estruturas condicionais 4

 Estrutura de caso 🌈
A estrutura de caso é aquela que tem vários blocos de código associados a uma
variável de verificação. Cada bloco corresponde a um valor possível da variável.
Assim, o programa pode executar um bloco ou outro dependendo do valor da
variável.

A estrutura de caso também pode ser representada por um fluxograma ou por um

pseudocódigo. Veja o exemplo abaixo:

Quadro 3 - Estrutura de caso em fluxograma e em

pseudocódigo fluxograma pseudocódigo <instruções> Valor 1
Valor 2 Valor 3 Valor 4 <instruções> <instruções> <instruções>
<variável de verificação> ESCOLHA variavel CASO valor1
comando1 CASO valor2 comando2 CASO valor3 comando3
CASO valorN comandoN FIMESCOLHA

graph TB
Start(Start)
Decision{ESCOLHA variavel}
Case1[Valor 1]
Command1[Comando 1]
Case2[Valor 2]
Command2[Comando 2]
Case3[Valor 3]
Command3[Comando 3]
CaseN[Valor N]
CommandN[Comando N]
End(FIMESCOLHA)

Start --> Decision

Decision -->|Caso valor1| Case1
Case1 --> Command1
Command1 --> End
Decision -->|Caso valor2| Case2
Case2 --> Command2
Command2 --> End
Decision -->|Caso valor3| Case3
Case3 --> Command3
Command3 --> End
Decision -->|Caso valorN| CaseN
CaseN --> CommandN
CommandN --> End

Unidade 3 Estruturas condicionais 5

 Nesse exemplo, o programa verifica o valor da variável de
verificação. Se for igual ao valor1, ele executa o comando1
dentro do primeiro bloco. Se for igual ao valor2, ele executa o
comando2 dentro do segundo bloco. E assim por diante, até o
valorN.

Por exemplo, suponha que temos uma variável

chamada operacao que armazena um código
numérico que representa uma operação matemática
entre dois números: 1 para soma, 2 para subtração, 3
para multiplicação e 4 para divisão. Queremos
mostrar na tela o resultado da operação escolhida
pelo usuário. Podemos usar uma estrutura de caso
para isso:

graph TB
Start(Start)
Input1[Digite o primeiro número]
Input2[Digite o segundo número]
Input3[Digite o código da operação]

Unidade 3 Estruturas condicionais 6

 Decision{ESCOLHA operacao}
Case1[1 - Soma]
Command1[O resultado da soma é]
Case2[2 - Subtração]
Command2[O resultado da subtração é]
Case3[3 - Multiplicação]
Command3[O resultado da multiplicação é]
Case4[4 - Divisão]
Decision2{num2 <> 0}
Command4[O resultado da divisão é]
Error1[Erro: divisão por zero não é permitida]
CaseN[Caso Contrario]
CommandN[Operação inválida]

Start --> Input1

Input1 --> Input2
Input2 --> Input3
Input3 --> Decision
Decision -->|Caso 1| Case1
Case1 --> Command1
Command1 --> End
Decision -->|Caso 2| Case2
Case2 --> Command2
Command2 --> End
Decision -->|Caso 3| Case3
Case3 --> Command3
Command3 --> End
Decision -->|Caso 4| Case4
Case4 --> Decision2
Decision2 -->|Verdadeiro| Command4
Command4 --> End
Decision2 -->|Falso| Error1
Error1 --> End
Decision -->|Caso Contrario| CaseN
CaseN --> CommandN
CommandN --> End

Unidade 3 Estruturas condicionais 7

 Visual G

algoritmo "exemplo1"
Var
operacao, num1, num2, resultado: real
Inicio
Escreva ("Digite o primeiro número")
Leia (num1)
Escreva ("Digite o segundo número")
Leia (num2)
Escreva ("Digite o código da operação (1 para soma, 2 para subtração, 3 para multipl
icação, 4 para divisão)")
Leia (operacao)

Escolha operacao
Caso "1"
resultado <- num1 + num2
Escreva ("O resultado da soma é ", resultado)
Caso "2"
resultado <- num1 - num2
Escreva ("O resultado da subtração é ", resultado)
Caso "3"
resultado <- num1 * num2
Escreva ("O resultado da multiplicação é ", resultado)
Caso "4"
Se num2 <> 0 entao
resultado <- num1 / num2
Escreva ("O resultado da divisão é ", resultado)

Unidade 3 Estruturas condicionais 8

 Senao
Escreva ("Erro: divisão por zero não é permitida")
FimSe
Caso Contrario
Escreva ("Operação inválida")
FimEscolha
FimAlgoritmo

Este código solicita ao usuário dois números e um código de operação. Em seguida,

ele realiza a operação correspondente ao código e exibe o resultado. Se o usuário
digitar um código inválido, o programa exibirá uma mensagem de erro. Além disso,
se o usuário tentar dividir por zero, o programa também exibirá uma mensagem de
erro. 🧮👍
Neste texto, você vai aprender sobre:
Espero que isso ajude! Se você tiver mais perguntas, fique à vontade para
perguntar. 😊
Exemplo 1: Calcular a média aritmética entre duas
notas e mostrar mensagem de Aprovado ou
Reprovado
O algoritmo que você forneceu calcula a média aritmética de três notas e exibe uma
mensagem com base no valor da média. No entanto, há um erro lógico no código. O
problema está na ordem das condições if .
O código primeiro verifica se a média é menor que 3 e, em seguida, verifica se a
média é maior ou igual a 7. No entanto, se a média estiver entre 3 e 7, nenhuma
dessas condições será verdadeira e o código irá para a condição else , exibindo
“Exame”. Isso significa que o código irá exibir “Exame” para médias entre 3 e 7, mas
também para médias menores que 3, o que não é o comportamento esperado.

A solução para esse problema é reorganizar as condições if para que elas

verifiquem primeiro se a média é maior ou igual a 7, depois se é menor que 3 e,
finalmente, se está entre 3 e 7.

Aqui está o código corrigido em JavaScript:

graph LR
Start(Start)
Input1[Digite o primeiro número]
Input2[Digite o segundo número]
Input3[Digite o código da operação]
Decision{ESCOLHA operacao}

Unidade 3 Estruturas condicionais 9

 Case1[1 - Soma]
Command1[O resultado da soma é]
Case2[2 - Subtração]
Command2[O resultado da subtração é]
Case3[3 - Multiplicação]
Command3[O resultado da multiplicação é]
Case4[4 - Divisão]
Decision2{num2 <> 0}
Command4[O resultado da divisão é]
Error1[Erro: divisão por zero não é permitida]
CaseN[Caso Contrario]
CommandN[Operação inválida]

Start --> Input1

Input1 --> Input2
Input2 --> Input3
Input3 --> Decision
Decision -->|Caso 1| Case1
Case1 --> Command1
Command1 --> End
Decision -->|Caso 2| Case2
Case2 --> Command2
Command2 --> End
Decision -->|Caso 3| Case3
Case3 --> Command3
Command3 --> End
Decision -->|Caso 4| Case4
Case4 --> Decision2
Decision2 -->|Verdadeiro| Command4
Command4 --> End
Decision2 -->|Falso| Error1
Error1 --> End
Decision -->|Caso Contrario| CaseN
CaseN --> CommandN
CommandN --> End

Visual G

algoritmo "exemplo1"
Var

Unidade 3 Estruturas condicionais 10

 operacao, num1, num2, resultado: real
Inicio
escreva ("Digite o primeiro número")
leia (num1)
escreva ("Digite o segundo número")
leia (num2)
escreva ("Digite o código da operação (1 para soma, 2 para subtração, 3 para multipl
icação, 4 para divisão)")
leia (operacao)

Escolha operacao
Caso"1"
resultado <- num1 + num2
escreva ("O resultado da soma é ", resultado)
Caso"2"
resultado <- num1 - num2
escreva ("O resultado da subtração é ", resultado)
Caso"3"
resultado <- num1 * num2
escreva ("O resultado da multiplicação é ", resultado)
Caso"4"
Se num2 <> 0 entao
resultado <- num1 / num2
escreva ("O resultado da divisão é ", resultado)
Senao
escreva ("Erro: divisão por zero não é permitida")
FimSe
Caso "Contrario"
escreva ("Operação inválida")
FimEscolha
FimAlgoritmo

java script

console.log("Digite três notas");

let n1 = parseFloat(prompt("Digite a primeira nota"));
let n2 = parseFloat(prompt("Digite a segunda nota"));
let n3 = parseFloat(prompt("Digite a terceira nota"));
let m = (n1 + n2 + n3) / 3;[^1^][1]
console.log("Média = " + m);
if (m >= 7) {
console.log("Aprovado");
} else if (m < 3) {
console.log("Reprovado");
} else {
console.log("Exame");
}

Unidade 3 Estruturas condicionais 11

 Exemplo 1: Calcular a média aritmética entre duas
notas e mostrar mensagem de Aprovado ou
Reprovado

graph LR
Start(Início)
Input1[Digite duas notas]
Decision{m >= 7}
Command1[Aprovado]
Command2[Reprovado]

Start --> Input1

Input1 --> Decision
Decision -->|Verdadeiro| Command1
Command1 --> End
Decision -->|Falso| Command2
Command2 --> End

Visual G

algoritmo "exemplo1"

var m, n1, n2: real

inicio
escreval("Digite duas notas")
leia(n1,n2)
m <- (n1+n2)/2
se m >= 7 entao
escreval("Aprovado")
senao
escreval("Reprovado")
fimse
fimalgoritmo

Unidade 3 Estruturas condicionais 12

 Exemplo 2: Receber três notas de um aluno, calcular
a média aritmética e mostrar mensagem conforme
tabela

graph LR
Start(Início)
Input1[Digite três notas]
Decision1{m >= 0 e m < 3}
Command1[Reprovado]
Decision2{m >= 3 e m < 7}
Command2[Exame]
Command3[Nota a ser tirada no exame]
Decision3{m >= 7}
Command4[Aprovado]

Start --> Input1

Input1 --> Decision1
Decision1 -->|Verdadeiro| Command1
Command1 --> End
Decision1 -->|Falso| Decision2
Decision2 -->|Verdadeiro| Command2
Command2 --> Command3
Command3 --> End
Decision2 -->|Falso| Decision3
Decision3 -->|Verdadeiro| Command4
Command4 --> End

algoritmo "exemplo2"

var m, n1, n2, n3, nf: real

inicio
escreval("Digite três notas")
leia(n1,n2,n3)
m <- (n1+n2+n3)/3
escreval("Média = ",m)
se (m >= 0) e (m < 3) entao
escreval("Reprovado")
fimse
se (m >= 3) e (m < 7) entao

Unidade 3 Estruturas condicionais 13

 escreval("Exame")
nf <- 10 - m
escreval("Nota a ser tirada no exame = ",nf)
fimse
se (m >= 7) entao
escreval("Aprovado")
fimse
fimalgoritmo

Exemplo 3: Receber dois números e mostrar o maior

graph LR
Start(Start)
Input1[Digite o primeiro número]
Input2[Digite o segundo número]
Decision1{num1 > num2}
Command1[O número num1 é o maior]
Decision2{num1 < num2}
Command2[O número num2 é o maior]
Command3[Números iguais]

Start --> Input1

Input1 --> Input2
Input2 --> Decision1
Decision1 -->|Verdadeiro| Command1
Command1 --> End
Decision1 -->|Falso| Decision2
Decision2 -->|Verdadeiro| Command2
Command2 --> End
Decision2 -->|Falso| Command3
Command3 --> End

Visual G

algoritmo "exemplo3"
// Função: receber dois números e mostrar o maior
// Autor: Ana Fernanda
// Data: 24/12/2018
// seção de declarações de variáveis e constantes
var num1, num2: real

Unidade 3 Estruturas condicionais 14

 inicio
escreval("Digite o primeiro número:")
leia(num1)
escreval("Digite o segundo número:")
leia(num2)
se (num1 > num2) entao
escreval("O número ",num1," é o maior")
senao
se (num1 < num2) entao
escreval("O número ",num2," é o maior")
senao
escreval("Números iguais")
fimse
fimse
fimalgoritmo

Exemplo 4: Receber os três lados de um triângulo e

classificar

graph LR
Start(Start)
Input1[Digite o primeiro lado]
Input2[Digite o segundo lado]
Input3[Digite o terceiro lado]
Decision1{x = y e y = z}
Command1[Triângulo Equilátero]
Decision2{x <> y e x <> z e y <> z}
Command2[Triângulo Escaleno]
Command3[Triângulo Isósceles]

Start --> Input1

Input1 --> Input2
Input2 --> Input3
Input3 --> Decision1
Decision1 -->|Verdadeiro| Command1
Command1 --> End
Decision1 -->|Falso| Decision2
Decision2 -->|Verdadeiro| Command2
Command2 --> End
Decision2 -->|Falso| Command3
Command3 --> End

Unidade 3 Estruturas condicionais 15

 Visual G

algoritmo "exemplo4"
// Função: receber os três lados de um triângulo e classificar
// Autor: Ana Fernanda
// Data: 24/12/2018
// seção de declarações de variáveis e constantes
var x, y, z: real
inicio
escreva("Digite o primeiro lado: ")
leia(x)
escreva("Digite o segundo lado: ")
leia(y)
escreva("Digite o terceiro lado: ")
leia(z)
se (x = y) e (y = z) entao
escreval("Triângulo Equilátero")
senao
se (x <> y) e (x <> z) e (y <> z) entao
escreval("Triângulo Escaleno")
senao
escreval("Triângulo Isósceles")
fimse
fimse
fimalgoritmo

Unidade 3 Estruturas condicionais 16