log prog - regular - aula 01

CURSO ON-LINE DE LÓGICA DE PROGRAMAÇÃO / PROGRAMAÇÃO ORIENTADA A OBJETOS / TESTES (TEORIA E EXERCÍCIOS) PARA O CARGO 25: ANALISTA DE

INFORMÁTICA/DESENVOLVIMENTO DE SISTEMAS – MPU/2010. PROFESSOR: LÊNIN CARNEIRO

1 www.pontodosconcursos.com.br

Olá, colegas,

Bm-vindos à primeira aula do curso de Lógica de Programação /

Programação Orientada a Objetos / Testes (teoria e exercícios) para o

Cargo 25 – MPU/2010.

O curso aborda os itens VII, XIII e XV (parte específica) do concurso

MPU/2010, cargo 25: ANALISTA DE INFORMÁTICA/DESENVOLVIMENTO DE

SISTEMAS. É um curso em TEORIA E EXERCÍCIOS, dividido em 4 aulas

semanais. Na aula de hoje trabalharemos os seguintes itens:

LÓGICA DE PROGRAMAÇÃO: Construção de algoritmos; tipos de dados

simples; variáveis e constantes; comandos de atribuição, entrada e

saída; avaliação de expressões; funções pré-definidas; conceito de

bloco de comandos; estruturas de controle, seleção, repetição e desvio;

operadores e expressões; conceitos básicos de programação

estruturada;

ALGORITMOS

Segundo o dicionário Aurélio, lógica é a “coerência de raciocínio, de

idéias”, ou ainda a “sequência coerente, regular e necessária de

acontecimentos, de coisas”. Ainda segundo Aurélio, algoritmos é

“processo de cálculo, ou de resolução de um grupo de problemas

semelhantes, em que se estipula, com generalidade e sem restrições,

regras formais para a obtenção do resultado ou da solução do

problema”.

Segundo o prisma da computação, Um algoritmo é uma sequência

finita de passos (ou instruções), descritos em uma ordem lógica, que




visam atingir um objetivo bem definido. As instruções devem ser bem

definidas e não ambíguas, bem como o tempo e o esforço para

executar as instruções devem ser finitos. Muitas vezes pensamos em

algoritmos como programas de computador, mas não são. Algoritmos

são sequências de instruções para realizar uma tarefa, não

necessariamente a serem implementadas em uma linguagem de

programação.

De outro lado, um programa de computador, segundo Wirth, “é um

formulação concreta de algoritmos abstratos, baseados em

representações e estruturas específicas de dados”. Isto é um programa

é o resultado de algoritmos + estrutura de dados.

A Lógica de programação pode ser definida como o estudo das leis do

raciocínio e do modo de aplicá-las corretamente na demonstração da

verdade. Chamamos de algoritmo lógico aquele algoritmo cujas

instruções estão dispostas ordenadamente e de maneira compreensível

por qualquer pessoa que possua conhecimento básico sobre o assunto.

Isto é, um algoritmo deve ser facilmente entendido, sem que seja

necessária uma grande perda de tempo para a tradução da idéia

contida no mesmo. Um algoritmo lógico deve ser, também, formado

apenas pelo número mínimo de instruções necessárias para a resolução

do problema referido.

Um algoritmo opera sobre um conjunto de entradas de modo a gerar

uma saída que seja útil para o usuário. Um algoritmo tem cinco

características importantes:

• Finitude: Um algoritmo deve sempre terminar após um número

finito de passos.




• Definição: Cada passo de um algoritmo deve ser precisamente

definido. As ações devem ser definidas rigorosamente e sem

ambiguidades.

• Entradas: Um algoritmo deve ter zero ou mais entradas, isto é

quantidades que são lhe são fornecidas antes do algoritmo

iniciar.

• Saídas: Um algoritmo deve ter uma ou mais saídas, isto é

quantidades que tem uma relação específica com as entradas.

• Efetividade: Um algoritmo deve ser efetivo. Isto significa que todas

as operações devem ser suficientemente básicas de modo que

possam ser em princípio executadas com precisão em um tempo

finito por um humano usando papel e lápis.

Neste curso utilizaremos o português estruturado para represent-

ar algoritmos.

Identificador

O elemento básico da linguagem é o identificador. Sua construção é

dada pelo diagrama a seguir:

identificador letra

letra

dígito




Os identificadores devem iniciar por uma letra (26 letras do alfabeto),

seguida de uma quantidade qualquer de dígitos (0 a 9). Não é

permitido utilizar os caracteres especiais (entre eles o espaço). Algumas

linguagens de programação (e autores) aceitam outros caracteres

como válidos (como o símnolo de sublinha “_”).

Tipos de Dados

Os algoritmos utilizam os comandos para manipular dados. Estes dados

ou fazem parte do algoritmo ou serão obtidos pelo algoritmo para

realizar as operações necessárias. É importante perceber que os dados

serão armazenados na memória da máquina, ou na porção de

memória reservada ao código do programa (instruções) – quando

fazem parte delas – ou em área reservada para armazenamento de

dados que podem ser modificados. Naturalmente somos levados a

pensar que os dados são de tipos diferentes, mas nem sempre nos

atentamos para as particularidades de cada tipo. Sabemos que na

vida real existem os nomes, os números, as respostas sim e não e outros

tipos de representação da informação. Quando falamos em máquinas,

o armazenamento é uma questão importante.

Os dados em memória são representados de formas diferentes

dependendo do que se quer representar e de quais operações

poderão ser realizadas. No caso dos caracteres, a representação é por

meio de 1 byte para cada caractere representado, de forma que o

byte é um número da tabela ASCII (American Code for Interchance

Information) associado ao caractere. Por exemplo, o número 65

representa o “A”, o 66 o “B”, o 32 é o espaço em branco, o 7 é o bip

(som) e assim por diante. Quando falamos em representar cadeias de

caracteres, então é preciso dimensionar a quantidade de caracteres




da cadeia e será consumido um byte para representar cada elemento.

Se a questão é armazenar apenas respostas sim e não, um bit é

suficiente, apesar de que a menor unidade para alocação é um byte.

Se o caso é o armazenamento de um número, então a quantidade de

bytes do número terá relação com a grandeza do mesmo. Note que

existe grande diferença entre armazenar um número inteiro e

armazenar um número real. O inteiro é uma sequência de bytes

interpretada como um todo. Já o número real é representado por um

número em notação científica, sendo composto por um grupo de bytes

dividido em duas partes, uma representa a mantissa e a outra o

