CURSO TÉCNICO EM INFORMÁTICA

PROFESSOR JEAN CARLOS COELHO DE ALENCAR

Apostila Lógica de Programação Parte 01

OURICURI - PE

SUMÁRIO
1.0 INTRODUÇÃO A LÓGICA.......................................................................................3 1.1 Lógica Aplicada à Tecnologia da Informação (Informática)................................4 2.0 INTRODUÇÃO AO ALGORITMO............................................................................6 2.1 Classificação de Algorítimo.................................................................................6 2.2 Exemplos de Algorítimo......................................................................................9 2.4 Tipos de Dados.................................................................................................12 2.5 Operadores.......................................................................................................12 2.5.1 Operadores Relacionais............................................................................12 2.5.2 Operadores Lógicos..................................................................................13 2.5.2.1 Operador Lógico não..........................................................................13 2.5.2.2 Operador Lógico ou............................................................................14 2.5.2.3 Operador Lógico e..............................................................................14 2.5.2.4 Operador Lógico xou..........................................................................15 2.5.3 Operadores Aritméticos.............................................................................15 2.5.5 Operadores de String................................................................................16 2.5.6 Operadores de Atribuição..........................................................................16 3.0 FORMAS DE REPRESENTAÇÃO DE ALGORÍTMOS.........................................17 3.1 Diagrama de Chaplin........................................................................................17 3.1 Fluxograma.......................................................................................................17 3.2 Português Estruturado (Portugol ou Pseudocódigo)........................................20 4.0 QUALIDADE DO ALGORITIMO:...........................................................................22 5.0 ESTRUTURAS DE ALGORITMO:........................................................................24 5.1 Declaração de Variáveis / Constantes..............................................................24 5.2 Comandos de Saída de Dados.........................................................................25 5.3 Comandos de Entrada (Leitura) de Dados.......................................................26 5.4 Estrutura Sequencial (Incondicional)................................................................26 5.5 Estrutura Condicional........................................................................................33 5.6 Estrutura Seleção Múltipla................................................................................47 5.7 Estrutura de Repetição - Laços........................................................................53 5.7.1 Estrutura de Repetição Pré-testada – "enquanto...faca"...........................54 5.7.2 Estrutura de Repetição Prós-testada – "repita...ate".................................59

3 de 65

1.0 INTRODUÇÃO A LÓGICA
Neste material serão apresentados os conceitos de lógica e algorítimo, que são a base para a programação de computadores. Esta pode ser considerada a “arte” de solucionar problemas em computação. Tecnicamente falando, programar é desenvolver algorítimos, ou seja, definir um conjunto lógico de instruções, que deverão ser fornecidas ao computador para ele executar alguma tarefa. É até possível se construir um pequeno programa em alguns dias, e sem necessariamente saber os conceitos de lógica e algorítimo, mas se você pretende ser um programador profissional e ter destreza com as centenas de comandos envolvidos numa programação, além de dominar sua sintaxe set ter de ficar refolheando múltiplas páginas a cada nova ideia que deseja implementar, é preciso, além de paciência, algumas centenas de horas de estudo e um certo “dom” para coisa. Usamos a lógica no nosso dia a dia, e muitas vezes nem nos damos conta. No ato de escovar os dentes, cozinhar, dirigir dentre outros, estamos sempre executando tarefas nas quais seguimos alguma sequência “lógica” (raciocínio lógico) de forma totalmente automática. Aristóteles, um filósofo grego que é considerado o criador da Lógica, embora ele não a chamasse assim, mas “Razão”. Definiu que a “Razão” é: um Instrumento, uma introdução para as ciências e para o conhecimento. O termo lógica foi adotado posteriormente, sedo originado do grego Logos que significa linguagem racional. De acordo com o dicionário Michaelis, lógica é a análise das formas e leis do pensamento, mas não se preocupa com o conteúdo do pensamento e sim com a forma. Pode ser definida também como a maneira pela qual um pensamento ou um ideia é organizada e apresentada, possibilitando que cheguemos a uma CONCLUSÃO. Um argumento pode ser composto por uma ou mais premissa, as quais podem ser verdadeiras ou falsas e que conduzem a uma conclusão, que também podem ser verdadeira ou falsa. Nos argumento apresentado abaixo, 1 e 2 representam as premissas e 3 a conclusão: 1. Ouricuri é uma cidade do estado de Pernambuco. 2. João nasceu em Ouricuri. 3. Portanto, João é Pernambucano.

4 de 65 Argumento é um conjunto de uma ou mais sentenças declarativas, também conhecidas como proposições, ou ainda, premissas, acompanhadas de uma outra frase declarativa conhecida como conclusão. Argumentos são classificados em dedutivos e indutivos. Os dedutivos afirmam que a verdade de uma conclusão é uma consequência lógica das premissas que a antecedem. Por exemplo: 1. 2. 3. Mamíferos, são animais que mamam; A cabra mama; Portanto, a cabra é um mamífero.

Já os indutivos afirmam que a verdade da conclusão é apenas apoiada pelas premissas, neste caso se torna preciso conhecer os fatos para se poder fazer a comparação. 1. No ano passado não choveu em janeiro e o ano foi de seca; 2. Neste ano choveu em janeiro; 3. Logo, neste ano não haverá seca. Toda e qualquer premissa, assim como toda conclusão, pode assumir apenas o valor verdadeiro ou falso e jamais poderá assumir ou possuir valores ambíguos. Sendo assim, as frases que apresentam um argumento são referidas como sendo verdadeiras ou falsas. Devemos programar nossas Mentes! Programar não é um tarefa difícil! • • • • Computador é uma réplica da Mente; Com uma – autoprogramação; Aprendizado (Cores, símbolos, sons...); Processo de aprendizado – autoprogramação;

O que será mais complexo nosso “cérebro” ou um simples “computador”? Lembrem-se a “inteligencia” do computador, somos “nós” que “fazemos” (programamos).

Este será o nosso desafio!!

1.1 Lógica Aplicada à Tecnologia da Informação (Informática)
O estudo da lógica, pode ser aplicado as mais diversas áreas do conhecimento. O proposito aqui, é apresentar a análise e desenvolvimento da lógica na construção de Softwares (Programas de Computador), onde a partir da

5 de 65 observação da lógica o programador (desenvolvedor) constrói seus algorítimos, que posteriormente virarão um software. Sendo estes, programas de computador, capazes de apresentar as mais diversas soluções, nas mais variadas áreas do conhecimento humano (contabilidade, administração, engenharia, educação...). Usaremos para a solução dos algorítimos, a Lógica Formal, também chamada de Lógica Simbólica que se preocupa basicamente com a estrutura do raciocínio. E lida com a relação entre conceitos e fornece um meio de compor provas de declarações. Os conceitos são rigorosamente definidos, e as sentenças são transformadas em notações simbólicas precisas, compactas e não ambíguas, esta também nos permite trabalhar com variáveis, permitindo assim, a utilização do mesmo raciocínio para a solução de vários problemas. Exemplos: 1. 2. 3. Mamíferos, são animais que mamam; A cabra mama; Portanto, a cabra é um mamífero. e

Baseados na lógica formal podemos substituir as palavras Mamíferos cabra, por X e Y. 1. 2. 3. X, são animais que mamam; A Y mama; Portanto, Y é um X.

Posteriormente falaremos sobre variáveis, e seu uso. Na logica aplicada a T.I., o resultado das sentenças será sempre, V ou F (Verdadeiro ou Falso), ela é a técnica de desenvolver algoritmos (sequências lógicas) para atingir determinados objetivos dentro de certas regras baseadas na Lógica Matemática, estes algorítimos serão adaptados para uma Linguagem de Programação utilizada pelo programador para construir seu software.

6 de 65

