decom€¦ · web viewassim como acontece com os operadores aritméticos, os parênteses podem ser...

Universidade Federal de Ouro Preto – UFOPInstituto de Ciências Exatas e Biológicas – ICEB

Departamento de Computação – DECOMResumo: Prof. Álvaro Guarda

2013-2

Capítulo 3 – Expressões de Desvio

3.3 - O tipo de dados lógicoO tipo de dados lógico pode assumir apenas dois valores possíveis: verdadeiro,

e falso. No ambiente do SCILAB, estes valores são apresentados como T e F, respectivamente. Abaixo é apresentada uma tabela que resume o que foi visto.

Valor Constante na linguagem Ambienteverdadeiro %t ou %T T

falso %f ou %F F

Para criar uma variável lógica, simplesmente atribua-lhe um valor lógico em uma declaração de atribuição. Por exemplo, a declaração

a1 = %t;

cria uma variável lógica a1 que contém o valor lógico verdadeiro. Diferentemente de outras linguagens de programação, está correto em SCILAB

misturar dados numéricos e lógicos em expressões. Se um valor lógico for utilizado onde seria esperado um valor numérico, valores T (verdadeiro) serão convertidos para 1 (um) e os valores F (falso) para 0 (zero), e a partir deste ponto eles serão utilizados como números. Se um valor numérico for utilizado onde seria esperado um valor lógico, valores diferentes de zero serão convertidos para T e valores iguais a zero o serão para F, e a partir deste ponto eles serão usados como valores lógicos.

3.3.1 - Operadores relacionaisOperadores relacionais são operadores com dois operandos numéricos ou de

cadeia de caracteres que produzem um resultado do tipo lógico, dependendo da relação entre os dois operandos. A forma geral de operador relacional é

a1 op a2

onde a1 e a2 são expressões aritméticas, variáveis ou cadeia de caracteres, e op é um dos operadores relacionais da Tabela 3.1.

Tabela 3.1 Operadores RelacionaisOperador Significado

== Igual a~= Diferente de> Maior que

>= Maior que ou igual a< Menor que

1



2013-2

<= Menor que ou igual a

Se a relação entre a1 e a2 expressa pelo operador for verdadeira, a operação retorna o valor T; caso contrário, retorna o valor F.

Objetos do tipo cadeia de caracteres podem ser utilizados apenas com os operadores == e ~=.

Algumas operações relacionais e seus resultados são apresentados a seguir.Operação Resultado

3 < 4 T 3 <= 4 T 3 == 4 F 3 > 4 F 4 <= 4 T 'A' < 'B' a expressão é inválida

Operadores relacionais podem ser usados para comparar um valor escalar com

uma matriz. Por exemplo, se a=[ 1 0−21]e b=0, então a expressão a>b produzirá a

matriz lógica [T FFT ]. Operadores relacionais podem também ser usados para comparar

duas matrizes, desde que ambas tenham o mesmo tamanho. Por exemplo, se a=[ 1 0−2 1] e

b=[ 0 2−2 1], então a expressão a≥b produzirá a matriz[T FT T ]. Se as matrizes tiverem

tamanhos diferentes, um erro será produzido.

Erros de ProgramaçãoCuidado para não confundir o operador de equivalência relacional (==) com a

declaração de atribuição (=).

Na hierarquia de operações, operadores relacionais são avaliados depois de

todos os operadores aritméticos. Portanto, as duas expressões seguintes são equivalentes (ambas são verdadeiras):

7 + 3 < 2 + 11(7 + 3) < (2 + 11)

3.3.2 Nota de atenção sobre os operadores == e ~ = Devido a erros de arrendondamento durante cálculos computacionais, dois

números teoricamente iguais podem ser ligeiramente diferentes, levando um teste de igualdade ou de desigualdade a falhar.

2



2013-2

Por exemplo, considere os dois seguintes números; ambos deveriam ser iguais a 0 (zero):

a = 0;b = sin(%pi);

Como esses números são teoricamente o mesmo, a operação relacional a == b deveria produzir T (verdadeiro), mas o SCILAB reporta que a e b são diferentes em decorrência de um erro de arredondamento no cálculo de sin(%pi) a ser 1,225 x 10 -16, em vez de exatamente zero.

Em vez de comparar dois números para ver a igualdade exata, você deve ajustar seus testes para determinar se dois números são aproximadamente iguais, com uma precisão que leve em conta os erros de arredondamento esperados para os números comparados. O teste