expoente. Isto permite armazenar um número muito grande, mas com

pouca precisão numérica. Veja:

3,14 x 1020 → 314 é a mantissa e 1018 o expoente. Assim precisaríamos de

2 bytes para representar a mantissa e 1 byte para representar o

expoente.

Fiz este resumo sobre as diferentes representações de dados em

memória para justificar a necessidade de definir tipos de dados.

Enquanto para os humanos isto pode ser indiferente (gastará a mesma

quantidade de papel), para os computadores significa espaços de

armazenamento diferentes, modos de operação diferentes, valores

diferentes. O mesmo grupo de bytes, se lido como inteiro representa um

número diferente do que se for lido como um número real.

Por isso, as linguagens de programação normalmente estabelecem

regras precisas para definir que tipos de dados elas irão manipular. Já os

algoritmos procuram abstrair-se destes detalhes, mas estabelecem

algumas regras que limitam o conjunto de dados existentes na natureza

e que poderão ser manipulados pelos algoritmos. Existem três tipos

básicos de dados que a linguagem irá manipular: dados numéricos

(inteiros e reais), dados alfanuméricos e dados Lógicos




Lembre-se de que os números reais possuem limitação para a

representação no computador. As linguagens limitam o número de

casas decimais e a quantidade de dígitos significativos. Além disso,

como o computador utiliza o sistema binário internamente, existem

problemas de perda de dígitos significativos no processo de conversão

decimal binário. Por exemplo, o número real 0.6 ao ser convertido

para a base dois gera uma dízima periódica.

Os dados alfanuméricos servem para tratamento de textos e

normalmente são compostos por uma sequência de caracteres

contendo letras, algarismos e outros caracteres da tabela ASCII

(normalmente caracteres de pontuação). Nos algoritmos estes dados

são representados por uma sequência de caracteres entre aspas.

Alguns autores e linguagens optam pela representação delimitada por

apóstrofes. Exemplo: “Ponto dos Concursos” ou 'Ponto dos Concursos'.

Já os dados Lógicos, também chamados de booleanos, somente

podem assumir dois valores: verdadeiro e falso. A representação

internar normalmente é feita por um byte do tipo inteiro, onde o valor

zero representa o falso e os demais valores o verdadeiro.

Estes três tipos de dados (numérico, alfa-numérico e lógico) são os

chamados tipos primitivos (simples). Existem outros tipos de dados,

chamados de tipos de dados compostos. Destaco, nesta categoria, os

vetores e as matrizes (ou arranjos). Os dados compostos são formados

por agrupamento de outros tipos de dados.

Constantes: Uma constante é um determinado valor que não se

modifica ao longo do tempo, durante a execução de um programa. É

permitido associar um nome (identificador) à constante para facilita a

manutenção do código e para dar maior clareza ao programa. Neste




caso, é preciso declarar a constante na sessão apropriada do

algoritmo.

Variável: corresponde a uma área de memória do computador, à qual

atribuímos um identificador. Esta área da memória armazena valores

que podem variar ao longo do tempo, durante a execução do

programa. No entanto, as variáveis só podem armazenar um valor por

vez. Ao executar um comando que envia um valor para uma variável, o

valor que já estiver armazenado será perdido. Além de possuir um

identificador (nome), cada variável deve estar associada a um tipo de

dado. Note que algumas linguagens não exigem nem a declaração

nem a designação de tipo para as variáveis, mas em algoritmos, tem-se

mantido este padrão. A forma de definir variáveis em um algoritmo é:

Atribuição

O comando de atribuição armazena um valor em uma variável. O valor

já existente na variável é substituído pelo novo valor, uma vez que uma

variável só pode assumir um valor de cada vez. Não é possível

,

: identificador inteiro

real

caracter

lógico




recuperar o valor alterado pelo comando de atribuição. O símbolo

deste comando (entendido como operador por alguns autores) é a

seta para esqueda: ←. Sua sintaxe é:

O novo valor atribuído à variável é feito durante o processamento do

programa utilizado e pode ser uma constante, o resultado de uma

expressão ou o valor de outra variável.

Exemplo:

X ← 30 NOTA ← 5.0 + 7.0

Observações Importantes

• a expressão que se encontra do lado direito da atribuição deve

ser compatível com o tipo de dado definido para a variável;

• na atribuição de variável inteira, a expressão deverá ser uma

expressão inteira;

• na atribuição de variáveis do tipo real, a expressão deverá ser

numérica, sem nenhuma outra restrição;

• na atribuição de variáveis caractere o valor deverá estar

envolvido por aspas. Ele não poderá ter um tamanho maior do

que aquele estabelecido para a variável. Se isto acontecer, o

valor será truncado.

• na atribuição de variáveis lógicas deveremos usar as palavras

VERDADEIRO e FALSO, ou quando não houver risco de confusão,

podemos usar as abreviaturas V e F.

identificador expressão




Operadores

Operadores são símbolos utilizados em expressões que contêm variáveis,

constantes e funções. De acordo com os tipos de dados das variáveis e

o resultado da operação, os operadores dividem-se em três tipos:

aritméticos, relacionais e lógicos.

ARITMÉTICOS: São aqueles que atuam apenas sobre constantes,

variáveis e funções numéricas, gerando um resultado numérico em uma

expressão. São eles:

+ adição

- subtração binária

* multiplicação

/ divisão

** ou ^ exponenciação

- menos unário

DIV E MOD

São duas importantes operações (entendidas também por funções)

matemáticas que atuam sobre números inteiros e dão como resultado

também números inteiros.

Y Div X - resultado inteiro de uma divisão inteira de Y por X

Y Mod X - resto inteiro de uma divisão inteira de Y por X

Operadores Relacionais

São aqueles que realizam uma comparação entre duas expressões e

geram resultados lógicos, isto é Verdadeiro ou Falso, são eles:




= igual

<> ou ≠ diferente

> maior que

< menor que

>= ou ≥ maior ou igual

<= ou ≤ menor ou igual

Operadores Lógicos

São aqueles que geram resultados lógicos através da comparação

entre duas expressões lógicas, são três:

conjunção E é aquele que exige que todos os termos da expressão sejam verdadeiros para que a expressão

inteira seja verdadeira.

disjunção OU é aquele que exige que apenas um dos termos da expressão seja verdadeiro para que a expressão

inteira seja verdadeira.

negação NÃO é aquele que inverte ou nega o valor lógico de um elemento.

Os operadores lógicos tem seu resultado baseado na Tabela Verdade,

eles operam sobre variáveis lógicas (V ou F) e tem como resultado