2.0 INTRODUÇÃO AO ALGORITMO
Quando desejamos criar ou desenvolver um programa de computador (software) para atender uma determinada situação e/ou para solucionar algum problema, devemos escrever toda a sequencia lógica (algorítimo) para tal solução, e esta deverá ser posteriormente traduzida para uma linguagem que tando o homem(programador), quanto a máquina(computador) entendam. Esta linguagem é denominada de Linguagem de Programação [ASCENCIO & CAMPUS, 2010]. Um algoritmo na realidade, é uma sequência não ambígua de instruções que é executada até que determinada condição se verifique. Mais especificamente, em matemática, constitui o conjunto de processos (e símbolos que os representam) para efetuar um cálculo. Existem três etapas básicas para se desenvolver um software: ➔ Análise que consiste no estudo do problema a ser corrigido, onde serão definidos todos os dados, prolemas, soluções... ➔ Algorítimo, onde a partir da análise, serão montadas todas as sequencia lógica para solução dos problemas levantados. Neste caso, poderemos utilizar as seguintes formas de representação: Descrição Narrativa, Fluxograma, Diagrama de Chapin e Pseudocódigos, também conhecidos como Português Estruturado ou Portugol. ➔ Codificação, fase na qual o algorítimo é traduzido para uma linguagem programador. ➔ Testes, após a construção do software, são realizados testes para conferir sua conformidade com os requisitos iniciais. O software deve satisfazer a todas especificações do cliente. de programação, normalmente dominada pelo

2.1 Classificação de Algorítimo
Segundo [WIKIBOOKS, 2010] os algorítimos podem ser classificados por: implementação, paradigma, campo de estudo e complexidade.

7 de 65 Classificação por implementação: Pode-se classificar algoritmos pela maneira pelo qual foram implementados. • Recursivo ou iterativo - um algoritmo recursivo possui a característica de invocar a si mesmo repetidamente até que certa condição seja satisfeita e ele é terminado, que é um método comum em programação funcional. Algoritmos iterativo usam estruturas de repetição tais como laços, ou ainda estruturas de dados adicionais tais como pilhas, para resolver problemas. Cada algoritmo recursivo possui um algoritmo iterativo equivalente e vice versa, mas que pode ter mais ou menos complexidade em sua construção. • Lógico - um algoritmo pode ser visto como uma dedução lógica controlada. O componente lógico expressa os axiomas usados na computação e o componente de controle determina a maneira como a dedução é aplicada aos axiomas. Tal conceito é base para a programação lógica. • Serial ou paralelo - algoritmos são geralmente assumidos por serem executados instrução à instrução individualmente, como uma lista de execução, o que constitui um algoritmo serial. Tal conceito é base para a programação imperativa. Por outro lado existem algoritmos executados paralelamente, que levam em conta arquiteturas de computadores com mais de um processador para executar mais de uma instrução ao mesmo tempo. Tais algoritmos dividem os problemas em subproblemas e o delegam a quantos processadores estiverem disponíveis, agrupando no final o resultado dos subproblemas em um resultado final ao algoritmo. Tal conceito é base para a programação paralela. Classificação por paradigma: Pode-se classificar algoritmos pela metodologia ou paradigma de seu desenvolvimento, tais como: • Divisão e conquista - algoritmos de divisão e conquista reduzem repetidamente o problema em subproblemas, geralmente de forma recursiva, até que o subproblema é pequeno o suficiente para ser resolvido. Um exemplo prático é o algoritmo de ordenação merge sort.

8 de 65 • Programação dinâmica - pode-se utilizar a programação dinâmica para evitar o recálculo de solução já resolvidas anteriormente. • Algoritmo ganancioso - um algoritmo ganancioso é similar à programação dinâmica, mas difere na medida que as soluções dos subproblemas não precisam ser conhecidas a cada passo, uma escolha gananciosa pode ser feita a cada momento com o que até então parece ser mais adequado. • Programação linear Redução - a redução resolve o problema ao transformá-lo em outro problema. É chamado também transformação e conquista. • Busca e enumeração - vários problemas podem ser modelados através de grafos. Um algoritmo de exploração de grafo pode ser usado para caminhar pela estrutura e retornam informações úteis para a resolução do problema. Esta categoria inclui algoritmos de busca e backtracking. • Paradigma heurístico e probabilístico - algoritmos probabilísticos realizam escolhas aleatoriamente. Algoritmos genéticos tentar encontrar a solução através de ciclos de mutações evolucionárias entre gerações de passos, tendendo para a solução exata do problema. Algoritmos heurísticos encontram uma solução aproximada para o problema. Classificação por campo de estudo: Cada campo da ciência possui seus próprios problemas e respectivos algoritmos adequados para resolvê-los. Exemplos clássicos são algoritmos de busca, de ordenação, de análise numérica, de teoria de grafos, de manipulação de cadeias de texto, de geometria computacional, de análise combinatória, de aprendizagem de máquina, de criptografia, de compressão de dados e de interpretação de texto. Classificação por complexidade: Alguns algoritmos são executados em tempo linear, de acordo com a entrada, enquanto outros são executados em tempo exponencial ou até mesmo nunca terminam de serem executados. Alguns problemas possuem múltiplos algoritmos enquanto outros não possuem algoritmos para resolução.

9 de 65

2.2 Exemplos de Algorítimo
Considere o problema das Torres de Hanoi . Analise e descreva uma maneira de mover os discos do pino A para o pino C, mantendo a mesma ordem. Em hipótese nenhuma um disco maior poderá ficar sobre o menor. Veja a figura abaixo:

Obs.: deve-se mover um único anel por vez e um anel de diâmetro maior nunca pode repousar sobre algum outro de diâmetro menor. Solução: Algoritmo para resolver o problema das Torres de Hanoi. Início 1. Mover o anel P da haste A para a haste C. 2. Mover o anel M da haste A para a haste B. 3. Mover o anel P da haste C para a haste B. 4. Mover o anel G da haste A para a haste C. 5. Mover o anel P da haste B para a haste A. 6. Mover o anel M da haste B para a haste C. 7. Mover o anel P da haste A para a haste C. Fim Um homem precisa atravessar um rio com um barco que possui capacidade de carregar apenas ele mesmo e mais uma das três cargas que são: um lobo, um bode e um maço de alfafas. Observe as leis naturais: o lobo é carnívoro e o bode é herbívoro. O que o homem deve fazer para conseguir atravessar o rio sem perder suas cargas? Solução: Algoritmo para resolver o problema das Travessia.

10 de 65 Início 1) O Homem leva o bode da margem 1 para a margem 2. 2) O Homem navega da margem 2 para a margem 1. 3) O Homem leva o lobo da margem 1 para a margem 2. 4) O Homem leva o bode da margem 2 para a margem 1. 5) O Homem leva a alfafa da margem 1 para a margem 2. 6) O homem navega da margem 2 para a margem 1. 7) O Homem leva o bode da margem 1 para a margem 2. Fim No nosso dia a dia, muitas vezes tratamos algorítimos sem nem perceber, observe a seguinte situação: Um cozinheiro precisa fazer um sanduíche de queijo, só que ele passa pelos seguintes dilemas: o queijo está fatiado ou o queijo está sem Fatiar. Solução 1: Algoritmo para resolver o problema de se fazer o sanduíche com o queijo estando fatiado. Início 1) Pegar a faca; 2) Pegar o pão; 3) Cortar o pão; 4) Colocar a faca na mesa; 5) Pegar a fatia de queijo; 6) Abrir o pão; 7) Colocar a fatia de queijo no pão. Fim Solução 2: Algoritmo para resolver o problema de se fazer o sanduíche com o queijo não estando fatiado. Início 1) Pegar a faca; 2) Pegar o pão; 3) Cortar o pão; 4) Colocar o pão na mesa; 5) Pegar o queijo;

11 de 65 6) Cortar uma fatia de queijo; 7) Colocar a faca na mesa; 8) Pegar e abrir o pão; 9) Colocar a fatia de queijo no pão. Fim Solução 3: Algoritmo para prevendo os dois problemas anteriores. Início 1) Pegar a faca; 2) Pegar o pão; 3) Cortar o pão; 4) Se o queijo estiver fatiado então 5) Passos de 4 a 6 da solução 1 6) Senão 7) Passos de 4 a 8 da solução 2 8) Colocar a fatia de queijo no pão. Fim

