Tubarão / Santa Catarina / BRAZIL E-Mail : osmarjr@unisul.rct-sc.

br

Índice
1. Introdução................................................................................................................................................4 1.1 Conceito de Algoritmo........................................................................................................................4 1.2 Fases de um Algoritmos......................................................................................................................4 1.3 Visão Geral.........................................................................................................................................5 2. Formas de Representação de Algoritmos.............................................................................................6 2.1 Descrição Narrativa...........................................................................................................................6 2.2 Fluxograma Convencional.................................................................................................................7 2.3 Pseudocódigo......................................................................................................................................8 2.4 Síntese..................................................................................................................................................9 3. Tipos de Dados.......................................................................................................................................11 3.1 Dados Numéricos..............................................................................................................................11 3.2 Dados Literais. .................................................................................................................................12 3.3 Dados Lógicos...................................................................................................................................13 3.4 Síntese................................................................................................................................................13 4. Variáveis.................................................................................................................................................15 4.1 Arquitetura de Memória...................................................................................................................15 4.2 Tipos de Dados..................................................................................................................................15 4.3 Armazenamento de Dados na Memória...........................................................................................16 4.4 Conceito e Utilidade de Variáveis....................................................................................................18 4.5 Definição de Variáveis em Algoritmos.............................................................................................19 4.6 Definição de Variáveis em Pascal....................................................................................................20 4.7 Mapeamento de Variáveis na Memória...........................................................................................21 4.8 Tipos de Dados em Pascal................................................................................................................22 4.9 Síntese................................................................................................................................................22 5. Expressões..............................................................................................................................................24 5.1 Operadores........................................................................................................................................24 5.2 Tipos de Expressões..........................................................................................................................25 5.3 Avaliação de Expressões..................................................................................................................29 5.4 Síntese................................................................................................................................................29 5.5 Exercício Resolvido..........................................................................................................................30 6. Instruções Primitivas............................................................................................................................32 6.1 Instrução Primitiva de Atribuição....................................................................................................32 6.2 Instrução Primitiva de Saída de Dados............................................................................................35 6.3 Instrução Primitiva de Entrada de Dados........................................................................................37 6.4 Síntese................................................................................................................................................40 6.5 Exercícios Resolvidos.......................................................................................................................41 7. Controle do Fluxo de Execução...........................................................................................................47

2

7.1 Comandos Compostos.......................................................................................................................47 7.2 Estrutura Seqüencial.........................................................................................................................47 7.3 Estruturas de decisão........................................................................................................................47 7.4 Estruturas de Repetição....................................................................................................................56 7.5 Aninhamentos....................................................................................................................................63 7.6 Síntese................................................................................................................................................64 8. Símbolos Usados em Fluxogramas.......................................................................................................68 9. Funções pré-definidas do Pascal..........................................................................................................70 9.1 Descrição das Funções/Rotinas: .....................................................................................................70 10. Problemas Resolvidos em Algoritmos, Pascal e C...........................................................................79 10.1 Algoritmo do Triangulo..................................................................................................................79 10.2 Algoritmo Preco Automóvel..........................................................................................................80 10.3 Algoritmo Media Valor...................................................................................................................81 10.4 Algoritmo 3 Menores......................................................................................................................82 10.5 Algoritmo Media Maior que 4........................................................................................................83 10.6 Algoritmo Salário............................................................................................................................85 10.7 Algoritmo 50 Triangulos.................................................................................................................86 10.8 Algoritmo Media Menores..............................................................................................................87

3

1.

Introdução

1.1

Conceito de Algoritmo

A automação é o processo em que uma tarefa deixa de ser desempenhada pelo homem e passa a ser realizada por máquinas, sejam estas dispositivos mecânicos, eletrônicos (como os computadores) ou de natureza mista. Para que a automação de uma tarefa sejam bem-sucedida é necessário que a máquina que passará a realizá-la seja capaz de desempenhar cada uma das etapas constituintes do processo a ser automatizado com eficiência, de modo a garantir a repetibilidade do mesmo. Assim, é necessário que seja especificado com clareza e exatidão o que deve ser realizado em cada uma das fases do processo a ser automatizado, bem como a seqüência em que estas fases devem ser realizadas. A especificação da seqüência ordenada de passos que deve ser seguida para a realização de uma tarefa, garantindo a sua repetibilidade, dá-se o nome de algoritmo. Ao contrário do que se pode pensar, o conceito de algoritmo não foi criado para satisfazer às necessidades da computação. Pelo contrário, a programação de computadores é apenas um dos campos de aplicação dos algoritmos. Na verdade, há inúmeros casos que podem exemplificar o uso (involuntário ou não) de algoritmos para a padronização do exercício de tarefas rotineiras. Tornando ao contexto computacional, daqui em diante a atenção deste trabalho estará voltada à automação de tarefas utilizando computadores. Algoritmo não é a solução de um problema, pois, se assim fosse, cada problema teria um único algoritmo. Algoritmo é um caminho para a solução de um problema, e em geral, os caminhos que levam a uma solução são muitas. O aprendizado de algoritmos não se consegue a não ser através de muitos exercícios. Algoritmos não se aprende: - Copiando Algoritmos Estudando Algoritmos Algoritmos só se aprendem: - Construindo Algoritmos - Testando Algoritmos Para que um computador possa desempenhar uma tarefa é necessário que este seja detalhada passo a passo, numa forma compreensível pela máquina, utilizando aquilo que se chama de programa. Neste sentido, um programa de computador nada mais é que um algoritmo escrito numa forma compreensível pelo computador.

1.2

Fases de um Algoritmos

Quando temos um problema e vamos utilizar um computador para resolve-lo inevitavelmente temos que passar pelas seguintes etapas: a) Definir o problema. b) Realizar um estudo da situação atual e verificar quais a(s) forma(s) de resolver o problema. c) Terminada a fase de estudo, utilizar uma linguagem de programação para escrever o programa que deverá a princípio, resolver o problema. d) Analisar junto aos usuários se o problema foi resolvido. Se a solução não foi encontrada, deverá ser retornado para a fase de estudo para descobrir onde está a falha. Estas são de forma bem geral, as etapas que um analista passa, desde a apresentação do problema até a sua efetiva solução. Iremos, neste curso, nos ater as etapas de estudo, também chamada

4

de análise, e a etapa de programação. Mas antes vamos definir o seguinte conceito: Programar um computador consiste em elaborar um conjunto finito de instruções, reconhecidas pela máquina, de forma que o computador execute estas instruções. Estas instruções possuem regras e uma Sintaxe própria, como uma linguagem tipo português ou inglês, sendo isto chamadas de linguagem de computador. No mundo computacional existe uma grande variedade de linguagens Pascal, C, C++, Java, Cobol, Fortran, etc… .

1.3

Visão Geral

O objetivo deste trabalho é prover ao leitor meios de organizar o raciocínio empregado na solução de problemas rotineiros e expressá-lo numa forma entendida (quase) diretamente pelos computadores. A técnica apresentada é basicamente a da Programação Estruturada, onde é enfatizada a abordagem de problemas pelo Método de Refinamento Sucessivos.

5

2.

Formas de Representação de Algoritmos

Existem diversas formas de representação de algoritmos, mas não há um consenso com relação à melhor delas. O critério usado para classificar hierarquicamente estas formas está diretamente ligado ao nível de detalhe ou, inversamente, ao grau de abstração oferecido. Algumas formas de representação de algoritmos tratam os problemas apenas em nível lógico, abstraindo-se de detalhes de implementação muitas vezes relacionados com alguma linguagem de programação específica. Por outro lado, existem formas de representação de algoritmos que possuem uma maior riqueza de detalhes e muitas vezes acabam por obscurecer a idéia principal, o algoritmo, dificultando seu entendimento. Dentre as formas de representação de algoritmos mais conhecidas sobressaltam: a Descrição Narrativa; o Fluxograma Convencional o Pseudocódigo, também conhecido como Linguagem estruturada ou Portugol.

2.1

Descrição Narrativa

Nesta forma de representação os algoritmos são expressos diretamente em linguagem natural. Como exemplo, têm-se os algoritmos seguintes: Receita de Bolo: Misture os Ingredientes Unte a forma com manteiga Despeje a mistura na forma Se houver coco ralado Então despeje sobre a mistura Leve a forma ao forno Enquanto não corar Deixe a forma no forno Retire do forno Deixe esfriar Troca de um pneu furado: Afrouxar ligeramente as porcas Suspender o carro Retirar as porcas e o pneu Colocar o pneu reserva Apertar as porcas Abaixar o carro Dar o aperto final nas porcas Tomando Banho: Entrar no banheiro e tirar a roupa Abrir a torneira do chuveiro Entrar na água Ensaboar-se Sair da água Fechar a torneira Enxugar-se Vestir-se Cálculo da média de um aluno: Obter as notas da primeira e da Segunda provas Calcular a média aritmética entre as duas Se a média for maior que 7, o aluno foi

-

-

-

6

Aprovado, senão ele foi reprovado. Esta representação é pouco usada na prática porque o uso da linguagem natural muitas vezes dá oportunidade a más interpretações, ambigüidades e imprecisões. Por exemplo, a instrução "afrouxar ligeiramente as porcas" no algoritmo da troca de pneus está sujeita a interpretações diferentes por pessoas distintas. Uma instrução mais precisa seria: "afrouxar a porca, girando-a de 30o no sentido anti-horário".

2.2

Fluxograma Convencional

E uma representação gráfica de algoritmos onde formas geométricas diferentes implicam ações (instruções, comandos) distintos. Tal propriedade facilita o entendimento das idéias contidas nos algoritmos e justifica sua popularidade. Esta forma e aproximadamente intermediária a descrição narrativa e ao pseudocódigo (subitem seguinte), pois e menos imprecisa que a primeira e, no entanto, não se preocupa com detalhes de implementação do programa, como o tipo das variáveis usadas (Capítulos 2 e 3). Ha vários padrões que definem as formas geométricas das figuras que devem ser usadas para representar cada um dos diversos tipos de instruções; contudo, nenhum deles se sobressai com relação aos demais no que diz respeito a aceitação por parte dos usuários. Nota-se que os fluxogramas convencionais preocupam-se com detalhes de nível físico da implementação do algoritmo. Por exemplo, figuras geométricas diferentes são adotadas para representar operações de saída de dados realizadas em dispositivos distintos, como uma fita magnética ou um monitor de vídeo. Como a abordagem deste texto não está interessada em detalhes físicos da implementação (onde fazer), mas tão somente com o nível lógico (o que fazer e como fazer) das instruções do algoritmo, será adotada a notação simplificada da Figura 1 para os fluxogramas. De qualquer modo, o Apêndice A contém uma tabela com os símbolos mais comuns nos fluxogramas convencionais. = Início e final do fluxograma

= Operação de entrada de dados

= Operação de saída de dados

= Operações de atribuição e chamada ou retorno de subalgoritmo

= Decisão Figura 1 - Principais formas geométricas usadas em fluxogramas De modo geral, um fluxograma se resume a um único símbolo inicial, por onde a execução do algoritmo começa, e um ou mais símbolos finais, que são pontos onde a execução de algoritmo se encerra. Partindo do símbolo inicial, há sempre um único caminho orientado a ser seguido, representando a existência de uma única seqüência de execução das instruções. Isto pode ser melhor visualizado pelo fato de que, apesar de vários caminhos poderem convergir para uma mesma figura do diagrama, há sempre um único caminho saindo desta. Exceções e esta regra são os símbolos finais, dos quais não há nenhum fluxo saindo, e os símbolos de decisão, de onde pode haver mais de um caminho de saída (usualmente dois caminhos), representando uma bifurcação no fluxo. A Figura 2 mostra a representação do algoritmo de cálculo da média de um aluno sob a forma de um fluxograma.

7

Início

N1, N2

Média ← (N1 + N2 ) /2

.V. Média > 7 .F.

"Aprovado"

"Reprovado"

Fim

Figura 2 - Exemplo de um fluxograma convencional

2.3

Pseudocódigo

Antes de utilizarmos uma linguagem de computador, é necessário organizar as ações a serem tomadas pela máquina de forma organizada e lógica, sem nos atermos as regras rígidas da Sintaxe de uma linguagem. Para isto utilizaremos uma forma de escrever tais ações, conhecida como algoritmo, ou pseudocódigo. Conceituando: Algoritmo consiste em um conjunto lógico e finito de ações ( instruções ) que resolvem um determinado problema. Esta forma de representação de algoritmos é rica em detalhes, como a definição dos tipos das variáveis usadas no algoritmo e, por assemelhar-se bastante à forma em que os programas são escritos, encontra muita aceitação. Na verdade, esta representação é suficientemente geral para permitir que a tradução de um algoritmo nela representada para uma linguagem de programação específica seja praticamente direta.

8

A forma geral da representação de um algoritmo na forma de pseudocódigo é a seguinte:
Algoritmo <Nome_do_algoritmo> <declaração_de_variáveis> <subalgoritmos> Início <Corpo_do_algoritmo> Fim. Em Pascal ficaria da seguinte forma: Program <Nome_do_programa>; <declaração_de_variáveis> <subalgoritmos> Begin <Corpo_do_Programa>; End. Onde: Algoritmo é uma palavra que indica o início da definição de um algoritmo em forma de pseudocódigo. <nome_do_algoritmo> é um nome simbólico dado ao algoritmo com a finalidade de distingui-lo dos demais. <declaração_de_variáveis> consiste em uma porção opcional onde são declaradas as variáveis globais usadas no algoritmo principal e, eventualmente, nos subalgoritmos. <subalgoritmos> consiste de uma porção opcional do pseudocódigo onde são definidos os subalgoritmos. Início e Fim são respectivamente as palavras que delimitam o início e o término do conjunto de instruções do corpo do algoritmo. Como exemplo, a Figura 3 mostra a representação do algoritmo do cálculo da média de um aluno, na forma de um pseudocódigo. Algoritmo Média Var N1, N2, Média : real Início Leia N1, N2 Média ← (N1 + N2) / 2 Se Média > 7 Então Escreva "Aprovado" Senão Escreva "Reprovado" Fim_se Fim Figura 3 - Figura de um pseudocódigo

2.4

Síntese

Há diversas formas de representação de algoritmos que diferem entre si pela quantidade de detalhes de implementação que fornecem ou, inversamente, pelo grau de abstração que possibilitam com relação à implementação do algoritmo em termos de uma linguagem de programação específica. Dentre as principais formas de representação de algoritmos destacam-se: a descrição narrativa, o fluxograma convencional e o pseudocódigo (ou linguagem estruturada).

2.4.1 Exercícios A
Usando Descrição Narrativa, Fluxograma e Pseudocódigo desenvolva os seguintes algoritmos: 1. Elabore um algoritmo para mudar um pneu furado. Admita que estão disponíveis um macaco e outro pneu em boas condições. 9

2. Elabore um algoritmo para fazer pipoca numa panela de fogão, usando manteiga, sal e milho de pipoca. 3. Desenvolva um algoritmo para trocar um vidro quebrado de uma janela. Numa lista à parte, descreva todos os matérias necessários. 4. Elabore um algoritmo que represente sua saída de casa pela manhã. Comece com o passo “dormindo na cama” e inclua todas as atividades matutinas normais. 5. (a) Elabore um algoritmo para realizar uma chamada telefônica. (b) Amplie a parte (a) para um algoritmo que permita realizar chamadas de longa distância. Inclua as possibilidades de chamadas aparelho-a-aparelho, a cobrar e de pessoa-a-pessoa.

10

3.

Tipos de Dados

Todo o trabalho realizado por um computador e baseado na manipulação das informações contidas em sua memória. Grosso modo, estas informações podem ser classificadas em dois tipos: As instruções que comandam o funcionamento da máquina e determinam a maneira como devem ser tratados os dados. As instruções são específicas para cada modelo de computador, pois são função do tipo particular de processador utilizado em sua implementação. Os dados propriamente ditos, que correspondem a porção das informações a serem processadas pelo computador. A maior parte das pessoas não ligadas a área de informática ignora o potencial dos computadores e imagina que eles são capazes de tratar apenas com dados numéricos. Na realidade, a capacidade dos mesmos se estende a outros tipos de dados. O objetivo deste capítulo e justamente o de classificar os dados de acordo com o tipo de informação contida neles. A classificação apresentada não se aplica a nenhuma linguagem de programação específica; pelo contrário, ela sintetiza os padrões utilizados na maioria das linguagens.

3.1

Dados Numéricos

Antes de apresentar formalmente os tipos de dados numéricos, e conveniente recordar alguns conceitos básicos relacionados a teoria dos números e conjuntos. O conjunto dos números naturais e representado por N é dado por: N = { 1, 2, 3, 4, ... } Algumas correntes de matemáticos teóricos convencionam que o número O está contido neste conjunto; contudo, não convém perder tempo em tais discussões filosóficas, uma vez que isto não influenciará de forma alguma este estudo. Na seqüência, encontramos o conjunto dos números inteiros: Z = { ..., -3, -2, -1, O. 1, 2, 3, ... } O conjunto Z contém todos os elementos de N. bem como alguns números que não pertencem a N (os números negativos e o zero). Portanto, dizemos que N está contido em Z. ou então, que Z contém N. Englobando o conjunto dos números inteiros, existe o conjunto dos números fracionários (Q), dado pelo universo dos números que podem ser expressos na forma de ma fração, isto e, um quociente onde o numerador e o denominador são números inteiros. Mais formalmente, Q = { p / q | p, q pertencem a Z } Por último, surge o conjunto dos números reais (R), formado pela união do conjunto dos números fracionários Q com o conjunto dos números que não podem ser expressos na forma de uma fração (os números irracionais). Ex.: 2 = 1.1412..., PI = 3.14159... A Figura 4 sintetiza a informação apresentada até aqui. Existe um conjunto que contém o conjunto dos números reais, o conjunto dos números complexos, cujo estudo extrapola os objetivos deste texto.

11

Tornando ao aspecto computacional, os dados numéricos representáveis num computador são divididos em apenas duas classes: os inteiros e os reais.

N

Z

Q

R

Figura 4 - Representação do Universos dos conjuntos numéricos e as relações de pertinência entre eles.