valores lógicos (V ou F).

OU V F E V F NÃO V F

V V V V V F F V

F V F F F F

Prioridades

Na execução de um comando complexo, podemos encontrar duas ou

mais operações numéricas uma ao lado da outra, e neste caso




devemos seguir regras de prioridades de operadores para sabermos

qual será executado primeiro. No Portugol as prioridades são:

PRIORIDADE COMANDO

1ª parênteses

2ª funções

3ª menos unário

4ª ** ou ^

5ª * e /

6ª + e -

7ª relacionais

8ª lógicos NÃO

9ª E

10ª OU

Se houverem duas operações de mesma prioridade, as operações

serão realizadas da esquerda para a direita.

ESTRUTURA DE UM ALGORITMO

A estrutura básica de um algoritmo é:

algoritmo declarações (variáveis, constantes, módulos) início comandos fim.

SEQUÊNCIA SIMPLES

Trata-se de um grupo de comandos executados de forma seqüencial.

Os comandos são executados de cima para baixo, sendo que o




próximo comando da lista só poderá ser executado após o término do

comando anterior. É comum delimitar os comandos de uma sequência

simples pelas palavras reservadas “INÍCIO” e “FIM”, formando assim um

bloco de comandos.

FLUXOGRAMA PORTUGOL

....

< comando 1 >

< comando 2 >

......

< comando n >

..

Exemplo: Calcular a área de um triângulo:

Algoritmo Declare B, H, AREA : real inicio leia (B) {base} leia (H) {altura} AREA ← ( B * H ) / 2 {calcula a área} escreva(AREA) fim.

COMANDOS DE ENTRADA E SAÍDA

A maioria dos algoritmos que escrevemos necessita receber dados

externos, e em algum momento necessitará comunicar respostas, para

tanto usamos os comandos de entrada e saída. Para a tarefa de buscar

comando 1

comando2

comando n




valores externos ao algoritmo utilizamos o comando LEIA e para enviar

dados para a unidade de saída utilizamos o IMPRIMA ou ESCREVA.

A sintaxe destes comandos é:

Entrada de dados:

leia (<identificador 1>, <identificador 2>, ..., <identificador n>)

Saída de dados:

imprima (<identificador 1>, <identificador 2>, ..., <identificador n>) imprima (<expressão numérica>) imprima( “cadeia de caracteres”)

FLUXOGRAMA PORTUGOL

LEIA (var 1, ..., var n) IM-PRIMA (var 1, ... , var n)

ou

IMPRIMA (“mensagem”, var )

ESTRUTURA CONDICIONAL SIMPLES

Na vida real tomamos decisões a todo o momento baseadas em uma

situação existente. Em um algoritmo, chamamos esta situação de

condição. Associada a uma condição, existirá uma alternativa possível

de ações. Exemplo: "se tiver R$ 10,00 sobrando então irei ao cinema

hoje à noite.”

leia var1, ..., var n

imprima var 1, ... var n




A condição nesta frase é "tiver R$ 10,00 sobrando". Ela é uma expressão

lógica, pois a pergunta "Tenho R$ 10,00 sobrando?" Pode (tem que) ser

respondida com "Sim" ou "Não". Lembre-se, então: em um algoritmo,

toda condição tem que ser uma expressão lógica, algo que possa-se

pensar como “ isto é VERDADEIRO” ou “isto é FALSO”. Se a condição for

verdadeira, a ação a ser executada é "irei ao cinema", se a resposta à

pergunta "Tenho dinheiro suficiente?" for "Sim". Então, em um algoritmo,

as ações são um ou mais comandos que serão realizados apenas se a

avaliação da condição resulta VERDADEIRO. Vamos colocar agora a

frase do exemplo anterior em outra forma, mais parecida com nosso

Português Estruturado:

se "tiver R$ 10,00 sobrando" então "irei ao cinema"

fim-se

Veja que grifei três palavras: se, então e fim-se. Elas são muito

importantes na estrutura dos comandos de decisão. Como próximo

passo, vamos generalizar a estrutura que criamos acima:

se <condição> então <ações a serem realizadas se a condição for verdadeira>

fim-se

Para terminar a nossa comparação, devemos lembrar que os

comandos de um algoritmo são sempre indispensáveis, e que o

computador só lida com quantidades definidas (ou seja, ele não sabe o

que é "ter R$ 10,00 sobrando"). Para aproximar mais nossa frase de um

algoritmo, poderemos ter a seguinte forma:

se Dinheiro >= 10 então Ir_ao_Cinema <- VERDADEIRO

Fim-se

O exemplo acima poderia ser estendido para o caso do sujeito não ter

dinheiro sobrando: "se tiver R$ 10,00 sobrando irei ao cinema hoje à




noite, mas se não tiver ficarei vendo TV em casa". Neste caso, uma

codificação possível para esse algoritmo seria:

se Dinheiro >= 10 então Ir_ao_Cinema <- VERDADEIRO Ver_TV <- FALSO

Fim-se

se Dinheiro < 10 então Ir_ao_Cinema <- FALSO Ver_TV <- VERDADEIRO

Fim-se

É importante frisar que sempre à direita do comando se deverá parecer

uma expressão lógica, e uma expressão cujo resultado é VERDADEIRO

ou FALSO. Assim, os seguintes comandos são incorretos:

se A <- B então // É uma atribuição e não uma ex-pressão ...

Fim-se

se A + B então // É uma expressão aritmética e não uma ex-pressão ...

Fim-se

Por outro lado, estão corretos os seguintes comandos:

se (A > B) e (A > C) e (B <> C) então ...

Fim-se

se não Achou então // Correto se Achou foi declarada como lógi-co ... Fim-se

A sintaxe da estrutura condicional simples é:

Se <condição> então <ação(ões)> fim-se

Alguns autores preferem colocar o então na segunda linha. Isto não

modifica a estrutura nem a forma de execução.

Se <condição> então <ação(ões)> fim-se




FLUXOGRAMA PORTUGOL

SE <condição > ENTÃO < comando 1> < comando 2> . .. <comando n>; FIMSE

ESTRUTURA CONDICIONAL COMPOSTA

É uma extensão da alternativa simples, neste caso temos determinar o

que fazer se a condição for verdadeira, e o que fazer se a condição for

falsa. O formato deste comando é:

Sintaxe:

Se <condição> então <ação 1> senão <ação 2>

fim-se

Semântica: se a condição contida no comando SE for verdadeira são

executados os comandos internos ao ENTÃO, e os comandos internos

