logprog_2013

APOSTILA PARA A DISCIPLINA

Lgica de Programao

CURSO Tcnico em Automao Industrial

Professor Thiago R. de Oliveira

Agosto de 2013

Lgica de Programao

Prof. Thiago de Oliveira ii Lgica de Programao

Sumrio CAPTULO 1 INTRODUO ................................................................................................................... 1

1. Lgica ................................................................................................................................................ 1 2. Instrues ........................................................................................................................................... 1 3. Algoritmos ......................................................................................................................................... 2 4. Programas e cdigos ........................................................................................................................... 4 5. Objetivos do curso .............................................................................................................................. 4

CAPTULO 2 ESTRUTURA DE UM ALGORITMO................................................................................ 6 1. Arquitetura bsica de um computador ................................................................................................. 6 2. Estruturas bsicas de algoritmos ......................................................................................................... 8 3. Variveis e constantes......................................................................................................................... 9 4. Tipos de dados ..................................................................................................................................10 5. Operadores ........................................................................................................................................11

CAPTULO 3 O VISUALG E A LINGUAGEM PORTUGOL .................................................................12 1. Formato bsico do cdigo ..................................................................................................................12 2. Tipos de dados ..................................................................................................................................13 3. Declarao de variveis .....................................................................................................................14 4. Operadores Aritmticos .....................................................................................................................14 5. Operadores Relacionais .....................................................................................................................15 6. Operadores lgicos ............................................................................................................................15

CAPTULO 4 - SEQUNCIA .......................................................................................................................16 1. Comando de atribuio ......................................................................................................................16 2. Comandos de entrada e sada de dados ...............................................................................................16 3. Funes e Procedimentos ...................................................................................................................18 3.1. Funes ..........................................................................................................................................18 3.2. Procedimentos ................................................................................................................................20

CAPTULO 5 ITERAO ........................................................................................................................23 1. Comando Para..faca ...........................................................................................................................24 2. Comando enquanto..faca ....................................................................................................................26 3. Comando repita..ate ...........................................................................................................................27

CAPTULO 6 - SELEO ...........................................................................................................................28 1. Comando Se..entao ............................................................................................................................28 2. Comando Se..entao..senao .................................................................................................................28 3. Comando Escolha ..............................................................................................................................29

REFERNCIAS ............................................................................................................................................30

Lgica de Programao

Prof. Thiago de Oliveira 1 Lgica de Programao

Captulo 1 Introduo

1. Lgica A lgica de programao necessria para pessoas que desejam trabalhar com

desenvolvimento de sistemas e programas, ela permite definir a sequncia lgica para o

desenvolvimento.

Ento o que lgica?

Lgica de programao a tcnica de encadear pensamentos para atingir

determinado objetivo.

Estes pensamentos podem ser descritos como uma sequncia de instrues, que devem

ser seguidas para se cumprir uma determinada tarefa. A essa sequncia de instrues, d-se o

nome de Sequncia lgica.

Sequncia Lgica so passos executados at se atingir um objetivo ou a soluo de

um problema.

2. Instrues Na linguagem comum, entende-se por instrues um conjunto de regras ou normas

definidas para a realizao ou emprego de algo. Em informtica, porm, instruo a

informao que indica a um computador uma ao elementar a executar. Convm ressaltar

que uma ordem isolada no permite realizar o processo completo, para isso necessrio um

conjunto de instrues colocadas em ordem sequencial lgica.

Por exemplo, se quisermos fazer uma omelete de batatas, precisaremos colocar em

prtica uma srie de instrues: descascar as batatas, bater os ovos, fritar as batatas, etc.

evidente que essas instrues tm que ser executadas em uma ordem adequada no se pode

descascar as batatas depois de frit-las. Dessa maneira, uma instruo tomada em separado

no tem muito sentido. Contudo ao colocarmos em prtica o conjunto de todas as instrues,

na ordem correta, conseguiremos atingir o objetivo desejado inicialmente.

Podemos definir instrues como:

Instrues so um conjunto de regras ou normas definidas para a realizao ou

emprego de algo. Em informtica, o que indica a um computador uma ao elementar

a executar.

Lgica de Programao


3. Algoritmos Um algoritmo formalmente uma sequncia finita de passos que leva execuo

de uma tarefa. Podemos pensar em algoritmo como uma receita, uma sequncia de

instrues que do cabo de uma meta especfica. Estas tarefas no podem ser redundantes

nem subjetivas na sua definio, devem ser claras e precisas.

Ao pensarmos em algoritmos no mbito da programao de computadores

importante determinar alguns aspectos importantes da sequncia lgica a ser construda:

Expresso finita: Um algoritmo uma lista de instrues, no entanto, ele

deve ser constitudo de uma quantidade finita de instrues. Essa exigncia

assegura que o algoritmo possa ser descrito e seja realmente executvel.

Execuo por mecanismo: Como o objetivo do curso estudar algoritmos

para programao de computadores, deve existir uma mquina capaz de

executar as etapas, ou sequncias, definidas no algoritmo. Ao atrelarmos a

execuo do algoritmo a um mecanismo autnomo, cria-se a exigncia de que

a construo do algoritmo deva ser feita de modo a no existirem instrues

ambguas e a necessidade de as instrues serem escritas em uma linguagem

possvel de ser interpretada pela mquina;

Execuo finita: Esta definio sutil exige que a execuo do algoritmo seja

realizada em tempo finito, ou seja, que o algoritmo tenha fim. Pode-se pensar

inicialmente que ao se ter um conjunto finito de instrues, a execuo do

algoritmo ser intrinsicamente finita em relao ao tempo. Contudo, podem

existir instrues que obriguem a mquina a executar uma tarefa repetidas

vezes, o que poderia fazer com que a execuo do algoritmo no tenha fim.

Os aspectos supracitados determinam algumas regras para a construo de algoritmos

que devem ser observadas:

1. Destrinchar o problema em uma sequncia finita de etapas a serem executadas;

2. Escrever como cada etapa ser executada, utilizando para isso uma linguagem objetiva

sem ambiguidades;

3. Garantir que a execuo das etapas ocorrer em tempo finito;

4. Garantir que a execuo das etapas pode ser realizada pelo mecanismo disponvel.

A ltima regra particularmente complexa, uma vez que atrela a construo do

algoritmo mquina que ir execut-lo. Para entender esse problema, vamos fazer um simples

exerccio de imaginao:

Lgica de Programao


Suponha por exemplo que voc deseja calcular o seno de 22, no entanto, voc dispe

apenas de uma calculadora de 4 operaes. Observe que a instruo passada a voc se torna

praticamente impossvel de ser executada, uma vez que a mquina a ser utilizada no

consegue realizar a operao seno. Desta forma, para que a instruo seja bem realizada, ou

seria necessria a utilizao de uma calculadora cientfica (mudana de mquina) ou a

descrio da tarefa em sequncias passveis de serem executadas pela calculadora (mudana

no algoritmo). Em ambas as situaes, nota-se que seria necessrio conhecer a estrutura e

capacidades da mquina antes de se construir o algoritmo.

Em nossa disciplina, a mquina para a qual iremos construir nossos algoritmos o

computador. O computador ento nada mais do que um mecanismo de execuo de

algoritmos programvel, capaz de lidar com instrues e dados e executar uma infinidade de

algoritmos. Contudo, como toda mquina, o computador tambm sofre das mesmas limitaes

citadas para a questo das calculadoras: ele possui um conjunto finito de instrues que

capaz de executar. Neste caso, como podemos escrever algoritmos para um computador?

Precisaramos conhecer a estrutura interna do computador e sua lista de instrues para

podermos desenvolver nossas sequncias lgicas? Bom, a princpio sim, em algum momento

o algoritmo dever ser escrito como uma sequncia de instrues que o computador possa

executar. Contudo, atualmente utilizamos ferramentas de programao que nos permitem

desenvolver um algoritmo com um nvel de complexidade muito menor do que a necessria

para operar diretamente o computador, estas ferramentas so descritas no diagrama da Figura

1.

Figura 1 - Etapas de construo de um algoritmo.

Como o diagrama mostra, existem pelo menos cinco etapas na construo de um

algoritmo at que ele esteja pronto para ser executado pelo computador:

Definio do algoritmo Nesta etapa as sequncias lgicas a serem

executadas sero definidas. No nos preocuparemos neste momento com a

Lgica de Programao


forma como cada instruo ser realizada, mas apenas nas etapas necessrias

para se atingir o objetivo desejado. A escrita do algoritmo pode ser feita como

uma lista de tarefas (pseudocdigo), como um fluxograma, ou outra forma que

facilita a compreenso por parte do ser humano;

Escrita em uma linguagem de programao Nesta etapa, o algoritmo feito

anteriormente ser traduzido para uma linguagem de programao em alto

nvel, ou seja, uma linguagem bem definida com uma lista de instrues de

sintaxe (forma de escrever) e semntica (significado) conhecidas, mas que

esteja mais prxima da linguagem humana do que da linguagem de mquina.

Existem diversas linguagens de programao (C, C++, Pascal, Cobol, Fortran,

Portugol, Phyton, HTML, Java, etc) cada uma com suas particularidades;

Compilagem ou interpretao O compilador um programa responsvel

por fazer a traduo de um algoritmo escrito em linguagem de programao

para uma linguagem de mquina especfica da mquina utilizada;

Execuo do algoritmo Aps o processo de compilao, gerado um

arquivo em linguagem de mquina, normalmente um arquivo executvel, que

ir desenvolver as sequncias lgicas desenvolvidas na etapa inicial da

construo do algoritmo.

Note que a utilizao dessas etapas permite que o programador escreva seu algoritmo

em uma linguagem mais simples e a traduo para um conjunto de instrues especfico do

computador utilizado fica a cargo do programa compilador. Apesar de ser um processo mais

fcil do que tentar conversar diretamente com o computador, exige que o programador tenha

domnio sobre a linguagem de programao a ser empregada, uma vez que a primeira etapa de

traduo deve ser realizada pelo ser humano mesmo.

4. Programas e cdigos Programas so algoritmos escritos em linguagem de programao, os quais tambm

so chamados de cdigos. O cdigo principal do programa chamado de cdigo fonte e os

programas perifricos, como funes e procedimentos, so denominados sub-programas, ou

sub-rotinas.

5. Objetivos do curso Este curso se prope a estudar e definir meios e procedimentos de se escrever

algoritmos. Contudo, para podermos desenvolver nosso trabalho com melhor xito

necessitamos definir tambm uma linguagem de programao base para estudo, sem, no

Lgica de Programao


entanto, ter ela com foco do trabalho. Assim, decidimos pelo uso da linguagem Portugol, que

uma linguagem bem simplificada, com instrues em portugus, mas que permite

compreender e aplicar os principais conceitos por traz da programao de computadores. O

Portugol utiliza um programa interpretador para executar os cdigos desenvolvidos, o qual,

nesta disciplina, ser o programa Visualg 2.0. Ao final da disciplina estudaremos formas de se

escrever algoritmos em um formato visualmente mais simples chamado de fluxograma.

Lgica de Programao


Captulo 2 Estrutura de um algoritmo

Como discutido anteriormente, um algoritmo uma sequncia de passos que leva

execuo de uma tarefa. Esta sequncia de passos, no entanto, deve ser traduzida em algum

momento para uma linguagem de programao, a fim de se possibilitar a futura execuo por

parte do computador. Assim sendo, ao se conhecer as estruturas bsicas de uma linguagem e

programao podemos economizar tempo e esforo na construo do algoritmo, definindo