3.1.1 Dados Numéricos Inteiros
Os números inteiros são aqueles que não possuem componentes decimais ou fracionários, podendo ser positivos ou negativos. Os elementos pertencentes aos conjuntos N e Z. apesar de serem representáveis na classe dos números reais, são classificados como dados do tipo inteiro, por não possuírem parte fracionária. está possibilidade e interessante por permitir ma economia do espaço de memória, como veremos adiante. Por sua vez, os elementos dos conjuntos Q e R. por possuírem parte fracionária, não podem ser representados na classe inteira, pertencendo necessariamente aos tipos de dados ditos reais. Como exemplo de números inteiros temos: 24 - número inteiro positivo 0 - número inteiro -12 - número inteiro negativo

3.1.2 Dados Numéricos Reais
Os dados de tipo real são aqueles que podem possuir componentes decimais ou fracionários, e podem também ser positivos ou negativos. Como dito anteriormente, os elementos dos conjuntos de números fracionários e reais são necessariamente representados nos computadores por dados do tipo real. Exemplos de dados do tipo real: 24.01 - número real positivo com duas casas decimais 144. - número real positivo com zero casas decimais -13.3 - número real negativo com uma casa decimal 0.0 - número real com uma casa decimal 0.0 0. - número real com zero casas decimais Observe que há uma diferença entre '0', que e um dado do tipo inteiro, e '0.' (ou '0.0') que é um dado do tipo real. Portanto, a simples existência do ponto decimal serve pare diferenciar um dado numérico do tipo inteiro de um do tipo real.

3.2

Dados Literais.

O tipo de dados literal e constituído por ma seqüência de caracteres contendo letras, dígitos e/ou símbolos especiais. Este tipo de dados e também muitas vezes chamado de alfanumérico, cadeia (ou cordão) de caracteres, ou ainda, do inglês STRING. Usualmente, os dados literais são representados nos algoritmos pela coleção de caracteres, delimitada em seu início e término com o caractere aspas ("). Diz-se que o dado do tipo literal possui um comprimento dado pelo número de caracteres nele contido. Exemplos de dados do tipo literal: "QUAL ?" - literal de comprimento 6

12

"" "qUaL ?!$" "AbCdefC Hi" "1-2+3=" "0"

- literal - literal - literal - literal - literal

de comprimento 1 de comprimento 8 de comprimento 9 de comprimento 6 de comprimento 1

Note que, por exemplo, "1.2" representa um dado do tipo literal de comprimento 3, constituído pelos caracteres "1","." e "2", diferindo de 1.2 que e um dado do tipo real

3.3

Dados Lógicos

A existência deste tipo de dado e, de certo modo, um reflexo da maneira como os computadores funcionam. Muitas vezes, estes tipos de dados são chamados de booleanos, devido a significativa contribuição de BOOLE a área da 1ógica matemática. O tipo de dados lógico e usado para representar dois únicos valores 1ógicos possíveis: verdadeiro e falso. E comum encontrar-se em outras referências outros tipos de pares de valores lógicos como sim/não, 1/0, true/false. Nos algoritmos apresentados neste texto os valores 1ógicos serão delimitados pelo caractere ponto (.). Exemplo: .V. - valor 1ógico verdadeiro .F. - valor 1ógico falso

3.4

Síntese

Os dados numéricos dividem-se em duas classes: inteiros, que não possuem parte fracionária e podem ser positivos ou negativos; reais, que podem possuir parte fracionária e podem ser positivos ou negativos. Os dados do tipo literal podem conter seqüências de letras, dígitos ou símbolos especiais, delimitados por aspas ("). Seu comprimento é dado pelo número de caracteres em STRING. Os dados do tipo lógico só possuem dois valores possíveis (.V. e .F.) e são sempre delimitados por pontos (.). A árvore abaixo resume a classificação dos dados com relação aos tipos de dados apresentados. Tipos de Dados

Numérico Inteiro Real

Literal

Lógico

Figura 5 - Representação dos diversos tipos de dados

3.4.1 Exercício B
1) Classifique os dados especificados abaixo de acordo com seu tipo, assinalando com I os dados do tipo inteiro, com R os reais, com L os literais, com B os lógicos (booleanos), e com N aqueles para os quais não é possível definir a priori um tipo de dado. ()0 ()1 ( ) 0.0 ( ) 0. ( ) -1 ( ) - 32 ( ) + 36 ( ) + 32. ( ) - 0.001 ( ) + 0.05 ( ) + 3257 ( ) "a" 13 ( ) "+3257" ( ) "+3257." ( ) "-0.0" ( ) ".F." ( ) - 0.0 ( ) .V. ()V ( ) "abc" ()F ( ) .F. ( ) "V" ( ) .F.

( ) 613.0 ( ) -613

( ) “613” ( ) -3.012 * 1015

( ) 17*1012 ( ) -28.3 *10 -23

( ) “Fim de Questão”

14

4.

Variáveis

A todo momento durante a execução de qualquer tipo de programa os computadores estão manipulando informações representadas pelos diferentes tipos de dados descritos anteriormente. Para que não se "esqueça" das informações, o computador precisa guardá-las em sua memória.

4.1

Arquitetura de Memória

De maneira bem simplificada, a memória de um computador pode ser vista como um conjunto ordenado de células, cada uma identificada unicamente por um número inteiro distinto, conhecido como endereço (Figura 6 ). Endereço 0 1 2 3 4 5 6 7 Figura 6 - Representação esquemática das células de memória de um computador. Cada célula de memória é mais conhecida como byte. Como mostrado na Figura 7, um byte é um agrupamento de 8 bits, numerados em ordem decrescente de 7 até 0. Diz-se que o bit 7 é o mais significativo (do inglês, MSB - Most Significant Bit) e o Bit 0 é o menos significativo (do inglês, LSB - Lest Significant Bit). Informação

7

6

5

4

3

2

1

0 bit

Figura 7 - Representação esquemática das células de memória de um computador Por sua vez, cada bit é capaz de armazenar uma informação binária (0 ou 1). Como um bit possui dois estados possíveis, e como um byte é formado por 8 bits, então um byte possui 28 = 256 estados possíveis Apesar dos bytes serem subdivididos em pedaços menores, os bits, a menor porção acessível de memória é o byte. Em outras palavras, se quisermos escrever (ou ler) algum dado da (na) memória do computador, teremos de fazê-lo byte a byte.

4.2

Tipos de Dados
Dados - Elementos conhecidos de um problema Informação - Um conjunto estruturado de dados, transmitido conhecimento

15

4.3

Armazenamento de Dados na Memória

Cada um dos diversos tipos de dados apresentados no capítulo anterior necessita de uma certa quantidade de memória par armazenar a informação representada por eles. Esta quantidade e função do tipo de dado considerado, do tipo de máquina (computador) e do tipo de linguagem de programação. Por isso, o que será exposto nos subitens seguintes não deve ser tomado como padrão, mas apenas como exemplo.

4.3.1 Armazenamento de Dados do Tipo Literal
Devemos sempre ter em mente que um byte consegue representar 256 ( = 28) possibilidades diferentes. Uma informação do tipo literal nada mais e do que um conjunto de caracteres que podem ser letras, dígitos ou símbolos especiais. A união de todos os caracteres existentes nos computadores resulta num conjunto com um número de elementos menor que 256. Deste resultado surgiu a idéia de associar a cada caractere um número (código) diferente, variando de 0 a 255 (256 possibilidades). No princípio, cada fabricante de computador adotava uma convenção diferente pare este código. Mais recentemente, esta convenção foi padronizada a fim de facilitar a portabilidade (migração) de programas entre máquinas diferentes. Esta convenção e representada na forma de uma tabela de mapeamento de caracteres em números. O padrão mais universalmente aceito e o ASCII. Assim, cada célula de memória (byte) pode conter um caractere, representado pelo seu código ASCII. Retornando a questão do armazenamento de informações do tipo literal na memória, deve-se lembrar que um dado deste tipo possui um certo comprimento dado pelo número de caracteres nele contido. Portanto, para guardar um dado do tipo literal devemos alocar (reservar) um espaço contíguo de memória igual ao comprimento do mesmo , destinando um byte pare cada caractere da informação. Exemplificando, a informação do tipo literal "banana" possui seis caracteres e, portanto, seis bytes são necessários pare reter a referida informação na memória. Em princípio, estes bytes podem estar em qualquer lugar na memória mas e conveniente que estejam juntos (posições contíguas). A primeira posição deste conjunto de bytes e absolutamente arbitrária e sua escolha geralmente e feita automaticamente pelo compilador (isto e, pelo programa que traduz um outro escrito em alguma linguagem de programação para outra, em geral, a linguagem de máquina do computador com que se trabalha). Endereço 0 1 2 3 4 5 Informação b (98) a (97) n (110) a(97) n (110) a (97)

Figura 8 - Armazenamento da Literal "banana" memória de um computador A Figura 8 mostra o caso em que se armazena a literal "banana" no conjunto de seis bytes contíguos de memória iniciando pela posição de memória 0. Na verdade, ao invés dos caracteres da literal, os códigos correspondentes aos mesmos e que são guardados na memória.

4.3.1.1 Manipulação de caracteres individuais em Literais
Muitas vezes é necessário manipular caracteres individuais em um literal. O Pascal possui uma forma toda especial de permitir tal operação, através do uso de colchetes( [ ] ) logo após o Nome da variável do tipo literal, e o número do caracter que se deseja manipular entre os colchetes. Iremos adotar o mesmo procedimento para o algoritmo. Exemplo: Atribuir o primeiro caracter de um literal a uma variável do tipo literal[1] ALGORITMO AtribuiString Var

16

Início Fim.

Letra Nome Nome Letra

: LITERAL[1] : LITERAL ← "Joao" ← Nome[1]

Quando definimos uma variável como sendo do tipo literal não estamos alocando 1 posição de memória apenas ( uma caixa, pela analogia inicial ), mas na verdade, estamos alocando até 255 caixas, uma para cada caracter da literal ( lembre-se que uma literal pode ter no máximo 255 caracteres ). Ao utilizarmos o símbolo de colchete , estamos na verdade indicando qual o caracter ( qual a caixa ) desejamos manipular. De acordo com o Exemplo acima , teríamos na memória a seguinte situação : a) Alocamos 255 bytes ( caracteres ) na memória . A estas posições de memória é dado o Nome de “Nome”. Inicialmente estas posições de memória ( Caixas ) possuem o conteúdo indefinido. b) Alocamos 1 byte ( caracter ) na memória . A este caracter é dado o Nome de “Letra”. Inicialmente esta posição de memória possuí o conteúdo indefinido. c) Na memória temos a seguinte situação : 1 2 3 Nome


Letra

255

d) Atribuímos a variável “Nome” o valor “Joao”, obtendo na memória a seguinte configuração Nome 1 2 3 4 … 255 ‘J’ ‘o’ ‘a’ ‘o’ e) Atribuímos a variável “Letra ” o primeiro caracter da variável “Nome”, ou seja, o conteúdo da primeira posição de memória ( caixa ). Na memória teremos a seguinte configuração : 1 ‘J’ 2 ‘o’ 3 ‘a’ Nome 4 ‘o’ Letra ‘J’ Obs.: É possível definir variáveis do tipo literal com menos de 255 caracteres . Para isto, basta colocar, após a palavra literal, o número de caracteres desejados entre colchetes ( [ ] ). Exemplo:

255

ALGORITMO Define
Var

Nome: LITERAL[80]
Início Fim. Desta forma, o espaço ocupado por uma variável literal passa de 255 bytes para apenas 80 bytes, na memória.

17

4.3.2 Armazenamento de Dados do Tipo Lógico
Uma informação do tipo lógico só possui dois valores possíveis: .V. ou .F.. Assim, em princípio, um único bit seria suficiente pare armazenar uma informação deste tipo. Contudo, deve-se lembrar que a menor porção de memória que se pode acessar e o byte. Portanto, uma informação do tipo 1ógico e armazenada em um byte de memória. De certa forma, se por um lado isto pode ser como um "desperdício" de memória por outro simplifica bastante a arquitetura de mem6ria dos computadores (por motivos que fogem ao escopo deste texto). Alem do mais, isto não e tão relevante, uma vez que na pratica o número de ocorrências de dados do tipo 1ógico e bastante inferior ao de ocorrências de dados do tipo literal ou numérico.

4.3.3 Armazenamento de Dados do Tipo Inteiro
O Conjunto dos números inteiros (Z) contém um número infinito de elementos: Z = { -∞, ..., -3, -2, -1, 0, 1, 2, 3, +∞} Obviamente e inviável o armazenamento de todos os números deste conjunto num computador. Faz-se necessário realizar um estudo para que se limite o número de elementos representáveis deste conjunto. Se apenas um byte fosse utilizado para armazenar os dados do tipo inteiro, existiriam apenas 256 números diferentes neste conjunto: {-128,-126, ...,-2,-1,0,1,2, ...,127,127} Esta restrição e bastante forte, uma vez que boa parte das aplicações práticas necessitam de números inteiros maiores que estes. Se forem utilizados dois bytes para armazenar um número inteiro, o universo de números representáveis cresce para 28 x 28 = 216 = 65536 possibilidades: {-32768,-32766, ..., -2,-1,0,1,2,...,32767,32767} Este conjunto satisfaz a grande maioria das necessidades práticas. Assim, em geral utilizam-se dois bytes para representar os números inteiros em computadores. Contudo, restam algumas aplicações muito específicas em que se precisa de um conjunto ainda maior. Para estes casos, algumas linguagens de programação fornecem mecanismos para trabalhar números inteiros com quatro bytes. Nestes casos os dados são ditos inteiros longos ou estendidos.

4.3.4 Armazenamento de Dados do Tipo Real
(O conjunto dos números reais (R) contém um número infinito de elementos e, pelas mesmas razões que o conjunto dos números inteiros, precisa ser limitado. Para dados deste tipo julgou-se apropriado adotar quatro bytes para sua representação interna nos computadores. São muito comuns situações como as aplicações científicas em que e necessária uma maior precisão de cálculo, intimamente ligada ao número de casas decimais dos dados. Para este caso, em analogia com o que acontece com os dados do tipo inteiro, algumas linguagens de programação decidiram criar dados do tipo real estendido (com oito bytes).

4.4

Conceito e Utilidade de Variáveis

Como visto anteriormente, informações correspondentes a diversos tipos de dados são armazenadas nas memórias dos computadores. Para acessar individualmente cada uma destas informações, em princípio seria necessário saber o tipo de dado desta informação (ou seja, o número de bytes de memória por ela ocupados) e a posição inicial deste conjunto de bytes na memória. Percebe-se que esta sistemática de acesso a informações na memória e bastante ilegível e difícil de se trabalhar. Para contornar esta situação criou-se o conceito de variável, que e uma entidade destinada a guardar uma informação. Basicamente, uma variável possui três atributos: um nome, um tipo de dado associado a mesma e a informação por ela guardada.

18

Nome

Tipo de Dado

Infomação Figura 9 - Atributos de uma variável Toda variável possui um nome que tem a função de diferenciá-la das demais. Cada linguagem de programação estabelece suas próprias regras de formação de nomes de variáveis. Adotaremos neste texto as seguintes regras: - um nome de variável deve necessariamente começar com uma letra em maiúscula e seguidas por um número ou letra todas em minúscula; - um nome de variável não deve conter nenhum símbolo especial, exceto a sublinha (_). Exemplos: Salário 1ano Ano1 A casa Sal/hora Sal_hora _desconto - Correto - Errado (não começou com uma letra) - Correto - Errado (contém o caractere branco) - Errado (contém o caractere "/") - Correto - Errado (não começou com uma letra)

Obviamente é interessante adotarmos nomes de variáveis relacionadas às informações que ela vai armazenar em um programa. Exemplo: uma variável para armazenar o salário dos funcionários em uma empresa num programa de processamento de folha de pagamento, seria interessante utilizar uma variável chamada Salário. Outro atributo característico de uma variável e o tipo de dado que ela pode armazenar. Este atributo define a natureza das informações contidas na variável. Por último, ha o atributo informação que nada mais e do que a informação útil contida na variável Uma vez definidos, os atributos nome e tipo de dado de uma variável não podem ser alterados e assim permanecem durante toda a sua existência, desde que o programa que a utiliza não seja modificado. Por outro lado, o atributo informação esta constantemente sujeito a mudanças, de acordo com o fluxo de execução do programa. Por exemplo, se definirmos que uma determinada variável e chamada Salário e destinada a guardar números reais, e possível que seu conteúdo seja, num dado instante, igual a 1.500,00 e posteriormente modificado para 3.152,19, de acordo com o programa executado. Em resumo, o conceito de variável foi criado para facilitar a vida dos programadores, permitindo acessar informações na memória dos computadores por meio de um nome, em vez do endereço de uma célula de memória.

4.5

Definição de Variáveis em Algoritmos

Todas as variáveis utilizadas em algoritmos devem ser definidas antes de serem utilizadas. Isto se fez necessário pare permitir que o compilador reserve um espaço na memória pare as mesmas. Algumas linguagens de programação (como BASIC e FORTRAN) dispensam esta definição, uma vez que o espaço na memória e reservado a medida que novas variáveis são encontradas no decorrer do programa. Nos algoritmos apresentados neste texto será adotada a seguinte convenção:

19

- todas as variáveis utilizadas em algoritmos serão definidas no início do mesmo, por meio de um comando de uma das formas seguintes: VAR ou VAR <lista_de_variáveis> : <tipo_das_variaveis> <nome_da_variável> : <tipo_da_variável>

- a palavra-chave VAR deverá estar presente sempre e será utilizada uma única vez na definição de um conjunto de uma ou mais variáveis; - numa mesma linha poderão ser definidas uma ou mais variáveis do mesmo tipo; Para tal, deve-se separar os nomes das mesmas por vírgulas; - variáveis de tipos diferentes devem ser declaradas em linhas diferentes. A forma de utilização deste comando ficará mais clara quando da utilização da representação de algoritmos em linguagem estruturada (pseudocódigo). Esta convenção e válida para a representação de algoritmos na forma de pseudocódigo. Em termos de fluxograma, não e usual adotar-se qualquer forma de definição de variáveis. Exemplo de definição de variáveis: VAR Nome Idade Salário Tem_filhos : literal[10] : inteiro : real : lógico

No exemplo acima foram declaradas quatro variáveis: - a variável - a variável - a variável - a variável Nome, capaz de armazenar dados literais de comprimento 10 (dez caracteres); Idade, capaz de armazenar um número inteiro; Salário, capaz de armazenar um número real; Tem_filhos, capaz de armazenar uma informação lógica.

4.6

Definição de Variáveis em Pascal

Para definir uma ou mais variáveis, devemos utilizar, em Pascal , a palavra VAR. Para manter uma compatibilidade , utilizaremos a mesma nomenclatura em nossos algoritmos. Abaixo segue Exemplo de algumas definições de variáveis: a) ALGORITMO Teste VAR Palavra : Literal INICIO <comandos> FIM ALGORITMO Teste VAR Letra, Caracter: Literal[1] INICIO <comandos> FIM ALGORITMO Teste VAR Letra, Caracter: Literal[1] Número: Inteiro INICIO 20 PROGRAM Teste; VAR