ao SENÃO são desprezados até encontrar o FIM-SE correspondente.

Caso contrário, se a condição contida no comando SE for falsa, os

comandos internos ao ENTÃO são desprezados e os comandos internos

ao SENÃO são executados até encontrar o FIM-SE correspondente.

comando 1

comando n

condição

V

F




Exemplo:

DELTA ← 4 * A * C - B ** 2 se DELTA < 0 então imprima (“raízes imaginárias”) senão X ← DELTA ^ 0.5 fim-se

FLUXOGRAMA PORTUGOL

SE <condição > ENTÃO < comando 1> < comando 2> . .. <comando n> SENÃO < comando 1> < comando 2> . .. < comando n> FIM-SE

ANINHAMENTO DE ESTRUTURAS

Os algoritmos podem ser formados por diversas estruturas, cada uma

com uma função específica. Existem casos em que uma estrutura

poderá estar dentro de outra, e a isto dá-se o nome de aninhamento.

Nada impede que exista uma condição dentro de outra, e isto também

poderá ocorrer com as próximas estruturas de comando.

Não existe um limite para o número de estruturas que podem ser

colocadas dentro de outra estrutura qualquer, mas se o número for

comando 1

comando n

condição

comando 11

comando nn

V F




muito grande, a compreensão e a visualização serão prejudicadas.

Para facilitar a compreensão e a visualização do início e do final de

cada estrutura, utiliza-se o artifício da identação.

Nos casos em que são necessárias muitas estruturas internas, a solução é

a utilização do processo de modularização do algoritmo, assunto que

será tratado na aula seguinte

Exemplo:

SEM IDENTAÇÃO COM IDENTAÇÃO Se A <> 0 então B ← 0 se C <> 0 então D ← 0 F ← 3 Fim-se; G ← 77 Fim-se;

Se A <> 0 então B ← 0 se C <> 0 então D ← 0 F ← 3 Fim-se G ← 77 Fim-se

Uma regra importante, que deve ser sempre seguida, é a de que o

início e o final da estrutura mais interna devem ser sempre dentro da

estrutura imediata que a contém.

MÚLTIPLA ESCOLHA

Em algumas situações é necessário termos várias soluções ligadas a

respostas diferentes, neste caso o comando de alternativa simples ou

composta não é uma solução prática, isto porque obrigará o

programador a escrever muitas linhas de programa, além de ter que

criar vários comandos de alternativas compostas e verificar a validade

de suas condições para que o comando execute o caminho correto

para uma determinada condição. Temos então o comando de




alternativa de múltipla escolha. O funcionamento deste comando

obedece a seguinte regra:

caso <expressão> valor1 : <comando1> valor 2 :< comando2> ... valor n : <comando n> senão: <comando n+1> fim-caso

Semântica:

• a expressão do CASO é avaliada, e deve gerar um resultado

determinado;

• este resultado é comparado com os valores indicados coloca-

dos do lado esquerdo do dois pontos ( : );

• quando um valor igual for encontrado, o comando colocado ao

lado direito do dois pontos ( : ) será executado, retornando ao

FIMCASO correspondente, sem executar mais nenhuma

comparação, onde prossegue o fluxo normal do algoritmo;

• caso nenhum valor seja igual ao resultado obtido na expressão do

CASO o comando existente do lado direito do dois pontos ( : ) do

SENÃO será executado, retornando ao FIMCASO onde prossegue

o fluxo normal do algoritmo.

Esta estrutura também aparece na literatura com a forma:

escolha < expressão-de-seleção > caso < exp 1 > , < exp 2 >, ... , < exp n >

< lista-de-comandos-1 > caso < exp 1 > , < exp 2 >, ... , < exp n >

< lista-de-comandos-2 > outrocaso

< lista-de-comandos-3 > Fim-escolha




TESTE DE MESA

Um algoritmo, depois de ser elaborado, pode (e deve) ser testado. Para

tal, utilizamos um método conhecido como teste de mesa. O teste de

mesa é como uma simulação de todos os passos, ou seja, entradas,

comandos e instruções do algoritmo, a fim de saber se ele chega ao

resultado a que se propõe e se a lógica está correta. Para tal,

preenche-se uma tabela com valores para as variáveis e segue-se o

fluxo de execução do algoritmo, simulando a execução de cada

instrução, ou seja, refazendo o que o computador faria ao executar

cada instrução. A cada comando simulado (executado), o valor das

variáveis na tabela deve ser atualizado. Se, para uma instrução

executada, uma ou mais variáveis não ficaram com os valores

esperados, há um erro na lógica do algoritmo.

Algoritmo Teste de Mesa Declare Variáveis Saída a,b,c: REAL a b c Inicio ? ? ? a <- 5 5 ? ? b <- 15 5 15 ? c <- a+b 5 15 20 escreva (c) 5 15 20 20 a <- 10 10 15 20 b <- 25 10 25 20 c <- a+b 10 25 35 escreva (c) 10 25 35 35 a <- a-b (10-25)= -15 25 35 escreva (a) -15 25 35 -15 a <- 0 0 25 35 b <- 0 0 0 35 c <- 0 0 0 0 Fim




Esta é uma sugestão. Você pode simplificá-la, escrevendo apenas as

variáveis e saídas. Economize tempo não escrevendo os comandos e

anotando apenas as alterações ocorridas nas variáveis. Quando algum

comando não efetuar alterações de valores nem uma saída, então não

precisará anotar. Isto resultará em ganho de tempo na construção do

teste.

ESTRUTURAS DE REPETIÇÃO

Para a solução de diversos problemas, as sequências simples e as

estruturas condicionais devem ser executadas diversas vezes. Em muitos

destes casos, as instruções para execução são as mesmas, alterando

apenas os valores das variáveis. Os comandos de repetição permitem o

reaproveitamento de instruções do algoritmo. Vejamos estas estruturas

ESTRUTURA DE REPETIÇÃO ENQUANTO

Na estrutura enquanto..faca, a expressão lógica é avaliada e, se ela for

verdadeira, a lista de comandos é executada. Isso se repete até que a

condição seja falsa. Veja a sua forma geral:

enquanto <expressão lógica> faça <lista de comandos>

Fim-enquanto

Semântica - a condição (<expressão lógica>) entre o ENQUANTO e o

FAÇA é avaliada antes de executar qualquer comando interno à

estrutura (<lista de comandos>). Se a condição for verdadeira, os

comandos são executados. Se for falsa todos os comandos internos ao