instrues compatveis com aquelas presentes na linguagem de programao. Antes de

estudar essas estruturas devemos entender como que um algoritmo executado em um

computador.

1. Arquitetura bsica de um computador Um computador construdo de um processador, tambm conhecida como CPU

(unidade de processamento central), a qual responsvel por executar o conjunto de

instrues do computador e realizar o processamento de dados; um sistema de

armazenamento de dados, composta por vrios dispositivos, entre eles a memria RAM, que

armazena dados e comandos em uso imediato, e o HD (Hard Disk), que armazena um grande

volume de dados e programas; e perifricos de entrada e sada de dados, como o monitor de

vdeo, o teclado, mouse e placa de rede. A Figura 2 mostra um diagrama simplificado dessa

arquitetura.

Figura 2 - Arquitetura bsica de um computador

O programa a ser executado pelo computador, aps o processo de compilao,

armazenado na memria do computador e ento executado, passo a passo pela CPU, caso a

instruo necessite de alguma informao (dado), a CPU ir busca-la tanto na memria,

quanto dos dispositivos de entrada e sada. Na memria RAM do computador podem estar

Lgica de Programao


armazenadas informaes referentes a diversos programas, de modo que dados manipulados

por um programa especfico podem ser utilizados por outro. Para evitar, no entanto que

informaes em processamento por um programa sejam destrudas, ou modificadas por outro

programa qualquer, existe a noo de alocao de memria. Neste processo, quando um

programa comea a ser executado pela CPU, uma parte da memria RAM destinada

exclusivamente para ele e nesta seo, os dados manipulados podem ser armazenados. Este

procedimento vai influenciar na forma como os programas enxergam os dados, o que ser

discutido posteriormente.

Tendo em vista a arquitetura bsica de um computador, podemos definir algumas

etapas que devem estar contidas em todos os algoritmos:

Entrada de dados Um programa, ou algoritmo, ir realizar o processamento

de informaes em sequncia, de modo a atingir um objetivo. A passagem

dessas informaes ao programa configura um processo de entrada de dados. A

entrada de dados pode ser feita manualmente, ou seja, o prprio usurio (ser

humano) passa as informaes para o programa, ou automaticamente, quando o

prprio programa solicita a outro programa ou algum dispositivo do

computador as informaes desejadas;

Processamento de dados Os dados de entrada sero manipulados pelo

programa, seguindo as etapas definidas pelo programados na construo do

algoritmo, de modo a se atingir o resultado esperado. Podem ser vistas como

tarefas de um processamento a atribuio de valores a variveis,

armazenamento de dados na memria, operaes, e execuo de instrues,

entre outras;

Sada de dados O resultado do processamento de dados normalmente

retornado para um ambiente externo ao programa executado. A informao

produzida pode ser apresentada ao usurio, por meio do monitor, impressora,

etc, ou repassada a outro perifrico do computador, como por exemplo o envio

de dados pela rede, armazenamento de dados no HD, etc.

Uma vez identificada essas trs etapas, se torna importante, ao escrevermos

algoritmos, identificarmos no problema a ser resolvido quais seriam os dados de entrada,

sada e quais processamentos seriam necessrios para transformar os dados de entrada nas

sadas adequadas.

Lgica de Programao


2. Estruturas bsicas de algoritmos Podemos agrupar a maioria das instrues disponveis em uma linguagem de

programao e, consequentemente, as etapas de um algoritmo em trs conceitos principais, as

quais controlam o fluxo de execuo do algoritmo: Sequncia, iterao e seleo.

Sequncia especifica uma ordem linear de execuo das instrues do algoritmo.

Apesar de muito simples, muitos iniciantes em programao de computadores realizam erros

de sequncia, no considerando a ordem de execuo de instrues. Como exemplo, imagine

que se deseje calcular a mdia de dois nmeros, um algoritmo para isso poderia ser: 1 - Defina um nmero x como entrada 2 - Defina um nmero y como entrada 3 - Defina um nmero z como sada 4 Atribua o valor 0 a z 5 - Entre com o valor de x 6 - Entre com o valor de y 7 - Faa z receber x+y 8 - Faa z receber z/2 9 - Retorne o valor de z Note que o objetivo de se obter a mdia de dois nmeros quaisquer apenas ser

alcanado se as etapas 1 a 9 forem executadas em sequncia. Se, por exemplo, as etapas 7 e 8

forem invertidas, a execuo possuir um resultado totalmente diferente. Por isso importante

sempre tem em mente que um algoritmo executado instruo por instruo em uma ordem

linear (um aps o outro).

Iterao execuo repetida de um grupo de instrues at que alguma condio seja

satisfeita. Em programas, comumente, alguma tarefa ou instruo deve ser repetida diversas

vezes. Considere por exemplo a tarefa de se somar uma lista de N nmeros, podemos escrever

N instrues do tipo adicionar o prximo nmero soma. Poderamos fazer o seguinte:

1 Defina um nmero N como entrada

2 Defina um nmero A como entrada

3 Defina um nmero S como sada

4 Atribua o valor 0 a S

5 Entre com o valor de N

6 Repita as etapas 7 e 8 N vezes, depois siga para a etapa 9:

7 Entre com o valor de A

8 Faa S receber S+A

9 Retorne o valor de S

Note que as etapas 7 e 8 sero executadas N vezes, de modo que o nmero A receber

N valores e o nmero S apresentar ao fim do algoritmo o somatrio desses valores. Com

Lgica de Programao


isso, um algoritmo que possuiria 100 etapas no mnimo em um sequncia normal executado

em 9 etapas, representando uma economia razovel de instrues, tempo e esforo, alm de

facilitar o entendimento do funcionamento do algoritmo.

Seleo a execuo seletiva de um grupo de instrues baseada em alguma

condio. Esta ideia nos permite escolher um caminho de execuo em funo dos dados

executados, permitindo uma flexibilidade maior ao algoritmo. Por exemplo, suponho que se