Palavra: String;
BEGIN <comandos>; END. PROGRAM Teste; VAR Letra, Caracter: CHAR; BEGIN <comandos>; END. PROGRAM Teste; VAR Letra, Caracter: CHAR; Número: INTEGER; BEGIN

b)

c)

<comandos> <comandos>; FIM END. Obs.: Os nomes dados as variáveis não podem ser os mesmos nomes de palavras reservadas do Pascal , tais como PROGRAM, BEGIN, END, VER, etc…

4.7

Mapeamento de Variáveis na Memória

O computador não e capaz de trabalhar diretamente com nomes simbólicos, como os nomes de variáveis. Pelo contrário, o computador só consegue tratar com células de memória por meio do conhecimento de seus endereços. Para intermediar esta situação, o tradutor (compilador ou interpretador) monta uma tabela de mapeamento dos nomes simbólicos em posições de memória. Esta tabela e denominada Tabela de Símbolos e esquematizada na Figura 10. Nome Simbólico Posição Inicial Tipo de Dado

Figura 10 - Forma geral de uma tabela de símbolos. Dentre as informações contidas na tabela de símbolos encontram-se: - o nome simbólico de cada uma das variáveis do programa; - a posição inicial do conjunto de bytes contíguous de memória onde esta armazenada a informação da variável; - o tipo de dado da variável, a partir do qual e possível determinar o tamanho do espaço de memória consumido pela mesma. Eventualmente a informação concernente ao tipo de dado da variável pode ser complementada ou simplesmente substituída na tabela de Símbolos pelo tamanho da variável. De posse da definição das variáveis utilizadas num programa, o tradutor e capaz de montar com pequeno esforço a referida tabela. A cada variável do programa corresponde uma linha da tabela. As informações contidas na tabela são absolutamente suficientes pare localizar qualquer uma das variáveis definidas no programa dentro da memória do computador. Inicialmente, toda a memória esta disponível e, a medida que novas variáveis vão sendo definidas, as células de memória vão sendo reservadas, começando pela primeira posição disponível. Para exemplificar, a tabela de Símbolos correspondente as variáveis definidas no exemplo anterior e dada abaixo: Nome Simbólico Posição Inicial Tipo de Dado Nome 0 Literal[10] Idade 10 Inteiro Salário 12 Real Tem_filhos 16 Lógico Figura 11 - Tabela de símbolos das variáveis definidas no exemplo anterior Supondo que a primeira posição de memória disponível e o byte 0, ao encontrar a definição da variável Nome como um literal de 10 caracteres, o tradutor reservará os 10 bytes iniciais da memória (posições 0 a 9) pare a informação da referida variável. Ao encontrar a definição da variável Idade como um inteiro, o tradutor reservará dois bytes de memória pare a mesma, iniciando pela primeira posição livre de memória, ou seja, os bytes 10 e 11. Prosseguindo no mesmo raciocínio, o tradutor reservará pare a variável Salário as posições de memória 12 a 15 e pare a variável Tem_filhos a posição 16.

21

4.8

Tipos de Dados em Pascal

O Pascal exige que no momento que formos trabalhar com variáveis, indiquemos o tipo de informação que uma variável pode conter, isto é, se uma dada posição de memória armazenará um número ou uma letra etc. Para isto, a linguagem Pascal possui definido alguns tipos que deverão ser usados quando formos trabalhar com variáveis. Alguns tipos são:

Algoritmo Pascal a) Inteiro a) INTEGER: b) Real c) Literal d) Lógica

Descrição Representa números entre -32768 até +32767. ocupa 2 bytes na memória . b) REAL: Representa os números entre 2.9 x 10 -39 até 1.7 x 1038 . Ocupa 6 bytes na memória . f) STRING: Conjunto de caracteres ( CHAR ). Ocupa de 1 a 255 bytes na memória . g) BOOLEAN: Valor lógico . Assuma somente dois valores: TRUE(Verdade) ou FALSE(Falso). ocupa 1 byte na memória. e) CHAR: Representa um dos caracteres , da tabela ASCII. Ocupa 1 byte na memória . c) WORD: Números de 0 até 65535. Ocupa 2 bytes na memória. d) BYTE: Números de 0 até 255. Ocupa 1 byte na memória . h) Shor Int Representa os números entre -128 até 128 . Ocupa 1 bytes na memória . i) LongInt Representa os números entre - 2.147.483.648 até 2.147.483.648 . Ocupa 4 bytes na memória. j) Single Representa os números entre 1.5 x 10 -45 até 3.4 x 1038 . Ocupa 4 bytes na memória . l) Double Representa os números entre 5 x 10 -324 até 1.7 x 10308 . Ocupa 8 bytes na memória .

4.9

Síntese

A memória dos computadores e composta por células numeradas ordenadamente denominadas bytes. Cada byte e constituído por 8 bits. Cada tipo de dado requer um número diferente de bytes pare armazenar a informação representada por ele na memória Esta quantidade também pode variar em função do tipo de computador considerado. Uma variável e uma entidade dotada de um nome pare diferenciá-la das demais e um tipo de dado que define o tipo de informação que ela e capaz de guardar. Uma vez definidos, o nome e o tipo de uma variável não podem ser alterados no decorrer de um programa. Por outro lado, a informação útil da variável e objeto de constante modificação durante o decorrer do programa, de acordo com o fluxo de execução do mesmo.

4.9.1 Exercício C
1. Na lista seguinte, assinale com V os nomes de variáveis válidos e com I os inválidos: ( ) 3abc ( ) _a ( ) Aa ( ) _1 ( ) _a123 ( ) Etc... ()A ( ) Acd1 ()1 ( ) A0123 ( ) B312 ( ) Guarda_chuva ( ) Abc ( ) 123a ()_ ( ) A123 ( ) A123 ( ) Abcde 2. (a)

Dadas as declarações de variáveis abaixo, monte as tabelas de símbolos correspondentes, como seria feito por um tradutor: VAR A, B, C : real

22

Delta Positivo Raiz1, Raiz2 (b) VAR X, Y Nome, Profissão Rua Número Renda

: real : lógico : real : inteiro : literal[20] : literal[30] : inteiro : real

23

5.

Expressões

O conceito de expressão em termos computacionais esta intimamente ligado ao conceito de expressão (ou fórmula) matemática, onde um conjunto de variáveis e constantes numéricas relacionamse por meio de operadores aritméticos compondo uma formula que, uma vez avaliada, resulta num valor.

H

B Figura 12 - Triângulo de base (B) e altura (H). Por exemplo, a fórmula de cálculo da área do triângulo da Figura 12 é dada por: Área = 0.5 x B x H Esta fórmula utiliza três variáveis: B e H. que contém as dimensões triângulo, e ÁREA onde e guardado o valor calculado (resultado da avaliação da expressão). Ha, também, uma constante (0.5) e o operador de multiplicação (x), que aparece duas vezes na expressão. O conceito de expressão aplicado a computação assume uma conotação mais ampla: uma expressão e uma combinação de variáveis, constante operadores, e que, uma vez avaliada, resulta num valor.

5.1

Operadores

Operadores são elementos funcionais que atuam sobre operandos e produzem um determinado resultado. Por exemplo, a expressão 3 + 2 relaciona dois operandos (os números 3 e 2) por meio do operador (+) que representa operação de adição. De acordo com 0 número de operandos sobre os quais os operador atuam, os últimos podem ser classificados em: - binários, quando atuam sobre dois operandos. Ex.: os operador das operações aritméticas básicas (soma, subtração, multiplicação divisão); - unários, quando atuam sobre um único operando. Ex.: o sinal de na frente de um número, cuja função e inverter seu sinal. Outra classificação dos operadores e feita considerando-se o tipo dado de seus operandos e do valor resultante de sua avaliação. Segundo esta classificação, os operadores dividem-se em aritméticos, lógicos e literais Esta divisão esta diretamente relacionada com o tipo de expressão onde aparecem os operadores. Um caso especial e o dos operadores relacionais, que permitem comparar pares de operandos de tipos de dados iguais, resultando sempre num valor lógico. Mais adiante serão apresentados formalmente os operadores dos diversos tipos acima relacionados.

24

5.2

Tipos de Expressões
As expressões são classificadas de acordo com o tipo do valor resultante de sue avaliação.

5.2.1 Expressões Aritméticas
Expressões aritméticas são aquelas cujo resultado da avaliação e do tipo numérico, seja ele inteiro ou real. Somente o uso de operadores aritméticos e variáveis numéricas e permitido em expressões deste tipo. Os operadores aritméticos relacionados as operações aritméticas básicas estão sumarizados na Tabela 1. Tabela 1 - Operadores aritméticos e sua ordem de prioridade Operador + * / ** + Tipo Binário Binário Binário Binário Binário Unário Unário Operação Adição Subtração Multiplicação Divisão Exponenciação Manutenção de sinal Inversão de sinal Prioridade 4 4 3 3 2 1 1

A prioridade entre operadores define a ordem em que os mesmos devem ser avaliados dentro de uma mesma expressão. Este assunto será tratado com major profundidade numa seção posterior. O caractere (*) e adotado na maioria das linguagens de programação pare representar a operação de multiplicação, ao invés do caractere (x), devido a possibilidade da ocorrência do mesmo no nome de variáveis. Pela mesma razão, o símbolo (**) e adotado pare representar a operação de exponenciação Algumas linguagens de programação adotam o símbolo (A) (circunflexo) pare esta finalidade, mas isto e pouco freqüente. As variáveis usadas em expressões aritméticas podem somente ser do tipo inteiro ou real. Se sodas as variáveis que aparecem numa expressão são do tipo inteiro, então o valor resultante da expressão e também do tipo inteiro. Se ao menos uma das variáveis da expressão aritmética for do tipo real, então o valor resultante da avaliação da expressão e necessariamente do tipo real. Nos exemplos seguintes, assumiremos que: - A, B e C são variáveis do tipo inteiro; - X, Y e Z são variáveis do tipo real. Exemplos: 1) A+B*C 2) A+B+Y 3) A/B 4) X/Y - expressão de resultado inteiro - expressão de resultado real - expressão de resultado inteiro - expressão de resultado real

O leitor deve estranhar o fato de no terceiro exemplo ser apresentada uma expressão onde se dividem dois números inteiros e se obtém como resultado um valor inteiro. Obviamente, o resultado da divisão entre dois números inteiros não e necessariamente inteiro. Na verdade, a operação representada no terceiro item e a divisão inteira, onde o resto da divisão e desprezado.

5.2.2 Expressões Lógicas
Expressões lógicas são aquelas cujo resultado da avaliação e um valor lógico. (.V. ou .F.). Os operadores lógicos e sues relações de precedência são mostrados na Tabela 2. Existem outros operadores lógicos, como por exemplo o OU_EXCLUSIVO., mas suas funções podem ser exercidas por combinações dos três tipos de operadores da Tabela 2. Tabela 2 - Operadores lógicos e suas relações de prioridade Operador Tipo 25 Operação Prioridade

.OU. .E. .NÃO

Binário Binário Unário

Disjunção Conjunção Negação

3 2 1

Para exemplificar o uso de operadores lógicos, a Tabela 5.3 apresenta duas variáveis lógicas A e B. Uma vez que cada variável lógica possui somente dois valores possíveis, então ha exatamente quatro combinações para estes valores, razão pela qual a tabela tem quatro linhas. As diversas colunas contém os resultados das operações lógicas sobre as combinações possíveis dos valores das variáveis A e B. Tabela 3 - Tabela-verdade dos operadores apresentadas na Tabela 2 A .F. .F. .V. .V. B .F. .V. .F. .V. .NÃO. A .V. .V. .F. .F. .NÃO.B .V. .F. .V. .F. A .OU. B .F. .V. .V. .V. A .E. B .F. .F. .F. .V. A .OU_EXCLUSIVO. B .F. .F. .F. .V.

Tabelas como a da Tabela 3 são chamadas de Tabelas-verdade. Convém salientar as seguintes conclusões que podem ser extraídas por observação da Tabela 3: - O operador lógico .NÃO. sempre inverte o valor de seu operando. Ex.: .NÃO..V. =.F. e .NÃO. .F. = .V.; - para que a operação lógica .OU. tenha resultado verdadeiro basta que um de seus operandos seja verdadeiro; Para melhor visualizar este efeito, podemos imaginar que as variáveis lógicas A e B são como dois interruptores ligados em paralelo num circuito de acionamento de uma lâmpada (Figura 5.2).

A

B
Bateria Lâmpada

Figura 13 - Representação da operação .OU. por meio de um circuito elétrico com interruptores em paralelo. Neste exemplo, um interruptor fechado (e que, portanto, permite a passagem de corrente elétrica) representa uma variável lógica cujo valor e verdadeiro (.V.). Por outro lado, um interruptor aberto representa uma variável lógica com valor falso (.F.). No circuito da Figura 13, para que a lâmpada acenda basta que um dos interruptores esteja fechado. Analogamente, para que a operação lógica .OU. tenha resultado verdadeiro (.V.) basta que apenas um dos operandos possua valor lógico .V. Por outro lado, para que a operação lógica .OU. possua resultado .F. (para que a lâmpada esteja apagada) e necessário que os dois operandos possuam valor .F. (e necessário que os dois interruptores estejam abertos). - para que a operação lógica .E. tenha resultado verdadeiro e necessário que seus dois operandos tenham valor lógico .V. . Em termos de um circuito elétrico, uma operação lógica .E. pode ser representada _A_ dois interruptores ligados em série. como na Figura 5.3.

A

B

Bateria

26

Lâmpada

Figura 14 - Representação da operação lógica .E. por meio de um circuito elétrico com interruptores em série. Nota-se no circuito acima que a lâmpada somente estará acessa quando os dois interruptores (A e B) estiverem fechados. Por outro lado, basta que um dos interruptores (A ou B) esteja aberto para que a lâmpada não acenda. Da mesma forma, a operação lógica E. só resulta em .V. quando A e B forem iguais a .V.; ainda, para que a operação lógica .E. resulte em .F. basta que um de seus operadores seja .F.. Nas expressões lógicas onde aparecem apenas os operadores lógicos da Tabela 2 somente variáveis do tipo lógico podem ser usadas. Isto parece óbvio, uma vez que os operadores lógicos somente atuam sobre valores (constantes ou variáveis) lógicos. Ha, ainda, outro tipo de operador que pode aparecer em operações lógicas os operadores relacionais, mostrados na Tabela 4. Tabela 4 - Operadores Relacionais Operador = <> < <= > >= Comparação Igual Diferente Menor Menor ou igual Maior Maior ou igual

Estes operadores são somente usados quando se deseja efetuar comparações. comparações só podem ser feitas entre objetos de mesma natureza, isto e, variáveis do mesmo tipo de dado. O resultado de uma comparação e sempre um valor lógico. O uso de operadores relacionais possibilita o aparecimento em expressões lógicas de variáveis de outros tipos de dados que não o lógico. Exemplo: sejam A e B variáveis lógicas, X e Y variáveis reais, e R. S e T variáveis literais, com os respectivos valores: A = .V. , B = .F., X = 2.5, Y = 5.0, R = "JOSÉ", S = "JOÃO" e T = "JOÃOZINHO" A tabela seguinte contém algumas expressões lógicas contendo estas variáveis.

27

Tabela 5 - Exemplos de avaliações de expressões lógicas. Expressão A .OU. B A .E. B . NÃO. A X=Y X = (Y/2) R=S S=T R<>S R>S S>T (( A .OU. B) .OU. (XY) .OU. (ST)) → → → → → → → → → → → Resultado .V. .F. .F. .F. .V. .F. .F. .V. .V. .F. .V.

Um resultado interessante de ser observado e o da expressão S > T. ou seja, "JOÃO" > "JOÃOZINHO", cujo resultado e falso. A primeira pergunta que surge deve ser com relação a maneira como e feita tal comparação. Para tal, deve-se recorrer mais uma vez ao Apêndice B. onde esta a tabela de códigos ASCII. Tal tabela estabelece para cada caractere um código diferente. De acordo com este código e possível comparar dois dados de tipo literal, comparando os caracteres dos mesmos da esquerda para a direita. Ao comparar os literais "JOSÉ" e "JOÃO", verificamos que seus dois primeiros caracteres (J e o) são iguais, mas que "S" e maior que "A", segundo a tabela ASCII. Portanto "JOSÉ" e maior que "JOÃO". Estes tipos de comparação são muito úteis na ordenação alfabética de variáveis literais.

5.2.3 Expressões Literais
Expressões literais são aquelas cujo resultado da avaliação e um valor literal Este tipo de expressão e bem menos freqüente que os anteriores. Os tipos de operadores existentes variam de uma linguagem de programação para outra, não havendo uma padronização. Para que o assunto não passe em branco, considere-se como exemplo a operação de concatenação de strings: tome-se duas strings e acrescenta-se (concatena-se) a segunda delas ao final da primeira. Em algumas linguagens esta operação e representada pelo símbolo (operador) (+). Por exemplo, a concatenação das strings "REFRIGERA" e "DOR" e representada por "REFRIGERA" + "DOR" e o resultado de sue avaliação e "REFRIGERADOR". Obs.: O operador “+” caso seja usado entre variáveis do tipo literal , causará uma ação conhecida por concatenação , ou seja, juntar os caracteres ou literais usados na operação em uma só literal. Exemplo: ALGORITMO Concatena Var Letra1, Letra2 : Literal[1] Nome1, Nome2, Nome : Literal Início Letra1 ← "D" Letra2 ← "a" Nome1 ← "João" Nome2 ← "Silva" Nome ← Nome1 + Letra1 + Letra2 + Nome2 Fim. As instruções acima resultarão no armazenamento do Nome "João Da Silva" na variável rotulada de "nome".

28

5.3

Avaliação de Expressões