ENQUANTO serão desprezados e a repetição é encerrada, mesmo se

não tiver executado os comandos uma vez. Ao encontrar o “fim-

enquanto”, a execução dos comandos volta para a linha enquanto,

analisando a expressão lógica novamente.




Exemplo: Calcular a soma dos números inteiros até 100.

Algoritmo Declare

SOMA, NUM: inteiro inicio SOMA ← 0 NUM ← 0 enquanto NUM <= 100 faça SOMA ← SOMA + NUM NUM ← NUM + 1 Fim-enquanto escreva(SOMA) fim.

Cuidado com os laços (repetições) infinitos. Em algumas construções, a

condição da estrutura de repetição (condição de interrupção) não

resulta em valores que resultem em interrupção da repetição. Nestes

casos, o programa é executado para sempre. É o costumeiro: TRAVOU!

FLUXOGRAMA PORTUGOL

ENQUANTO <condição > FAÇA < comando 1>; < comando 2>; . .. <comando n>; FIMENQUANTO;

comando 1

comando n

condição

F

V




REPITA...ATÉ

Nessa estrutura, todos os comandos da lista são executados e uma

expressão lógica é avaliada. Isto se repete até que a avaliação da

condição resulte em FALSO, quanto então o próximo comando a ser

executado é o comando imediatamente após o ate. Cada repetição

da lista de comandos também é chamada de iteração e essa estrutura

também é chamada de laço de repetição. Sua forma geral é:

Sintaxe:

repita <lista de comandos>

até <expressão lógica>

Semântica : os comandos internos ao REPITA são executados até que a

condição após o até seja avaliada com resultado VERDADEIRO. Se o

resultado da expressão lógica for FALSO, a lista de comandos será

executada novamente. Observe que a lista de comandos é executada

antes da avaliação da expressão. Desta forma, a lista é executa, no

mínimo, uma vez, independente da expressão lógica.

Exemplo:

Algoritmo que escreve os números de 1 a 10.

Algoritmo DECLARE

i: INTEIRO inicio

i<- 1 repita

escreva (i) i <- i + 1

ate i > 10 fim-algoritmo




No exemplo acima, a variável i controla o número de repetições do

laço. Normalmente, a variável de controle do laço recebe um valor

inicial, é incrementada (ou decrementada) de um valor constante no

laço e tem seu valor testado no final do laço. Ao chegar a um

determinado valor, o laço é interrompido. A inicialização da variável

contadora deve acontecer fora do laço, antes do seu início.

FLUXOGRAMA PORTUGOL

REPITA

< comando 1> < comando 2> . .. <comando n>

ATÉ <condição >

COMPARAÇÃO ENTRE OS COMANDOS ENQUANTO E REPITA ENQUANTO REPITA

1. os comandos internos ao enquanto podem nunca serem executados;

1. os comandos internos ao repita são executados pelo menos uma vez;

2. o laço do enquanto é executado quando a condição for verdadeira;

2. o laço do repita é realizado quando a condição for falsa;

3. a estrutura enquanto testa e faz.

3. a estrutura repita faz e testa.

comando 1

comando n

condição F

V




ESTRUTURA DE REPETIÇÃO COM VARIÁVEL DE CONTROLE

O comando para...faça também permite a descrição, dentro de um

algoritmo, de uma estrutura de repetição. Sua forma geral é:

para <variável de controle> de <valor inicial> até <valor final> [passo <incremento>] faça <lista de comandos> Fim-para

Na estrutura para..faça, a variável de controle é inicializada com <valor

inicial> e no início de cada iteração, seu valor é comparado com

<valor final>. Se o valor da variável for menor ou igual a <valor final>, a

lista de comandos é executada e após ser executado o último

comando da lista, a variável de controle é incrementada. Isto repete-se

até que o valor da variável de controle seja maior que <valor final>,

quando então é executado o comando imediatamente após a palavra

fim-para. A instrução passo é necessária se o incremento for diferente

de 1.

Um algoritmo que lê escreve os números ímpares de 1 a 1000.

para i de 1 ate 1000 passo 2 faça // Incrementa i de 2 em 2 escreva (i, “ é ímpar”) fim-para

Observações sobre o comando:

• dentro dos comandos internos ao PARA a variável de controle não pode ser alterada

• os valores de inicio, final e incremento podem ser números, variáveis ou expressões.

• não é permitido alterar as variáveis com os valores de início, final e incremento dentro da estrutura.

• quando o valor do incremento for 1, este pode ser omitido;




• o valor do incremento pode ser negativo, neste caso o valor inicial da variável de controle deve ser maior do que seu valor final.

FLUXOGRAMA PORTUGOL

PARA <variável> DE <inicio> ATÉ <final> PASSO <incremento> FAÇA <lista de comandos>

FIM-PARA

RESUMO – ESTRUTURAS DE REPETIÇÃO

A- ENQUANTO Enquanto a condição for VERDADEIRA, o conjunto de comandos é executado.

Se a condição é FALSA o conjunto NÃO é executado

ENQUANTO < condição > FAÇA comando 1 comando n FIM-ENQUANTO

B- REPITA -Os comandos internos a ele são executados ao menos uma vez, independente da condição - O laço REPITA é realizado somente se a condição for FALSA

REPITA comando 1 … comando n ATÉ <condição>

C- PARA uma variável que controla o início e o fim da execução

PARA variável DE valor1 ATÉ valor2 PASSO valor3 FAÇA comando 1 … comando n FIM-PARA

para <var > de <inicio> até <fim> passo <valor>

comando 1

comando n




VARIÁVEIS COMPOSTAS HOMOGÊNEAS - ARRAYS

A declaração de variáveis, uma a uma, é suficiente para a codificação

algorítmica da solução de uma ampla gama de problemas, mas é

insuficiente para resolver um grande número de problemas

computacionais. Imagine, por exemplo, como faríamos para construir

um algoritmo, que lesse os nomes de 500 pessoas e imprimisse um

relatório destes mesmos nomes, mas ordenados alfabeticamente. Não

seria uma tarefa simples, pois teríamos que definir 500 variáveis do tipo

literal, como é mostrado abaixo:

Algoritmo "Inviável" Declare

nome1, nome2, nome3, nome4, ..., nome499, nome500: cara-ctere inicio

leia (nome1,nome2,...,nome500) ...

Fim

Considere o tamanho do algoritmo, e o trabalho braçal necessário para

construí-lo. Para resolver problemas como este, e outros, existem as

variáveis indexadas. A declaração de uma variável indexada

corresponde, na verdade, à declaração de várias variáveis cujo