deseje fazer um algoritmo que calcule o peso ideal de um ser humano, sabe-se que a equao

que calcula esse peso :

= 100

, para homens

= 100

, para mulheres

Onde h a altura da pessoa em centmetros. Assim sendo, nota-se que a execuo do

programa pode tomar dois caminhos dependendo do sexo do indivduo. Um exemplo de

algoritmo para execuo dessa tarefa seria:

1 Defina um nmero h como entrada

2 Defina um nmero S como entrada

3 Defina um nmero P como sada

4 Entre com o valor de h //altura em centmetros

5 Entre com o valor de S //1 para homem ou 2 para mulher

6 Se S = 1, ento execute as etapa 7, seno execute a etapa 9

7 Faa P receber h 100 (h-150)/4

8 v para etapa 10

9 Faa P receber h 100 (h-150)/2

10 Retorne o valor de P

Observe que a sequncia de execuo do algoritmo depende do valor do nmero S, o

qual definido pelo prprio usurio.

3. Variveis e constantes Nos itens anteriores mencionamos que os dados manipulados pelo programa em algum

momento sero armazenados na memria do computador. Assim para podermos referenciar

esses dados em nosso cdigo, sem necessariamente nos preocuparmos em qual posio exata

de memria esse dado foi armazenado, utilizamos um indentificador (nome) e definimos o

tipo de informao que desejamos manipular (nmeros, letras, etc). Assim, o compilador ao

fazer a traduo do cdigo para linguagem de mquina saber fazer a indexao dos

identificadores com as posies de memria corretas. A informao referenciada aos

Lgica de Programao


identificadores pode variar ao longo da execuo do programa, por isso d-se a ela o nome de

varivel. Uma varivel ento um espao reservado na memria do computador para

armazenar um tipo de dado determinado.

Nos algoritmos citados anteriormente, quando utilizamos uma instruo do tipo:

Defina um nmero h como entrada, estamos na realidade fazendo uma declarao de uma

varivel. Neste exemplo, a varivel de nome h receber informaes numricas, ou seja, o

compilador saber que toda vez que o algoritmo utilizar o nome h a CPU dever

buscar/armazenar a informao sempre na mesma posio de memria e que todos os dados

manipulados por esta varivel sero do tipo numrico, o que indica ao computador qual o

tamanho da posio de memria.

Alm das variveis, os algoritmos tambm lidam com informaes do tipo constante,

esses tipos de dados no alteram seu valor ao longo da execuo do programa. Em um

algoritmo anterior escrevemos, por exemplo, Faa P receber h 100 (h-150)/4, neste caso,

os nmeros 100, 150 e 4 so constantes, uma vez que no variam ao longo do programa. No

entanto, esses exemplos no necessariamente possuem uma posio de memria reservada.

Podem existir situaes onde criamos uma constante e definimos uma posio de memria

especfica para ela, como exemplo: Defina um nmero PI = 3.141592. Neste caso,

reservamos uma posio de memria do tipo numrico, atribumos a ela o identificador PI e o

contedo dessa posio de memria ser sempre 3.141592 ao longo de toda a execuo do

programa, neste caso, apesar de passar por todas as etapas que a declarao de uma varivel,

declaramos uma constante. Note que em muitos casos a diferena entre varivel e constante

depende unicamente da lgica de uso dos dados.

4. Tipos de dados Na seo anterior discutimos que ao se declarar uma varivel devemos tambm

informar ao compilador qual tipo de informao ser manipulada por ela, ou seja, uma vez

definido que uma varivel ser numrica, no poderemos tentar manipular dados do tipo

caracteres e letras com esta mesma varivel, seria o mesmo que comprar uma vasilha de

biscoitos e tentar colocar nela uma bicicleta. forma da informao manipulada pelas

variveis damos o nome de Tipos de dados.

primeira vista, existe uma infinidade de tipos de dados que podemos utilizar ao

construir nossos algoritmos. Contudo, cada linguagem de programao possui sua prpria

lista de tipos, os quais ela consegue gerenciar. Em muitas linguagens o prprio programador

pode criar um tipo prprio de dados e dar mais flexibilidade ao seu cdigo. O Portugol

Lgica de Programao


tambm possui sua lista de tipos, mas discutiremos as particularidades da linguagem que

utilizaremos nos prximos captulos.

Independentemente da linguagem de programao a ser empregada na escrita do

cdigo do algoritmo, podemos dividir os tipos de variveis possveis em 3 grupos principais:

Numricas manipulam informaes numricas, como nmeros reais, inteiros

ou complexos. Esse tipo de dados permite operaes aritmticas;

Caracteres manipulam informaes do tipo texto: letras, palavras e

conjuntos alfanumricos, no entanto, no permitem operaes aritmticas, pois

enxergam as informaes como sequncias de caracteres;

Lgicas Armazenam informaes lgicas, as quais apenas permitem dois

estados: Verdadeiro ou falso. Possibilita o uso de operadores lgicos;

5. Operadores Os dados contidos em variveis podem ser manipulados por operaes sobre eles

realizadas. Em todas as linguagens de programao existem pelo menos 3 conjuntos de

operadores:

Aritmticos - os operadores aritmticos so os utilizados para obter resultados

numricos. Alm da adio, subtrao, multiplicao e diviso, podem utilizar

tambm o operador para exponenciao;

Relacionais so operadores utilizados para comparar dois conjuntos de dados