Expressões que apresentam apenas um único operador podem ser avaliadas diretamente. No entanto, a medida que as mesmas vão-se tornando mais complexas com o aparecimento de mais de um operando numa mesma expressão, e necessária a avaliação da mesma passo a passo, tomando um operador por vez. A seqüência destes passos e definida de acordo com o formato geral da expressão, considerando-se a prioridade (precedência) de avaliação de seus operadores e a existência ou não de parênteses na mesma. As seguintes regras são essenciais pare a correta avaliação de expressões: 1. Deve-se observar a prioridade dos operadores, conforme mostrado nas Tabela 1 e Tabela 2: operadores de major prioridade devem ser avaliados primeiro. Se houver empate com relação a precedência, então a avaliação se fez considerando-se a expressão da esquerda pare a direita. 2. Os parênteses usados em expressões tem o poder de "roubar" a prioridade dos demais operadores, forçando a avaliação da subexpressão em seu interior. 3. Entre os quatro grupos de operadores existentes, a saber, aritmético, lógico, literal e relacional, ha uma certa prioridade de avaliação os aritméticos e literais devem ser avaliados primeiro; a seguir, são avaliadas as subexpressões com operadores relacionais e, por último, os operadores lógicos são avaliados. Exemplos: suponha que X, Y e Z são variáveis reais, e A e B variáveis lógicas, com os respectivos valores: X = 2.0, Y = 3.0, Z = 0.5, A = .V. e B = .F. Considere as seguintes expressões e o resultado de suas avaliações: 1) X*Y-Z 2) X*(Y-Z) 3) X + Y * Z 4)X+(Y*Z) 5) (X+Y)*Z 6) X ** Y - 1 7) (X**Y)-1 8) X ** (Y - 1) 9) B.E.A.OU.X<>Y/2 10) B.E.(A.OU.X<>Y/2) - 5.5 - 5.0 - 3.5 - 3.5 - 2.5 - 7.0 - 7.0 - 4.0 - .V. - .F.

Das expressões do exemplo acima podemos observar que: - a aplicação da regra 2 fez com que a expressão 2) tenha um resultado diferente da expressão 1). O mesmo acontece com as expressões 3) e 5), 6) e 8), e 9) e 10); - o agrupamento de subexpressões usando parênteses, contendo operadores de prioridade major que a dos operadores que permaneceram fora dos parênteses, não altera a ordem de avaliação das expressões e, portanto, não modifica seus resultados, como acontece em 3) e 4), e 6) e 7); - a aplicação da regra 3 define a única seqüência correta pare se avaliar as expressões 9) e 10). De fato, esta regra define que a subexpressão Y / 2 deve ser avaliada antes de se comparar seu resultado com X ( em X <> Y / 2). De fato, se a comparação X <> Y fosse feita, seu resultado seria um valor lógico, que posteriormente seria dividido por 2, o que e impossível.

5.4

Síntese

Uma expressão e uma combinação de variáveis, constantes e operadores, que resulta num valor quando avaliada. Operadores são elementos funcionais que atuam sobre operandos. Segundo o número de operandos sobre os quais atua, um operador pode ser classificado em unário ou binário. Segundo os tipos de dados de seus operandos e do valor resultante de sue avaliação, os operadores podem ser classificados em aritméticos, lógicos ou literais. 29

Um tipo especial de operador e o relacional, que e usado na comparação de operandos de um mesmo tipo de dado e cujo resultado da avaliação e sempre um valor lógico. As expressões são classificadas de acordo com o valor resultante de sue avaliação em: - aritméticas, que resultam num valor numérico (real ou inteiro); - lógicas, que resultam num valor lógico; - literais, que resultam num valor literal. Ha três regras básicas que definem a seqüência correta de avaliação passo a passo de expressões: 1. Operadores de major prioridade devem ser avaliados primeiro. Em caso de empate, a avaliação se fez da esquerda pare a direita. 2. O uso de parênteses em subexpressões force a avaliação das mesmas com major prioridade. 3. Os diversos tipos de operadores devem ser avaliados na seguinte seqüência dentro de uma expressão complexa: primeiro os aritméticos e literais; a seguir, os relacionais e, por último, os lógicos.

5.5

Exercício Resolvido

Dada a tabela-verdade correspondente a operação lógica .OU_EXCLUSIVO. A .F. .F. .V. .V. B .F. .V. .F. .V. A .OU_EXCLUSIVO. B .F. .V. .V. .F.

encontre uma expressão lógica equivalente a mesma e que utilize apenas os operadores lógicos .OU., .E. e .NÃO.. Solução: Observando-se a tabela dada, nota-se que o resultado da operação lógica em questão e verdadeiro (.V.) somente quando A e .F. e B e .V., ou então, quando A e .V. e B e .F.. Formalmente, pode-se fazer: A.OU_EXCLUSIVO. B = ((.NÃO. A).E. B).OU. (A.E. (.NÃO. B))

5.5.1 Exercícios D
1. Dada a declaração de variáveis VAR A, B, C X, Y, Z Nome, Rua LI, L2 : inteiro : real : literal[20] : lógico

classifique as expressões seguintes de acordo com o tipo de dado do resultado de sue avaliação, em I (inteiro), R (real), L (literal), B (lógico) ou N (quando não for possível defini-lo): ( )A+B+C ( )A+B+Z ( ) Nome + Rua ( ) L1 .OU. L2 ( ) (Rua < > Nome) .E. (.NÃO. (A=B)) ( ) A + B /C ()A+X/Z ()A+Z/A ( )A>B ( )A>Y ( ) Nome > Rua ( ) A > B = L1 ()X+Y/Z ()X+Z/A ( ) L1 ** L2

2. Para as mesmas variáveis declaradas no exercício 1, às quais são dados os valores seguintes 30

A=1 B=2 C=3 X = 2.0

Y = 10.0 Z = -1.0 L1 = .V. Nome = "PEDRO"

Rua = "PEDRINHO" L2 = .F.

Determine o resultado da avaliação das expressões abaixo: a) A + C / B → b) A + B /C → c) C / B / A → d) A ** B ** A → e) Z * X ** B → f) -X ** B → g) ( X ** B) → h) ( - X ) ** B → i) Nome + Rua → j) Nome = Rua → k) L1 .OU. L2 → l) ( L1 .E. (.NÃO. L2)) → m) ( L2 .E. (.NÃO. L1)) → n) ( L1 .E. (.NÃO. L2)) .OU. (L2 .E. (.NÃO. L1)) → o) X > Y .E. C < = B → p) ( C -3 * A) < (X +2 * Z) → 3. Dada a tabela - verdade A .F. .F. .V. .V. B .F. .V. .F. .V. A .op. B .V. .F. .V. .F.

Encontre uma expressão lógica equivalente à mesma e que utilize apenas os operadores lógicos .E., .OU. e . NÃO. .

31

6.

Instruções Primitivas

Como o próprio nome diz, instruções primitivas são os comandos básicos que efetuam tarefas essenciais pare a operação dos computadores, como entrada e saída de dados (comunicação com o usuário e com os dispositivos periféricos), e movimentação dos mesmos na memória. Estes tipos de instrução estão presentes na absoluta maioria das linguagens de programação. De fato, um programa que não utilize nenhuma instrução primitiva - como as que serão definidas neste capítulo - e incapaz de se comunicar com o mundo exterior e, portanto não tem utilidade alguma. Antes de passar a descrição das instruções primitives, e necessária a definição de alguns termos que serão utilizados mais a frente: dispositivo de entrada e o meio pelo qual as informações (mais especificamente os dados) são transferidas pelo usuário ou pelos níveis secundários de memória ao computador. Os exemplos mais comuns são: o teclado, o cartão perfurado (já obsoleto), as fitas e os discos magnéticos, entre outros; dispositivo de saída e o meio pelo qual as informações (geralmente, os resultados da execução de um programa) são transferidas pelo computador ao usuário ou aos níveis secundários de memória. Exemplos: monitor de vídeo, impressora, fitas e discos magnéticos, entre outros: sintaxe e a forma como os comandos devem ser escritos, a fim de que possam ser entendidos pelo tradutor de programas. A violação das regras sintáticas e considerada um erro sujeito a pena do não-reconhecimento do comando por parte do tradutor; semântica e o significado, ou seja, o conjunto de ações que serão exercidas pelo computador durante a execução do referido comando. Daqui em diante, todos os comandos novos serão apresentados por meio de sue sintaxe e sue semântica, isto é, a forma como devem ser escritos e a(s) ação(ões) que executam.

6.1

Instrução Primitiva de Atribuição

A instrução primitiva de atribuição, ou simplesmente atribuição, e a principal maneira de se armazenar uma informação numa variável. Sua sintaxe e: <nome_de_variável> ← <expressão> Em termos de fluxograma, os comandos de atribuição são representados como na Figura 15.

<Variável> ← <Expressão>

Figura 15 - Forma de representação de comandos de atribuição em fluxograma O modo de funcionamento (semântica) de uma atribuição consiste 1) na avaliação da expressão e 2) no armazenamento do valor resultante na posição de memória correspondente a variável que aparece a esquerda do comando. A expressão presente no comando de atribuição pode ser de qualquer um dos tipos descritos no capítulo anterior. Uma implicação bastante séria, pare qual a atenção deve ser dirigida, e a necessidade da compatibilidade entre o tipo de dado resultante da avaliação da expressão e o tipo de dado da variável, no sentido em que esta deve ser capaz de armazenar o resultado da expressão. Mais explicitamente, se uma expressão resulta num valor lógico, então a variável deve ser também do tipo lógico. O mesmo acontece no caso de dados literais e reais. Uma exceção, ao e o cave em que a variável e do tipo real e a expressão resulta num valor inteiro. Nesta situação, o resultado (dado do tipo inteiro) e convertido pare o tipo real e posteriormente armazenado na variável. Esta operação de conversão de tipos de dados e conhecida por coerção.

32

A Figura 16 mostra um exemplo de algoritmo onde algumas atribuições são feitas: os valores 5.0 e 10 são atribuídos as variáveis Preço_unit e Quant, respectivamente; posteriormente, o resultado do produto entre as duas anteriores e armazenado em Preço_tot. Quando definimos uma variável é natural atribuirmos a ela uma informação . Uma das formas de colocar um valor dentro de uma variável , consequentemente colocado este dado na memória do computador, é através da atribuição direta, do valor desejado que a variável armazena . Para isto utilizaremos o símbolo (← (Algoritmo), : = (Pascal)), que significa : recebe , ou seja, a posição , de memória que uma variável representa, receberá uma informação , a qual será armazenada no interior desta variável .

Exemplo:
ALGORITMO Teste Var Número: INTEIRO Início Número ← 10 Fim. O Exemplo acima nos informa que: a) Foi definido uma variável , a qual demos o Nome de “Número”, e informamos que esta variável , ou posição de memória , só poderá aceitar dados, que sejam numéricos e que estejam entre -32768 a +32767 ( tipo INTEGER ). b) Atribuímos à variável “Número” o valor 10 A memória se comportaria da seguinte forma, de acordo com os itens acima : a) b) Variável Número Variável Número Conteúdo indefinido Conteúdo 10 PROGRAM Teste; VAR Número: INTEGER; BEGIN Número: =10; END.

6.1.1 Exercícios E
1. Faça um algoritmo para atribuir a variáveis as seguintes informações: a) 12345.0 b) 123456 c) -1122 d) 10 e) VERDADE f) 12345605 2. No seguinte algoritmo existe algum erro? Onde?

ALGORITMO Teste
Var Maria idade letra Maria Início idade idade

: LITERAL[100] : INTEIRO : LITERAL[1] : REAL
← 23 ← 678 33

Fim.

idade letra letra letra

← letra ← ABC ←A ←2

3. Qual a diferença existente nas seguintes atribuições ? a) b) Letra Nome Letra Nome ← “A” ← “João” ←A ← João

4. É correto definir uma variável como sendo literal[1] e atribuirmos a ela o valor: “PEDRO” ? E se a variável fosse definida como LITERAL[100], a mesma poderia receber um valor do tipo

LITERAL[1]?
5. Dar o valor da variável Resultado após execução da seguinte seqüência de operações (Suponha que todas as variáveis seja reais): a) Resultado ← 3.0 * 6 b) X ← 2.0 Y ← 3.0 Resultado ← X ** Y - X c) Resultado ← 4 X ←2 Resultado ← Resultado * X 6. Suponha que A, B e C sejam variáveis reais e que I, J e K sejam variáveis inteiras. Dados A = 4.0, B = 6.0 e I = 3, qual seria o valor final dos comandos seguintes? a) C ← A * B – I C= _______ b) K ← I / 4 * 6 K = _______ c) C ← B / A + 1.5 C = _______ d) K ← ( B / A + 4.7) K = _______ e) J ← ( A / ( 5 / I)) J = _______ f) K ← ( A – B) * 2 + 1 K = _______ 7. Construa o algoritmo que calcule as seguintes expressões, utilize parênteses: a) 2 + 3 * { 23 - 12 + [ { ( 123 / 34 ) + 10 } / 2 - 1 * ( 45 - 12 ) ] / 3 } b) [ ( 2 * 3 ) **2 - 1 ] ** 4 c) ( 2 + [ 2 * 3 - ( 4 / 20 ) ** 2 ] )/ (10 * { [ ( 7 * 3 ) - 2 ] ** 3 }) 8. Escreva o comando de atribuição e resolva a expressão das seguintes formulas matemáticas. a)

a +1 b a +b c −d a+

d) a +

b c −d c d

b)

e) (a + b)

b c c) e d− f

B C f) X = E D− F A+

34

2 X 2 − 3 X ( X +1) + g) 2 Y= 2X
h) X =

X +1 X

i) Y = 2 H −  j) X =

 45  − 4H ( 3 − H )   3X 

2H

2 B − 4 A + 2 F −3 3− 2A

(a − b ) + ( e + f ) i * (c − d ) + (g + h ) j

6.2

Instrução Primitiva de Saída de Dados

O algoritmo da Figura 16 não e prático, pois, apesar do computador ter calculado um determinado valor ou armazenado o mesmo na variável Preço_tot, este valor ficou retido na memória do computador e não foi mostrado ao usuário, o major interessado no mesmo. As instruções primitivas de saída de dados são o meio pelo qual informações contidas na memória dos computadores são colocadas nos dispositivos de saída, pare que o usuário posse apreciálas. Ha duas sintaxes possíveis pare esta instrução: Escreva <lista_de_variáveis> ou Escreva <literal>

35

Início

Preço_Unit ← 5.0 Quant ← 10 Preço_Tot ← Preço_Unit * Quant. (a) Fim Algoritmo EXEMPLO_6_1 Var Preço_unit Preço_tot : real Quant : inteiro Início Preço_unit ← 5.0 Quant ← 10 Preço_tot ← Preço_unit * Quant Fim. Program EXEMPLO_6_1; Var Preço_unit Preço_tot : real; Quant : inteiro; Begin Preço_unit := 5.0; Quant := 10; Preço_tot := Preço_unit * Quant; End.

(b)

(c)

Figura 16 - Exemplo de aplicação de comandos de atribuição: (a) Fluxograma; (b) pseudocódigo; (c) pascal. Daqui por diante, Escreva será considerada uma palavra reservada não mais poderá ser utilizada como nome de variável (ao menos nos algoritmo apresentados neste texto), de modo que toda vez que for encontrada em algoritmos será identificada como um comando de saída de dados. Uma lista_de_variáveis e um conjunto de nomes de variáveis separados por vírgulas. Um literal e simplesmente um dado do tipo literal delimita por aspas.

36

Em termos de fluxograma, uma instrução de saída de dados e representada como na Figura 17.

<Lista_de_Variáveis> ou <Literal>

Figura 17 - Forma de representação de uma instrução de saída de dados em fluxograma Repare que a representação no fluxograma dispense o uso da palavra reservada Escreva, uma vez que a mesma já esta embutida na forma geométrica da figura. A semântica da instrução primitiva de saída de dados e muito simples: os argumentos do comando são enviados pare o dispositivo de saída. No cave de uma lista de variáveis, o conteúdo de cada uma delas e pesquisado na posição de memória correspondente a variável e depois enviado pare o dispositivo de saída. No cave de argumentos do tipo string, estes são enviados diretamente ao referido dispositivo. Há, ainda, a possibilidade de se misturar nomes de variáveis com literais na lista de um mesmo comando. O efeito obtido e bastante útil e interessante: a lista e lida da esquerda pare a direita e cada elemento da mesma e tratado separadamente; se um nome de variável for encontrado, então a informação da mesma e pega da memória e colocada no dispositivo de saída; no caso de um literal, o mesmo e escrito diretamente no dispositivo de saída. O exemplo da Figura 16 torna-se muito mais interessante com a aplicação de instruções de saída de dados, como na Figura 17.

6.3

Instrução Primitiva de Entrada de Dados

O algoritmo da Figura 18 ainda carece de uma melhoria essencial. Toda vez que ele e executado, o mesmo valor e calculado, já que os valores das variáveis Preço_unit é Quant permanecem inalterados. Seria interessante que estes valores pudessem ser fornecidos ao computador pelo usuário do programa toda vez que o programa fosse executado, pare que o usuário tivesse um maior controle sobre o valor calculado. A instrução primitiva de entrada de dados foi criada pare suprir esta necessidade.

37

Sua sintaxe é: Leia <lista_de_variáveis> Início

Preço_Unit ← 5.0 Quant ← 10 Preço_Tot ← Preço_Unit * Quant.

Preço Tot (a) Fim Algoritmo EXEMPLO_6_2 Var Preço_unit, Preço_tot : real Quant : inteiro Início Preço_unit <- 5.0 Quant <- 10 Preço_tot <- Preço_unit * Quant Escreva Preço_tot Fim. Program EXEMPLO_6_2; Var Preço_unit, Preço_tot : real; Quant : integer; Begin Preço_unit := 5.0; Quant := 10; Preço_tot := Preço_unit * Quant; Write(Preço_tot); End.

(b)

(c)

Figura 18 - Exemplo de aplicação da instrução primitiva de saída de dados: (a) fluxograma; (b)pseudocódigo; (c) Pascal. Da mesma forma que Escreva, daqui em diante Leia será tratada como uma palavra-reservada e não mais poderá ser usada como nome de variável em algoritmos. A lista_de_variáveis e um conjunto de um ou mais nomes de variáveis, separados por vírgulas A Figura 19 mostra como uma instrução de entrada de dados e representada em fluxogramas. Esta representação dispense o uso da palavra-reservada Leia, pelo fato da mesma já estar de certo modo embutida na forma geométrica da figura.