identificador difere apenas por um índice. O índice corresponde a um

valor numérico começando por 1. Cada variável indexada pode

receber valores no decorrer do algoritmo como se fosse uma variável

comum.

VARIÁVEIS COMPOSTAS HOMOGÊNEAS UNIDIMENSIONAIS (VETORES)

Variáveis indexadas com uma única dimensão, também conhecidas

como vetores, são referenciadas por um único índice. A sintaxe para

declaração é:

<identificador> : vetor [<tamanho>] de < tipo >

Tamanho [VI..VF] Vi é o valor inicial do índice e VF é o valor final do índice.




Exemplo IDADE: VETOR [1..5] DE INTEIRO NOMES: VETOR [1..5] DE CARACTERE

A declaração acima corresponde à declaração de 10 variáveis:

nomes[1], nomes[2], nomes[3], nomes[4], nomes[5], idades[1], idades[2], idades[3], idades[4] e idades[5].

Para se atribuir um valor a um elemento do vetor devemos utilizar o

seguinte padrão:

< identificador>[<posição>] <- <valor>

Exemplos: 1. nomes[1] <- “João da Silva” 2. idades[1] <- 35 3. nomes[3] <- “Maria Aparecida” 4. idades[3] <- idades[1] 5. i <- 5 6. idades[i] <- 45

Algoritmo que lê um vetor NUMERO de 6 posições e o escreve. A seguir,

ele conta quantos valores de NUMERO são negativos e escreva esta

informação.

Algoritmo "vetores" Declare

NUMERO: VETOR [1..6] DE REAL I, conta_neg: INTEIRO

inicio conta_neg <- 0 para i de 1 ate 6 faca

leia (NUMERO[i]) se NUMERO[i] < 0 entao

conta_neg <- conta_neg + 1 fim-se

fim-para para i de 1 ate 6 faca

imprima(NUMERO[i]) fim-para imprima("Total de números negativos: ", conta_neg)

fim




VARIÁVEIS COMPOSTAS HOMOGÊNEAS BIDIMENSIONAIS (MATRIZES)

Variáveis indexadas com duas dimensões, também conhecida como

matrizes, são referenciadas por dois índices, cada qual começando por

1. Observe que as linguagens de programação determinam os limites

válidos para os índices. Cada dimensão da matriz, em geral, representa

uma classificação de informação. Por exemplo, as linhas poderiam

representar um aluno, enquanto as colunas representariam as notas. É

possível criar variáveis compostas com mais de duas dimensões, basta

acrescentar as novas dimensões na declaração e na manipulação (da

mesma forma como acrescentamos aqui).

É importante ressaltar que cada posição da matriz é uma variável

interna e, como tal, ocupa espaço. Assim, temos que nos preocupar

com o total de espaço utilizado pela estrutura para não consumir todo

o espaço disponível e causar falhas nos programas.

A sintaxe para declaração é:

<identificador> : vetor [<tamanho1>,<tamanho2>] de < tipo >

Ex: PESSOAS: VETOR [1..2,1..3] DE CARACTERE

A declaração acima corresponde à declaração de 6 variáveis:

PESSOAS[1,1], PESSOAS [1,2], PESSOAS[1,3],

PESSOAS[2,1], PESSOAS[2,2], e PESSOAS [2,3].

Para se atribuir um valor a um elemento do vetor devemos utilizar o

seguinte padrão:

< identificador>[<posição 1>,<posição 2>] <- <valor>

Ex: PESSOAS[1,3]<- “Tonet”

Algoritmo que lê uma matriz vê Valores(3,3) e calcula as somas:




a) da linha 3 de Valores;

b) da coluna 2 de Valores;

c) da diagonal principal;

d) da diagonal secundária; e

e) de todos os elementos da matriz.

Algoritmo "Matriz" Declare

VALORES : VETOR [1..3,1..3] DE REAL somaLinha3, somaColuna2, somaDiagPrinc, somaDiagsecu, somaTudo: REAL i, j: INTEIRO //os índice sempre inteiro

inicio somaLinha3 <- 0 somaColuna2 <- 0 somaDiagPrinc <- 0 somaDiagsecu <- 0 somaTudo <- 0 Para i de 1 ate 3 faca

Para j de 1 ate 3 faca Escreva("Digite um valor para a matriz") Leia (VALORES[i,j]) somaTudo <- VALORES[i,j] + somaTudo se i=3 entao

somaLinha3 <- VALORES[i,j]+ somaLinha3 fim-e se j=2 entao

somaColuna2 <- VALORES[i,j]+ somaColuna2 fim-e se i=j entao

somaDiagPrinc <- VALORES[i,j]+ somaDiagPrinc fim-e se j=4-i entao

somaDiagsecu <- VALORES[i,j]+ somaDiagsecu fim-e

fim-ara fim-ara Para i de 1 ate 3 faca

para j de 1 ate 3 faca escreva(VALORES[i,j])

fim-ara fim-ara escreva("Soma de todos os elementos é ", somaTudo) escreva("Soma dos elementos da linha 3 é ", somaLinha3) escreva("Soma dos elementos da coluna 2 é ", somaColuna2) escreva("Soma dos elementos da diagonal principal é ",

somaDiagPrinc) escreva("Soma dos elementos da diagonal secundária é ",

somaDiagsecu) fim




EXERCÍCIOS COMENTADOS

01. (FCC - 2010 - DPE - SP - Agente de Defensoria - Analista de Sistemas) É utilizada para avaliar uma determinada expressão e definir se um bloco de código deve ou não ser executado. Essa é a definição da estrutura condicional: a) For b) If...Then...Else c) While d) Do...While e) Next

Comentários: a estrutura utilizada para definir se um bloco de código deve ou não ser executado, com base na avaliação de uma expressão é a estrutura condicional. Normalmente é representada por “If...Then...Else” ou “Se...Então...Senão”.

GABARITO: B.

02. (CESPE - 2009 - ANAC - Analista Administrativo - Tecnologia da

Informação) Julgue os itens que se seguem, com relação a conceitos

de construção de algoritmos.

Na construção de um algoritmo, utilizam-se estruturas de repetição para

que um bloco de comandos seja executado várias vezes. Todos os tipos

de estrutura de repetição permitem que o bloco de comandos seja

executado zero, uma ou mais vezes, de acordo com uma condição

que será avaliada a cada iteração.

( ) Certo ( ) Errado

Comentários: A estrutura de repetição com interrupção no final,

“repita...até”, executa os comandos uma vez antes de avaliar a