2.3 Variáveis / Constantes
O uso de variáveis / constantes, nos permite a utilização do mesmo algorítimo para a solução de vários problemas, inclusive determinando seus tipos de dados. As variáveis são alocações na memória do computador para armazenar dados podem mudar seus valores no decorrer do algorítimo. Já as constantes são alocações na memória do computador para armazenar dados que no decorrer do algoritmo ou processamento sempre terá o mesmo valor. Toda variável / constante tem um nome e um valor. O nome das variáveis deverá ser escrito no padrão CamelCase, as constantes devem ser nomeadas em caixa alta(maiúsculas), e seguindo as seguintes regras: Devem começar por uma letra e depois conter letras, números ou underline “_”, até um limite de 30 caracteres. As variáveis podem ser simples ou estruturadas.

12 de 65 Não pode haver duas variáveis com o mesmo nome, com a natural exceção dos elementos de um mesmo vetor.

2.4 Tipos de Dados
Existem quatro tipos de dados básicos utilizados na construção de algorítimos: inteiro, real, cadeia de caracteres(strings) e lógico(booleano). Baseado na utilização do VisuAlg, um editor e interpretador de Pseudocódigos. As palavras-chave que utilizaremos para definir estes tipos serão as seguintes (observe que elas não têm acentuação): ➢ inteiro: define variáveis numéricas do tipo inteiro, ou seja, sem casas decimais. ➢ real: define variáveis numéricas do tipo real, ou seja, com casas decimais. ➢ caractere: define variáveis do tipo string, ou seja, cadeia de caracteres. ➢ logico: define variáveis do tipo booleano, ou seja, com valor VERDADEIRO ou FALSO. No caso de constantes, os tipos de dados aceitáveis são: Caracteres, Lógicos e Numéricos que podem ser inteiros ou reais. Neste último caso, o separador de decimais é o ponto e não a vírgula.

2.5 Operadores
São os símbolos usados para o trabalho com variáveis e constantes. Há basicamente cinco grupos de operadores: ✗ relacionais; ✗ lógicos; ✗ aritméticos; ✗ de strings; ✗ de atribuição. 2.5.1 Operadores Relacionais

13 de 65 São utilizados em expressões lógicas para se testar a relação entre dois valores do mesmo tipo, são eles: = < > igual; menor que; maior que;

<= menor ou igual a; >= maior ou igual a; <> diferente de P.S.: Retornam Verdadeiro ou Falso, como resposta. Exemplos: 3=4 ---> FALSO 3<4 ---> VERDADEIRO 3>4 ---> FALSO 3 <= 4 ---> VERDADEIRO 3 >= 4 ---> FALSO 3 <> 4 ---> VERDADEIRO ”A” = ”A” ---> VERDADEIRO ”C” = ”D” ---> FALSO “A” = “a” ----> VERDADEIRO

(Em algumas linguagens de programação

case sensitive, como Java, é considerado FALSO) 2.5.2 Operadores Lógicos São utilizados em expressões lógicas para se testar a relação entre dois valores lógicos(booleanos). • • • • nao; ou; e; xou;

P.S.: Retornam Verdadeiro ou Falso, como resposta. 2.5.2.1 Operador Lógico não Operador unário de negação. nao VERDADEIRO = FALSO, nao FALSO = VERDADEIRO. Tem a maior precedência entre os operadores lógicos. Equivale ao NOT do Pascal ou ! Do Java.

14 de 65

2.5.2.2 Operador Lógico ou Operador que resulta VERDADEIRO quando um dos seus operandos lógicos for verdadeiro. Equivale ao OR do Pascal ou || do Java. Observe a tabela abaixo:

Valor 01 Verdadeiro Falso Verdadeiro Falso

Valor 02 Verdadeiro Verdadeiro Falso Falso

Resultado Verdadeiro Verdadeiro Verdadeiro Falso

Exemplos: A = verdadeiro , B = falso e C = falso A ou nao B nao(A ou B) A ou B C ou B nao A ou B ---> ---> ---> ---> ---> VERDADEIRO FALSO VERDADEIRO FALSO FALSO

2.5.2.3 Operador Lógico e Operador que resulta VERDADEIRO quando todos os seus operandos lógicos forem verdadeiros. Possui precedência sobre “ou” e “xou”. Equivale ao AND do Pascal ou && do Java. Observe a tabela abaixo: Valor 01 Verdadeiro Falso Verdadeiro Falso Valor 02 Verdadeiro Verdadeiro Falso Falso Resultado Verdadeiro FALSO FALSO Falso

Exemplos:

15 de 65 A = verdadeiro , B = falso e C = falso A e ( B ou A) (A e B ) ou nao (B e C) (A e B ) ou (B e C) (A e B) e (A ou B) nao(A ou B) e nao(B e C) 2.5.2.4 Operador Lógico xou Operador que resulta VERDADEIRO se seus dois operandos lógicos forem diferentes, e FALSO se forem iguais. Equivale ao XOR do Pascal. Observe a tabela abaixo: ---> ---> ---> ---> ---> VERDADEIRO VERDADEIRO VERDADEIRO FALSO FALSO

Valor 01 Verdadeiro Falso Verdadeiro Falso

Valor 02 Verdadeiro Verdadeiro Falso Falso

Resultado FALSO Verdadeiro Verdadeiro FALSO

Exemplos: A = verdadeiro , B = falso e C = falso A e ( B xou A) (A xou B ) e nao (B e C) (A e B ) xou (B ou C) (A e B) xou (A e B) nao(A xou B) xou nao(B e C) 2.5.3 Operadores Aritméticos São os que recebem números e retornam números, após terem efetuado alguma operação aritmética. São eles: Operadores unários, isto é, são aplicados a um único operando. São os operadores aritméticos de maior precedência. Exemplos: -3, +x. Enquanto o operador unário - inverte o sinal do seu operando, o operador + não altera o valor em nada o seu valor. ---> ---> ---> ---> ---> VERDADEIRO VERDADEIRO FALSO FALSO VERDADEIRO

+,-

16 de 65 \ Operador de divisão inteira. Por exemplo, 5 \ 2 = 2. Tem a mesma precedência do operador de divisão tradicional. Operadores aritméticos tradicionais de adição, subtração, multiplicação e divisão. Por convenção, * e / têm precedência sobre + e -. Para modificar a ordem de avaliação das operações, é necessário usar parênteses como em qualquer expressão aritmética. Operador de módulo (isto é, resto da divisão inteira). Por exemplo, 8 MOD 3 = 2. Tem a mesma precedência do operador de divisão tradicional. Operador de potenciação. Por exemplo, 5 ^ 2 = 25. Tem a maior precedência entre os operadores aritméticos binários (aqueles que têm dois operandos).

+,-,*,/

MOD ou % ^

2.5.5 Operadores de String Operador de concatenação de strings (isto é, cadeias de caracteres), quando usado com dois valores (variáveis ou constantes) do tipo "caractere". Por exemplo: "Ouri" + "curi" = "Ouricuri" .

+

2.5.6 Operadores de Atribuição Os operadores de atribuição servem basicamente para atribuirmos valores a variáveis e constantes. Operador de atribuição usado com todos os tipos de dados. Por exemplo: A <- 2, isto quer dizer que o valor de A é 2; B <- A + 3, significa q B é cinco (2+3 = 5)

<-

17 de 65

3.0 FORMAS DE REPRESENTAÇÃO DE ALGORÍTMOS
Existem diversas formas de representação e confecção de algoritmos. Dentre elas, podemos destacar o diagrama de chaplin, o fluxograma e o Português Estruturado (Portugol ou pseudocódigo).

3.1 Diagrama de Chaplin
O diagrama de Chaplin utiliza poucos símbolos com significados predefinidos. Constitui-se de dois segmentos verticais de retas paralelas, interligadas por outros segmentos, formando retângulos ou triângulos sobrepostos. Este tipo de diagrama dispensa modelos específicos de desenho, como gabaritos, e é de fácil confecção. Veja os símbolos abaixo:
Utilizado na representação de inicio ou fim do algoritmo, e processamento / instruções.