38

<Lista_de_Variáveis>

Figura 19 - Forma de representação de uma instrução de entrada de dados em fluxograma A semântica da instrução de entrada (ou leitura) de dados e, de certa forma, inversa a da instrução de escrita: os dados são fornecidos ao computador por meio de um dispositivo de entrada e armazenados nas posições de memória das variáveis cujos nomes aparecem na lista_de_variáveis. O algoritmo da Figura 18 , modificado para que os valores das variáveis Preço_unit e Quant sejam lidos no dispositivo de entrada, esta na Figura 20. O algoritmo da Figura 20 ainda precise sofrer algumas modificações pare ficar perfeito. Em sua forma atual, ao Início de sue execução, ele procure ler os valores para as variáveis Preço_unit e Quant. Um usuário diferente daquele que criou o programa, a não ser que esteja bem treinado no uso do mesmo, poderá encontrar dificuldades na interação com o programa. Ele pode confundir a ordem em que os dados devem ser fornecidos ou simplesmente esquecer o que o programa deseja que ele digite. Ao término da execução o programa escreve como resultado um número que pode não possuir nenhum significado ao usuário se este não souber a finalidade pare a qual o algoritmo foi concebido.

39

Início

Preço_Unit, Quant Preço_Tot ← Preço_Unit * Quant.

Preço Tot (a) Fim Algoritmo EXEMPLO_6_2 Var Preço_unit Preço_tot : real Quant : inteiro Início Leia Preço_unit, Quant Preço_tot ← Preço_unit, * Quant Escreva Preço_tot Fim.

(b)

Program EXEMPLO_6_2; Var Preço_unit Preço_tot : real; Quant : integer; Begin Read(Preço_unit, Quant); Preço_tot : = Preço_unit, * Quant; Write(Preço_tot); (c) End. Figura 20 - Exemplo de aplicação da instrução primitiva de entrada de dados num algoritmo: (a) Fluxograma; (b) pseudocódigo; (c) Pascal. Uma preocupação constante de um bom programador deve ser a de conceber um programa "amigo do usuário". Esta preocupação e traduzida no planejamento de uma interface com o usuário (meio pelo qual um programa e o usuário "conversam") bastante amigável. Em termos práticos, isto se resumem a aplicação de duas regras básicas: - toda vez que um programa estiver esperando que o usuário forneça a ele um determinado dado (operação de leitura), ele deve ante enviar uma mensagem dizendo ao usuário o que ele deve digitar, por meio de uma instrução de saída de dados; - antes de enviar qualquer resultado ao usuário, um programa deve escrever uma mensagem explicando o significado do mesmo. Estas medidas tornam o diálogo entre o usuário e o programador muito mais fácil. A versão final do algoritmo estudado é mostrado na Figura 21.

6.4

Síntese

A instrução primitiva de atribuição avalia uma expressão e armazena o valor resultante numa variável. O valor resultante da expressão e a variável devem ter tipos compatíveis. A instrução primitiva de saída de dados admite como argumentos uma lista de variáveis, um literal, ou uma mistura de ambos. No primeiro caso, o valor de cada uma das variáveis e buscado na 40

memória e colocado no dispositivo de saída. No cave de literais, estes são copiados diretamente no dispositivo de saída. A instrução primitiva de entrada de dados busca, no dispositivo de entrada, dados que são guardados nas posições de memória correspondentes as variáveis da lista que Ihe são passadas como argumento.

6.5

Exercícios Resolvidos

1. Escreva um algoritmo (fluxograma e pseudocódigo) pare calcular a média entre dois números quaisquer. solução: A idéia principal do algoritmo esta centrada na expressão matemática utilizada no cálculo da media (M) entre dois números, N1 e N2, dada por: M= (N1 +N2)/2 Para que o valor de M posse ser calculado pelo algoritmo, e necessário que os valores de N1 e N2 tenham sido fornecidos ao mesmo com antecedência. Portanto, a primeira etapa do algoritmo consiste da obtenção (leitura) dos valores de N1 c N2 e armazenamento dos mesmos em posições distintas de memória (variáveis).

41

Início "Digite o preço unitário"

Preço_unit.

"Digite a quantidade"

Quantidade Preço_Tot ← Preço_Unit * Quant. "Preço total :"" Preço Tot (a)

Fim Algoritmo EXEMPLO_6_2 Var Preço_unit, Preço_tot : real Quant : inteiro Início Escreva "Digite o Preço unitário" Leia Preço_unit, Escreva "Digite a quantidade" Leia Quant Preço_tot <- Preço_unit * Quant Escreva " Preço total : ", Preço_tot Fim. Program EXEMPLO_6_2; Var Preço_unit, Preço_tot : real; Quant : integer; Begin Write ('Digite o Preço unitário'); Read (Preço_unit); Write ('Digite a quantidade'); Read (Quant); Preço_tot := Preço_unit * Quant; Write ('Preço total :' , Preço_tot); End.

(b)

(c)

Figura 21 - Exemplo de aplicação das instruções primitivas de atribuição, entrada e saída de dados num algoritmo: (a) fluxograma; (b) pseudocódigo; (c) pascal. Na seqüência, o valor da media deve ser calculado por meio de uma expressão apropriada e atribuído a uma terceira variável (M). Por fim, deve-se relatar ao usuário o valor calculado por meio de uma instrução primitive de saída de dados.

42

O fluxograma do algoritmo descrito e mostrado a seguir. Note que ele esta enriquecido com instruções para informar sue finalidade, os dados que devem ser fornecidos ao usuário e o significado do valor calculado. Início

" Algoritmo para calcular a média entre dois número"

"Digite o primeiro número"

N1 "Digite o segundo número"

N2 M ←(N1 + N2) /2 "O Valor da média é :" ,M Preço Tot

Fim A transformação do fluxograma em pseudocódigo exige a disponibilidade de algumas informações adicionais concernentes ao tipo das variáveis utilizadas. Como o algoritmo opera apenas com dados numéricos, certamente variáveis utilizadas serão do tipo inteiro ou real. Como se deseja calcular media entre dois números quaisquer, então as variáveis N1 e N2 devem ser capazes de armazenar números com ou sem parte fracionária e, portanto necessário que estas sejam do tipo real. Como o valor médio entre dois números reais e um número que pode ou não ter parte fracionária, então a variável também deve ser do tipo real.

43

De posse dessa informação, pode-se escrever o pseudocódigo do algoritmo em questão, a partir de seu fluxograma. Algoritmo Média VAR N1, N2, M : real Início Escreva "Algoritmo pare calcular números" Escreva "Digite 0 primeiro número" Leia N1 Escreva "Digite o segundo número" Leia N2 M <- (N1+ N2) / 2 Escreva "O valor da media e:", M Fim.

a

média

entre

dois

2. Escreva um algoritmo pare calcular o valor de y como função de segundo a função y(x) = 3x + 2, num domínio real. Solução: Essencialmente o algoritmo usado na solução deste problema consiste na obtenção do valor de x pare o qual se deseja calcular a função, o cálculo desta propriamente dito e a mostra do resultado obtido ao usuário. Veja fluxograma correspondente a seguir: Início

" Algoritmo para calcular y = 3x + 2"

"X = "

X Y ←3 * X + 2

"Y = ", Y

Fim Para que se possa escrever o pseudocódigo do algoritmo deve-se decidir qual será o tipo das variáveis X e Y. Como especificado no enunciado do problema, o algoritmo deve operar num domínio real e, portanto, as variáveis X e Y devem ser do tipo real. então, o pseudocódigo fica assim:

44

Algoritmo Função_de_x VAR X, Y : real Início Escreva "Algoritmo pare calcular y = 3x + 2" Escreva "X = " Leia X y <- 3 * X + 2 Escreva "Y = ", Y Fim. 3. Escreva um algoritmo pare calcular o consumo médio de um automóvel (medico em Km/l), dado que são conhecidos a distância total percorrida e o volume de combustível consumido pare percorrê-la (medido em litros). Solução: A principal questão a ser levantada na obtenção do algoritmo pedido consiste na formulação da expressão usada pare calcular o consumo médio (CM) a partir da distância total percorrida (DIST) e do volume de combustível consumido (VOL), que e dada por: CM = DIST / VOL Uma vez obtida esta expressão, a formulação do algoritmo desejado consiste em uma simples repetição daqueles apresentados nas questões anteriores: deve-se obter o valor das variáveis DIST e VOL, calcular o consumo pela expressão acima e, finalmente, mostrar ao usuário 0 valor calculado. O fluxograma correspondente ao algoritmo e o seguinte: Início " Algoritmo para calcular o consumo"

"Distância total percorrida (Km): "

Dist

"Volume de combutível gasto (1) : "

Vol CM ← Dist / Vol

"Consumo médio = ", CM, "Km/l "

Fim Assumindo que sodas as variáveis utilizadas (CM, DIST e VOL) são do tipo real, pode-se escrever o pseudocódigo seguinte pare o fluxograma anterior: Algoritmo Consumo_médio VAR

45

CM, DIST, VOL : real Início Escreva "Algoritmo pare calcular o consumo" Escreva "distância total percorrida (Km):" Leia DIST Escreva "Volume de Combustível Gasto (1):" Leia VOL CM <- DIST / VOL Escreva "Consumo médio = ", CM, " Km/l" Fim.

6.5.1 Exercícios F
Para cada um dos problemas propostos a seguir, expresse um algoritmo que pode ser usado em sua solução na forma de um fluxograma e de um pseudocódigo. 1. Ler as seguintes informações de uma pessoa: Nome, Idade, Sexo, Peso, Altura, Profissão, Rua, Bairro, Cidade, Estado, CEP, Telefone. 2. Cálculo da média de quatro números inteiros dados. 3. cálculo do quadrado de um número, ou seja, o produto de um número por si mesmo. 4. Cálculo da função f(x, y) = 2x + 3y2, num domínio real. 5. Cálculo do preço médio do quilômetro rodado (em US$/litro) para uma dada distância percorrida (em Km) e um certo volume de combustível consumido (em litros). Nota: uma vez que o preço do combustível também pode variar, ele também deve ser fornecido como dado para o algoritmo. 6. Ler as seguintes informações de um funcionário: Nome, idade cargo e o seu salário bruto considere: a) O salário bruto teve um reajuste de 38%. b) O funcionário receberá uma gratificação de 20% do salário bruto. c) O Salário total é descontado em 15% E escrever os seguintes resultados: • Imprimir Nome, idade e cargo. • Imprimir o salário bruto. • Imprimir o salário líquido. 7. Ler a base e a altura de um triângulo. Em seguida, escreva a área do mesmo. Obs.: Área = ( Base * Altura ) / 2 8 .Uma empresa tem para um determinado funcionário uma ficha contendo o nome, número de horas trabalhadas e o n0 de dependentes de um funcionário. Considerando que: a) A empresa paga 12 reais por hora e 40 reais por dependentes. b) Sobre o salário são feito descontos de 8,5% para o INSS e 5% para IR. Leia o Nome, número de horas trabalhadas e número de dependentes de um funcionário. Após a leitura, escreva qual o Nome, salário bruto, os valores descontados para cada tipo de imposto e finalmente qual o salário líquido do funcionário. 9. O preço de um automóvel é calculado pela soma do preço de fábrica com o preço dos impostos (45% do preço de fábrica) e a percentagem do revendedor (28% do preço de fábrica). Leia o nome do automóvel e o preço de fábrica e escreva o nome do automóvel e o preço final.

46

7.

Controle do Fluxo de Execução

Até o momento os algoritmos estudados utilizam apenas instruções primitive de atribuição, e de entrada e saída de dados. Qualquer conjunto de dada fornecido a um algoritmo destes será submetido ao mesmo conjunto de instruções, executadas sempre na mesma seqüência. No entanto, na prática muitas vezes e necessário executar ações diversas em função dos dados fornecidos ao algoritmo. Em outras palavras, dependendo do conjunto de dados de entrada do algoritmo, deve-se executar um conjunto diferente de instruções. Além disso, pode ser necessário executar um mesmo conjunto de instruções um número repetido de vezes. Em resumo necessário controlar o fluxo de execução das instruções (a seqüência em que instruções são executadas num algoritmo) em função dos dados fornecidos com entrada ao mesmo. Neste capítulo serão estudadas as estruturas básicas de controle de fluxo de instruções de um algoritmo. De acordo com o modo como este controle é feito, estas estruturas são classificadas em: estruturas seqüenciais; estruturas de decisão; estruturas de repetição.

7.1

Comandos Compostos

Um comando composto é um conjunto de zero ou mais comandos (ou instruções) simples, como atribuições e instruções primitives de entrada ou saída de dados, ou alguma das construções apresentadas neste capítulo. Este conceito e bastante simples e será útil e conveniente nos itens seguintes, na definição das estruturas básicas de controle de execução.

7.2

Estrutura Seqüencial

Na estrutura seqüencial os comandos de um algoritmo são executados numa seqüência préestabelecida. Cada comando e executado somente após o término do comando anterior. A Figura 22 exemplifica um trecho seqüencial de um algoritmo. Em termos de fluxogramas, a estrutura seqüencial e caracterizada por um único fluxo de execução (um único caminho orientado) no diagrama. Em pseudocódigos, a estrutura seqüencial caracteriza-se por um conjunto de comandos dispostos ordenadamente. Como exemplos de aplicação desta estrutura de controle tem-se os algoritmos do capitulo anterior, onde não ha estruturas de decisão ou de repetição.

7.3

Estruturas de decisão

Neste tipo de estrutura o fluxo de instruções a ser seguido e escolhido em função do resultado da avaliação de uma ou mais condições. Uma condição e uma expressão lógica. A classificação das estruturas de decisão e feita de acordo com o número de condições que devem ser testadas pare que se decide qual o caminho a ser seguido. Segundo esta classificação tem-se dois tipos de estruturas de decisão:

- Se

47

- Escolha <Comando 1> <Comando 2> <Comando 1> (a)

... <Comando 1> <Comando 2> <Comando 3> ...

(b)

Figura 22 - Trecho seqüencial de um algoritmo: (a) fluxograma; (b) pseudocódigo.

7.3.1 Estruturas de decisão do Tipo Se
Nesta estrutura uma única condição (expressão lógica) e avaliada. Se o resultado desta avaliação for verdadeiro (.V.), então um determinado conjunto de instruções (comando composto) e executado. Caso contrário, ou seja, quando resultado da avaliação for falso (.F.), um comando diferente e executado. Em termos de fluxogramas, uma construção do tipo Se pode ser encarada como uma bifurcação onde há dois caminhos que podem ser seguidos (Figure 7.2 (a)). A execução do algoritmo prosseguirá necessariamente por um deles. Esta escolha e feita em função do resultado da expressão: um dos caminhos e rotulado com (.V.) e será seguido quando a condição for verdadeira o outro e rotulado com (.F.) e será seguido quando a condição for falsa. A sintaxe da estrutura de decisão do tipo SE e mostrada na Figura 23.

48

.V. <Condição> <Comando Composto 1>

.F.

<Comando Composto 2>

(a)

Se <Condição> Então <Comando_Composto_1> Senão <Comando_Composto_1> Fim_se If <Condição> Then Begin <Comandos>; End Else Begin <Comandos>;

(b)

(c)

End;
Figura 23 - Sintaxe da estrutura de decisão Se-Então-Senão-Fim_se: (a) fluxograma; (b) pseudocódigo e (c) pascal. Note-se o aparecimento de novas palavras-reservadas Se, Então, Senão e Fim_se. A semântica desta construção e a seguinte: a condição e avaliada. Se o resultado for verdadeiro, então o comando_composto_1 e executado. Ao término de sue execução o fluxo do algoritmo prossegue pela instrução seguinte a construção, ou seja, o primeiro comando após o Fim_se. Nos casos em que a condição e avaliada como false, o comando_composto_2 e executado e, ao término do mesmo, o fluxo de execução prossegue pela primeira instrução seguinte ao Fim_se. Há casos particulares e muito comuns desta construção, onde o comando_composto_2 e um conjunto vazio de instruções. Neste caso, a porção relativo ao Senão pode ser omitida, resumindo a sintaxe da construção forma mostrada na Figura 24.

49

.V. <Condição> .F.

<Comando Composto 1>

(a)

Se <Condição> Então <Comando_Composto_1> Fim_se If <Condição> Then <Comando_Composto_1>; (c) (b)

Figura 24 - Sintaxe da estrutura de decisão Se-Então-Fim_se: (a) Fluxograma; (b) pseudocódigo; (c) pascal. A semântica desta construção e a seguinte: no caso da condição seja verdadeira, o comando_composto_1 é executado e, após seu término, o fluxo de execução prossegue pela próxima instrução após o Fim_se. Quando a condição e false, o fluxo de execução prossegue normalmente pela primeira instrução após o Fim_se. A Figura 25 exemplifica 0 uso da construção Se-Então-Senão Fim_se num algoritmo para determinar se uma pessoa é maior ou menor de idade

50

Início Idade

.V. Idade > = 18

.F.

"Maior de Idade"

"Menor de Idade"

Fim Algoritmo Exemplo_7_1 Var Idade : inteiro Início Leia Idade Se Idade >= 18 Então Escreva "Maior de idade" Senão Escreva "Menor de idade" Fim_se Fim. Program Exemplo_7_1; Var Idade : integer; Begin Read(Idade); If Idade >= 18 Then Write ('Maior de idade') Else Write ('Menor de idade'); End. Figura 25 - Exemplo de aplicação da estrutura de decisão Se-Então-Senão-Fim_se.

7.3.2 Exercícios G
1. Faça um algoritmo que leia os valores A, B, C, e diga se a soma de A + B é menor que C. 2. Faça um algoritmo que leia dois valores inteiros A e B, e se os valores forem iguais deverá se somar os dois, caso contrário multiplique A por B ao final do calculo atribuir o valor para uma variável C. 3. Faça um algoritmo que leia o nome e as três notas de uma disciplina de uma aluno e ao final escreva o nome do aluno, sua média e se ele foi aprovado a média é 8.

51