(=, >,

Lgica de Programao


Captulo 3 O visualg e a linguagem Portugol

Neste captulo discutiremos algumas particularidades sobre a linguagem Portugol e o

programa Visualg. No faremos um tutorial de uso do programa, uma vez que existem outros

textos que lidam com isso, mas discutiremos principalmente sobre conceitos j apresentados e

como podemos utiliz-los neste ambiente.

Antes de comearmos a discutir mais sobre a linguagem, deve-se mencionar alguns

pontos importantes sobre o Portugol do Visualg:

Permite apenas um comando por linha;

No h necessidade de smbolos que identificam o fim de uma instruo,

como vrgulas e ponto e vrgula, como ocorre em outras linguagens;

No permite o uso de smbolos como acentos, cedilhas e etc;

No existe diferenciao entre letras maisculas e minsculas;

Os nomes de variveis no podem conter espaos, comear com nmeros ou

possurem mais do que 30 caracteres;

O smbolo // marca o incio de um comentrio, ou seja, um pedao de texto

que ser ignorado pelo compilador do Visualg.

1. Formato bsico do cdigo O formato bsico do cdigo do Portugol no Visualg : algoritmo "Nome do programa" // Funo : // Autor : // Data : 27/07/2013 var // Seo de Declaraes inicio // Seo de Comandos fimalgoritmo

Note que as informaes precedidas pelo smbolo // so destacadas em verde e so

consideradas pelo programa como comentrios, isso significa que sero ignoradas pelo

programa e no tero nenhuma ao na execuo do algoritmo. A sua finalidade meramente

orientar o programador ou leitor. A informao Nome do programa (entre aspas duplas) o

nome dado ao algoritmo escrito, essa informao obrigatria, no entanto, pode se utilizar o

Lgica de Programao


nome que o programador desejar. As aspas duplas informam apenas que aquela informao

deve ser encarada como uma sequncia de caracteres.

As informaes destacadas em azul definem algumas sees da linguagem:

Todo algoritmo deve estar contido entre as palavras-chave algoritmo e

fimalgoritmo;

A palavra-chave var marca o incio da seo de declarao de variveis. Nesta

seo, e unicamente nesta seo, todas as variveis a serem utilizadas no

programa devero ser declaradas, ter um tipo de dados e um identificador a

elas atribudos;

A palavra-chave inicio marca o comeo da seo de comandos. Nesta seo as

instrues referentes entrada e sada de dados, operaes, atribuies,

comandos de seleo, iterao, etc, podero ser utilizadas. Nesta seo a

lgica do algoritmo ser efetivamente escrita.

2. Tipos de dados O visualg possui quatro tipos de variveis disposio do programador e no permite

a criao de novos tipos. Os tipos de dados so:

Inteiro manipula dados numricos inteiros, ou seja, sem casas decimais;

Real manipula dados numricos reais, ou seja, com casas decimais;

Caractere manipula dados do tipo sequncia de letras, palavras e textos;

Logico manipula dados lgicos, como Verdadeiro ou Falso;

O visualg permite tambm o uso de variveis estruturadas como vetores ou matrizes.

Os vetores so variveis agrupadas sob um mesmo identificador como uma sequncia linear

referenciada por um ndice, como exemplifica a Figura 3.

Figura 3 - Vetor N de 9 posies

Note que o vetor possui apenas um identificador (N), no entanto ele acomoda 9

variveis do mesmo tipo. O contedo dessa varivel pode ser acessado por meio do

identificador e do ndice do vetor, por exemplo, a expresso N[3] acessa o contedo da

varivel existente na posio nmero 3 do vetor N, e assim por diante. A grande vantagem

Lgica de Programao


dessa estrutura que o ndice pode ser referenciado por constantes ou por variveis do tipo

inteiro.

As matrizes so como vetores, mas alm do ndice de linhas possui tambm um ndice

de colunas.

3. Declarao de variveis A declarao de variveis do ambiente visualg deve ser realizada na seo demarcada

pela palavra-chave var. A sequncia de declarao deve ser o identificador da varivel,

seguido de dois pontos e seguido do tipo de dados da varivel:

Identificador: tipo de dados

Caso mais de uma varivel de um mesmo tipo for definida, pode-se fazer a declarao

na mesma linha, separando os identificadores por vrgula:

Identificador1, Identificador2: tipo de dados

Abaixo seguem alguns exemplos de declarao de variveis dos quatro tipos existentes

no ambiente visualg. var a: inteiro Valor1, Valor2: real nome_do_aluno: caractere sinalizador: logico

A declarao dos tipos estruturados feita da forma mostrada a seguir: var vet: vetor [1..10] de real matriz: vetor [0..4,8..10] de inteiro No exemplo, o identificador vet atribudo a um vetor de 10 posies, cujo ndice

inicial 1 e o final 10, e este vetor contm variveis do tipo real. O identificador matriz foi

atribudo a uma matriz de 5 linhas (ndice inicial 0 e final 4) e 3 colunas (ndice inicial 8 e

final 10) e esta matriz contm variveis do tipo inteiro.

4. Operadores Aritmticos Os operadores aritmticos existentes no ambiente visualg so:

Smbolo Significado

+, - Operadores unrios. Aplicados a um nico operando. O operador inverte o valor do operando, enquanto o + no altera o seu valor. Exemplo: -3, +x

\ Diviso inteira. Exemplo: 5\2 resultar em 2 +, -, /, * Adio, subtrao, diviso e multiplicao.

MOD ou % Resto da diviso. Exemplo: 8 mod 3 = 2 ^ Potenciao. Exemplo: 5^2 = 25

Lgica de Programao


Os operadores aritmticos seguem uma hierarquia de precedncia, ou seja, o

compilador avalia o resultado de algumas expresses antes de outras. A hierarquia :

1 Parnteses ();

2 Operadores unrios;

3 Potenciao;

4 Multiplicao, diviso, diviso inteira e resto da diviso;

5 adio e subtrao.

Assim, a expresso -3*7+2-1/7^2 resultaria em -19.02.

O smbolo de adio (+) pode ser empregado para operar variveis do tipo caractere

tambm, no entanto, neste caso o resultado seria a concatenao das sequncias de caracteres,

por exemplo: Suponha que A = Ho e B = je, o resultado de A+B seria Hoje.

5. Operadores Relacionais Os operadores relacionais em visualg so:

Smbolo Nome

= Igual

> Maior que

< Menor que

>= Maior ou igual a

Lgica de Programao


Captulo 4 - Sequncia Neste captulo descreveremos alguns comandos e definies necessrias para

desenvolver um algoritmo e escrev-lo em uma linguagem de programao. Focaremos-nos

no conceito de sequncia, ou seja, comandos e instrues que podem ser empregadas em um

fluxo contnuo de execuo sem desvios ou repetio. Esses comandos certamente sero

responsveis por grande parte das linhas de cdigo dos programas que o programador ir

realizar ao longo de sua vida.

1. Comando de atribuio A atribuio de valores a variveis no visualg deve ser realizada apenas na seo de

comandos. Este comando altera o contedo de uma determinada varivel. O visualg aceita

dois smbolos para representar a atribuio de valores:

Lgica de Programao


Este comando solicita ao usurio a insero de dados, uma vez que estes dados so

inseridos eles sero armazenados nas variveis listas no argumento da funo (lista de

variveis). Por exemplo, suponha que se escreva o seguinte cdigo na seo de comando:

leia(x)

Sendo x uma varivel do tipo real. Ao ler esse comando o visualg ir esperar a

insero de dados pelo usurio. Como padro, o programa espera a insero de dados via

teclado. Uma vez que o usurio escreveu a informao e apertou o boto enter do teclado, a

informao digitada ir ser atribuda (armazenada) na varivel x.

OBS: O visualg permite que a forma de entrada de dados seja configurada,

podendo ser feita por meio de dados aleatrios informados pelo prprio computador, ou

lidos de um arquivo .txt, para mais informaes veja o manual do visualg, disponvel no

prprio programa.

Os comandos de sada do visualg so os comandos escreva() e escreval(). Ambos

possuem a mesma sintaxe:

escreva ()

escreval ()

Esses comandos iro escrever a lista de expresses na tela do computador, de modo a

permitirem uma comunicao do programa com o usurio. A lista de expresses pode ser

composta por caracteres, variveis, etc, todas separadas por vrgula, como mostra o exemplo

abaixo: algoritmo "exemplo" var x: real y: inteiro a: caractere l: logico inicio x

Lgica de Programao


contedo dessa varivel. A principal diferena entre os comandos que o comando escreva()

escreve a lista de expresses na tela e mantem o cursor na mesma linha, enquanto que o

comando escreval(), escreve a lista de expresses e em seguida faz o cursor pular uma linha.

3. Funes e Procedimentos Em muitas situaes existem tarefas especificas dentro de um algoritmo que so executadas

repetidamente. Dependendo da complexidade dessas tarefas a sua definio do longo do cdigo-fonte

pode gerar um cdigo confuso e de difcil interpretao. Imagine novamente a situao onde se deseja

calcular o seno de um ngulo, mas o mecanismo apenas realiza as quatro operaes bsicas. Existem

descries da funo seno que permitem fazer esse clculo, mas o algoritmo por traz dessa operao

realmente complexo. Agora, se ao longo do programa a chamada da funo seno for algo recorrente, o

programa se tornar muito complicado.

Uma soluo criar um subprograma que execute essa tarefa especfica, no caso, por

exemplo, execute o algoritmo que calcule o seno de um ngulo usando apenas as operaes bsicas, e

ao longo do cdigo-fonte esse subprograma chamado. A grande vantagem que a escrita do cdigo

fonte se torna algo muito mais simples e, logo, de fcil interpretao. Alm disso, o subprograma pode

ser reutilizado em outros programas. importante, no entanto, entender que ao chamar uma funo, o

programa principal interrompido e o fluxo de execuo do programa desviado para a sequncia de

instrues do subprograma. Ao trmino da execuo do subprograma, o programa principal volta a ser

executado de onde foi interrompido.

3.1. Funes H um caso particular de subprograma que recebe o nome de funo. Uma funo,

alm de executar uma determinada tarefa, retorna um valor para quem a chamou, sendo este

valor o resultado da sua execuo. Por este motivo, a chamada de uma funo aparece no

corpo do programa principal como uma expresso, e no como um comando. Cada funo,

alm de ter acesso s variveis do programa que o chamou (as variveis globais), pode

possuir suas prprias variveis (as variveis locais), que existem apenas durante sua chamada.

Ao se chamar uma funo, tambm possvel passar-lhe determinadas informaes que

recebem o nome de parmetros. A quantidade dos parmetros, sua sequncia e respectivos

tipos no podem mudar: devem estar de acordo com o que foi especificado na sua

correspondente declarao.

No visualg a declarao de funes deve ser feita na seo de declarao de variveis,

logo aps a declarao das variveis globais. A sintaxe de declarao : funcao []: // Seo de declarao de variveis locais var inicio

Lgica de Programao


// Seo de comandos da funo fimfuncao

O define o identificador da funo e deve receber as mesmas

atenes que destinadas aos identificadores de variveis. A define os argumentos da funo. O define o tipo do dado que

ser retornado pela funo. No corpo da funo existem as sees de declarao e de

comandos, assim como ocorre nos programas principais, no entanto, a seo de declarao

dedicada definio de variveis locais, ou seja, variveis que apenas existiro dentro da

funo, e aps a execuo dela, sero apagados.

A seguir est um exemplo de declarao de uma funo que recebe um nmero e

calcula a sua raiz quadrada. A funo abaixo utiliza passagem de parmetro por valor. funcao raizquad (x: real): real var aux:real inicio aux

Lgica de Programao


exemplo, modificar a estrutura da funo, de modo a calcularmos a raiz de qualquer ordem,

podemos fazer: funcao raiz (x: real;q:inteiro): real var aux:real inicio aux

Lgica de Programao


sub-rotinas para clculo da raiz quadrada de um nmero e para o clculo da raiz de qualquer

ordem de um nmero.

Primeiramente, utilizamos o procedimento que altera variveis globais. Suponha que

existam no programa principal as variveis

a,b:real Assim podemos definir o seguinte procedimento: procedimento raizquad(x:real) var aux:real inicio aux

Lgica de Programao


inicio escreva(Entre com um nmero:>) leia(a) raizquad(a,b) escreva(A raiz quadrada de ,a, : ,b) fimalgoritmo

Observe que na chamada do procedimento, a varivel global b foi referenciada pela

varivel local y. Assim, a varivel b ir ao final da execuo do procedimento receber tambm

o resultado do calculo da raiz, assim, poderemos utilizar no programa principal esse valor. J

a varivel a, no entanto, enxergada pela funo como sendo um parmetro de passagem de

valor, ou seja, apenas o contedo de a utilizado, logo, se o procedimento alterasse o valor da

varivel local x, nada ocorreria com a varivel global a.

Podemos tambm utilizar o procedimento para calcular tanto a raiz quadrada, quanto a

raiz geral de um nmero, para isso tome o exemplo: procedimento raizgeral(x,q:real; var y,z:real) inicio y

Lgica de Programao


Captulo 5 Iterao

As estruturas de algoritmos discutidas anteriormente so baseadas simplesmente na

ideia de se fazer construes sequenciais. Com estas estruturas podemos avaliar o contedo

de frmulas matemticas e executar tarefas simples, no entanto, as possibilidades dos

algoritmos que se utilizam apenas dessas tcnicas so muito limitadas. Neste captulo

comearemos a discutir estruturas que atribuem maior potencialidade a algoritmos de modo a

permitir que problemas mais complexos sejam executados. Os comandos a serem estudados

nesta seo sero baseados no conceito de iterao, ou seja, na repetio de tarefas.

Considere, por exemplo o problema de se calcular a soma dos N primeiros nmeros

inteiros no-negativo. No caso de fixarmos um valor para N, N = 14, por exemplo,

poderamos utilizar as noes de sequncia para escrever um programa que calcule a soma

dos primeiros 14 nmeros inteiros: Algoritmo Soma 14 primeiros nmeros no-negativos var N,soma:inteiro inicio soma:= 1+2+3+4+5+6+7+8+9+10+11+12+13+14 escreva(O resultado da soma : ,soma) fimalgoritmo Este algoritmo, apesar de apresentar o resultado correto, decepcionante uma vez que

ele permite apenas o clculo da soma dos primeiros 14 nmeros. Caso se deseje realizar a

mesma operao para um total de nmeros diferentes seria necessrio escrever outro cdigo e

medida que o total de nmeros aumenta, a dificuldade de se escrever o cdigo se torna

maior. Esse algoritmo inflexvel e pouco prtico.

Outra forma de se implementar esse tipo de soma lembrar que ela pode ser escrita

como sendo = , com isso podemos escrever o mesmo problema com outro algoritmo:

Algoritmo Soma 14 primeiros nmeros no-negativos por somatrio var N,soma:inteiro inicio soma:= 0 soma:=soma+1 soma:=soma+2 soma:=soma+3 soma:=soma+4 soma:=soma+5 soma:=soma+6 soma:=soma+7

Lgica de Programao


soma:=soma+8 soma:=soma+9 soma:=soma+10 soma:=soma+11 soma:=soma+12 soma:=soma+13 soma:=soma+14 escreva(O resultado da soma : ,soma) fimalgoritmo O resultado deste algoritmo o mesmo obtido no algoritmo anterior, contudo, ele to

intil quanto o anterior no que se refere sua escrita genrica e a sua utilizao para N14.

Apesar disso, a escrita do algoritmo dessa maneiro nos permite visualizar que a execuo do

somatrio na realidade uma repetio da expresso:

soma:= soma+N

Ou seja, a varivel de sada soma recebe a cada instante o seu valor anterior

adicionado ao valor atual do nmero N. Caso dispusssemos de uma estrutura de repetio,

poderamos condensar todas as linhas iguais em um s comando. A seguir veremos algumas

estruturas de repetio disponveis no visualg.

1. Comando Para..faca Um dos comandos de repetio disponveis e que encontra semelhantes em todas as

linguagens de programao existentes o comando Para..faca, a sintaxe desse comando a

seguinte: para de ate [passo ] faca fimpara

Onde:

varivel uma varivel do tipo inteiro que serve como um contador para o

nmero de repeties a serem executadas pelo comando;

valor-inicial Inicializao da varivel contadora, indica qual o valor da

varivel no primeiro ciclo de iterao do comando;

valor-final valor que define o fim da contagem;

passo - define qual o passo de incremento da varivel, ou seja,

ao final da sequncia de comandos indica qual o valor ser adicionado

varivel. O valor padro 1;

- Indica quais instrues sero utilizadas dentro do

lao de repetio

Lgica de Programao


fimpara Indica o trmino do comando, indispensvel para orientar o visualg

sobre quais instrues pertencem ao lao de iterao e quais no.

Esse comando permite a repetio de um determinado conjunto de instrues um

nmero de vezes definido por

. Voltando ao exemplo da soma dos N

primeiros nmeros no-negativos, podemos escrever um algoritmo com a funo para..faca

mais elegante, e que permita uma maior flexibilidade em relao ao nmero de termos da

soma: Algoritmo Soma N primeiros nmeros no-negativos por iterao var N,soma,i:inteiro inicio escreva(Digite o nmero de termos N desejados:> ) leia(N) soma:= 0 para i de 1 ate N faca

soma:=soma+i fimpara escreva(O resultado da soma : ,soma) fimalgoritmo No algoritmo acima, a instruo soma:=soma+i ser repetida N vezes, sendo o que o

nmero N pode ser definido pelo usurio, de modo que a expresso do somatrio dos N

primeiros nmeros pode ser utilizado para qualquer N desejado, mostrando uma maior

simplicidade e flexibilidade do que o apresentado pelos algoritmos meramente sequenciais.

OBS: Por padro o incremento da varivel contadora se d de forma crescente,

enquanto o incremento for positivo. Caso se deseje fazer uma contagem decrescente deve-se

utilizar um passo negativo, como mostra o exemplo a seguir: algoritmo "Numeros de 10 a 1" var j: inteiro inicio para j de 10 ate 1 passo -1 faca

escreva (j:3) fimpara fimalgoritmo O algoritmo acima imprime os nmeros de 10 a 1 de forma decrescente na tela em

uma mesma linha, note que o passo utilizado -1. Observe que o comando escreva() utiliza

uma expresso j:3, os smbolos :3 indicam que aps a impresso do contedo da varivel j,

deve-se dar 3 espaos.

Outro uso muito comum da estrutura para..faca para preencher um vetor com

valores, como mostra o exemplo a seguir:

Lgica de Programao


algoritmo "preenchimento de vetor" var j: inteiro ent: vetor [1..20] de real inicio para j de 1 ate 20 faca

escreva(Insira um valor:> ) leia(ent[j])

fimpara fimalgoritmo

2. Comando enquanto..faca Outra estrutura de iterao o lao condicional, cujo representante no visualg o

comando enquanto..faca, cuja sintaxe a seguinte: enquanto faca

fimenquanto Este comando realiza a repetio da sequncia de comandos enquanto uma expresso

lgica satisfeita (Verdadeira). Lembrando que um elemento lgico apenas pode receber

valores Verdadeiro ou Falso, assim a expresso lgica pode ser escrita como uma varivel

lgica ou o resultado de uma operao lgica ou relacional. O exemplo do somatrio dos N

primeiros nmeros no negativos pode ser escrito tambm pelo comando enquanto..faca: Algoritmo Soma N primeiros nmeros no-negativos por iterao var N,soma,i:inteiro inicio escreva(Digite o nmero de termos N desejados:> ) leia(N) soma:= 0 i:=1 enquanto (i

Lgica de Programao


interrupo do lao sem que a expresso lgica seja satisfeita. No visualg esse comando o

interrompa.

3. Comando repita..ate O comando repita..ate tambm um comando de lao condicional, assim como o

enquanto..faca. No entanto a expresso lgica vem depois da sequncia de comandos, como

mostra a sintaxe abaixo: repita

ate No entanto, ao contrrio do que ocorre no comando anterior, a repetio se dar

sempre que a expresso lgica for falsa. Assim, o exemplo da soma dos N primeiros nmeros

no-negativos se torna: Algoritmo Soma N primeiros nmeros no-negativos por iterao var N,soma,i:inteiro inicio escreva(Digite o nmero de termos N desejados:> ) leia(N) soma:= 0 i:=1 repita

soma:=soma+i iN escreva(O resultado da soma :> ,soma) fimalgoritmo

Lgica de Programao


Captulo 6 - Seleo Como a iterao, a seleo permite a execuo condicional de um bloco de comandos

baseada na avaliao de dados. Contudo, enquanto a iterao destinada a permitir a

repetio de um conjunto de instrues, a seleo focada em realizar a uma simples escolha

entre alternativas, de modo que um conjunto de instrues ser executado se uma determinada

condio for verdadeira e outro conjunto ser executado, se esta mesma condio for falsa. A

seguir sero discutidas algumas estruturas de seleo.

1. Comando Se..entao O comando se..entao utilizado para executar um conjunto de instrues se um

determinada condio for satisfeita, so essa condio no seja satisfeita, o comando no

realiza nada. A sintaxe deste comando apresentada abaixo: se entao

fimse

2. Comando Se..entao..senao O comando se..entao..senao uma extenso do comando anterior. Ele define um

conjunto de instrues a serem executadas se a expresso-lgica for satisfeita e outro

conjunto, se ela no for satisfeita.

Como exemplo de utilizao, podemos escrever um algoritmo que calcula e apresenta

as razes de um polinmio de segundo grau. Sabemos que uma funo de segundo grau

apresenta a seguinte estrutura bsica:

= + + Sendo que as razes deste polinmio so definidas pela expresso:

= 42 Sendo que, se a expresso = 4 for positiva ou nula, as razes do polinmio

so reais. Por outro lado se

Lgica de Programao


leia(a) escreva(Entre com o valor de b:) leia(b) escreva(Entre com o valor de c:) leia(c) delta:=b^2-4*a*c se (delta>=0) ento

x1r = (-b+delta^(1/2))/(2*a) x2r = (-b-delta^(1/2))/(2*a) escreval(x1 = ,x1r) escreval(x2 = ,x2r)

seno x1r = -b/(2*a) x2r = x1r x1i = +(-delta)^(1/2) escreval(x1 = ,x1r, + i*,x1i) escreval(x2 = ,x2r, - i*,x1i)

fimse fimalgoritmo

3. Comando Escolha O comando escolha permite selecionar um conjunto de instrues a serem executadas

dependendo do valor exibido por uma expresso de seleo. A sintaxe deste comando : escolha caso , , ...,

caso , , ...,

... outrocaso

fimescolha

Um exemplo de utilizao: algoritmo "Times" var time: caractere inicio escreva ("Entre com o nome de um time de futebol: ") leia (time) escolha time caso "Flamengo", "Fluminense", "Vasco", "Botafogo"

escreval (" um time carioca.") caso "So Paulo", "Palmeiras", "Santos", "Cornthians"

escreval (" um time paulista.") outrocaso

escreval (" de outro estado.") fimescolha fimalgoritmo

Lgica de Programao


Referncias

[1] HOLLOWAY, James Paul. Introduo Programao para Engenharia. Rio de Janeiro: LTC, 2006;

[2] Manual Software Visualg, 2010.

logprog_2013

Documents