condição de interrupção. Neste caso, não é possível que o bloco de

comandos não seja executado (“zero vezes” como afirma questão).

GABARITO: ERRADO.




03. (FCC - 2008 - METRÔ-SP - Analista Treinee - Ciências da

Computação) Em relação à lógica de programação, considere os

pseudocódigos:

a) Somente Alg1 tem consistência em sua representação e chega a um resultado. b) Ambos os algoritmos abordam o mesmo problema e chegam ao mesmo resultado. c) Somente Alg2 tem consistência em sua representação e chega a um resultado. d) O resultado da solução apresentada por Alg2 é maior do que a de Alg1. e) O resultado da solução apresentada por Alg2 é menor do que a de Alg1.

Comentários: Observe que a diferença entre os algoritmos reside na

fórmula de cálculo da variável SalReceber. Enquanto o primeiro

algoritmo calcula o valor em duas etapas, o segundo calcula por meio

de uma única fórmula. Assim, o Algoritmo 2 dispensa uma variável. No

entanto, o resultado é o mesmo e ambos calculam o valor líquido de




um salário, com base em uma gratificação de 5% e um desconto de

7%¨.

GABARITO: B

04. (FCC - 2010 - TRF - 4ª REGIÃO - Analista Judiciário) Considere: algoritmo PROVA var N, X, CONTA, CONTB, EXP, RESP: inteiro inicio N ← 4 X ← 2 RESP ← X para CONTA ← 2 até N passo 2 faça EXP ← X CONTB ← 1 para CONTB = 1 até CONTA-1 passo 1 faça EXP ← EXP * X fim-para RESP ← RESP + EXP fim

Dado o algoritmo representado na forma de português estruturado, o valor de saída contido na variável RESP será a) 342. b) 6. c) 22. d) 86. e) 0.

Comentários: Para resolver este tipo de questão, quando a banca

apresenta um algoritmo com repetições e cálculos, temos duas opções.

1) Realizamos o “teste de mesa” para apurar o resultado, ou seja

executamos o algoritmo manualmente anotando os valores das

variáveis no decorrer da execução.

2) Analisamos o algoritmo para encontrar o problema que ele

resolve. Assim obtemos uma fórmula para calcular o resultado do

algoritmo em função dos valores de entrada.

Minha sugestão é para que você decida o caminho para a solução da

questão com base na quantidade de repetições que serão efetuadas.




Adote como padrão a primeira opção, que é a mais segura. Mas, se o

número de repetições for grande, então você precisará de muito

tempo para resolver (pode até ser que o tempo de prova seja

insuficiente). Nestes casos, procure realizar algumas simulações para

buscar a fórmula que o algoritmo implementa.

No caso da questão acima, observe que ela possui duas estruturas de

repetição. A quantidade de execuções da primeira depende de N e o

número de execuções da segunda depende da primeira. Como N é

pequeno, sem maiores análises, provavelmente a quantidade de

repetições será pequena. Como N é igual a 4, a primeira repetição será

executada de 2 a 4, com passo 2. Neste caso, a variável CONTA

assumirá os valores 2 e 4, na primeira e segunda repetições,

respectivamente. Então, a segunda repetição – interna à primeira – será

executada 2 vezes. Uma para CONTA = 2 e outra para CONTA = 4. Note

que para esta repetição o passo é 1, ou seja, na primeira vez será

executada de 1 a 1 (CONTA-1) e na segunda vez de 1 a 3 (CONTA-1).

Total de repetições para CONTB = 4 (1 repetição para CONTA = 2 e 3

repetições para CONTA = 4). Concluímos que a quantidade de

repetições é pequena, podemos fazer o teste de mesa.

OBSERVAÇÃO: quando for fazer a prova, não há necessidade de fazer

todos estes cálculos. Observe apenas se as repetições são grandes e se

existem muitas repetições aninhadas.

Apresento uma variação do teste de mesa mostrado na aula.

passo N X CONTA EXP CONTAB RESP

1) 4

2) 2

3) 2

4) 2

5) 2




6) 1

7) 1

8) 2*2=4

9) 2+4=6

10) 2+2=4

11) 2

12) 1

13) 1

14) 2*2=4

15) 2

16) 4*2=8

17) 3

18) 8*2=16

19) 6+16=22

GABARITO: C

05. (FCC - 2008 - METRÔ-SP - Analista Treinee - Ciências da Computação) Em relação à lógica de programação, considere os pseudocódigos:




a) Somente Alg1 tem consistência em sua representação e chega a um resultado. b) Ambos os algoritmos abordam o mesmo problema e chegam ao mesmo resultado. c) Somente Alg2 tem consistência em sua representação e chega a um resultado. d) O resultado da solução apresentada por Alg2 é maior do que a de Alg1. e) O resultado da solução apresentada por Alg2 é menor do que a de Alg1.

Comentários: Observe que a diferença entre os algoritmos reside na fórmula de cálculo da variável SalReceber. Enquanto o primeiro algoritmo calcula o valor em duas etapas, o segundo calcula por meio de uma única fórmula. Assim, o Algoritmo 2 dispensa uma variável. No entanto, o resultado é o mesmo e ambos calculam o valor líquido de um salário, com base em uma gratificação de 5% e um desconto de 7%¨.

GABARITO: B

06. (FCC - 2009 - TRE-PI - Técnico Judiciário - Programação de Sistemas)




No algoritmo do enunciado, observa-se que os tipos de dados não foram declarados. Nesse caso, para ajustar o algoritmo, os tipos de dados para nome, aux, salario e nivel_superior seriam, respectivamente a) real, lógico, inteiro e real. b) caracter, real, inteiro e lógico. c) real, lógico, inteiro e inteiro. d) caracter, inteiro, real e lógico. e) caracter, lógico, real e real.

Comentários: nome deve ser do tipo caractere, para que o identificador faça sentido. Não há restrições quanto ao tipo desta variável, uma vez que ela é lida no início e depois não é mais utilizada. Aux recebe um valor no decorrer do programa e aparece em dois outros momentos: em uma expressão lógica e um comando de saída. No comando de atribuição e na expressão lógica, a variável é tratada como número. A comparação é feita com um número inteiro, então a variável deve ser classificada como inteiro. Salário, ora recebe o valor 1000 (inteiro) ora recebe o resultado de 1000 x 1.15. Aqui fica claro que é uma variável do tipo real, pois o resultado da expressão 1000 x 1.5 é um número real. A última variável, nível_superior, só pode ser classificada como sendo do tipo lógico, uma vez que ela é a própria condição da estrutura se...então...senão. Atenção, a variável não participa de uma expressão lógica, ela é a própria expressão lógica.