4. Faça um algoritmo que leia 2 números inteiros e escreva o menor deles. 5. Faça um algoritmo que leia 3 números inteiros e escreva o menor deles. 6. Faça um algoritmo que leia 4 números inteiros e escreva o menor deles. 7. Dados três valores distintos, fazer um algoritmo que, após a leitura destes dados coloque-os em ordem crescente. 8. Dado três valores X, Y, Z, verificar se eles podem ser os comprimentos dos lados de um triângulo, e se forem, verificar se é um triângulo equilátero, isósceles ou escaleno. Se eles não formarem um triângulo, escrever uma mensagem. Antes da elaboração do algoritmo, torna-se necessária a revisão de algumas propriedades e definições. Propriedade - O comprimento de cada lado de um triângulo é menor do que a soma dos comprimentos dos outros dois lados. Definição 1 - Chama-se triângulo equilátero os que tem os comprimentos dos três lados iguais, Definição 2 - Chama-se triângulo isósceles ao triângulo que tem os comprimentos de dois lados iguais. Definição 3 - Chama-se triângulo escaleno ao triângulo que tem os comprimentos dos três lados diferentes. 9. Uma empresa decide dar um aumento de 30% aos funcionários cujo salário é inferior a R$ 5.000,00 . Escreva um algoritmo que possa ser utilizado para o calculo de reajuste do salário de um funcionário. 10. Uma empresa decide dar um aumento de 25,5 % aos funcionários cujo o salário é inferior a R$ 2.000,00 e tenha mais de 2 dependentes e 15% para os que ganham acima de R$ 2.000,00 e tenha um dependente e 7,5% para os que acima e não tenham dependente.

52

7.3.3 Estruturas de decisão do Tipo Escolha
Este tipo de estrutura e uma generalização da estrutura Se, onde somente uma condição era avaliada e dois caminhos podiam ser seguidos. Na estrutura de decisão do tipo Escolha pode haver uma ou mais condições a serem testadas e um comando composto diferente associado a cada uma destas. A sintaxe da construção de Escolha e mostrada na Figura 26:

.V. <Condição_1> .F. .V. <Condição_2> .F. <Comando Composto 2> <Comando Composto 1>

.V. <Condição_N> .F. <Comando Composto S> (a) <Comando Composto N>

Escolha Caso <Condição_1> <Comando_composto 1> Caso <Condição_2> <Comando_composto_2> ... Caso <Condição_n> <Comando_composto_n> Senão <Comando_composto_s> Fim_escolha

(b)

53 (c)

Case <Variável> Of <Condição_1> : <Condição_2> : ... <Condição_n> : Else Begin <Comandos>; End; End;

Begin <Comandos_compos_1>; End; Begin <Comandos_compos_2>; End; Begin <Comandos_compos_s>; End;

Figura 26 - Sintaxe usada em (a) fluxogramas; (b) pseudocódigo e (c) pascal para a construção Escolha. Seu funcionamento e o seguinte: ao entrar-se numa construção do tipo Escolha, a Condição_1 é testada: se for verdadeira, o comando_composto_1 e executado e, após seu término, o fluxo de execução prossegue pela primeira instrução após o final da construção (Fim_escolha); se a Condição 1 for falso, a condição_2 é testada: se esta for verdadeira, o comando_composto_2 e executado e, ao seu término, a execução prossegue normalmente pela instrução seguinte ao Fim escolha. O mesmo raciocínio e estendido a sodas as condições da construção. No cave em que sodas as condições são avaliadas como falsas, o comando composto_s (correspondente ao Senão da construção) e executado. Um exemplo de aplicação desta construção e mostrado na Figura 27, baseado num algoritmo de reajuste salarial variável em função da profissão.

54

Algoritmo Exemplo_7_2 Var Salário, Sal_reaj : real Prof : literal[20] Início Leia Salário, Prof Escolha Caso Prof = "Técnico" Sal_reaj <- 1.5 * Salário Caso PROF = "Gerente" Sal_reaj <- 1.3 * Salário Senão Sal_reaj <- 1.1 * Salário Fim_escolha Escreva SALÁRIO Reajustado = ", Sal_reaj Fim. Início Salário, Prof.

.V. Prof.= "Técnico .F. .V. Prof.="Gerente" Sal.Reaj ← 1.3 * Salário Sal.Reaj ← 1.5 * Salário

.F. Sal.Reaj ← 1.1 * Salário

"Salário Reajustado =", Reaj

Figura 27 - Exemplo de aplicação da construção Escolha. Fim Um caso particular desta construção e aquele em que o comando_composto_s não contém nenhuma instrução. Isto ocorre nas situações em que não se deseja efetuar nenhuma ação quando sodas as condição testadas são falsas. Assim, pode-se dispensar o uso do Senão na construção como acontece também na construção Se.

7.3.4 Exercícios H
1. Faça um algoritmo que leia um número que represente um determinado mês do ano. Após a leitura escreva por extenso qual o mês lido. Caso o número digitado não esteja na faixa de 1..12 escreva uma mensagem informando o usuário do erro da digitação . 55

2. Faça um algoritmo que leia um número qualquer. Caso o número seja par menor que 10, escreva ‘Número par menor que Dez’, caso o número digitado seja ímpar menor que 10 escreva ‘Número Ímpar menor que Dez’, caso contrário Escreva ‘Número fora do Intervalo’. 3. Uma empresa irá dar um aumento de salário aos seus funcionários de acordo com a categoria de cada empregado . O aumento seguirá a seguinte regra: a) Funcionários das categorias A, C, F, e H ganharão 10% de aumento sobre o salário b) Funcionários das categorias B, D, E, I, J e T ganharão 15% de aumento sobre o salário c) Funcionários das categorias K e R ganharão 25% de aumento sobre o salário d) Funcionários das categorias L, M, N, O, P, Q e S ganharão 35% de aumento sobre o salário e) Funcionários das categorias U, V, X, Y, W e Z ganharão 50% de aumento sobre o salário Faça um algoritmo que Escreva Nome, categoria e salário reajustado de cada Empregado.

7.4

Estruturas de Repetição

São muito comuns as situações em que se deseja repetir um determinado trecho de um programa um certo número de vezes. Por exemplo, pode-se citar o caso em que se deseja realizar um mesmo processamento para conjuntos de dados diferentes. Exemplo: processamento de folha de pagamentos de uma empresa, em que o mesmo cálculo e efetuado pare cada um dos funcionários. As estruturas de repetição são muitas vezes chamadas de Laços ou, também, de Loops. A classificação das estruturas de repetição e feita de acordo com o conhecimento prévio do número de vezes que o conjunto de comandos será executado. Assim, os laços dividem-se em: laços contados, quando se conhece previamente quantas vezes o comando composto no interior da construção será executado; laços condicionais, quando não se conhece de antemão o número de vezes que o conjunto de comandos no interior do laço será repetido, pelo fato de o mesmo estar amarrado a uma condição sujeita a modificação pelas instruções do interior do laço.

7.4.1 Laços Contados
Os laços contados são úteis quando se conhece previamente o número de vezes que se deseja executar um determinado conjunto de comandos. então, este tipo de laço nada mais e que uma estrutura dotada de mecanismos para contar o número de vezes que o corpo do laço (ou seja, o comando composto em seu interior) e executado. A sintaxe usada em pseudocódigos para os laços contados e mostrada na Figura 28. Para <var> de <Início> até <final> incr de <inc> faça <Comando_composto> (a) Fim_para For <Variável > : = <INICIO> TO <FIM> DO Begin <Comando>; End;

(b)

Figura 28 - Sintaxe usada em laços contados: (a) pseudocódigo e (b) pascal. Em termos de fluxograma, há varias representações possíveis e, ate o momento, não há um consenso quanto a forma mais conveniente. A Figura 29 apresenta duas formas bastante usadas, sendo que aquela mostrada na Figura 29 (a) será a adotada neste texto. <Var>← <Início> <Var> ← <Var>+<Inc> 56 <Comando Composto>

<Var>=<Início> <Fim>, <Inc>

<Var> > <Fim> .F.

.V.

<Comando Composto>

(a)

(b)

Figura 29 - Duas formas possíveis de representação de laços contados em algoritmos. A semântica do laço contado e a seguinte: no Início da execução construção o valor <Início> e atribuído a variável <var>. A seguir, o valor variável <var> e comparado com o valor <final>. Se <var> for maior <final>, então o comando composto não e executado e a execução do algoritmo prossegue pelo primeiro comando seguinte ao Fim_para. Por outro lado, se valor de <var> for menor ou igual a <final>, então o comando composto interior da construção e executado e, ao final do mesmo, o valor e adicionada variável <var>. Feito isso, retorna-se a comparação entre <var> e <final> repetese o processo até que <var> tenha um valor maior que <final>, quando o laço e finalizado e a execução do algoritmo prossegue pela instrução imediamente seguinte ao Fim_para. Algumas observações interessantes devem ser feitas: <var> é necessariamente uma variável, uma vez que seu valor é alterado a cada iteração (volta do laço); <Início>, <fim> e <inc> podem ser constantes ou variáveis. segundo cave (variáveis), algumas linguagens de programa proíbem que seus valores sejam modificados durante a execução do laço; <inc> e 0 valor que e adicionado a variável <var> ao final de cada iteração do laço. Há linguagens de programação que permitem que Ihe seja atribuído um valor negativo, de modo que o valor da variável <var> diminui a cada iteração. Neste caso, deve-se atentar à necessidade de inversão do sinal da comparação (de > para <) que e feito cada volta do laço, pare seu correto funcionamento. Contudo, e texto assumirá que <inc> possui um valor sempre positivo, o que não cause perda de generalidade, já que um resultado análogo pode ser obtido com o uso das construções enquanto e repita, apresentadas a seguir; na grande maioria dos casos <inc> tem o valor 1 (incremento unitário). Portanto, admite-se a omissão do trecho incr de <inc> da sintaxe do comando Para e, quando isto ocorre, assume-se um incremento de 1.

7.4.1.1 Exercícios I
1. Faça um algoritmo para ler base e altura de 50 triângulos e escreva a sua área. 2. Faça um algoritmo para calcular N!. 3. Faça um algoritmo para calcular um valor A elevado a um expoente B. Os valores A e B deverão ser lidos. Não usar A** B. 4. Faça um algoritmo para: a) Ler um valor x qualquer b) Calcular Y = ( x+1)+(x+2)+(x+3)+(x+4)+(x+5)+…(x+100). 5. Faça um algoritmo para somar os números pares positivos < 1000 e ao final imprimir o resultado. 6. Faça um algoritmo para gerar os termos da seguinte P.G.: 3,9,27,81,…,calcule o 100º termo. 7. Ampliando o exercício acima, faça um algoritmo para calcular a soma dos termos da P.G.. 8. Faça um algoritmo para calcular a série Fibonacci até 0 N-ésimo termo. A série tem a seguinte forma: 1,1,2,3,5,8,13,21,34,… 9. Faça um algoritmo para ler um valor X e calcular Y = X+2X+3X+4X+5X+…+20X

57

10. Para cada nota de compra , tem-se o Nome do produto comprado, o valor e o imposto. Faça um algoritmo que escreva o valor total bruto, o imposto total cobrado e o valor total líquido de todas as notas. Considere 500 notas 11. Faça um algoritmo que calcule a hipotenusa de 10 triângulos. hipotenusa2 = cateto1 2 + cateto2 2 12. Faça um algoritmo para calcular a área de N quadriláteros. Fórmula: Área = Lado * Lado 13. Faça um algoritmo para calcular a área de N Círculos . Fórmula : Área = π raio 2 π = 3,141592. 14. Fazer um algoritmo que calcule escreva a soma dos 50 primeiros termos das seguinte série:

1000 997 994 991 − + − +... 1 2 3 4 15. Faça um algoritmo para ler N números inteiros e ao final escrever sua média.

16. Uma turma possui N alunos, e para cada aluno tem-se uma média para cada disciplina. O professor de Matemática precisa saber a média geral de sua disciplina em um turma. Faça um algoritmo para auxiliar a encontrar este valor.
17. Faça um algoritmo para calcular: a)

N −1 50

∑2 N
2

50

b)

N −1 50

∑N
N− 1 50

c)

∑N
1

1

d)

N −1 50

∑2 N ∑N
1
2

e)

N −1

18. Uma empresa possui 100 vendedores que ganham por comissão sobre cada produto vendido. Cada vendedor em um determinado mês vendeu X produtos, onde cada produto pode ou não ter preços iguais. A empresa deseja obter um relatório com o Nome, o total de vendas e o valor a ser pago a cada vendedor. A comissão paga pela empresa é de 30% sobre o valor de cada produto vendido. 19. Dado uma relação de 1000 números em graus Célcius, faça um algoritmo que imprima o seguinte relatório : Graus Fahrenheit xxxxxx Obs.: Graus Célcius xxxxxx

ºF =

9º C + 32 5

58

20. Escrever um programa para gerar e escrever uma tabela com os valores de seno de um Angulo A em radianos, utilizando a série de Mac-Laurin Truncada apresentada a seguir:

SenA = A −

A3 A5 A7 + − 6 120 5040

Condições: os valores dos ângulos devem variar de 0.0 a 6.3, inclusive, de 0.1 em 0.1

7.4.2 Laços Condicionais
Laços condicionais são aqueles cujo conjunto de comandos em seu interior e executado ate que uma determinada condição seja satisfeita. Ao contrário do que acontece nos laços contados, nos laços condicionais não se sabe de antemão quantas vezes o corpo do laço será executado. As construções que implementam laços condicionais mais comuns nas linguagens de programação modernas são: Enquanto Repita

7.4.2.1 Construção Enquanto
Sua sintaxe e mostrada na Figura 30. Sua semântica e a seguinte: ao Início da construção Enquanto a condição e testada. Se seu resultado for falso, então o comando composto no seu interior não e executado e a execução prossegue normalmente pela instrução seguinte ao Fim_enquanto. Se a condição for verdadeira o comando composto e executado e ao seu término retorna-se ao teste da condição. Assim, o processo acima será repetido enquanto a condição testada for verdadeira. Quando esta for false, o fluxo de execução prosseguirá normalmente pelas instruções posteriores ao Fim_enquanto.

.V. <Condição> .F. Enquanto <condicão> Faça <comando composto> Fim_enquanto PROGRAM ExEnquanto; WHILE <Condição for verdadeira> DO BEGIN <Comandos>; END.

<Comando Composto> (a)

(b)

(c)

Figura 30 - Sintaxe da Enquanto para laços condicionais, sendo (a) fluxograma; (b) pseudocódigo e (c) Pascal Uma vez dentro do corpo do laço, a execução somente abandonará mesmo quando a condição for falsa. O usuário deste tipo de construção deve estar atento a necessidade de que em algum momento a condição deverá que avaliada como falsa. Caso contrário, o programa permanecerá indefinidamente no interior do laço, o que e conhecido como Laço infinito.

7.4.2.1.1

Exercícios J

1. Faça um algoritmo para ler base e altura de 50 triângulos e escreva a sua área.

59

2. Faça um algoritmo para calcular N!. 3. Faça um algoritmo para calcular um valor A elevado a um expoente B. Os valores A e B deverão ser lidos. Não usar A** B. 4. Faça um algoritmo para: a) Ler um valor x qualquer b) Calcular Y = ( x+1)+(x+2)+(x+3)+(x+4)+(x+5)+…(x+100). 5. Faça um algoritmo para somar os números pares positivos < 1000 e ao final imprimir o resultado. 6. Faça um algoritmo para gerar os termos da seguinte P.G.: 3,9,27,81,…,calcule o 100º termo. 7. Ampliando o exercício acima, faça um algoritmo para calcular a soma dos termos da P.G.. 8. Faça um algoritmo para calcular a série Fibonacci até 0 N-ésimo termo. A série tem a seguinte forma: 1,1,2,3,5,8,13,21,34,… 9. Faça um algoritmo para ler um valor X e calcular Y = X+2X+3X+4X+5X+…+20X 10. Faça um algoritmo para ler e escrever o Nome, idade e sexo de um número indeterminado de alunos. Ao final escreva o total de alunos lidos. 11. Para cada nota de compra , tem-se o Nome do produto comprado, o valor e o imposto. Faça um algoritmo que escreva o valor total bruto, o imposto total cobrado e o valor total líquido de todas as notas. Considere 500 notas 12. O valor aproximado de PI pode ser calculado usando-se a série

1 1 1 1 1 + 3 + 3 + 3 + 3 +... 3 1 3 5 7 9 sendo Π = 3 S ∗32 S=

fazer um algoritmo para calcular e escrever o valor de PI com 51 termos 13. Faça um algoritmo para ler um valor X e um valor n. Após, calcule a seguinte expressão: ( X + 1) ( X + 2) ( X + 3) ( X + N) Y= + + +.. .+ 1! 2! 3! N! 14. Faça um algoritmo para somar os restos da divisão por 3 de 200 números. 15. Faça um algoritmo que calcule a hipotenusa de 10 triângulos. hipotenusa2 = cateto1 2 + cateto2 2 16. Faça um algoritmo para calcular a área de N quadriláteros. Fórmula: Área = Lado * Lado 17. Faça um algoritmo para calcular a área de N Círculos . Fórmula : Área = π raio 2 π = 3,141592. 18. Fazer um algoritmo que calcule escreva a soma dos 50 primeiros termos das seguinte série:

1000 997 994 991 − + − +... 1 2 3 4 19. Faça um algoritmo para ler N números inteiros e ao final escrever sua média. 20. Uma turma possui N alunos, e para cada aluno tem-se uma média para cada disciplina. O professor de Matemática precisa saber a média geral de sua disciplina em um turma. Faça um algoritmo para auxiliar a encontrar este valor. 21. Uma empresa com X funcionários precisa saber a média de seus salários. Faça um algoritmo para ler a quantidade de funcionários e o salário de cada um e escrever a média dos salários.
60

22. Faça um algoritmo que calcule e escreva o valor de S onde:

S=

1 3 5 7 99 + + + + ... + 50 49 48 46 1

23. Uma empresa possui um conjunto indeterminado de funcionários e precisa saber a média de seus salários e a quantidade de funcionários. 24. Uma turma possui um conjunto indeterminado de alunos e para cada aluno tem-se uma média para cada disciplina. Os professores de matemática e português desejam saber a média geral de sua disciplina nesta turma. 25. Dado um conjunto indeterminado de alunos sendo que para cada aluno tem-se uma ficha contendo Nome e Idade. Escreva o nome do aluno mais velho e mais novo.

61

7.4.2.2 Construção Repita
Sua sintaxe e mostrada na Figura 31.

<Comando Composto>

.F. <Condição> .V. Repita <comando composto> até que <condição> REPEAT (a)

(b)

<Comandos> UNTIL <Condição for verdadeira>;