instruções

condição V F

Utilizado na representação de uma estrutura de decisão (seleção ou condicional).

instruções condição

Estrutura de Repetição: REPITA-ATÉ.

condição instruções

Estrutura de Repetição: ENQUANTO-FAÇA e PARA-ATÉ-FAÇA

3.1 Fluxograma
Uma das técnicas usadas para definir os passos da solução dos algoritmos é a fluxogramação, que consiste em escrevê-los utilizando algumas figuras geométricas interligadas entre si. Estas figuras seguem padrões baseados na Norma ISO 5807 – 1985. A utilização de símbolos com significados próprios não requer papel específico e tem a vantagem de ser muito fácil de entender, pois ao visualizar já se entende o que aquela instrução deseja executar, sua desvantagem é obrigar o

18 de 65 programador a saber o significado de cada símbolo existente para este fim. Veja os símbolos abaixo: Terminal Utilizado na representação de inicio ou fim do algoritmo.

Processamento

Utilizado na representação de um processamento / instrução.

Entrada manual

Utilizado na representação de uma entrada de dados manual.

Exibição

Utilizado na representação de uma exibição no vídeo (monitor)

Utilizado na representação de uma estrutura de decisão Decisão (seleção ou condicional), bem nas Estrutura de Repetição: REPITA-ATÉ e ENQUANTO - FAÇA. Este símbolo representa a definição de um grupo de operações Preparação estabelecidas como uma sub-rotina de processamento. Utilizado na representação de uma estrutura de Repetição: PARA – ATÉ - FAÇA Conector - Este símbolo representa a entrada ou saída em outra parte do fluxograma. Conector de Páginas – Utilizado para interligar partes do fluxogramas em distintas. Seta de orientação de Fluxo

19 de 65 Exemplo: Algoritmo para exibir o nome da disciplina:

Início

”Lógica de Programação”

Fim

Exemplo 2: Algoritmo para receber dois números, via teclado e verificar se são iguais:

20 de 65

3.2 Português Estruturado (Portugol ou Pseudocódigo)
Consiste em escrever o algorítimo por meio de regras pré-definidas. O Português Estruturado, é uma forma especial de linguagem bem mais restrita que a Língua Portuguesa e com significados bem definidos para todos os termos utilizados nas instruções (comandos). Essa linguagem também é conhecida como Portugol (junção de Português com Algol), Pseudocódigo ou Pseudolinguagem. O Português Estruturado na verdade é uma simplificação extrema da língua portuguesa, limitada a pouquíssimas palavras e estruturas que têm significado pré-definido, pois deve-se seguir um padrão. Emprega uma linguagem intermediária entre a linguagem natural e uma linguagem de programação, para descrever os algoritmos. Faremos aqui uma adaptação do portugol de forma utilizarmos esta linguagem de construção de algoritmos, no padrão do software VisualG, da Apoio Informática. Segue abaixo, o formato básico do nosso pseudocódigo no padrão VisualG: algoritmo "semnome" // Função : // Autor : // Data : // Seção de Declarações inicio // Seção de Comandos fimalgoritmo Portugol - VisualG Exemplo: Algoritmo para exibir o nome da disciplina: algoritmo "Exibe disciplina" // Autor : Jean Carlos // Data: 20/02/2011 inicio escreva (“Lógica de Programação”) fimalgoritmo Exemplo:

21 de 65 Algoritmo para receber dois números, via teclado e verificar se são iguais: algoritmo "Verifica números iguais" var A, B: inteiro inicio leia (A,B) se(A = B) entao escreva (“iguais”) senao escreva (“diferentes”) fimse fimalgoritmo

22 de 65

4.0 QUALIDADE DO ALGORITIMO:
Para mantermos uma boa qualidade nos nossos algoritmos, devemos observar dentre outras, as seguintes regras: ➢ Indentação: Segundo [WIKIPROG 2010], em algoritmos / programação, indentação (recuo, neologismo derivado da palavra em inglês indentation, também encontram-se as formas indentação e endentação) é um termo aplicado ao código fonte de um programa para indicar que os elementos hierarquicamente dispostos têm o mesmo avanço relativamente à posição (x,0). Na maioria das linguagens a indentação tem um papel meramente estético / organizacional, tornando a leitura do código fonte muito mais fácil (read-friendly), porém é obrigatória em outras. A verdadeira valia deste processo é visível em arquivos de código fonte extensos, não se fazendo sentir tanto a sua necessidade em arquivos pequenos (relativamente ao número de linhas).

A figura acima representa um algoritmo utilizando de indentação.

23 de 65
A figura acima representa um algoritmo que não utiliza indentação.

➢ Nomenclatura de Variáveis / Constantes, como demonstrado no item 2.3. ➢ Comentários: são informações que você inclui no seu algorítimo para documentar o que está fazendo. Exemplo:
algoritmo "Verifica se números são iguais" var A, B: inteiro inicio escreva ("Digite o primeiro Número: ") leia (A) escreva ("Digite o segundo Número: ") leia (B) //teste se A e B são iguais se(A = B) entao escreva (A, " e", B ," são iguais") senao escreva (A, " e", B ," são diferentes") fimse fimalgoritmo

Exemplo de comentário

➢ Modularização: é um conceito onde o sistema ou software é divido em partes distintas. Compõe o ferramental necessário para um programa mais legível com uma melhor manutenção e melhor desempenho por meio da programação estruturada, falaremos mais sobre modularização alguns capítulos a frente.

24 de 65

5.0 ESTRUTURAS DE ALGORITMO:
Os algoritmos são basicamente formados por uma ou mais das estruturas abaixo: ➔ Estrutura Sequencial (Incondicional); ➔ Estrutura Seletiva (de Seleção ou Condicional); ➔ Estrutura Multi seletiva; ➔ Estrutura de Repetição.

5.1 Declaração de Variáveis / Constantes.
Constantes, são valores que não se alteram ao longo do programa. Uma constante pode aparecer sob forma de um valor explícito (constante literal) ou um nome simbólico que representa um determinado valor ao longo do programa (constante simbólica). Em VisuAlg não existe declaração de constantes, mas para simular o uso de constantes, usamos uma atribuição no início o programa a uma variável. Devemos tomar o cuidado de não alterar o seu valor durante a execução do algoritmo. Uma constante simbólica é definida da seguinte forma: < NOME_CONSTANTE > : < tipo > E no inicio do corpo se atribui o seu valor como demonstrado abaixo:
... var PI : numerico … inicio PI <- 3.14 … fimalgoritimo

OBS: Utiliza-se como padrão colocar nome da constante simbólica em letra maiúscula. Variáveis, uma variável identifica um espaço na memória do computador, reservado para armazenar valores de um determinado tipo. Uma variável é definida da seguinte forma: < nomeDaVariavel > : < tipo > < listaDeVariaveis > : < tipo >

25 de 65 ... var PI : numerico a: inteiro Valor1, Valor2: real nomeDoAluno: caractere sinalizador: logico …

5.2 Comandos de Saída de Dados
escreva (<lista-de-expressões>) Escreve no dispositivo de saída padrão (isto é, na área à direita da metade inferior da tela do VisuAlg) o conteúdo de cada uma das expressões que compõem <lista-de-expressões>. As expressões dentro desta lista devem estar separadas por vírgulas; depois de serem avaliadas, seus resultados são impressos na ordem indicada. É equivalente ao comando write do Pascal ou print do Java. escreval (<lista-de-expressões>). Idem ao anterior, com a única diferença que força a quebra de uma linha (pula uma linha em seguida). É equivalente ao writeln do Pascal ou println do Java. Exemplos:
algoritmo "exemplo" var salario : real codigo : inteiro nome : caractere teste : logico inicio salario <- 1500.3456 codigo <- 23 nome <- "João" teste <- falso escreval (salario : 1: 2) escreval (codigo ) escreval (nome) escreval (“Seu nome é: ”,nome) escreval (teste) escreva (nome,” é”, teste) fimalgoritmo

Resultado na máquina:

26 de 65