abs(a-b) < 1.0E-14produz a resposta correta (verdadeiro), apesar dos erros de arredondamento no cálculo de b.

Boa Prática de ProgramaçãoCuidado ao testar a igualdade de valores numéricos, pois erros de

arrendondamento podem fazer variáveis que deveriam ser iguais falharem no teste de igualdade. Em vez disso, teste para ver se as variáveis são quase iguais dentro de um erro de arrendondamento esperado para o seu computador.

3.3.3 Operadores lógicosOperadores lógicos são operadores com um ou dois operandos lógicos que

produzem um resultado lógico. Existem dois operadores lógicos binários: E (&) e OU (|); e um operador unário: NÃO (~). A forma geral de uma operação lógica binária é

l1 op l2

e a forma geral de uma operação lógica unária é

op l1

onde l1 e l2 são expressões ou variáveis, e op é um dos operadores lógicos mostrados na Tabela 3.2. Se a relação entre l1 e l2 expressa pelo operador for verdadeira, a operação retorna o valor T; caso contrário, a operação retorna o valor F.

Tabela 3.2 Operadores LógicosOperador Significado

& E lógico| OU lógico

3



2013-2

~ NÃO lógico

Os resultados dos operadores estão nas tabelas-verdades apresentadas na Tabela 3.3, que mostram o resultado de cada operação para todas as combinações possíveis de l1 e l2.

O Operador Lógico EO resultado de um operador E é verdadeiro se e somente se os dois operandos

forem verdadeiro. Se um deles for falso, o resultado será falso, conforme apresentado na Tabela 3.3.

Tabela 3.3 Tabelas-Verdade para Operadores LógicosEntradas E OU NÃO

l1 l2 l1 & l2 l1 | l2 ~ l1

falso falso falso falso verdadeirofalso verdadeiro falso verdadeiro verdadeiro

verdadeiro falso falso verdadeiro falsoverdadeiro verdadeiro verdadeiro verdadeiro falso

O Operador Lógico OUO resultado de um operador OU é verdadeiro se um dos operandos for

verdadeiro. Se os dois operandos forem avaliados como falso, o resultado será falso, conforme apresentado na Tabela 3.3.

O Operador Lógico NÃOO operador NÃO é um operador unário, pois tem somente um operando. O

resultado de um operador NÃO será verdadeiro se o seu operando for falso, e falso se o seu operando for verdadeiro, conforme apresentado na Tabela 3.3.

Uso Operadores Lógicos com Operandos Numéricos Operadores lógicos também podem ser utilizados com operandos numéricos.

Porém, antes de efetuar as operações lógicas, os valores diferentes de zero são convertidos para verdadeiro e o zero para falso. Assim, o resultado ~5 é falso é ~0 é verdadeiro.

Os operadores lógicos podem ser usados para comparar um valor escalar com

uma matriz. Por exemplo, se a=[T FFT ] e b=falso, então a expressão a∧b apresentará o

resultado [F FF F].

4



2013-2

Operadores lógicos podem também ser usados para comparar duas matrizes,

desde que ambas tenham o mesmo tamanho. Por exemplo, se se a=[T FFT ] e b=[T TFT ], então a expressão a∨b apresentará o resultado [T TFT ].

Se as matrizes tiverem tamanhos diferentes, um erro será reportado.

Hierarquia das OperaçõesNa hierarquia de operações, os operadores lógicos são avaliados depois de

todas as operações aritméticas e relacionais. A ordem de avaliação dos operadores em uma expressão é dada a seguir.

1. Todos os operadores aritméticos são avaliados primeiro, na ordem descrita anteriormente.

2. Todos os operadores relacionais (==, ~=, >, >=, <, <=) são avaliados, da esquerda para a direita.

3. Todos os operadores ~ são avaliados.4. Todos os operadores & são avaliados, da esquerda para a direita.5. Todos os operadores | são avaliados, da esquerda para a direita.

Assim como acontece com os operadores aritméticos, os parênteses podem ser usados para mudar a ordem-padrão de avaliação. Exemplos de operadores lógicos e seus resultados são dados no Exemplo 3.1.

Exemplo 3.1Considere que as seguintes variáveis foram iniciadas com os valores

mostrados.

valor1 = %tvalor2 = %fvalor3 = 1

valor4 = -10valor5 = 0valor6 = [1 2; 0 1]

As expressões abaixo são avaliadas com segue:

Expressão Resultado Comentário

a. valor1 T

5



2013-2

b. ~valor3 F O número 1 é convertido para T antes de aplicar a operação.

c. valor1 | valor2 T

d. valor1 & valor2 F

e. valor4 & valor5 F -10 é convertido para T e 0 é convertido para F antes de aplicar a operação.

f. ~(valor4 & valor5) T -10 é convertido para T e 0 é convertido para F antes de aplicar a operação. Como a precedência do operador NÃO é maior que o operador E, então os parênteses são necessários.

g. valor1 -9 valor1 é convertido para o número antes de efetuar a soma.

h. valor1 + (~valor4) 1 O valor lógico valor1 é convertido para o número 1 antes de efetuar a soma. O número valor4 é convertido para T antes de usar o operador NÂO. Depois disso, ~valor4 é avaliado como F. Este valor F é, então, convertido para 0 antes de efetuar a soma, e o resultado final é 1 + 0 = 1.

i. valor3 & valor6 [T TFT ] Esta é uma operação E entre um escalar e uma matriz

j. valor2 | valor3 > valor4 + 3 T Primeiro calcula a expressão aritmética valor4 + 3, resultando em -7; depois executa o operador relacional valor3 > -7, retornando T; finalmente conclui, avaliando a expressão lógica valor2 | T.

3.3.4 Funções LógicasAs funções lógicas retornam verdadeiro quando a condição testada for

verdadeira e falso, caso contrário. Essas funções podem ser utilizadas com operadores relacionais e lógicos.

6



2013-2

Tabela 3.4 Algumas Funções Lógicas do SCILABFunção Descrição

isempty(a) Retorna verdadeiro se a for uma matriz vazia, e falso caso contrário.isinf(a) Retorna verdadeiro se o valor de a for infinito, e falso caso contrário.

3.4 Comandos de Desvio (Ramificações)Até este ponto, foi estudado como executar uma sequência de instruções para

se obter um certo resultado. Entretanto, dependendo do problema, pode ser necessário executar um conjunto de instruções apenas em determinadas situações. Para isto utilizamos comandos de desvio de fluxo de execução.

Comandos de desvio permitem selecionar e executar seções específicas de código (denominadas bloco) e saltar outras seções do código.

3.4.1 A construção ifA construção if possui muitas variações e as três formas alternativas mais

comuns são explicadas a seguir. A utilização da partícula “then” é opcional em todas as alternativas.

Alternativa 1if expr_logica then instrução 1. . . instrução n

} Bloco

end

instrução n+1...

Se a expressão lógica expr_logica for verdadeira, então as instruções de 1 a n contidas no Bloco são executadas e o programa continua após o end, executando as demais instruções (instrução n+1, ...), se houverem.

Alternativa 2if expr_logica then instrução 1. . . instrução n

} Bloco 1

else

7



2013-2

instrução 1. . . instrução n

} Bloco 2

end

instrução n+1...

Se a expressão lógica expr_logica for verdadeira, então as instruções de 1 a n contidas no Bloco 1 são executadas e o programa continua após o end, executando as demais instruções (instrução n+1, ...), se houverem. As instruções do Bloco 2 não são executadas.

Caso a expressão lógica expr_logica seja falsa, então as instruções de 1 a n contidas no Bloco 2 é que são executadas e o programa continua após o end, executando as demais instruções (instrução n+1, ...), se houverem. As instruções do Bloco 1 não são executadas.

Alternativa 3if expr_logica_1 then instrução 1. . . instrução n

} Bloco 1

elseif expr_logica_2 instrução 1. . . instrução n

} Bloco 2

. . .

elseif expr_logica_n instrução 1. . . instrução n

} Bloco n

else instrução 1. . . instrução n

} Bloco n+1

end

instrução n+1...

8



2013-2

Se a expressão lógica expr_logica_1 for verdadeira, então as instruções de 1 a n contidas no Bloco 1 são executadas e o programa continua após o end, executando as demais instruções (instrução n+1, ...), se houverem. As instruções dos demais blocos não são executadas.

Caso a expressão lógica expr_logica_2 seja verdadeira, então as instruções de 1 a n contidas no Bloco 2 é que são executadas e o programa continua após o end, executando as demais instruções (instrução n+1, ...), se houverem. As instruções dos demais blocos não são executadas.