(c)

Figura 31 - Sintaxe da construção Repita pare laços condicionais, sendo (a) fluxograma; (b) pseudocódigo e (c) Pascal. Seu funcionamento e bastante parecido ao da construção Enquanto. O comando e executado uma vez. A seguir, a condição e testada: se ela for false, o comando composto e executado novamente e este processo e repetido ate que a condição seja verdadeira, quando então a execução prossegue pelo comando imediatamente seguinte ao final da construção. Esta construção difere da construção Enquanto pelo fato de o comando composto ser executado uma ou mais vezes (pelo menos uma vez), ao passo que na construção Enquanto o comando composto e executado zero ou mais vezes (possivelmente nenhuma). Isto acontece porque na construção Repita o teste da condição e feito ao final da construção, ao contrário do que acontece na construção Enquanto, onde o teste da condição e feito no Início da mesma.

7.4.2.2.1

Exercícios L

1. Faça um algoritmo para ler base e altura de 50 triângulos e escreva a sua área. 2. Faça um algoritmo para calcular N!. 3. Faça um algoritmo para calcular um valor A elevado a um expoente B. Os valores A e B deverão ser lidos. Não usar A** B. 4. Faça um algoritmo para: a) Ler um valor x qualquer b) Calcular Y = ( x+1)+(x+2)+(x+3)+(x+4)+(x+5)+…(x+100). 5. Faça um algoritmo para somar os números pares positivos < 1000 e ao final imprimir o resultado. 6. Faça um algoritmo para gerar os termos da seguinte P.G.: 3,9,27,81,…,calcule o 100º termo. 7. Ampliando o exercício acima, faça um algoritmo para calcular a soma dos termos da P.G.. 62

8. Faça um algoritmo para calcular a série Fibonacci até 0 N-ésimo termo. A série tem a seguinte forma: 1,1,2,3,5,8,13,21,34,… 9. Faça um algoritmo para ler um valor X e calcular Y = X+2X+3X+4X+5X+…+20X 10. Leia 20 valores reais e escreva o seu somatório. 11. Dado um número indeterminado de funcionários, onde é fornecido o Nome, número de dependentes e o número de horas trabalhadas. Pede-se que seja impresso, para cada funcionário, o seu Nome, salário bruto, salário líquido e o valor descontado. A empresa, paga R$ 2.250,00 por hora de trabalho, e R$ 125,55 por dependente, e ainda faz um desconto de 12% sobre o salário bruto. Pede-se ainda que seja impresso o total de funcionários da empresa, o total gasto com salários, e o total descontado. 12. Faça um algoritmo para: a) Leia um valor X e um valor N. b) Calcular: Y = X - 2X + 4X - 6X + 8X - 10X + … NX. 13. Faça um algoritmo para ler um valor X e um Valor N. Após, calcule a seguinte expressão: ( X + 1) ( X + 2) ( X + 3) ( X + N) Y= + + +.. .+ 1! 2! 3! N! 14. Faça um algoritmo que calcule a hipotenusa de 10 triângulos. hipotenusa2 = cateto 2 + cateto 2 15. Faça um algoritmo para calcular a área de N quadriláteros. Fórmula: Área = Lado * Lado 16. Faça um algoritmo para calcular a área de N Círculos . Fórmula : Área = π raio 2 π = 3,141592. 17. Fazer um algoritmo que calcule escreva o valor de S onde:

1 3 5 7 99 S = + + + +...+ 1 2 3 4 50
18. Fazer um algoritmo que calcule escreva o valor de S onde:

S=

1 2 3 4 5 10 − + − + ...− 1 4 9 16 25 100

19. Dado um conjunto indeterminado de alunos sendo que para cada aluno tem-se uma ficha contendo Nome e Idade. Escreva o nome do aluno mais velho e mais novo.

7.5

Aninhamentos

Um aninhamento ou embutimento e o fato de se ter qualquer um dos tipos de construção apresentados anteriormente dentro do conjunto de comandos (comando composto) de uma outra construção. Em qualquer tipo de embutimento e necessário que a construção interna esteja completamente embutida na construção externa. A Figura 7.11 ilustra aninhamentos válidos e inválidos.

(a)

(b)

63

Figura 32 - Exemplos de aninhamentos (a) válidos e (b) inválidos

7.6

Síntese

As estruturas de controle do fluxo de execução são essenciais pare que se pode alterar a seqüência de execução dos comandos de um programa em função dados do mesmo. Um comando composto e um conjunto de zero ou mais comandos simples, sejam eles instruções primitives ou construções como as estuda neste capítulo. Uma estrutura Seqüencial e aquela em que os comandos vão se executados numa seqüência pré-estabelecida, um após o outro. As estruturas de decisão permitem escolher qual o caminho a seguido num algoritmo em função de uma ou mais condições. A construção utilize apenas uma condição, ao passo que a construção Escolha utiliza uma ou mais condições As estruturas de repetição são usadas quando se deseja repetir trecho de um algoritmo (comando composto). Quando o número de vezes que trecho será repetido e conhecido diz-se que o laço e do tipo contado (construção Para). Quando este número não é conhecido, mas e função de uma determinada condição então têm-se os laços condicionais (construção Enquanto e Repita). As construções Repita e Enquanto diferem uma da outra pelo fato de a primeira efetuar o teste da condição no final da construção e, portanto, executar o comando composto ao menos uma vez. Por outro lado, a construção Enquanto efetua o teste da condição em seu Início e execute o comando composto zero ou mais vezes. Os aninhamentos podem usar qualquer uma das construções apresentadas neste capítulo desde que atendam, a uma regra única: a construção mais interna deve estar inteiramente contida na construção imediatamente mais externa.

7.6.1 Exercícios M
1. Dado um conjunto de n registros cada registro contendo um valor real, faça um algoritmo que calcule a média dos valores maiores que 4. 2. Dado uma relação de 100 carros escreva quantos são da cor azul. Sendo para cada carro tem-se uma ficha contento o nome e a cor. 3. Dado uma série de 20 valores reais, faça uma algoritmo que calcule e escreva a média aritmética destes valores, entretanto se a média obtida for maior que 8 deverá ser atribuída 10 para a média. 4. Faça um algoritmo para somar os números pares < 1000 e ao final escreva o resultado. 5. Dado um conjunto de 20 valores reais, faça um algoritmo que: a) Imprima os valores que não são negativos. b) Calcule e imprima a média dos valores < 0. 6. Suponha que para cada aluno de sua sala exista uma ficha contendo o nome e a idade do aluno. Supondo que exista 50 alunos, faça uma algoritmo que determine quantos alunos tem idade maior que 30. 7. Dado modelo, ano de fabricação, cor e placa de 1000 carros, faça um algoritmo que: a) Imprima quantos são, da cor verde e o percentual em relação ao total. b) Imprima quantos foram fabricados antes de 1990 e o percentual em relação ao total. c) Imprima quantos são FIAT UNO e o percentual em relação ao total. d) Imprima quantos carros tem na placa o digito 5 e o percentual em relação ao total. Considere placas com seguinte formato “AANNNN”. 8. Dado Nome e notas ( total de 6 ) de n alunos, faça um algoritmo que: 64

a) Imprima Nome e média dos alunos aprovados. Média > = 7.0. b) Imprima Nome e média dos alunos em recuperação. 5.0 >= Média <7.0. c) Imprima Nome e média dos alunos reprovados. Média <5.0. 9. Faça um algoritmo que simule um cronometro com horas, minutos e segundos. A simulação deverá mostrar no vídeo o cronometro no seguinte formato HH: MM: SS. Inicialmente o cronometro será zerado ( 00: 00: 00 ), sendo que os segundos começarão a ser incrementados, depois os minutos e depois as horas. Lembre-se que a cada 60 segundos os minutos deverão ser incrementados, depois os minutos voltarão a zero. Quando as horas estiverem prestes a chegar em 25, o cronometro deverá voltar a zero ( 00: 00: 00 ). 10. Dado Nome e salário de um número indeterminado de funcionários, escreva o Nome e o salário de quem tem o maior salário, bem como o Nome e o salário que possui o menor salário. 11. Um hotel cobra R$ 300,00 por diária e mais uma taxa adicional de serviços. Se a diária for menor que 15 a taxa e de R$ 20,00. Se o número de diárias for igual a 15 a taxa é de R$ 14,00 e se o número for maior que 15 a taxa é de R$ 12,00. Considerando-se que se tenha 200 pessoas e para cada pessoa tenha-se um registro contendo seu nome e o número de diárias. Faça um algoritmo que imprima o nome e o total a pagar de cada pessoa e imprimir também o total ganho pelo hotel e o número total de diárias. 12. Dado que cada pessoa tenha o seu nome e a sua idade e o seu peso em uma ficha, faça uma algoritmo que: a) Imprimir o nome da pessoa cujo a idade esta na faixa de 20 a 30 anos inclusive os extremos; b) Calcule a idade média das pessoas com peso maior que 80 Kg, considere que exista N pessoas. 13. Faça um algoritmo que calcule o salário e o imposto de renda de um grupo de pessoas, considerando: a) Para cada pessoa tem-se: Nome, Número de Dependentes, Renda Bruta Anual; b) O imposto é calculado segundo a tabela abaixo: Renda Liquida % até R$ 10.000,00 isento > R$ 10.000,00 até R$ 30.000,00 5% > R$ 30.000,00 até R$ 60.000,00 10% > R$ 60.000,00 15% c) Há um desconto de R$ 600,00 para cada dependente. d) Sendo que a renda liquida é igual a renda bruta menos o abatimento de cada dependente. 14. O Departamento de transito do estado anotou dados de acidentes de transito no último ano. Para cada motorista envolvido no acidente, tem-se as seguintes informações: - Ano de nascimento; - Sexo (M - Masculino, F - Feminino) - Procedência ( 0 - Capital, 1 - Interior, 2 - Outro estado); Faça um algoritmo que : a) Calcule a porcentagem de motoristas com menos de 21 anos; b) Calcule quantas mulheres são da capital; c) Calcule quantos motoristas do interior do estado tem idade maior que 60 anos; d) Verifique se existe alguma mulher com idade maior que 60 anos; R. 15 . Suponha que para cada tipo de computador fabricado, a SEI, tem os seguintes informações: - Nome do computador; - O nome do fabricante; - e a sua capacidade de armazenamento; Faça um algoritmo que: a) Determine qual o valor da maior capacidade de memória; b) Determine quantos computadores diferentes a IBM fabrica; c) Verifique se tem algum computador chamado PS/1. Se tiver qual o seu fabricante; 16. Dado um conjunto N números inteiros escreva quantos números e ímpares existem no conjunto.

65

17. Uma empresa possui um número indeterminado de clientes. Para cada cliente tem-se uma ficha contendo Nome, Estado Civil. Estado Civil é um número codificado da seguinte forma: 1 – Solteiro, 2 – Casado, 3- Divorciado e 4 – Viúvo. A empresa deseja saber a quantidade de clientes para cada estado civil.

7.6.2 Exercícios N
1. Ler um LITERAL em forma de data. Exemplo : ‘26/09/95’ e escrever o dia , mês e ano desta data todos em separados. 2. Dado uma relação de 100 literais no formato de data ( Exemplo "10/12/95" ), imprima aquelas que correspondem ao mês ‘09’. 3. Dado um conjunto indeterminado de palavras , sendo que cada palavra possui um tamanho indeterminado, sendo que as mesmas sempre terminam com o caracter “$”, o qual deverá ser lido pelo teclado , faça um algoritmo que imprima um relatório como é mostrado no Exemplo abaixo: Suponha que a palavra digitada foi “MARIA”. M A R I A A I R A M

4. Dado uma frase de exatamente 80 caracteres, escreva a frase de trás para frente, um caracter por linha. 5. Dado uma quantidade indeterminada de palavras, sendo que as mesmas sempre terminam com o caracter “$”, escreva o tamanho de cada uma das mesmas ( o sinal de “$” não deve ser considerado na contagem ). 6. Dado uma palavra terminada com o sinal “$”, faça um algoritmo para criar uma nova literal, a ser formada com os caracteres da primeira palavra invertidos. 7. Dado uma relação de 100 literais no formato de data ( Exemplo "10/12/95" ), imprima um relatório no seguinte formato: Data 26/09/95 Por Extenso 26 de setembro de 1995

8. Dados uma relação de n literais, todas terminadas com o caracter “$”, faça um algoritmo que escreva a literais e o seu tamanho. 9. Dado uma relação de n literais, todas terminadas com o caracter “$”, faça um algoritmo que imprima aquelas que tem tamanho par. 10. Dado uma relação de n literais, todas terminadas com o caracter “$”, faça um algoritmo que escreva as literais ímpares cujo caracter central é uma vogal. 11. Dado uma relação de n literais, todas terminadas com o caracter “$”, faça um algoritmo que imprima aquelas que são palíndromes (Ex. ANA, ARARA, OTTO). 12. Faça um algoritmo para ter uma frase terminada em $. Após a leitura identificar e escrever quantas letras A, E, I, O e U existem em separado. 13. Dado uma literal terminada com o caracter “$” faça um algoritmo que imprima quantas vogais existem nesta literal. 14. Dado uma literal terminada com o caracter “$” faça um algoritmo que imprima quantas Ocorrências de cada vogal em separado existe nesta literal. 66

67

8.

Símbolos Usados em Fluxogramas

Terminal - O ponto de início, término ou interrupção de um programa.

Direção do Fluxo - A direção do fluxo de dados ou de processamento.

Conexão - Uma entrada ou uma saída de ou para uma outra parte do fluxograma

Processamento - Um grupo de instruções que executam uma função de processamento do programa.

Cartão Perfurado - Todas as variedades de cartão perfurado. Função generalizada neste texto para indicar entrada de dados.

Documento - Documentos relatórios de todas as variedades. Função generalizada neste texto para indicar saída de dados.

Decisão - Indica a possibilidade de desvios para diversos outros pontos do fluxograma, de acordo com situações variáveis.

Fita Magnética - Algum tipo de dispositivo de armazenamento seqüencial.

68

Teclado de linha - Informação fornecida ou recebida de ou por um computador utilizando um dispositivo.

Entrada/Saída - Qualquer função de um dispositivo de entrada/saída, fornecendo informações para processamento, gravação, posicionamento da fita etc.

Entrada/Saída - Qualquer tipo de documento ou dados.

Fita Perfurada - Fita de papel ou plástico.

Acesso arbitrário de disco ou de tambor.

Exibição - Informações exibidas por dispositivos visuais.

Disco magnético - Dispositivo de disco magnético para armazenamento de dados

69

9.

Funções pré-definidas do Pascal

O Pascal , possui muitas funções/Rotinas pré-definidas, sendo que iremos estudar algumas das principais . Caso haja necessidade , o manual da linguagem Pascal pode, e deve, ser usado como fonte de pesquisa de outras funções. Dentre as Rotinas que iremos abordar, algumas necessitam que um comando especial seja colocado no início do PROGRAMA. Tal comando é mostrado abaixo: PROGRAM Teste; USES CRT; BEGIN <Comandos>; END. Obs.: As funções que necessitarem o comando especial mostrado acima terão colocados ao lado a palavra CRT.

9.1

Descrição das Funções/Rotinas:

Rotina : ABS() Função : Retorna o valor absoluto de um valor numérico . Sintaxe : Resultado: =ABS(Valor) Exemplo: PROGRAM Teste; VAR X1 : REAL; X2 : INTEGER ; BEGIN X1: =ABS( -2.3 ); ( 2.3 ) X2: =ABS( -157 ); ( 157 ) END. Rotina : CHR() Função : Retorna um caracter da tabela ASCII de acordo com um determinado valor numérico Sintaxe : Resultado: =CHR(Valor) Exemplo: PROGRAM Teste; VAR X1 : CHAR; BEGIN X1: =CHR( 65 ); ( ‘A’ ) END.

70

Rotina : CLRSCR Função : Limpa a tela de vídeo Sintaxe : CLRSCR Exemplo: PROGRAM Teste; USES CRT; BEGIN CLRSCR; END. Rotina : CONCAT() Função : Concatena ( Junta ) uma seqüência de STRING’s Sintaxe : Resultado: =CONCAT( s1,s2,…,sn) Exemplo: PROGRAM Teste; VAR s1,s2 : STRING; BEGIN s1: =CONCAT(‘João’,’Mineiro’); s2: = CONCAT(‘ABC’,’DEFG’,’HIJ’); END.

(‘João Mineiro’ ) (‘ABCDEFGHIJ’)

Rotina : COPY() Função : Copia n caracteres de uma STRING a partir de uma posição específica Sintaxe : Resultado: =COPY(s1, posição , quantidade) Exemplo: PROGRAM Teste; VAR s1 :STRING; BEGIN s1: =COPY(‘ABCDEFGH’,2,3); (‘BCD’) END. Rotina : COS() Função : Retorna o cosseno de um valor numérico Sintaxe : Resultado: = COS(Valor) Exemplo: PROGRAM Teste; VAR x : REAL; BEGIN x: =COS(10); END.

71

Rotina : DEC() Função : Decrementa uma variável numérica Sintaxe : DEC(Valor) Exemplo: PROGRAM Teste; VAR x : INTEGER ; BEGIN x: =10; DEC(x) ; (9) END. Rotina : DELAY() ( CRT ) Função : Interrompe o processamento por um número especificado de milisegundos Sintaxe : DELAY(Tempo) Exemplo: PROGRAM Teste; USES CRT; BEGIN DELAY(200); END. Rotina : DELETE () Função : Deleta n caracteres de uma STRING, a partir de uma posição inicial Sintaxe : DELETE (s ,posição , quantidade) Exemplo: PROGRAM Teste; VAR s : STRING; BEGIN s: =‘João da Silva’; DELETE (s,5,3); (‘João Silva’) END. Rotina : EXP() Função : Retorna “e” elevado a um determinado valor numérico Sintaxe : Resultado: =EXP(Valor) Exemplo: PROGRAM Teste; VAR x : REAL; BEGIN x: : =EXP(10); END.

72