5.3 Comandos de Entrada (Leitura) de Dados
leia (<lista-de-variáveis>) Recebe valores digitados pelos usuário, atribuindo-os às variáveis cujos nomes estão em <lista-de-variáveis> (é respeitada a ordem especificada nesta lista). É análogo ao comando read do Pascal. Veja no exemplo abaixo o resultado:
algoritmo "exemplo 1" var x: inteiro inicio escreval(“Digite um número:”) leia (x) escreva (“O número digitado foi”,x) fimalgoritmo

Resultado na máquina:

5.4 Estrutura Sequencial (Incondicional)
A estrutura sequencial é aquela na qual uma ação (instrução) segue a outra em sequência, sem que haja algum tipo de desvio. Exemplo 01: Algoritmo para exibir um nome: Pseudocódigo:
algoritmo “Exiba um nome” Inicio escreva(“Jean Carlos”) fimalgoritmo

Diagrama de Chaplin:
Inicio Escreva “Jean Carlos” Inicio

27 de 65 Fluxograma:
Inicio

“Jean Carlos”

Fim

Resultado na máquina:

Exemplo 02: Algoritmo para ler e exibir um número: Pseudocódigo:
algoritmo “Ler e exibir um número” var numero: inteiro inicio escreval(“Digite um número”) leia(numero) fimalgoritmo Neste momento, a variável numero recebe o valor digitado pelo usuário, ou seja, se o usuário digitar 30, o valor de numero será 30

escreva(“O número digitado foi:”, numero)

Diagrama de Chaplin:

Inicio Escreva “Digite um número” Leia(numero) Escreva “O número digitado foi:”, numero Fim

28 de 65 Fluxograma:
Inicio

“Digite um número:”

numero

“O número digitado foi:”, numero

Fim

Resultado na máquina:

Exemplo 03: algoritmo, onde se solicite ao usuário o seu nome e sua idade, e posteriormente seja exibido na tela a seguinte mensagem: <nome digitado> tem <idade digitada> anos de idade. Informações sobre como gerar o resultado: O usuário digitou João e depois 20. O resultado será:

29 de 65 João tem 20 anos de idade Pseudocódigo:
algoritmo “Ler e exibir nome e idade” var Neste momento, a variável nome recebe o valor digitado pelo nome: caracter usuário, ou seja, se o usuário digitar André, o valor de nome será André. escreva(“Digite seu nome: ”) Neste momento, a variável idade leia(nome) recebe o valor digitado pelo usuário, ou seja, se o usuário escreva(“Digite sua idade: ”) digitar 14, o valor de idade será leia(idade) 14. escreva(nome,” tem “, idade,” anos de idade”) idade: inteiro inicio

fimalgoritmo

Diagrama de Chaplin:

Inicio

Escreva “Digite seu nome: ”

Leia(nome)

Escreva “Digite sua Idade: ”

Leia(idade)

Escreva nome,” tem “, idade,” anos de idade”

Fim

30 de 65 Fluxograma:

Inicio

“Digite seu nome: ”

nome

“Digite sua Idade: ”

idade

nome,” tem “, idade,” anos de idade”

Fim

Resultado na máquina:

Exemplo 04: algoritmo, onde se solicite ao aluno o seu nome e sua nota 01, sua nota 02, e posteriormente seja exibido na tela a seguinte mensagem:

31 de 65 <nome digitado>, sua média é: <valor da média>. Informações sobre como gerar o resultado: O usuário digitou João, e depois 6 e 7. O resultado será: João , sua média é: 6.5 Pseudocódigo:
algoritmo “Ler o nome, duas notas e exibir exibir a média” var nota1, nota2, media: real nome : caracter inicio escreva(“Digite seu nome: ”) leia(nome) escreva(“Digite a primeira nota: ”) leia(nota1) escreva(“Digite a segunda nota: ”) leia(nota2) media <- (nota1 + nota2)/2 escreva(nome,” sua média é: ”, media) fimalgoritmo

Diagrama de Chaplin:

Inicio Escreva “Digite seu nome: ” Leia(nome) Escreva “Digite a primeira nota: ” Leia(nota1) Escreva “Digite a segunda nota: ” Leia(nota2) media <- (nota1 + nota2)/2 Escreva nome,” sua média é: ”, media Fim

32 de 65 Fluxograma:
Inicio

“Digite seu nome: ”

nome

“Digite a primeira nota: ”

nota1

“Digite a segunda nota: ”

nota2

media <- (nota1 + nota2)/2

nome,” sua média é: ” , media

Fim

Resultado na máquina:

33 de 65

5.5 Estrutura Condicional
É a estrutura que permite a tomada de decisão, em um algoritmo, mediante a análise lógica de uma condição – teste lógico / expressão-lógica; Condição → comparação que somente possui dois valores possíveis (verdadeiro ou falso); Estrutura: se <expressão-lógica> entao <sequência-de-comandos> fimse Se o seu resultado da <expressão-lógica> for VERDADEIRO, todos os comandos da <sequência-de-comandos> (entre esta linha e a linha com fimse) são executados. Se o resultado for FALSO, estes comandos são desprezados e a execução do algoritmo continua a partir da primeira linha depois do fimse. se <expressão-lógica> entao <sequência-de-comandos-1> senao <sequência-de-comandos-2> fimse Nesta outra forma do comando, se o resultado da avaliação de <expressãológica> for VERDADEIRO, todos os comandos da <sequência-de-comandos-1> (entre esta linha e a linha com senao) são executados, e a execução continua depois a partir da primeira linha depois do fimse. Se o resultado for FALSO, estes comandos são desprezados e o algoritmo continua a ser executado a partir da primeira linha depois do senao, executando todos os comandos da <sequência-decomandos-2> (até a linha com fimse). Estes comandos equivalem ao if...then e if...then...else do Pascal, e ao if e if...else do JAVA. Note que não há necessidade de delimitadores de bloco (como begin e end, e { }), pois as sequências de comandos já estão delimitadas pelas palavras-chave senao e fimse. O VisuAlg permite o aninhamento desses comandos de desvio condicional.

34 de 65 Exemplo 01: Algoritmo para verificar e um número é par: Pseudocódigo:
algoritmo “Verifica se é Par” var num, resto: inteiro Inicio escreva(“Digite um número ”) leia(num) resto <- num mod 2 se resto = 0 entao escreva(“O número ”, num, “ é par.”) fimse fimalgoritmo //Poderia ser também num % 2

Fluxograma:

35 de 65 Diagrama de Chaplin:

Resultado na máquina:

Exemplo 02: Algoritmo para verificar e um número é par ou impar: Pseudocódigo:
algoritmo “Verifica se é Par ou Impar” var num, resto: inteiro Inicio escreva(“Digite um número ”) leia(num) resto <- num mod 2 se resto = 0 entao escreva(“O número”, num, “ é par.”) senao escreva(“O número”, num, “ é impar.”) fimse fimalgoritmo //Poderia ser também num % 2

36 de 65 Fluxograma:

Diagrama de Chaplin:

37 de 65 Resultado na máquina:

Exemplo 03: Algoritmo que solicite dois números e informe qual é o maior: Pseudocódigo:
algoritmo “Verifica qual é o maior” var num1, num2: inteiro Inicio escreva(“Digite o primeiro número ”) leia(num1) escreva(“Digite o segundo número ”) leia(num2) se num1 > num2 entao escreva(“O número”, num1, “ é maior que ”, num2) senao se num1 < num2 entao escreva(“O número”, num2, “ é maior que ”, num1) senao escreva(“O número”, num1, “ é igual ao ”, num2) fimse fimse fimalgoritmo

Resultado na máquina:

38 de 65

Exemplo 04: Faça um algoritmo, onde se solicite ao aluno o seu nome e sua nota 01, sua nota 02, e posteriormente seja exibido na tela as seguintes mensagens: Quando o aluno atingir nota superior ou igual a 6,00: <nome digitado>, sua média é: <valor da média>, você está aprovado. Caso contrário: <nome digitado>, sua média é: <valor da média>, você está reprovado. Pseudocódigo:
algoritmo “Calcula média e verifica aprovação” var nota1, nota2, media: real nome: caracter Inicio escreva(“Digite seu nome”) leia(nome) escreva(“Digite a primeira nota”) leia(nota1) escreva(“Digite a segunda nota”) leia(nota2) media <- (nota1 + nota2) / 2 se media >= 6 entao