O mesmo raciocínio é aplicado em todas as cláusulas elseif, sendo possível colocar quantas sejam necessárias. Resumindo, apenas um bloco é executado, aquele cuja expressão lógica associada é verdadeira ou aquele da cláusula else, Bloco n+1, quando todas as expressões lógicas são falsas.

3.4.2 Exemplos de utilização de construções ifSão analisados dois exemplos de problemas que exigem o uso das

construções de desvio. Primeiro é apresentado um enunciado inicial e depois os passos necessários para desenvolver a solução são descritos.

Exemplo 3.2 – Equação quadrática (de 2º grau)Escreva um programa para resolver as raízes de uma equação quadrática,

independente do tipo.

Solução1. Descreva o problema de forma detalhada

A apresentação do problema para este exemplo é muito simples. Queremos escrever um programa para encontrar as raízes de uma equação quadrática, independentemente de serem raízes reais distintas, reais ou complexas.

As raízes da equação quadrática ax2+bx+c=0 são calculadas com a equação

x=−b±√b2−4ac2a

sendo que o termo b2−4 ac é conhecido como discriminante.Se o discriminante é positivo, então as raízes são reais; se for igual a zero,

então há somente uma raiz real; se for negativo, então há duas raízes complexas.

2. Defina as entradas e saídasAs entradas requeridas para este programa são os coeficientes A, B e C da

equação quadrática ax2+bx+c=0.A saída do programa serão as raízes da equação quadrática,

independentemente de serem raízes reais distintas, reais ou complexas.9



2013-2

A formatação de entrada e saída deve ser bem definida. Abaixo é apresentada uma possível interação quando o programa é executado:

Este programa encontra as raízes de uma equação quadrática

da forma A*X^2 + B*X + C = 0.

Entre o coeficiente A: 1Entre o coeficiente B: 5Entre o coeficiente C: 6

Esta equação tem duas raízes reais:x1 = -2.000000x2 = -3.000000

3. Projete o algoritmoEssa tarefa pode ser quebrada em três seções, cujas funções são entrada,

processamento e saída.

Leia os dados de entradaCalcule as raízesEscreva as raízes

Agora, quebramos as seções acima em partes menores e mais detalhadas. Existem três possíveis maneiras de calcular as raízes, dependendo do valor do discriminante. É razoável, portanto, implementar este algoritmo com uma construção if de três ramificações. O pseudocódigo resultante é

Solicite ao usuário os coeficientes a, b e cLeia a, b e cCalcule o discriminante: b2−4 ac Calcule e escreva as raízes, de acordo com o valor do discriminante:

Se discriminante > 0

x1=−b+√b2−4ac2a

x2=−b−√b2−4 ac2a

Escreva que a equação tem duas raízes reais distintasEscreva as duas raízes

SenãoSe discriminante == 0

x1=−b2a

Escreva que a equação tem duas raízes reais idênticasEscreva a raíz

10



2013-2

Senão

partereal=−b2a

parteimag=√−discriminante

2aEscreva que a equação tem duas raízes complexasEscreva as duas raízes

Fim

4. Transforme o algoritmo em código SCILABCódigo final:

// Script file: calc_roots.sce//// PROPÓSITO:// Este programa encontra as raízes de uma equação quadrática// da forma a*x**2 + b*x + c = 0. A resposta é calculada// independentemente do tipo de raízes que a equação possua.//// VARIÁVEIS:// a -- Coeficiente do termo x^2 da equação// b -- Coeficiente do termo x da equação// c – Termo constante da equação// discriminante – Discriminante da equação// parte_imag -- Parte imaginária da equação (para raízes complexas)// parte_real – Parte real da equação (para raízes complexas)// x1 -- Primeira solução da equação (para raízes reais)// x2 -- Segunda solução da equação (para raízes reais)

// Solicita ao usuário os coeficientes da equaçãoclear;clc;disp ('Este programa encontra as raízes de uma equação quadrática ');disp ('da forma A*X^2 + B*X + C = 0. ');disp('');a = input ('Entre o coeficiente A: ');b = input ('Entre o coeficiente B: ');c = input ('Entre o coeficiente C: ');

// Calcula o discriminantediscriminante = b^2 - 4 * a * c;

// Encontra as raízes, dependendo do valor do discriminanteif discriminante > 0 // existem duas raízes reais x1 = ( -b + sqrt(discriminante) )/( 2 * a ); x2 = ( -b - sqrt(discriminante) )/( 2 * a ); disp ('Esta equação tem duas raízes reais:'); mprintf ('x1 = %f\n', x1); mprintf ('x2 = %f\n', x2);elseif discriminante == 0 // há uma raíz repetida x1 = ( -b )/( 2 * a );