Rotina : FRAC() Função : Retorna a parte fracionária de um valor numérico Sintaxe : Resultado: =FRAC(Valor) Exemplo: PROGRAM Teste VAR x: REAL BEGIN x: =FRAC(2.345) ( 345 ) END Rotina : GOTOXY() ( CRT ) Função : Posiciona o cursor no vídeo em uma determinada coluna ( x ) e linha ( y ) Sintaxe : GOTOXY( coluna, linha ) Exemplo: PROGRAM Teste; USES CRT; BEGIN GOTOXY(10,20); END. Rotina : INC() Função : Incrementa uma variável numérica Sintaxe : INC(Valor) Exemplo: PROGRAM Teste; VAR x : INTEGER ; BEGIN x: =10; INC(x); (11) END. Rotina : INSERT () Função : Insere uma STRING dentro de outra STRING a partir de uma determinada posição Sintaxe : INSERT (STRING_Fonte, STRING_Destino, posição ) Exemplo: PROGRAM Teste; VAR s : STRING; BEGIN s: =‘João Silva’; INSERT (‘Da ’,s,6); (‘João Da Silva’) END.

73

Rotina : INT() Função : Retorna a parte inteira de um valor numérico Sintaxe : REsultado : =INT(Valor) Exemplo: PROGRAM Teste; VAR x : REAL; BEGIN x: =INT(2.345); END.

(2)

Rotina : KEYPRESSED ( CRT ) Função : Retorna TRUE se uma tecla foi pressionada, FALSE caso contrário Sintaxe : KEYPRESSED Exemplo: PROGRAM Teste; USES CRT; BEGIN REPEAT UNTIL KEYPRESSED; END. Rotina : LENGTH() Função : Retorna o número de caracteres de uma STRING Sintaxe : Resultado: = LENGTH(s) Exemplo: PROGRAM Teste; VAR x : INTEGER ; BEGIN x: = LENGTH(‘João’); END.

(4)

Rotina : LN() Função : Retorna o logaritmo natural de um determinado valor numérico Sintaxe : Resultado: =LN(Valor) Exemplo: PROGRAM Teste; VAR x : REAL; BEGIN x: =EXP(LN(2)*3); (* 2**3 ( 8 ) *) END.

74

Rotina : ODD() Função : Retorna TRUE se uma determinado valor numérico FOR impar, FALSE caso contrário Sintaxe : Exemplo: PROGRAM Teste; VAR x : Boolean; BEGIN c: =odd(65); ( TRUE ) END. Rotina : ORD() Função : Retorna qual o número na tabela ASCII de um determinado caracter Sintaxe : Resultado: =ORD(Caracter) Exemplo: PROGRAM Teste; VAR x : INTEGER ; BEGIN x: =ORD(‘A’); ( 65 ) END. Rotina : PI Função : Retorna o valor de PI Sintaxe : Resultado: =PI Exemplo: PROGRAM Teste; VAR x : REAL; BEGIN x: =PI; ( 3.1415926535…) END. Rotina : POS() Função : Retorna a posição da primeira ocorrência dos caracteres de uma STRING dentro de outra STRING Sintaxe : Resultado: =POS(Caracteres ,STRING_A_SER_PROCURADA) Exemplo: PROGRAM Teste; VAR x : INTEGER ; BEGIN x: =POS(‘ABC’,’DEABCDFG’); (3) END.

75

Rotina : READKEY ( CRT ) Função : Faz a leitura de um caracter do teclado , não sendo necessário pressionar ENTER Sintaxe : Resultado: =READKEY Exemplo: PROGRAM Teste; USES CRT; VAR tecla: CHAR; BEGIN tecla: =READKEY; END. Rotina : SIN() Função : Retorna o seno de um valor numérico Sintaxe : Resultado: =SIN(Valor) Exemplo: PROGRAM Teste; VAR x : REAL; BEGIN x : = SIN(10); END. Rotina : SQR() Função : Retorna um valor numérico elevado ao quadrado Sintaxe : Resultado: =SQR(Valor) Exemplo: PROGRAM Teste; VAR x : INTEGER ; BEGIN x: =SQR(3); (9) END. Rotina : SQRT() Função : Retorna a raiz quadrada de um valor numérico Sintaxe : Resultado: =str(Valor) Exemplo: PROGRAM Teste VAR x: INTEGER BEGIN x: =SQRT(9) (3) END

76

Rotina : STR() Função : Converte um valor numérico para a sua representação em STRING Sintaxe : STR(Valor, STRING_Resultante ) Exemplo: PROGRAM Teste; VAR s : STRING; BEGIN STR(2.345,s); END. Rotina : TEXTBACKGROUND() ( CRT ) Função : Altera a cor de fundo nas operações de E/S Sintaxe : TEXTBACKGROUND(Cor) Exemplo: PROGRAM Teste; USES CRT; BEGIN TEXTBACKGROUND(0); TEXTBACKGROUND(1); TEXTBACKGROUND(2); TEXTBACKGROUND(3); TEXTBACKGROUND(4); TEXTBACKGROUND(5); TEXTBACKGROUND(6); TEXTBACKGROUND(7); END. Rotina : TEXTCOLOR() ( CRT ) Função : Altera a cor das letras nas operações de E/S Sintaxe : TEXTCOLOR(Cor) Exemplo: PROGRAM Teste; USES CRT; BEGIN TEXTCOLOR (0); TEXTCOLOR(1); TEXTCOLOR (2); TEXTCOLOR(3); TEXTCOLOR(4); TEXTCOLOR(5); TEXTCOLOR(6); TEXTCOLOR(7); END.

(Preto) (Azul) (Verde) (Ciano) (Vermelho) (Mangenta) (Marrom) (Cinza)

(Preto) (Azul) (Verde) (Ciano) (Vermelho) (Mangenta) (Marrom) (Cinza)

77

Rotina : TRUNC() Função : Trunca um valor REAL para um valor Inteiro Sintaxe : Resultado: =TRUNC(Valor) Exemplo: PROGRAM Teste; VAR x : INTEGER ; BEGIN x: =TRUNC(2.345); END

(2)

Rotina : UPCASE() Função : Converte um caracter minúsculo para maiúsculo Sintaxe : Resultado: =UPCASE(Caracter) Exemplo: PROGRAM Teste; VAR x : CHAR; BEGIN x: =UPCASE(‘a’); ( ‘A’ ) END. Rotina : VAL() Função : Converte uma STRING para a sua representação numérica Sintaxe : VAL(STRING_ORIGEM,VALOR_RESPOSTA,CODIGO_ERRO) Exemplo: PROGRAM Teste; VAR x, e : INTEGER; BEGIN VAL(‘12345’,x,e); ( 12345 ) END.

78

10.

Problemas Resolvidos em Algoritmos, Pascal e C
Alguns Exemplos de problemas resolvidos em Algoritmos, Pascal e C.

10.1

Algoritmo do Triangulo

Faça um algoritmo para ler a base e a altura de um triângulo. Em seguida, escreva a área do mesmo. Obs: Área = ( Base * Altura ) / 2 Em Algoritmo: Algoritmo Triangulo Var base, altura, area : real; Inicio Leia(Base) Leia(Altura) Area ← (Base * Altura)/2 Escreva (Area) Fim Em Pascal: program triangulo; var area, base, altura: real; begin { Entrada } write ('Digite a base: '); readln (base); write ('Digite a altura: '); readln (altura); { Calculos } area:= (base*altura)/2; { Saida} writeln ('A area do triangulo e: ',area:10:2); end. Em C: #include <stdio.h> main () { /* declaracao de variaveis */ float area,base,altura; /* Entrada de dados */ printf ("Digite base: "); scanf ("%f", &base) ; printf ("Digite altura: "); scanf ("%f", &altura); 79

/* Calculos */ area = (base*altura)/2; /* Resultados */ printf ("A area do triangulo e: %10.2f\n", area); }

10.2

Algoritmo Preco Automóvel

O preço de um automóvel é calculado pela soma do preço de fábrica com o preço dos impostos (45% do preço de fábrica) e a percentagem do revendedor (28% do preço de fábrica). Faça um algoritmo que leia o nome do automóvel e o preço de fábrica e imprima o nome do automóvel e o preço final. Em Algoritmo: Algoritmo automovel Var Nome : literal Precofabrica, Precofinal, Imposto : real Inicio Leia (Nome, Precofabrica) Imposto ← Precofabrica * (0,45 + 0,28) Precofinal ← Precofabrica + Imposto Escreva (Nome, Precofinal) Fim. Em Pascal: program preco; var nome: string; Precofabrica, PrecoFinal, imposto : real; begin write ('Digite nome: '); readln (nome); write ('Digite preco de fabrica: '); readln (Precofabrica); Imposto := Precofabrica * (0.45 + 0.28); PrecoFinal := PrecoFabrica + imposto; writeln ('Automovel:', nome); writeln ('Preco de venda:', PrecoFinal:10:2); end. Em C: #include <stdio.h> main () { /* declaracao de variaveis */ char nome[60] ; float precofabrica, precofinal, imposto ; /* Entrada de dados */ printf ("Digite nome: "); scanf ("%s", &nome) ; 80

printf ("Digite preco de fabrica: "); scanf ("%f", &precofabrica); /* Calculos */ imposto = precofabrica *(0.45 + 0.28); precofinal = precofabrica + imposto; /* Resultados */ printf ("Automovel: %s\n", nome); printf ("Preco de venda: %10.2f\n", precofinal); }

10.3

Algoritmo Media Valor

Dado uma série de 20 valores reais, faça uma algoritmo que calcule e escreva a média aritmética destes valores, entretanto se a média obtida for maior que 8 deverá ser atribuída 10 para a média. R. Algoritmo Serie Var Contador: Inteiro N,Soma, Media :Real Inicio Contador ← 0 Soma ← 0 Enquanto Contador < 20 faca Leia (N) Soma ← Soma + N Contador ← Contador + 1 Fim Enquanto Media ← Soma / 20 Se Media > 8 Entao Media ← 10 Fim Se Escreva (Media) Fim. Em Pascal: Program MEDIA_20; Uses crt; var conta:integer; media,num,soma:real; Begin Clrscr; conta := 0; soma := 0; Writeln ('Digite 20 números'); While conta < 20 do Begin read (num); soma := soma + num; conta := conta + 1; End; media := (soma / 20); if media > 8 then 81

Writeln ('media =10'); else Writeln ('A media ‚'); Writeln (media); End. Em C: #include<stdio.h> #include<conio.h> main() { float media,num,soma; int cont; soma=0; cont=0; clrscr(); printf("\nDigite 20 números\n"); while (cont<20) { scanf("%f",&num); soma=soma+num; num=soma; cont++; } media=num/20; if (media > 8) { printf("Media ‚ igual a 10"); } else { printf("Media ‚ igual a: %2.2f\n",media); { } } return(0); }

10.4

Algoritmo 3 Menores
Faça um algoritmo que leia 3 números inteiros e imprima o menor deles.

Em Algoritimo: Algoritmo Menor Var A, B, C, Menor : Inteiro Inicio Leia ( A,B,C) Se (A < B) E (A <C) Entao Menor ← A Senao Se B < C Entao Menor ← B Senao Menor ← C Fim se Fim se 82

Escreva (Menor) Fim. Em Pascal: Program MENOR_N; Uses crt; var n1,n2,n3,menor:integer; Begin Clrscr; Writeln ('Digite 3 valores'); Read (N1,N2,N3); If (N1<N2) And (N1<N3) Then menor:=N1 Else If (N2<N1) And (N2<N3) Then menor:=N2 Else menor:=N3 Writeln ('O menor valor ‚'); Writeln (menor); End. Em C: #include<stdio.h> #include<conio.h> main() { int n1,n2,n3; clrscr(); printf("\nDigite 3 valores\n"); scanf("%d",&n1); scanf("%d",&n2); scanf("%d",&n3); if ((n1<n2) && (n1<n3)) { printf("\nO menor número ‚ :%d\n",n1); } else { if ((n2<n1) && (n2<n3)) { printf("\nO menor número ‚ :%d\n",n2); } else { printf("\nO menor número ‚ :%d\n",n3); } } return(0); }

10.5

Algoritmo Media Maior que 4

Dado um conjunto de n registros cada registro contendo um valor real, faça um algoritmo que calcule a média dos valores maiores que 4. 83

Em Algoritmo: Algoritmo Media Var N, Conta, Maior4 : Inteiro Soma, Media, Número :Real Inicio Conta ← 1 Maior4 ← 0 Soma ← 0 Leia (N) Enquanto Conta < N Faça Leia (Número) Se Número > 4 Entao Soma ← Soma + Número Maior4 ← Maior4 + 1 Fim Se Conta ← Conta + 1 Fim Enquanto Media ← Soma / Maior4 Escreva (Media) Fim. Em Pascal: program maior4; uses CRT; var n, aux: integer; soma, media, número: real; begin Clrscr; write ('Digite valores diferentes de 999'); writeln; aux := 0; soma := 0; read (número); while número <> 999 do begin if número > 4 then begin soma:= soma + número; aux := aux + 1; end; read (número); end; media := (soma/aux); write ('MEDIA='); write (media); end. Em C: #include <iostream.h> #include <conio.h> main () { clrscr();

84

int n; float soma,media,número,aux; cout <<"digite valores diferentes de 999 -> "; cin >> número; aux =1; soma =0; while (número != 999) { if (número > 4) { soma = soma + número; aux =aux+1; } media = (soma/aux); cout << "\nEntre com o proximo ->"; cin >> número; } cout << media; return 0; }

10.6

Algoritmo Salário

Uma empresa tem para um determinado funcionário uma ficha contendo o nome, número de horas trabalhadas e o n0 de dependentes de um funcionário. Considerando que: a) A empresa paga 12 reais por hora e 40 reais por dependentes. Sobre o salário são feito descontos de 8,5% para o INSS e 5% para IR. Faça um algoritmo para ler o Nome, número de horas trabalhadas e número de dependentes de um funcionário. Após a leitura, escreva qual o Nome, salário bruto, os valores descontados para cada tipo de imposto e finalmente qual o salário líquido do funcionário. Em Algoritmo: Algoritmo salario var nome : literal dependente : inteiro horas, salariol, salariob, DescontoI, DescontoR : real; Inicio Leia(nome,horas, dependente) salariob ← (12 * horas) + (40 * dependente) DescontoI ← (salariob*0,085) DescontoR ← (salariob*0,05) salariol ← (salariob - DescontoI, DescontoR) Escreva(nome,salarioB, DescontoI, DescontoR, salarioL) Fim. Em Pascal: Program Salario; Uses Crt; Var Nome:String; Numhora, Salbruto, Salliq:Real; Numdep:Integer; Begin Clrscr; Write ('Digite O Nome Do Funcionario:'); 85

Read (Nome); Writeln; Write ('Número De Horas Trabalhadas:'); Read (Numhora); Writeln; Write ('E Número De Dependentes:'); Read (Numdep); Writeln; Salbruto:=(12*Numhora)+(40*Numdep); Salliq:=Salbruto-((Salbruto*0.085)+(Salbruto*0.05)); Write ('Nome Do Funcionario:'); Write (Nome); Writeln; Write ('Salario Liquido:'); Write (Salliq); End. Em C: #include <iostream.h> #include <conio.h> #include <stdio.h> main () { clrscr(); int numdep; float numhora,salbruto,salliq; char nome[20]; cout << "Digite o nome do funcionario -> "; scanf ("%s", &nome); cout << "Número de horas trabalhadas -> "; scanf ("%f", &numhora); cout << "Número de dependentes -> "; scanf ("%f", &numdep); salbruto = (12*numhora)+(40*numdep); salliq = salbruto -((salbruto*0.085)+(salbruto*0.05)); cout << "\nNome do Funcionario: "<< nome; cout << "\nSalario Liquido: " << salliq; return 0; }

10.7

Algoritmo 50 Triangulos

1) Faça um algoritmo para ler base e altura de 50 triângulos e imprimir a sua área. Em Algoritmo: Algoritmo Triangulo Var Contador: Inteiro Base, Haltura, Area :Real Inicio Contador ← 1 Enquanto Contador < 51 faca 86

Leia (Base Leia (Haltura) Area ← (Base * Haltura)/2 Escreva( Area) Contador ← Contador + 1 Fim Enquanto Fim. Em Pascal: program triangulo; uses crt; var base,altura,area:real; contador:integer; begin clrscr; contador:=1; while contador < 51 do begin writeln('Digite a Base'); read(base); writeln('Digite a Altura'); read(altura); area:=(base*altura)/2; write('Esta e a area do triangulo writeln (area); contador:=contador+1; end; repeat until keypressed; end. Em C: /*program triangulo*/ #include <stdio.h> main () { float base,altura,area; int contador = 1; while (contador < 51) { printf ("\nDigite a Base\n"); scanf ("%f",&base); printf ("\nDigite a Altura\n"); scanf ("%f",&altura); area=(base*altura)/2; printf ("\nA area do triangulo de número %d eh %f",area); contador++; } return (0); }

');

10.8

Algoritmo Media Menores

Dado um conjunto de 20 valores reais, faça um algoritmo que: 87

a) Imprima os valores que não são negativos. b) Calcule e imprima a média dos valores < 0. Em Algoritmo: Algoritmo Conjunto20 Var N, SomaMenor, MediaMenor : Real ContaMenor, Contador : Inteiro Inicio Contador ← 0 ContaMenor ← 0 SomaMenor ← 0 Enquanto Contador < 20 faca Leia(N) Se N >= 0 Entao Escreva (N) Senao SomaMenor ← SomaMenor + N ContaMenor ← ContaMenor + 1 Fim Se Contador ← Contador + 1 Fim Enquanto MediaMenor ← SomaMenor / ContaMenor Fim. Em Pascal: program números; uses crt; var valor,media,soma:real; cont,contpos:integer; begin clrscr; cont:=1; while cont < 21 do begin writeln('Digite um valor real'); read(valor); if valor < 0 then begin media:=media+valor; contpos:=contpos+1; end else begin write (valor); writeln (' e um valor maior que Zero'); end; cont:=cont+1; end; media:=media/contpos; write ('O número de valores menores que Zero sao '); writeln (contpos); write ('A media do valores menores que Zero e '); writeln (media); repeat until keypressed; end.

88

Em C: /* números */ #include <stdio.h> main() { float int

valor ,media; cont = 1, contpos= 0;

while (cont < 21) { printf ("\nDigite um valor real\n"); scanf ("%f", &valor); if (valor < 0) { media=media+valor; contpos++; } else { printf ("\n %f",valor); printf (" e um valor maior que Zero"); } cont++; } media = media / contpos; printf ("\nO número de valores menores que Zero eh %d",contpos); printf ("\nA media dos valores menores que Zero e %f",media); return (0); }

89

Sign up to vote on this title
UsefulNot useful