escreva(nome, “ sua média é:”, media, “ você está aprovado.”)
senao

escreva(nome, “ sua média é:”, media, “ você está reprovado.”)
fimse fimalgoritmo

39 de 65 Resultado na máquina:

Exemplo 05: Fazer um algoritmo que receba dois números e um operador (+, -, / e *), e de acordo com o operador digitado, efetue a operação correta e exiba o resultado. Caso a operação escolhida seja divisão, verificar se o segundo número é igual a 0, e sendo, informar que a divisão não é possível. Pseudocódigo:
algoritmo "Calculadora" // Seção de Declarações var n1, n2: inteiro sinal:caracter inicio escreval("Digite um número") leia(n1) escreval("Digite a operação (+, -, * ou / )") leia(sinal) escreval("Digite um número") leia(n2) se(sinal = "+") entao escreva("O resultado é: ", n1 + n2) senao se(sinal = "-") entao escreva("O resultado é: ", n1 - n2) senao se(sinal = "*") entao

40 de 65
escreva("O resultado é: ", n1 * n2) senao se(sinal = "/") entao se (n2 = 0) entao escreva("Divisão por zero não é permitido") senao escreva("O resultado é: ", n1 / n2) fimse senao escreva(sinal, ", não é um operador válido") fimse fimse fimse fimse fimalgoritmo

Resultado na máquina:

41 de 65 Exemplo 06: Fazer um algoritmo que receba o tipo de figura: q, r, t (quadrado, retângulo e triângulo respectivamente). Para q solicitar um lado, r e t dois lados. Calcular e exibir sua área e valores digitados. Caso se digite tipos diferentes informar. Área do quadrado = L² ; Área do quadrado = L1 * L2 Área do triângulo = (L1 * L2) / 2 Pseudocódigo:
algoritmo "Calcula área de polígonos" // Seção de Declarações var L1, L2 : inteiro poligono : caracter area : real inicio escreval("Digite um Poligono:") escreval("Q - Quadrado") escreval("R - Retângulo") escreval("T - Triângulo") leia(poligono) se(poligono = "Q") entao escreval("Digite o lado do Quadrado") leia(L1) se(L1 > 0) entao area <- L1 ^ 2 escreva("A área do Quadrado é:", area) senao escreva("O valor do Lado não pode ser menor ou igual a 0") fimse senao se(poligono = "R") entao escreval("Digite o lado 1 do Retângulo") leia(L1) escreval("Digite o lado 2 do Retângulo") leia(L2) se(L1 <= 0) e (L1 <= 0)entao escreva("O valor do Lado não pode ser menor ou igual a 0") senao area <- L1 * L2 escreva("A área do Retângulo é:", area) fimse senao se(poligono = "T") entao escreval("Digite o lado 1 do Triângulo") leia(L1) escreval("Digite o lado 2 do Triângulo") leia(L2) se(L1 <= 0) e (L1 <= 0)entao escreva("O valor do Lado não pode ser menor ou igual a 0")

42 de 65
senao area <- L1 * L2/2 escreva("A área do Triângulo é:", area) fimse senao escreva(poligono, ", não é um poligono válido!!!!") fimse fimse fimse fimalgoritmo

Resultado na máquina:

Exemplo 07: Fazer um algoritmo que receba o tipo de associação de resistores: S ou P (Série ou Paralelo), e três valores de resistências. Caso se digite tipos

43 de 65 diferentes de associação, informar! Se o valor da resistência for zero informar que este valor é inválido. Série => RT = R1 + R2 + R3 Paralelo => 1/RT = 1/R1 + 1/R2 + 1/R3 ou (R1 * R2) / (R1 +R2) de dois em dois. Pseudocódigo:
Algoritmo "Calcula Resistência" var acao: caracter RT, R1, R2, R3 : Real inicio escreval("Digite a associação:") escreval("S - Série") escreval("P - Paralelo") leia(acao) se acao = "S" entao escreva("Digite o valor de R1 ") leia(R1) escreva("Digite o valor de R2 ") leia(R2) escreva("Digite o valor de R3 ") leia(R3) se (R1 <= 0) ou (R2 <= 0) ou (R3 <= 0) entao escreva("Impossível calcular") senao escreva("O valor da Resistência é: ", R1 + R2 + R3) fimse senao se acao = "P" entao escreva("Digite o valor de R1 ") leia(R1) escreva("Digite o valor de R2 ") leia(R2) escreva("Digite o valor de R3 ") leia(R3) se (R1 <= 0) ou (R2 <= 0) ou (R3 <= 0) entao escreva("Impossível calcular") senao RT <- (R1 * R2) / R1 + R2 RT <- (RT * R3) / RT + R3 escreva("O valor da Resistência é: ", RT) fimse senao escreva(acao, " É um valor inválido") fimse fimse fimalgoritmo

44 de 65 Resultado na máquina:

Exemplo 08: Fazer um algoritmo que calcule os valores de corrente (i), tensão (u) e resistência (r), de acordo com as fórmulas abaixo: u = i * r; i = u / r ; r = u / i Se algum valor digitado for zero informar q é inválido.

45 de 65

Pseudocódigo:
Algoritmo "Cálculo de P, U, R, I" var acao: caracter U,I,R,P : Real inicio escreval("Indique o que você pretende calcular:") escreval("P - Potência") escreval("U - Tensão") escreval("I - Corrente") escreval("R - Resistência") leia(acao) se acao = "P" entao escreva("Digite o valor de U - Tensão: ") leia(U) escreva("Digite o valor de I - Corrente: ") leia(I) se (U > 0) e (I > 0) entao P <- U * I escreva("O valor de P, é: ",P,"W") senao escreva("Impossível calcular") fimse senao se acao = "I" entao escreva("Digite o valor de U - Tensão: ") leia(U) escreva("Digite o valor de R - Resistência: ") leia(R) se (U > 0) e (R > 0) entao I <- U / R escreva("O valor de I, é: ",I,"A") senao escreva("Impossível calcular") fimse senao se acao = "U" entao escreva("Digite o valor de R - resistência: ") leia(R) escreva("Digite o valor de I - Corrente: ") leia(I) U <- R * I escreva("O valor de U, é: ",U,"V") senao se acao = "R" entao escreva("Digite o valor de U - Tensão: ") leia(U) escreva("Digite o valor de I - Corrente: ") leia(I) se (U > 0) e (I > 0) entao R <- U / I escreva("O valor de R, é: ",R,"ohm") senao escreva("Impossível calcular") fimse senao

46 de 65
escreva(acao, ", é um valor inválido!!") fimse fimse fimse fimse fimalgoritmo

Resultado na máquina:

Exemplo 09: Faça um algoritmo que receba um número e verifique se ele é impar. Sendo verificar se é múltiplo de 9, e quando for informar ao usuário com a seguinte mensagem: <Número digitado> é impar e múltiplo de 9. quando for apenas impar exibir a mensagem: <Número digitado> é impar e , mas não é múltiplo de 9. caso contrário, apresentar a seguinte informação: <Número digitado> não é impar:

47 de 65

Pseudocódigo:
algoritmo "Verifica se é impar e múltiplo 9" // Data : 2/5/2011 // Seção de Declarações var num, res, eDivi9 : inteiro inicio escreva("Digite um número: ") leia(num) res <- num mod 2 eDivi9 <- num mod 9 se (res <> 0) e (eDivi9 = 0) entao escreva(num, ", é impar e múltiplo de 9") senao se (res <> 0) e (num mod 9 <> 0) entao escreva(num, ", é impar, mas não é múltiplo de 9") senao escreva(num, ", Nao impar") fimse fimse fimalgoritmo

Resultado na máquina:

5.6 Estrutura Seleção Múltipla
É a estrutura que permite a tomada de decisão, comparando um dado valor a constantes, desviando o fluxo de código para o ponto indicado pela primeira constante onde há similaridade;

48 de 65 O VisuAlg implementa (com certas variações) o comando case do Pascal ou switch case do Java. A sintaxe é a seguinte: Estrutura: escolha <expressão-de-seleção> caso <exp11>, <exp12>, ..., <exp1n> <sequência-de-comandos-1> caso <exp21>, <exp22>, ..., <exp2n> <sequência-de-comandos-2> ... outrocaso <sequência-de-comandos-extra> fimescolha Quando o resultado da avaliação de <expressão-de-seleção> for igual ao valor de <exp11> ou <exp12> ou <exp1n> (caso <exp11>, <exp12>, ..., <exp1n>), todos os comandos da <sequência-de-comandos-1> são executados, caso contrário, serão testados os valores para <exp21> ou <exp22> ou <exp2n> (caso <exp21>, <exp22>, ..., <exp2n>) e neste caso, todos os comandos da <sequênciade-comandos-2> são executados, e assim por diante. Se ocorrer de nenhum dos valores testados nas linhas com a palavra-chave “caso”, ocorrerá a execução do que for previso com a palavra-chave “outrocaso”, ou seja, todos os comandos da <sequência-de-comandos-extra> são executados. Exemplo 01: Algoritmo para selecionar um dia da semana: Pseudocódigo:
Algoritmo "Dias da semana" var dia: inteiro inicio escreval("Digite um número de 1 a 7") leia(dia) escolha dia caso 1 escreva("Domingo") caso 2 escreva("Segunda-feira") caso 3 escreva("Terça-feira") caso 4

49 de 65
escreva("Quarta-feira") caso 5 escreva("Quinta-feira") caso 6 escreva("Sexta-feira") caso 7 escreva("Sábado") outrocaso escreva(dia, " É um valor inválido") fimescolha fimalgoritmo

Fluxograma:

50 de 65 Resultado na máquina:

Exemplo 02: Algoritmo que solicita ao usuário a quantidade e o código de um produto e depois seja exibido qual produto, quantidade de produtos informada e o valor total da compra: Veja a tabela abaixo: Código 1 2 3 4 5 Feijão Arroz Macarrão Picanha Leite Produto Preço R$2,30 R$4,21 R$1,10 R$9,66 R$2,15

Pseudocódigo:
Algoritmo "Localiza produtos" var codigo: inteiro quantidade, valorTotal: real inicio escreval("Digite o código do produto:") leia(codigo)

51 de 65
escolha codigo caso 1 escreval("Digite a quantidade de produtos") leia(quantidade) se quantidade <= 0 entao escreva("A quantidade não pode ser igual ou menor que 0") senao valorTotal <- quantidade * 2.30 escreva("Você comprou", quantidade, "Kg de Feijão e vai pagar, R$",valorTotal) fimse caso 2 escreval("Digite a quantidade de produtos") leia(quantidade) se quantidade <= 0 entao escreva("A quantidade não pode ser igual ou menor que 0") senao valorTotal <- quantidade * 4.21 escreva("Você comprou", quantidade, "Kg de Arroz e vai pagar, R$",valorTotal) fimse caso 3 escreval("Digite a quantidade de produtos") leia(quantidade) se quantidade <= 0 entao escreva("A quantidade não pode ser igual ou menor que 0") senao valorTotal <- quantidade * 1.10 escreva("Você comprou", quantidade, "Kg de Macarrão e vai pagar, R$",valorTotal) fimse caso 4 escreval("Digite a quantidade de produtos") leia(quantidade) se quantidade <= 0 entao escreva("A quantidade não pode ser igual ou menor que 0") senao valorTotal <- quantidade * 9.66 escreva("Você comprou", quantidade, "Kg de Picanha e vai pagar, R$",valorTotal) fimse caso 5 escreval("Digite a quantidade de produtos") leia(quantidade) se quantidade <= 0 entao escreva("A quantidade não pode ser igual ou menor que 0") senao valorTotal <- quantidade * 2.15 escreva("Você comprou", quantidade, "L de Leite e vai pagar, R$",valorTotal) fimse outrocaso escreva(codigo, " É um valor inválido") fimescolha fimalgoritmo

52 de 65 Resultado na máquina:

Exemplo 03: Algoritmo para exibir quantidade de dias de um determinado mês: Pseudocódigo:
Algoritmo "Dias / Mês" var mes: inteiro inicio escreval("Digite um Mês de 1 a 12") leia(mes) escolha mes caso 1, 3, 5, 7, 8, 10, 12 escreva("O Mês",mes, ", possui 31 mess") caso 2 escreva("O Mês",mes, ", possui 28 mess") caso 4, 6, 9, 11 escreva("O Mês",mes, ", possui 30 mess") outrocaso escreva(mes, " É um valor inválido") fimescolha fimalgoritmo

Resultado na máquina:

53 de 65

5.7 Estrutura de Repetição - Laços
É a estrutura de desvio do fluxo de controle presente em algoritmos que realiza e repete diferentes ações dependendo de uma condição ser verdadeira ou falsa; Estão associados a uma estrutura de repetição uma condição de parada (teste lógico) e um conjunto (sequência) de instruções: verifica-se a condição, e caso seja verdadeira (dependendo do tipo de laço, pode ser verificado antes ou após a execução das instruções), o bloco é executado. Após o final da execução do conjunto de instruções, a condição é verificada novamente, e caso ela ainda seja verdadeira, o código é executado novamente. Um item que merece atenção na criação de algoritmos que utilizem estruturas de repetição é: se o conjunto de instruções nunca alterar o estado da condição, o algoritmo entrará numa situação conhecida com laço infinito, ou seja, o algoritmo nunca saíra da execução do laço. Existem três estruturas de repetição usuais nas linguagens de programação e algoritmos, sendo estas também implementadas no VisuAlg: ➔ ➔ ➔ Repetição pré-testada – "enquanto...faca"; Repetição pós-testada - “Repita … até”; Repetição com variável de controle - “ para...ate...faca”.

54 de 65

5.7.1 Estrutura de Repetição Pré-testada – "enquanto...faca"
Esta estrutura repete uma sequência de comandos enquanto uma determinada condição (especificada através de uma expressão lógica) for satisfeita. Estrutura:

enquanto <expressão-lógica> faca <sequência-de-comandos> fimenquanto Neste tipo de laço, a <expressão-lógica> (condição de parada) é primeiramente verificada, e se for verdadeira a <sequência-de-comandos> é executada. No final da execução da <sequência-de-comandos>, atingir o comando fimenquanto, volta-se ao início do laço onde a condição de parada <expressãológica> é novamente testada, dando prosseguimento a repetição do laço até a <expressão-lógica>, retornar falso. Exemplo 01: Algoritmo que solicite ao usuário um número, e seja capaz de exibir todos os números inteiros a partir do digitado até 50: Pseudocódigo:
algoritmo "sequencia de números até 50" // Função : // Autor : // Data : 28/5/2011 // Seção de Declarações var num:inteiro inicio escreva("Digite um numero: ") leia(num) enquanto num <= 50 faca escreva(num) num <- num + 1 fimenquanto fimalgoritmo

55 de 65 Fluxograma:

Diagrama de Chaplin:

56 de 65 Resultado na máquina:

Exemplo 02: Elabore um algoritmo que solicite ao usuário um número, e seja capaz de exibir todos os números inteiros de 1 até ele: Pseudocódigo:
algoritmo "sequencia de números até até o digitado" // Função : // Autor : // Data : 28/5/2011 // Seção de Declarações var num,aux:inteiro inicio escreva("Digite um numero: ") leia(num) aux<-1 enquanto aux <= num faca escreva(aux) aux<-aux+1 fimenquanto fimalgoritmo

Resultado na máquina:

57 de 65 Exemplo 03: Elabore um algoritmo que a partir do exemplo 2 exiba também a soma dos números gerados: Pseudocódigo:
algoritmo "sequencia de números até até o digitado + Soma" // Função : // Autor : // Data : 28/5/2011 // Seção de Declarações var num,soma,aux:inteiro inicio escreva("Digite um numero: ") leia(num) aux<-1 soma<-0 enquanto aux<=num faca escreval(aux) soma<-soma+aux aux<-aux+1 fimenquanto escreva("A soma e: ",soma) fimalgoritmo

Resultado na máquina:

Exemplo 04: Elabore um algoritmo que solicite o nome do usuário ou a letra “s” para sair, e enquanto não se desejar sair, solicitar também o telefone: Pseudocódigo:
algoritmo "Solicita nome e telefone - Laço" // Função : // Autor : // Data : 28/5/2011 // Seção de Declarações var

58 de 65
nome, telefone: caracter inicio escreva("Digite seu nome ou 's' para sair: ") leia(nome) enquanto nome <> "s" faca escreva("Digite seu telefone:") leia(telefone) escreval("Usuário: ", nome, " - Telefone: ", telefone) escreva("Digite seu nome ou 's' para sair: ") leia(nome) fimenquanto fimalgoritmo

Resultado na máquina:

Exemplo 05: Elabore um algoritmo que a partir do exemplo 4 exiba também a quantidade de usuários cadastrados: Pseudocódigo:
algoritmo "Solicita nome e telefone - Laço e conta usuários" // Função : // Autor : // Data : 28/5/2011 // Seção de Declarações var nome, telefone: caracter cont: inteiro inicio cont <- 0 escreva("Digite seu nome ou 's' para sair: ") leia(nome) enquanto nome <> "s" faca escreva("Digite seu telefone:") leia(telefone) escreval("Usuário: ", nome, " - Telefone: ", telefone) escreva("Digite seu nome ou 's' para sair: ") leia(nome) cont <- cont + 1 fimenquanto escreva("Total de usuários cadastrados: ", cont) fimalgoritmo

59 de 65

Resultado na máquina:

5.7.2 Estrutura de Repetição Pós-testada – "repita...ate"
É uma variação da estrutura anterior, e difere pela verificação da condição que é feita após uma execução da sequencia de comandos e a expressão lógica que necessita de seu resultado falso para dá prosseguimento ao laço. Estrutura: repita <sequência-de-comandos> ate <expressão-lógica> Neste tipo de laço, a <sequência-de-comandos> é executada primeiramente para depois a <expressão-lógica> (condição de parada) ser verificada. A palavra chave repita indica o inicio do laço. Já a palavra chave ate indica o fim da <sequência-de-comandos> a serem repetidos (laço). Cada vez que o programa chega neste ponto (ate), <expressão-lógica> é avaliada, e se for falsa, volta-se ao início do laço (repita), onde a <sequência-de-comandos> é executada novamente, e depois a condição de parada <expressão-lógica> é novamente testada, dando prosseguimento a repetição do laço até seu valor ser verdadeiro.

60 de 65 Exemplo 01: Algoritmo que solicite ao usuário um número, e seja capaz de exibir todos os números inteiros a partir do digitado até 50: Pseudocódigo:
algoritmo "sequencia de números até 50" // Função : // Autor : // Data : 28/5/2011 // Seção de Declarações var num:inteiro inicio escreva("Digite um numero: ") leia(num) repita escreva(num) num <- num + 1 ate num > 50 fimalgoritmo

Se o usuário digitar um número maior que 50 ele será exibido pelo menos uma vez! Corrigível com a estrutura “se”, não utilizada para simplificar o algoritmo

Observe que utilizando a estrutura enquanto, o teste era efetuado ao contrário: num <= 50, e não, num > 50

Fluxograma:

61 de 65

Diagrama de Chaplin:

Resultado na máquina:

Obs: resultado incorreto para o solicitado no algoritmo

Exemplo 02: Elabore um algoritmo que solicite ao usuário um número, e seja capaz de exibir todos os números inteiros de 1 até ele: Pseudocódigo:
algoritmo "sequencia de números até até o digitado" // Função : // Autor : // Data : 28/5/2011 // Seção de Declarações var num,aux:inteiro inicio escreva("Digite um numero: ") leia(num) aux<-1

62 de 65
enquanto aux <= num faca escreva(aux) aux<-aux+1 fimenquanto fimalgoritmo

Resultado na máquina:

Exemplo 03: Elabore um algoritmo que a partir do exemplo 2 exiba também a soma dos números gerados: Pseudocódigo:
algoritmo "sequencia de números até até o digitado + Soma" // Função : // Autor : // Data : 28/5/2011 // Seção de Declarações var num,soma,aux:inteiro inicio escreva("Digite um numero: ") leia(num) aux<-1 soma<-0 enquanto aux<=num faca escreval(aux) soma<-soma+aux aux<-aux+1 fimenquanto escreva("A soma e: ",soma) fimalgoritmo

63 de 65 Resultado na máquina:

Exemplo 04: Elabore um algoritmo que solicite o nome do usuário ou a letra “s” para sair, e enquanto não se desejar sair, solicitar também o telefone: Pseudocódigo:
algoritmo "Solicita nome e telefone - Laço" // Função : // Autor : // Data : 28/5/2011 // Seção de Declarações var nome, telefone: caracter inicio escreva("Digite seu nome ou 's' para sair: ") leia(nome) enquanto nome <> "s" faca escreva("Digite seu telefone:") leia(telefone) escreval("Usuário: ", nome, " - Telefone: ", telefone) escreva("Digite seu nome ou 's' para sair: ") leia(nome) fimenquanto fimalgoritmo

Resultado na máquina:

Exemplo 05:

64 de 65 Elabore um algoritmo que a partir do exemplo 4 exiba também a quantidade de usuários cadastrados: Pseudocódigo:
algoritmo "Solicita nome e telefone - Laço e conta usuários" // Função : // Autor : // Data : 28/5/2011 // Seção de Declarações var nome, telefone: caracter cont: inteiro inicio cont <- 0 escreva("Digite seu nome ou 's' para sair: ") leia(nome) enquanto nome <> "s" faca escreva("Digite seu telefone:") leia(telefone) escreval("Usuário: ", nome, " - Telefone: ", telefone) escreva("Digite seu nome ou 's' para sair: ") leia(nome) cont <- cont + 1 fimenquanto escreva("Total de usuários cadastrados: ", cont) fimalgoritmo

Resultado na máquina:

65 de 65

BIBLIOGRAFIA
FORBELLONE, Andre Luiz Vilar; EBERSPACHER, Henri Frederico. Lógica de programação: a construção de algoritmos e estruturas de dados. 3. ed. São Paulo: Makron Books; Pearson Education do Brasil, 2006. ASCENCIO, Ana Fernanda Gomes; CAMPOS, Edilene Aparecida Veneruchi. Fundamentos da Programação de Computadores: Algorítimos, Pascal, C++ e Java. 2. ed. São Paulo: Pearson Education do Brasil, 2010. PUGA, Sandra; RISSETTI Gerson. Lógica de Programação e Estruturas de Dados: com Aplicações em Java. 2. ed. São Paulo: Pearson Education do Brasil, 2010. ZIVIANI, Nivio. Projeto de Algoritmos: com Implementações em Java e C ++. 2. ed. São Paulo: Thomson; Cengage Learning, 2007. FREITAS, Maria Ester; DANTAS, Marcelo. Algoritmos e Lógica de Programação. 2. ed. São Paulo: Cengage Learning, 2011. WIKIBOOKS (2010). Introdução à Programação. Acessado em: 02/ 02/ 2011, em: http://pt.wikibooks.org/wiki/Introdu%C3%A7%C3%A3o_%C3%A0_programa %C3%A7%C3%A3o/Defini%C3%A7%C3%B5es_sobre_L %C3%B3gica_de_Programa%C3%A7%C3%A3o#T.C3.A9rmino_do_algoritmo WIKIPROG(2010). Algoritmo (Indentação). Acessado em: 02/ 02/ 2011,em: http://pt.wikipedia.org/wiki/Indentação

Sign up to vote on this title
UsefulNot useful