GABARITO: D

07. (CESPE - 2009 - ANAC - Analista Administrativo - Tecnologia da Informação) Julgue os itens que se seguem, com relação a conceitos de construção de algoritmos. Um array é um agregado, possivelmente heterogêneo, de elementos de dados. Nele, um elemento individual é identificado por sua posição em relação ao primeiro. ( ) Certo ( ) Errado

Comentários: Um arranjo (array, vetor ou matriz) é um agregado HOMOGÊNEO de elementos de dados. Não há possibilidade de que o array seja de elementos heterogêneos. Não confunda um arranjo onde os elementos são registros (onde os componentes do registro podem ser de tipos diferentes) com a ideia de arranjo heterogêneo. Quando o arranjo é um agregado de registros, todos os elementos do arranjo possuem a mesma forma (definida pelo registro), ou seja, o arranjo é homogêneo. Outro cuidado é não confundir o tipo de dado do arranjo




(homogêneo = tipos iguais) com o conteúdo de cada elemento do arranjo (valores diferentes).

GABARITO: ERRADO.

08. (ESAF - 2009 - ANA - Analista Administrativo - Tecnologia da Informação - Desenvolvimento) Na programação estruturada, são necessários apenas três blocos de formas de controle para implementar algoritmos. São eles: a) seleção, repetição e aninhamento. b) empilhamento, aninhamento e operação. c) sequência, aninhamento e seleção. d) sequência, seleção e repetição. e) função, operação e programa.

Comentários: Os controles disponíveis para os algoritmos são a sequência, a seleção (estrutura condicional) e a repetição.

GABARITO: D

09. (CESGRANRIO - 2006 - DNPM - Técnico Administrativo - Especialidade - Informática) Considere o algoritmo abaixo, descrito em pseudocódigo.

Suponha que os dados de entrada SALARIO e TITULO sejam, respectivamente, "1000,00" e "Doutor". Qual o valor do salário com a gratificação, em reais, que será apresentado na saída do algoritmo? a) 1000,00 b) 2000,00 c) 3000,00




d) 5000,00 e) 6000,00

Comentários: A estrutura caso está avaliando a variável Título para definir qual linha será executada. A condição de guarda (caso) que será satisfeita com os dados informados é a primeira (“Doutor”). Assim, SALARIO_GRAT receberá o valor de SALARIO * 3, ou seja, 1000 x 3 = 3000,00.

GABARITO: C

10. (CESGRANRIO - 2004 - Prefeitura de Manaus - Analista de Sistemas) Considere a sub-rotina abaixo para responder às questões XX e XX.

Com base no algoritmo acima, e supondo que o valor fornecido para "A" na linha "leia A" seja 3 e o valor fornecido para "B" na linha "leia B" seja 4, pode-se afirmar que o valor da variável "C" na linha "escreva C" é: a) 24 b) 28 c) 32 d) 34 e) 43

Comentários: Questão típica para teste de mesa. Mas como não tem repetições, basta aplicar a fórmula. C (3 + 4) * 4. C = 28.

GABARITO: B

11. (CESGRANRIO - 2004 - Prefeitura de Manaus - Analista de Sistemas) Considere a sub-rotina abaixo para responder às questões XX e XX.




Com base no algoritmo acima, e supondo que o valor fornecido para "B" na linha "leia B" seja 5, pode-se afirmar que o valor da variável "A" na linha "escreva A" é: a) 7 b) 9 c) 12 d) 16 e) 21

Comentários: Esta questão mostra o comando interrompa. Este comando encerra a execução da repetição de modo imediato (sem esperar a condição). Faça o teste de mesa para a questão. A repetição será executada 2x e o valor em A será 16 0 + 7 + 9.

GABARITO: D

12. (CESGRANRIO - 2004 - Prefeitura de Manaus - Analista de Sistemas) Um Analista de Sistemas recebeu a tarefa de implementar uma sub-rotina que, a partir de uma matriz de entrada "A", gerasse uma outra matriz de saída "B". Um pedaço desta sub-rotina, implementada em Visual Basic 6.0, está apresentado abaixo.




Considere a matriz A = (aij) de dimensão 2 x 2, a seguir, onde aij são os elementos da matriz A.

Nesta matriz, por exemplo, o elemento a11 possui o valor 3. A matriz "B" resultante da execução do algoritmo acima, tendo a matriz "A" como entrada, é:

a)

b)

c)

d)

e)

Comentários: Como as repetições serão executadas apenas 4x, podemos aplicar o teste de mesa. Mas se observarmos o algoritmo apresentado, podemos concluir que os elementos de B são os elementos de A com os números de posição invertidos. Como as posições onde a linha e coluna são iguais não são afetadas, temos apenas as seguintes diferenças: Assim B(1,2) = A(2,1) e B(2,1) = A(1,2).

GABARITO: C




12. (CESGRANRIO - 2005 - MPE-RO - Analista Programador) Analise o algoritmo a seguir.

Com base no algoritmo acima, e supondo que o valor fornecido para "B" na linha "leia B" seja 7, pode-se afirmar que o algoritmo apresentará como saída na linha "escreva F", respectivamente, a seqüência:

a) 0, 1, 2, 3, 4 e 5. b) 1, 2, 3, 4, 5 e 6. c) 1, 1, 2, 3, 5 e 8. d) 1, 1, 3, 5, 7 e 9. e) 1, 2, 3, 6, 7 e 9.

Comentários: Observe que a banca mostra uma variação do comando repita. Aqui o comando não é repita...até <condição> e sim repira...<interrompa>...fim repita. No entanto, como existe o comando interrompa, podemos executar. Observe que será interrompida a repetição quando A for >= B. Sendo B = 7 e A, que inicia em 1, aumentando de 1 em 1 a cada repetição, a quantidade de vezes que os comandos da repetição serão executados será 6. Aplique o teste de mesa e veja se consegue os mesmos valores.




A B C D E F Saída 1 7 1 ? 0 1 1 1 1 1 2 2 1 1 1 1 2 3 6 4 2 2 3 2 4 15 9 3 3 5 3 5 40 25 5 5 8 5 6 104 64 8 8 13 8 7 253 149

interrompe

GABARITO: C

log prog - regular - aula 01

Documents

curso em teoria

algoritmo lgico

ordem lgica

curso on

algoritmos processo

aula do curso

instrues necessrias

instrues esto