11



2013-2

disp ('Esta equação tem duas raízes reais idênticas:'); mprintf ('x1 = x2 = %f\n', x1);else // raízes complexas parte_real = ( -b )/( 2 * a ); parte_imag = sqrt ( abs ( discriminante ) )/( 2 * a ); disp ('Esta equação tem raízes complexas:'); mprintf('x1 = %f +i %f\n', parte_real, parte_imag ); mprintf('x1 = %f -i %f\n', parte_real, parte_imag );end

5. Teste o programaA seguir vamos testar o programa utilizando dados reais. Como existem três

possíveis situações no programa, precisamos testar todos os três caminhos antes de termos certeza de que o programa está funcionando apropriadamente. A partir da equação quadrática, ax2+bx+c=0, podemos verificar que as soluções das equações abaixo estão corretas.

x2+5 x+6=0 x=−2e x=−3x2+4 x+4=0x=−2x2+2 x+5=0x=−1± i2

Abaixo são apresentados os resultados obtidos com a execução do programa três vezes, uma para cada situação. O que é digitado pelo usuário aparece em negrito.

-->exec('calc_raizes.sce',0)




Esta equação tem duas raízes reais:x1 = -2.000000x2 = -3.000000




Entre o coeficiente A: 1Entre o coeficiente B: 4

12



2013-2

Entre o coeficiente C: 4

Esta equação tem duas raízes reais idênticas:x1 = x2 = -2.000000





Esta equação tem raízes complexas:x1 = -1.000000 +i 2.000000x1 = -1.000000 -i 2.000000

O programa forneceu as respostas corretas para os nossos dados de teste, portanto podemos concluir que o mesmo está correto.

Exemplo 3.3 – Avaliando uma função de duas variáveisEscreva um programa para avaliar uma função f(x, y) para quaisquer valores x

e y especificados pelo usuário. A função f(x, y) é definida a seguir:

f (x , y )={ x+ y ,∧x ≥0e y≥0x+ y2 ,∧x ≥0e y<0x2+ y ,∧x<0e y≥0x2+ y2 ,∧x<0e y<0

1. Estabeleça o problemaA apresentação do problema deste exemplo é muito simples: avalie a função

f(x, y) para quaisquer valores x e y fornecidos pelo usuário.

2. Defina as entradas e saídasAs entradas requeridas pelo programa são os valores das variáveis

independentes x e y. A saída do programa será o valor da função f(x, y).A formatação de entrada e saída deve ser bem definida. Abaixo é apresentada

uma possível interação quando o programa é executado:Entre o coeficiente x: 2Entre o coeficiente y: 3

13



2013-2

O valor da função é 5

3. Projete o algoritmoEssa tarefa pode ser quebrada em três seções, cujas funções são entrada,

processamento e saída.

Leia os valores de entrada x e yCalcule f(x, y)Escreva o resultado de f(x, y)

A seguir, dividimos as seções acima em partes menores e mais detalhadas, de acordo com a especificação de f(x, y).

Solicite ao usuário os valores de x e yLeia x e yCalcule f(x, y) de acordo com os valores de x e y

Se x >= 0 e y >= 0f = x + y

SenãoSe x >= 0 e y < 0f = x + y^2

SenãoSe x < 0 e y >= 0f = x^2 + y

Senãof = x^2 + y^2

FimEscreva o resultado de f(x, y)

4. Transforme o algoritmo em código SCILABCódigo final:

// Arquivo com o programa: funxy.sce//// Propósito:// Este programa soluciona a função f(x,y) para// x e y informados pelo usuário, onde f(x,y) é definido como://// f(x,y) = x + y se x >= 0 e y >= 0// f(x,y) = x + y^2 se x >= 0 e y < 0// f(x,y) = x^2 + y se x < 0 e y >= 0// f(x,y) = x^2 + y^2 se x < 0 e y < 0////// Definição das variáveis:// x – Primeira variável independente// y -- Segunda variável independente

14



2013-2

// f – Resultado da função

// Solicita ao usuário os valores x e yx = input ('Entre o coeficiente x: ');y = input ('Entre o coeficiente y: ');

// Calcula a função f (x,y) baseado nos sinais de x e y.if x >= 0 & y >= 0 f = x + y;elseif x >= 0 & y < 0 f = x + y^2;elseif x < 0 & y >= 0 f = x^2 + y;else // x < 0 e y < 0 f = x^2 + y^2;end

// Escreve o valor da função.disp ('O valor da função é ' + string(f));

5. Teste o programaAgora vamos testar o programa utilizando dados reais. Como existem

caminhos possíveis situações no programa, precisamos testar todos os quatro antes de termos certeza de que o programa está funcionando apropriadamente. Abaixo estão os cálculos para quatro conjuntos de valores, um para cada caminho:

f(2, 3) = 2 + 3 = 5f(2, -3) = 2 + (-3)2 = 11f(-2, 3) = (-2)2 + 3 = 7f(-2, -3) = (-2)2 + (-3)2 = 13

Abaixo são apresentados os resultados obtidos com a execução do programa

quatro vezes, uma para cada possibilidade. O que é digitado pelo usuário aparece em negrito.

-->exec('função.sce',0)

Entre o coeficiente x: 2Entre o coeficiente y: 3



Entre o coeficiente x: 2Entre o coeficiente y: -3

15



2013-2



Entre o coeficiente x: -2Entre o coeficiente y: 3



Entre o coeficiente x: -2Entre o coeficiente y: -3


O programa forneceu as respostas corretas para os nossos dados de teste, portanto podemos concluir que o mesmo está correto.

3.4.3 Notas sobre a utilização de construções ifA construção if é muito flexível. Ela exige uma declaração if e uma end. No

meio, pode ter qualquer número de elseif, e apenas uma cláusula else. Com esta combinação de características, é possível implementar qualquer construção desejada de desvios.

Adicionalmente, construções if podem ser aninhadas. Duas construções if são aninhadas se uma delas se posiciona inteiramente dentro de um único bloco de código da outra. As duas construções if a seguir estão aninhadas.

if x > 0 . . . if y < 0 . . . end . . .end

O interpretador do SCILAB sempre associa uma dada declaração end com a declaração if mais recente, assim, o primeiro end indica o fim do bloco da declaração if y < 0; enquanto que o segundo end indica o fim do bloco da declaração if x < 0. Isto funciona

16



2013-2

bem para um programa escrito corretamente, mas pode levar o interpretador a produzir mensagens de erro confusas se o programador elaborar um código errôneo. Por exemplo, suponha que tenhamos um programa de grande porte com uma construção deste tipo:

. . .if expr_logica_1 . . . if expr_logica_2 . . . if expr_logica_1 . . . end . . . end . . .end

Esse programa contem três construções if aninhadas e se acidentalmente uma declaração end for removida ou esquecida, o interpretador vai relatar um erro, informando que falta um end. Em um programa maior e mais complexo é difícil determinar onde está o erro.

Existem situações em que pode ser mais interessante utilizar estruturas aninhadas, mas sempre onde for possível, é melhor utilizar estruturas com cláusulas elseif.

Exemplo 3.4 – Distribuição de notas usando letrasEscreva um programa para ler a nota de um aluno, no formato numérico, e

associar à mesma uma letra, informando o usuário, conforme a definição abaixo.

Nota Letra nota > 9,0 A

9,0 ≥ nota > 7,5 B7,5 ≥ nota > 6,0 C6,0 ≥ nota > 3,0 D3,0 ≥ nota > 0,0 E

Solução utilizando-se cláusulas elseif:

nota=input("Entre com a nota: ");if nota > 9 then disp("A nota é A");elseif nota > 7.5 disp("A nota é B");

17



2013-2

elseif nota > 6 disp("A nota é C");elseif nota > 3 disp("A nota é D");else disp("A nota é E");end

Solução utilizando-se estruturas aninhadas:

nota=input("Entre com a nota: ");

if nota > 9 then disp("A nota é A");else if nota > 7.5 disp("A nota é B"); else if nota > 6 disp("A nota é C"); else if nota > 3 disp("A nota é D"); else disp("A nota é E"); end end endend

No exemplo acima fica claro que pode ser mais simples utilizar uma única construção if com múltiplas cláusulas elseif.

Boa Prática de ProgramaçãoPara ramificações com muitas opções mutuamente exclusivas, utilize uma

única construção if com múltiplas cláusulas elseif, em vez de construções if aninhadas.

18

decom€¦ · web viewassim como acontece com os operadores aritméticos, os parênteses podem ser...

Documents