Curso Essencial de Logica de Pr - Marilane Almeida

Prévia do material em texto

Curso essencial de
 
Marilane Almeida
 
Sumário
Capítulo 1 - Pequena abordagem no método de criação de um programa ...................................5
Capítulo 2 - Lógica de programação ......................9
2.1. 	Programa 	10
....................................................................................
2.2. Linguagens de programação 10 ....................................................
Capítulo 3 - Algoritmo .......................................... 13
3.1. 	Entrada, processamento 	e 	saída 	14
...............................................
3.2. 	Formas 	de 	representação 	15
.........................................................
3.3. 	Exercícios 	resolvidos 	20
.................................................................
Capítulo 	4 	- 	Tipos 	de 	dados, 	constantes 	e 	variáveis
..........................................25
4.1. 	Tipos 	de 	dados 	26
...........................................................................
4.2. 	Constantes 	26
.................................................................................
4.3. 	Variáveis 	27
.....................................................................................
Capítulo 5 - Comandos de atribuição ..................31
Capítulo 6 - Operadores .......................................35
6.1. 	Operadores 	aritméticos 	36
.............................................................
6.2. 	Operadores 	relacionais 	37
.............................................................
6.3. 	Operadores 	lógicos 	38
...................................................................
6.4. 	Exercícios 	resolvidos 	41
.................................................................
Capítulo 7 - Expressões ........................................43
7.1. 	Expressões 	aritméticas 	44
..............................................................
7.2. Expressões lógicas ....................................................................44
7.3. 	Expressões 	relacionais 	44
..............................................................
7.4. 	Como 	avaliar 	uma 	expressão 	44
....................................................
7.5. 	Como 	linearizar 	expressões 	45
......................................................
Capítulo 8 - Operações lógicas ............................. 47
Capítulo 9 - Funções .............................................49
Capítulo 10 - Estruturas para a construção de algoritmos
.................................... 51
10.1. 	Estrutura 	de 	seqüência 	52
............................................................
10.2. 	Estrutura 	de 	decisão 	ou 	seleção 	52
.............................................
10.3. 	Estrutura 	de 	repetição 	59
.............................................................
10.4. 	Exercícios 	resolvidos 	65
...............................................................
Capítulo 11 - Dados ...............................................73
11.1. Consistência de dados .............................................................
74
11.2. Arquivos de dados ...................................................................
11.3. Organizando arquivos ..............................................................
11.4. Manipulação de registros (comandos e funções) ................. 79
11.5. Exercícios resolvidos ...............................................................
80
11.6. Estruturas de dados homogêneos .......................................... 84
11.7. Exercícios resolvidos ...............................................................
86
Capítulo 12 - Modularização .................................91
12.1. 	Procedimento
...........................................................................92
12.2. 	Função
......................................................................................93
12.3. Variáveis globais e variáveis locais .........................................
93
12.4. 	Parâmetros
...............................................................................95
12.5. Exercícios resolvidos ...............................................................
97
Capítulo 13 ..........................................................103
Capítulo 1
Pequena abordagem no método de criação de um programa
Neste capítulo, será mostrada uma prévia sobre os métodos de criação de um programa, para que você possa entender melhor a lógica de programação que será iniciada no próximo tópico.
0 método de criação de um programa é um conjunto de atividades que são divididas em fases, cujo objetivo é atingir o real desenvolvimento de um software durante a realização de cada uma delas, sendo possível haver diversas maneiras de representação das fases em que consiste o processo de desenvolvimento. Essas maneiras podem variar tanto em relação ao número de fases como nas atividades que precisam ser feitas por cada uma delas.
Veja na ilustração a seguir uma maneira de representação do método de criação de um programa:
Figura 1.1: Fases do processo de desenvolvimento de software.
Tal método é dividido em seis fases. Na sequência temos uma breve descrição de cada uma:
1. Planejamento: o início da criação de um software é realizado nesta fase, em que alguns pontos de grande importância são definidos, tais como: missão, objetivos do sistema, abrangência do sistema, cronogramas de desenvolvimento, análise custo x benefício e vários outros.
2. Análise: nesta fase, conhecida também como análise de requisitos, são desenvolvidos os modelos do sistema, na qual se deve alcançar um ótimo entendimento sobre ele. 0 entendimento desta fase proporciona a base para uma ótima implementação do
programa.
3. Projeto: nesta fase são estabelecidos os algoritmos dos programas a serem implementados, etapa conhecida também como especificação do projeto. Nela é feita uma arquitetura de implementação para o programa que atenda aos requisitos do sistema identificados na análise.
4. Implementação: os programas são desenvolvidos nesta fase apartir da arquitetura de implementação especificada na fase anterior.
5. Teste: todos os programas desenvolvidos passam pela fase deteste antes de serem repassados para o cliente. É nesta fase que é verificado se o programa funciona corretamente, por meio de uma enorme variedade de testes que são realizados. E se, por um acaso, essa fase não for realizada adequadamente e futuramente for encontrado algum erro, mais tempo e dinheiro será gasto para repará-lo. Portanto, a responsabilidade do programador é maior no desenvolvimento dos algoritmos do que na sua implementação.
6. Manutenção: nesta fase são realizados os ajustes do programaimplementado, e tais ajustes podem ser originados de diversas causas: erros de projeto identificados após a implementação e o teste do programa, inovações tecnológicas, dentre outras.
Capítulo 2
Lógica de Programação
 
A lógica de programação tem como objetivo mostrar métodos para solucionar problemas, além de determinar a seqüência lógica para o desenvolvimento de um programa. Se você pretende ser um bom programador, é de grande importância aprender a lógica. Ela lhe dará base para o aprendizado das linguagens de programação. Para
que você possa utilizá-la, é preciso ter domínio sobre os pensamentos, bem como saber pensar. É a metodologia de encadear pensamentos para chegar a um objetivo. A lógica de programação é criada a partir de um conjunto de elementos como:
organização, perseverança, padronização, criatividade e otimização.
Para que ela seja assimilada, você precisa praticar sempre, especialmente se você ainda não tem muitos conhecimentos.
2.1. Programa
Um programa é um algoritmo criado segundo as regras de sintaxe de uma linguagem de programação. Consiste em uma seqüência de comandos que apresenta as tarefas a serem realizadas para atingir a solução de um determinado problema. Estes comandos devem ser escritos numa linguagem de programação para que eles possam ser executados em um computador.
Se você deseja aprender uma linguagem de programação, obrigatoriamente tem de saber criar algoritmos. Depois que você souber criaralgoritmos, será extremamente simples criar programas independentemente da linguagem, basta fazer uma pesquisa de qual comando realizará a ação que você quiser.
2.2. Linguagens de programação
Uma linguagem de programação consiste em um conjunto de normas sintáticas e semânticas utilizadas para determinar um programa de computador e tem um poder de criação ilimitado, que permite desenvolver desde aplicativos de planilhas eletrônicas até jogos e editores de texto. São consideradas linguagens de programação: Pascal, C++, Java, entre outras.
Além disso, existem ferramentas que permitem a criação de programas em uma linguagem de alto nível (semelhante à nossa linguagem) e transformam esses comandos em uma linguagem de máquina. São os chamados ambientes de desenvolvimento que compilam esses comandos e geram programas executáveis. Por exemplo: Visual Basic (para desenvolvimento em Basic) e Delphi (para desenvolvimento em Pascal).
 
Capítulo 3
Algoritmo
Um algoritmo consiste em uma série limitada de etapas, cujo objetivo é executar uma determinada tarefa. Melhor dizendo, é uma série de instruções' ordenadas de maneira lógica para solucionar determinado problema.
Imagine uma receita de bolo com todos os passos a serem seguidos. A sequência necessária que você deverá observar para fazê-lo é a mesma que você atribui ao algoritmo. Tais passos devem ser claros e precisos.
É preciso ter na elaboração de um algoritmo:
utilização de apenas uma ação por instrução;
· objetividade;
· número finito de etapas;
· zero ou mais entradas tomadas de conjuntos bem determinados;
· uma ou mais saídas;
· uma condição de fim sempre atingida para quaisquer entradas e num tempo finito.
Para que uma tarefa possa ser realizada por um computador é preciso que ela seja definida passo a passo, de uma maneira compreendida pela máquina, usando o que nós chamamos de programa.
Para a construção de algoritmos temos três estruturas. São elas: sequenciação, seleção e repetição. Por meio da combinação dessas três estruturas pode-se construir algoritmos para a resolução de problemas complexos. A programação estruturada é baseada nessas três estruturas.
3.1. Entrada, processamento e saída
Para criar um algoritmo, é preciso dividir o problema em questão em três etapas importantes: entrada, processamento e saída. Com isso, todo programa trabalhará com esses três conceitos. Caso os dados forem informados de maneira incorreta, conseqüentemente não serão processados de maneira correta e resultarão em respostas inválidas.
· Entrada: são os dados indispensáveis para a resolução do problema em questão. Nem sempre é necessário pedir informações para resolver um problema.
· Processamento: procedimento usado para se chegar ao resultado final.
· Saída: são os dados processados que mostram o resultado para o problema em questão.
3.2. Formas de representação
Temos diversas formas que podem ser usadas para a representação de algoritmos, tais como: descrição narrativa, pseudocódigo (conhecido também como linguagem estruturada ou portugol), diagrama de Nassi-Shneiderman (ou Chapin), fluxograma, entre outras.
a. Descrição narrativa: os algoritmos nesta forma são descritos em português. É a maneira mais simples de representação de algoritmos, pois usamos a linguagem do nosso dia-a-dia, sendo eles escritos com um texto simples. Tem-se vantagens pelo fato de ser descrito em português e desvantagens, como a pouca confiabilidade e a extensão que, geralmente, faz com que se escreva muito para dizer pouca coisa. A seguir um pequeno exemplo:
· Algoritmo para tomar banho
1. Pegue a toalha.
2. Entre no banheiro.
3. Tire a roupa.
4. Abra o chuveiro.
5. Entre embaixo do chuveiro.
6. Depois de estar completamente molhada(o), desligue o chuveiro.
7. Pegue o sabonete.
8. Passe o sabonete em todo o corpo.
9. Retire todo o sabonete.
10. Feche o chuveiro.
11. Pegue a toalha.
12. Seque todo o corpo.
13. Vista a roupa.
14. Saia do banheiro.
b. Pseudocódigo: Esta forma de representação de algoritmos, conhecida também como linguagem estruturada ou portugol, é rica em detalhes e, por parecer bastante com a forma em que os programas são escritos, é muito bem aceita.
Um ponto importante é que não temos um padrão para os comandos utilizados nos algoritmos, ou seja, cada autor e/ou professor traça comentários sobre isso da forma mais didática possível. 0 que importa é a lógica, o pensamento formado, e não a linguagem usada.
A seguir, a representação do algoritmo na forma de pseudocódigo:
Definição:
1. ALGORITMO: conjunto das regras e procedimentos lógicos perfeitamente definidos que levam à solução de um problema em um número finito de etapas.'
2.<nomedoalgoritmo>: é usado como um título que define o nome do programa. Exemplo: Algoritmo Soma;
3. <declaraçãodevariáveis>: nesta opção é indicado o tipo de dado correspondente aos nomes de variáveis. É onde as variáveis globais usadas são declaradas no algoritmo principal e nos subalgoritmos. Exemplo: Var N1, N2;
4. <subalgoritmo>: é usado opcionalmente no pseudocódigo onde são determinados os subalgoritmos;
S. INÍCIO e FIM: são as palavras que determinam o início e o término do conjunto de comandos do corpo do algoritmo.
A seguir temos um exemplo de algoritmo pseudocódigo da soma:
c. Diagrama de Nassi-Shneiderman (ou Chapin): conhecido também como Diagrama de Chapin, foi criado por Ned Chapin como uma forma de auxiliar nos valores da abordagem de programação estruturada; foi definido trocar o fluxograma tradicional por um diagrama que proporcionasse uma visão hierárquica, clara, para a representação de seqüência, seleção e repartição da lógica de programação. A vantagem em utilizar esse diagrama é o aspecto de as estruturas terem um ponto de entrada e um ponto de saída. 0 intuito deste diagrama é representar os comandos de um algoritmo dentro de um único retângulo, subdividindo-o em retângulos menores, que representam os diferentes blocos de seqüência de comandos do algoritmo.
Seqüência de comando:
Figura 3.1
Seleção / Condição:
Figura 3.2 Exemplo:
Figura 3.3
d. Fluxograma: é uma ferramenta utilizada e criada pelos profissionais de análise de sistemas, e também por profissionais de organização, sistemas e métodos. Utiliza símbolos convencionais, aceitando poucas mudanças. Ele é representado por alguns desenhos geométricos básicos, onde são mostrados os símbolos de entrada, processamentos e saída de dados, acompanhados dos métodos exigidos pelo analista de sistemas e a serem desenvolvidos por um programador por meio da criação do raciocínio lógico, no qual terá de resolver o problema do programa.
Veja a seguir um pequeno fluxograma:
Figura 3.4
Nota: muitas pessoas que trabalham na área da tecnologia da informação pensam que os fluxogramas e os diagramas de blocos têm o mesmo significado. Entretanto, é bom destacar que estas palavras possuem significados diversos, os quais irão executar tarefas contrárias e diferentes. Anteriormente já definimos fluxograma, a seguir será mostrado o que é um diagrama de bloco.
e. Diagrama de bloco: é uma ferramenta utilizada pelo profissional que trabalha com programação, e tem como objetivo apresentar métodos e seqüência do processo dos planos em um computador. Tal ferramenta utiliza vários símbolos geométricos, assim como no fluxograma. É um intermediário entre a descrição narrativa e o pseudocódigo, pois é menos indeterminado que a descrição narrativa. Sendo assim, não existe a preocupação com detalhes do programa, como o tipo das variáveis utilizadas.
Exemplo:
Figura 3.10
3.3. Exercícios resolvidos
1. Este é um exercício bastante encontrado em livros de lógica, e é sempre bom relembrá-lo: temos uma turma de alunos da 5a série. Tais alunos, no decorrer do semestre, realizaram quatro provas, classificadas como: P1, P2, P3 e P4. Encontre a média final dos alunos.
Resolução:
Para que se possa montar o algoritmo, serão feitas três perguntas em relação ao que você já estudou até agora:
a. Quais são os dados de entrada?
R.: Os dados de entrada são P1, P2, P3 e P4.
b. Quais serão os dados de saída?R.: A média final será o dado de saída.
c. Qual o procedimento que será usado para a construção do
algoritmo?
R.: Terá que somar todos os dados de entrada e dividi-los por quatro.
Figura 3.11
2. Faça um algoritmo que realize o cálculo do salário líquido de uma professora. Para realizar este exercício você necessitará de algumas informações como: valor da hora-aula, quantidade de horas trabalhadas em um mês e percentual de desconto.
Resolução:
Inicialmente, deve-se estabelecer qual será o seu salário bruto para realizar o desconto e ter o valor do salário líquido. Neste exercício usaremos três formas de representação: descrição narrativa, diagrama de bloco e pseudocódigo.
• Descrição narrativa:
Algoritmo Cálculo Salário
Início
1. Estabelecer a leitura da variável HT horas trabalhadas.
2. Estabelecer a leitura da variável HA hora-aula.
3. Estabelecer a leitura da variável D Desconto.
4. Calcular salário bruto (SB). É resultado das variáveis HT e HAmultiplicadas.
5. Calcular total de desconto (TD) com base no valor de D divididopor 100.
6. Fazer o cálculo do salário líquido (SL), subtraindo o desconto do salário bruto.
7. Mostrar valores dos salários líquido e bruto SL SB.
· Pseudocódigo:
· Diagrama de bloco:
Figura 3.12
Capítulo 4
Tipos de dados, constates e variáveis
 
As variáveis e constantes são conceitos importantes para o desenvolvimento de algoritmos e programas de computadores. É por meio deles que um algoritmo armazena os dados do problema. Os elementos básicos que um programa manipula são variáveis e constantes.
Um programa deve possuir declarações que citem e às vezes um valor inicial de que tipo são as variáveis que ele usará. Tais tipos podem ser: reais, inteiros, caracteres, entre outros. As expressões fazem a combinação entre variáveis e constantes para calcular novos valores. A variável é um espaço reservado na memória do computador para guardar um tipo de informação. Variáveis devem receber nomes para poder servir de referência e serem alteradas quando necessário.
4.1. Tipos de dados
O trabalho feito por um computador baseia-se na manipulação dos dados contidos em sua memória. Os tipos de dados mais comuns são nomeados como tipos primitivos de dados, tais quais: Inteiros, Reais, Caracteres e Lógicos.
· Inteiros: são os dados numéricos positivos ou negativos, eliminando-se destes qualquer número fracionário.
· Reais: são os dados numéricos positivos, negativos e números fracionários.
· Caracteres: são as sequências, que devem ser mostradas entre "aspas". Caracteres são conhecidos também como alfanuméricos, string, literal ou cadeia.
· Lógicos: são os dados com valor verdadeiro ou falso, podendo ser representados apenas por um dos dois valores. Também nomeados por alguns de "tipo booleano", devido à contribuição do filósofo e matemático inglês "George Boole" na área da lógica matemática. Para facilitar a citação de um dado tipo lógico, destaca-se que estes deverão ser mostrados e delimitados pelo caractere ponto (.).
4.2. Constantes
São denominados constantes os dados cujos valores são fixos e que não se alteram ao longo da execução de um programa.
Exemplos: números, letras, palavras, entre outros.
Geralmente, a constante é definida no início do programa e sua utilização acontece no decorrer dele.
Figura 4.1
4.2.1. Definindo uma constante em algoritmos
Em algoritmos, todas as constantes usadas serão definidas em seu início por meio de um comando que indica uma área de declarações. Veja tal comando a seguir:
Figura 4.2
4.3. Variáveis
As variáveis usadas em algoritmos devem ser declaradas antes de serem utilizadas, visto que o compilador precisa reservar um espaço na memória para cada uma delas.
Variável é a representação simbólica dos elementos de certo conjunto. Cada variável ocupa uma posição de memória, cujo conteúdo pode se modificar durante a execução de um programa. Mesmo que uma variável assuma diferentes valores, ela só poderá armazenar um valor por vez.
Figura 4.3
4.3.1. Declaração de variáveis
Quando se declara uma variável, é definido o tipo de dado que se pode armazenar no decorrer da execução do algoritmo. Para que você possa realizar essa declaração, será necessário criar um identificador, que será o nome da variável no algoritmo. Você também terá que determinar o tipo de dado que a variável pode guardar. Observe a seguir um pequeno exemplo sobre a declaração variável:
Figura 4.4
Em algoritmos, todas as variáveis usadas serão determinadas no seu início, através do comando. Veja a seguir tal comando:
Figura 4.5
· Tipo: pode ser inteiro, real, caractere ou lógico.
· Lista de variáveis: serão os nomes dos identificadores.
Exemplos:
Nota: Variável (VAR) necessitará estar sempre presente e terá que ser usada apenas uma vez na determinação de um conjunto de uma ou mais variáveis. Numa mesma linha pode-se determinar uma ou mais variáveis do mesmo tipo, e para isso os nomes devem ser separados por vírgula. Se as variáveis forem de tipos diferentes, devem ser declaradas em linhas também diferentes.
Exemplos: observe a seguir que foram declaradas três variáveis.
4.3.2. Variáveis do tipo caractere e cadeia de caracteres
Variáveis do tipo caractere e cadeia de caracteres possuem alguns pontos importantes que devem ser falados, quais sejam:
· A utilização de aspas simples ('): é usada na hora em que se faz atribuições de um valor para uma variável do tipo caractere.
· A utilização de aspas duplas ("): é usada na hora em que se faz atribuições de um valor para uma variável do tipo cadeia de caracteres.
 
Capítulo 5
Comando de atribuição
Tal comando é usado para atribuir um valor a uma variável, onde o tipo do dado atribuído para a variável necessita ser compatível com o tipo declarado para a mesma.
Geralmente, o comando de atribuições é representado por uma seta sinalizando para a esquerda, e, além disso, também possui outros símbolos para representar a atribuição, dependendo da maneira de representação do algoritmo. A seguir, temos a sintaxe usada:
Figura 5.1
Na sintaxe anterior, o identificar é o nome da variável que receberá a expressão. Vale a pena lembrar que em relação a atribuições na parte esquerda pode-se ter apenas a variável, pois é só ela que recebe algo. Um exemplo: é impossível ter um cálculo ou uma constante recebendo algo. A seguir, temos alguns exemplos para que você possa entender melhor:
Exemplo 1:
(Lê-se: blusa recebe 20,00)
Exemplo 2:
Exemplo 3:
Exemplo 4: o T guarda o resultado das atribuições e o v guarda um valor constante.
Existe também outra forma de representação, veja a seguir:
Figura 5.2
 
Capítulo 6
Operadores
Os operadores são meios pelos quais comparamos, incrementamos, decrementamos e avaliamos dados dentro do computador. Existem três tipos de operadores, que são: operadores aritméticos, operadores relacionais e operadores lógicos. A seguir, mostraremos detalhadamente cada operador.
6.1. Operadores aritméticos
Na criação de expressões aritméticas, tanto constantes como variáveis, poderão ser usadas desde que sejam colocadas como "inteira" ou "real", e, para que isso aconteça, é preciso utilizar os operadores aritméticos.
Operadores aritméticos são classificados em duas categorias, ou seja, binários ou unários:
· Binários: quando agem em dois operando. Exemplos: operações de exponenciação, multiplicação, divisão, adição e subtração.
· Unários: quando agem sobre um único operando, melhor dizendo,quando operam na inversão de um valor atribuindo a este o sinal positivo ou negativo. Veja, na seqüência, a tabela de prioridade matemática existente quando da utilização destes operadores.
Hierarquia:
1°: parênteses;
2°: exponenciação;
3°: multiplicação, divisão (o que vier primeiro); 4°: + ou - (o que vier primeiro).
6.2. Operadores relacionais
Usamos tais operadores para comparar string de caracteres e números. Os valores a serem comparados podem ser caracteres ou variáveis. Eles são operadores binários e geralmente retornam valores lógicos, no caso: verdadeiro (true) ou falso (false). No que diz respeito a qual operação a ser executadainicialmente, use os parênteses para estabelecer a prioridade. A seguir, os operadores relacionais:
Tabela 6.2
Tais valores são apenas utilizados quando você quiser efetuar comparações, e estas só podem ser realizadas entre objetos da mesma natureza e variáveis do mesmo tipo de dado, sendo sempre um valor lógico o resultado de uma comparação.
Suponha que a variável inteira Número tenha valor 6. A primeira das expressões a seguir fornece um valor verdadeiro e a segunda um valor falso:
Figura 6.1
Exemplo: Tem-se duas variáveis de valores M = 2 e N = 4. A seguir, o resultado das expressões:
Tabela 6.3
Veja a seguir o símbolo usado para comparação entre expressões:
Figura 6.2
6.3. Operadores lógicos
Tais operadores são utilizados para combinar expressões relacionais, melhor dizendo, eles estabelecem a conexão para a formação de novas proposições e também retornam como resultado, valores lógicos verdadeiro ou falso. Quando usados em português, os mesmos são colocados entre pontos: .e., .ou., .não. Veja a seguir os operadores lógicos:
Tabela 6.4
· E/AND: é verdadeira se todas as condições forem verdadeiras.
Sintaxe
Diagrama de bloco
Figura 6.3
Nota: Esse operador faz com que apenas uma determinada operação seja executada se todas as condições citadas forem verdadeiras.
· OR/OU: verdadeira se pelo menos uma condição for verdadeira.
Sintaxe
Diagrama de bloco
Figura 6.4
- NOT/NÃO: a expressão NOT inverte o valor da expressão ou condição. Se falsa, inverte para verdadeira e vice-versa.
Sintaxe
Diagrama de bloco
Figura 6.5
Tabela verdade
Para que você possa trabalhar corretamente com os operadores lógicos, terá de aprender a tabela verdade. Ela é o conjunto de todas as possibilidades combinatórias entre os valores das variáveis lógicas. Veja a seguir:
Tabela 6.5
Exemplo de operadores lógicos: suponha que temos três variáveis M = 7, N = 10 e 0 =2. Com isso, teremos:
Figura 6.6
6.4. Exercícios resolvidos
1. Utilize o operador E, mostre apenas a mensagem (Número nafaixa de 30 a 90), caso o valor fornecido da variável número seja entre 30 e 90. Qualquer valor fornecido fora desta faixa, mostrará a mensagem (Número está fora da faixa 30 a 90). Utilize o pseudocódigo.
2. Utilize o operador ou, mostre apenas a mensagem (Vendo animal), caso o valor fornecido da variável Animal seja cachorro ou gato. Para qualquer outro valor fornecido, mostre a mensagem (Não vendo este tipo de animal). Utilize o pseudocódigo.
Resolução:
3. Esse exercício será feito em relação ao operador Não, e, através deste operador, apenas será realizado o cálculo z <- (K + Y) + W, se o valor da variável w não for maior que 4. Valores de 4 para baixo realizarão o cálculo z <- (K + Y) + W. Caso o valor de w seja menor que 4, será realizado o cálculo z <- (K - Y) + W. Utilize o pseudo- código.
Capítulo 7
Expressões
Em termos computacionais, a definição de expressão está intensamente ligada ao conceito de expressão ou fórmula matemática, no qual um conjunto de constantes numéricas e variáveis se relaciona através de operadores aritméticos criando uma fórmula que, uma vez analisada, resulta em um valor. A seguir, você verá a definição de expressões aritméticas e lógicas.
7.1. Expressões aritméticas
São expressões em que o resultado da avaliação é do tipo numérico, seja real ou inteiro. Apenas a utilização de operadores aritméticos, variáveis numéricas e parênteses é aceitável em expressões deste tipo.
7.2. Expressões lógicas
São expressões em que o resultado da avaliação é um valor lógico verdadeiro ou falso. Em tais expressões são utilizados os operadores relacionais e os operadores lógicos (mostrados no tópico 6.3), podendo ainda ser combinados com expressões aritméticas.
Quando duas ou mais expressões que usam operadores lógicos e relacionais forem combinadas, deve-se usar parênteses para mostrar a ordem de precedência.
7.3. Expressões relacionais
Tais expressões são comparações. As mesmas, quando avaliadas, geram, como resultado, verdadeiro ou falso (valor lógico). Com isso, podemos concluir que uma expressão relacional só pode ser atribuída a uma variável lógica.
7.4. Como avaliar uma expressão
Quando as expressões apresentarem um único operador, podem ser avaliadas diretamente. Entretanto, conforme elas vão ficando mais difíceis com o surgimento de mais de um operador, é preciso a avaliação da mesma, passo a passo, recebendo um operador por vez. Tal seqüência é determinada de acordo com o formato geral da expressão, levando em consideração a precedência de avaliação de seus operadores e a existência ou não de parênteses na mesma. A seguir, as regras necessárias para a avaliação de expressões:
•observar a precedência dos operadores, de acordo com a explicação feita nas tabelas de operadores. Os operadores de maior precedência devem ser avaliados inicialmente. Caso ocorra empate em relação à precedência, a avaliação deverá ser feita da esquerda para a direita;
•parêntese utilizado em expressões tem a capacidade de roubar precedência dos demais operadores, obrigando a avaliação da subexpressão em seu interior;
•dentre os operadores existentes, apresentam certa prioridade de avaliação os aritméticos. Na seqüência, são avaliadas as subexpressões com operadores relacionais e, por último, os operadores lógicos.
7.5. Como linearizar expressões
Todas as expressões aritméticas devem ser linearizadas para a construção de algoritmos, ou seja, elas necessitam ser colocadas em linhas e não devemos nos esquecer de usar os operadores corretamente.
As expressões matemáticas na forma linearizada não são usadas apenas em algoritmos, mas, também, em grande parte das linguagens de programação.
A seguir, um pequeno exemplo para que você tenha um melhor entendimento.
· Expressão tradicional:
Figura 7.1
· Expressão computacional:
Figura 7.2
 
Capítulo 8
Operadores lógicos
São usadas as operações lógicas quando é preciso tomar decisões em um diagrama de bloco. Toda decisão terá sempre como resposta o resultado verdadeiro ou falso; como no exemplo, um algoritmo "Rodízio de pizza". Neste exemplo, existem algumas pessoas que não gostam de pizza de camarão, veja a seguir:
"Rodízio de pizza"
1. Garçom traz a pizza.
2. A pizza é de camarão?
3. Se sim, não aceite a pizza.
4. Se não, continue com o algoritmo.S. Coloque a pizza no prato.
6. Coma a pizza.
7. Espere o retorno do garçom.
Iremos agora passar este mesmo algoritmo usando o diagrama de bloco:
Figura 8.1
 
Capítulo 9
Funções
Além dos operadores mostrados anteriormente, pode-se utilizar funções matemáticas. Elas, além de serem muito parecidas com os procedimentos, têm uma especialidade de retornar ao programa que as chamou um valor associado ao nome da função. Tal característica aceita uma analogia com o conceito de função da Matemática. Elas podem ser determinadas pela linguagem ou desenvolvidas pelo programador dependendo do seu interesse.
Veja a seguir um quadro com algumas funções numéricas predefinidas:
	Função
	Finalidade
	Tipo de Argumento
	Tipo de Resultado
	ABS (X)
	Valor Absoluto
	Integer, Real
	Integer, Real
	FRAC (X)
	Parte Fracionária
	Real
	Real
	TRUNC(X)
	Parte Inteira
	Real
	Integer
	ROUND(X)
	Valor Arredondado
	Real
	Integer
	SQR(X)
	Eleva ao Quadrado
	Integer, Real
	Integer, Real
	SQRT(X)
	Raiz Quadrada
	Integer, Real
	Real
	LN(X)
	Logaritmo Natural
	Real
	Real
	EXP(X)
	Exponencial
	Real
	Real
Tabela 9.1
 
Capítulo 10
Estruturas para construção de algoritmo
As estruturas para a construção de algoritmos são: seqüenciação, decisão (seleção) e repetição. Veja a seguir a definição de cada uma. 10.1. Estrutura de seqüência
A estrutura de seqüência é a mais simples que usamos na construção de algoritmos estruturados. Os comandos do algoritmo fazem parte de uma seqüência, na qual são executadas uma de cada vez. Pode-se definir então a estrutura de seqüência como conjuntos de comandos que serão executados da mesma maneira que a escrita, numa seqüência linear de cima para baixo e da esquerda para a direita, uma de cada vez e que contenha praticamente comandos de atribuição,comandos de entrada e comandos de saída. Utilizam-se as palavras início e fim para delimitar o bloco de seqüência.
Sintaxe
10.2. Estrutura de decisão ou seleção
A estrutura de decisão, conhecida também como seleção ou condição, é usada para tomar uma decisão e aceita escolher um conjunto de ações para serem executadas a partir do resultado de uma condição. Esta estrutura é representada por uma expressão lógica. A decisão tem que ser utilizada quando existe a necessidade de testar alguma condição e em função de ela tomar uma atitude. Ela pode ser simples (SE/ENTÃO), composta (SE/ENTÃO/SENÃO), encadeada (SE/ ENTÃO/SENÃO/SE/ENTÃO/SENÃO), múltipla (CASO/SELECIONE).
10.2.1. Estruturas de decisão simples
A estrutura de decisão simples é utilizada quando se necessita testar uma condição antes de executar um comando. Usamos o SE/ENTÃO.
Sintaxe
A <condição> é uma expressão lógica que determina um resultado VERDADEIRO ou FALSO.
1. Caso a <condição> tenha um resultado VERDADEIRO, o comando mostrado na cláusula ENTÃO será executado.
2. Caso a <condição> tenha um resultado FALSO, nenhum comando será executado e termina a seleção simples FIM-SE. 0 próximo comando a ser executado será o que estiver citado após o FIM-SE.
3. Caso a <condição> tiver um resultado VERDADEIRO, então será executada a seqüência de comandos mencionada no bloco verdade; e se isso não ocorrer, ou seja, se a <Condição> tiver um resultado FALSO, nenhum comando será executado.
Nota: no Pascal, o comando IF é equivalente ao comando SE da linguagem algorítmica, e o THEN é equivalente ao comando ENTÃO. Veja, a seguir, a utilização do mesmo:
No diagrama de blocos a estrutura para o comando SE/ENTÃO é representado por:
Figura 10.1
10.2.2. Estruturas de decisão compostas
Neste tipo de estrutura de decisão é usado o SE/ENTÃO/SENÃO, e apenas uma condição é avaliada. Caso a <Condição> seja VERDADEIRA, um comando ou conjunto de comandos serão executados, e caso o resultado da <Condição> seja FALSO, o comando após a cláusula SENÃO será executado.
Sintaxe
Nota: no Pascal, os comandos IF (SE) e THEN (ENTÃO) Continuam da mesma forma da estrutura de decisão simples, sendo apenas acrescentado o comando ELSE (SENÃO) para a mesma se tornar uma estrutura de decisão composta. Veja a seguir:
A estrutura para o comando SE/ENTÃO/SENÃO no diagrama de blocos é representada como a seguir:
Figura 10.2
10.2.3. Estruturas de seleção encadeadas
A estrutura de seleção encadeada, também conhecida como aninhada, geralmente é usada quando se faz diversas comparações sempre com a mesma variável. Ela se chama encadeada porque na sua representação (tanto em Português Estruturado, quanto em Chapin) fica uma seleção dentro da outra.
Os comandos que fazem parte de um bloco VERDADEIRO ou FALSO também podem ser uma estrutura de seleção, isso quer dizer que se pode testar mais que uma condição.
Uma das vantagens das estruturas encadeadas também é a de tornar o algoritmo mais rápido, pois a realização de testes e comparações é menor e isso resulta em um número também menor de passos para se chegar ao final dele.
Sintaxe
Figura 10.3
10.2.4. Estruturas de decisão de múltipla
A estrutura de decisão CASO/SELECIONE é usada para testar a condição, numa única expressão, que gera um resultado, ou valor de uma variável, que se encontra guardado num determinado conteúdo.
Nesta estrutura pode se ter uma ou mais condições a serem testadas e um comando diferente associado a cada uma destas.
Sintaxe
Esta estrutura ocorre da seguinte maneira:
Ao entrar neste tipo de estrutura (caso), a <Condição1>- é testada com a variável: se for VERDADEIRA, executa o <comando composto 1> e, após seu término, o fluxo de execução continua pela primeira instrução após o final da construção (fim); Caso a <condição1>_ seja FALSA, a <condição2> é testada, e se esta for VERDADEIRA, o <comando_composto2> é executado e, ao seu término, a execução continua pela instrução seguinte ao final da construção (fim). Esse mesmo raciocínio é passado a todas as condições da construção. Se por um acaso todas as condições forem avaliadas como FALSAS, o <comandocompostos>, que corresponde ao Senão da construção, é executado.
Com isso, um caso reservado desta construção, ou seja, aquele em que o <comandocompostos>, não possui nenhuma instrução. Isso se dá em situações que não se deseja realizar nenhuma ação quando todas as condições são FALSAS. Assim, o uso do SENÃO na construção Caso pode ser dispensado.
A seguir, esta estrutura representada pelo diagrama de blocos:
Figura 10.4
10.3. Estrutura de repetição
Esta estrutura aceita que uma seqüência de comandos seja executada em um determinado número de vezes até que certa condição seja satisfeita. São bastante comuns os casos em que se quer repetir um determinado trecho de um programa certo número de vezes. Em diversas ocasiões, tais estruturas são chamadas de laços ou loops.
Sua classificação é realizada de acordo com o prévio conhecimento do número de vezes que a seqüência de comandos será executada. Os laços dividem-se em laços contados e laços condicionais.
Veja a seguir a definição de cada um:
•Laços contados: também conhecidos como "repetição com variável de controle". Estes laços são usados quando se tem uma prévia de quantas vezes o comando composto no interior da construção será executado.
•Laços condicionais: caso não se saiba, antecipadamente, o número de vezes em que o conjunto de comandos no interior do laço se repetirá, por ele encontrar-se amarrado a uma condição sujeita à alteração pelas instruções do interior do laço.
Chamamos de algoritmo com repetição aquele que tem um ou mais de seus passos repetidos por um determinado número de vezes.
Devido ao uso de estruturas de repetição para a preparação de algoritmos, é preciso utilizar dois tipos de variáveis para a resolução de diversos tipos de problemas, como variáveis acumuladoras e variáveis contadoras.
1. Variável acumuladora: na maioria das vezes é a variável utilizada na estrutura de controle. Esta variável recebe um valor inicial, normalmente o zero antes do início de uma estrutura de repetição, e é incrementada no interior da estrutura de um valor variável. Veja, a seguir, um exemplo:
2. Variável contadora: é aquela que recebe um valor inicial, normalmente o 0 antes do início de uma estrutura de repetição, sendo incrementada no interior da estrutura por um valor constante, na maioria das vezes 1. Veja, a seguir, um exemplo:
10.3.1. Laços condicionais
São laços nos quais uma seqüência de comandos será executada em seu interior até que uma determinada condição seja satisfeita. Nas linguagens de programação modernas, as construções que implementam laços condicionais são:
•enquanto: laço condicional com teste no início;
•repita: laço condicional com teste no final.
Nestes tipos de laços, a variável que é testada, tanto no início quanto no final, terá que estar associada sempre a um comando que faça a atualização no interior do laço. Se isso não acontecer, o programa repetirá indefinidamente este laço, causando uma situação que se chama laço infinito.
10.3.1.1. Laços condicionais com teste no início
Este tipo de laço realiza um teste lógico em seu início, conferindo se é aceitável ou não executar o conjunto de comandos no interior do mesmo. Caso o resultado do teste seja VERDADEIRO, o laço é executado, retornando outra vez ao teste lógico e, desse modo, o processo será repetido enquanto a condição examinada for VERDADEIRA.
Quando o resultado da <Condição> for FALSO, será executada a instrução ou o bloco de instruções imediatamente posterior ao FIM-
ENQUANTO.
Sintaxe
Observe a seguir como funciona sua semântica:
A condição é testada no início da construção Enquanto. Caso seu resultado seja FALSO, o comando no seu interior não será executado e a execução continua normalmente pela instrução seguinte à palavra-reservada FIM, que identifica o término da construção.
Caso a condição seja VERDADEIRA, o comando é executado e, quando ele for finalizado, voltará ao teste da condição. Com isso, o processo anterior serárepetido enquanto a condição testada for VERDADEIRA. Quando esta for FALSA, o fluxo de execução continua normalmente pela instrução seguinte à palavra-reservada FIM que identifica a finalização da construção. A execução apenas deixará o laço quando a condição for falsa. Com este tipo de construção deve-se ficar atento à necessidade de que, em algum instante, a condição terá de ser avaliada como FALSA. Caso contrário, o programa continuará de modo indefinido no interior do laço executando "laço infinito".
A seguir, esta estrutura representada pelo diagrama de blocos:
Figura 10.5
10.3.1.2. Laços condicionais com teste no final
Este tipo de laço, muito semelhante ao da construção Enquanto, realiza um teste lógico no final de um laço, conferindo se é aceitável ou não executar outra vez o conjunto de comandos em seu interior. A principal característica desta estrutura é que a instrução ou o bloco verdade será efetuado pelo menos uma vez, independente do resultado da <condição>.
Funciona da seguinte maneira:
0 comando é executado uma vez; na seqüência, a condição é testada. Caso a mesma seja FALSA, novamente o comando é executado e este procedimento se repete até que a condição seja VERDADEIRA, e, com isso, a execução segue pelo comando imediatamente seguinte ao final da construção.
Tal estrutura se distingue da construção Enquanto pelo fato de o comando ser executado uma ou mais vezes, "uma vez pelo menos". Já na construção Enquanto, o comando é executado zero ou mais vezes, "provavelmente nenhuma". Isso ocorre pelo fato de que na construção Repita, o teste é realizado no final; já na construção Enquanto, o teste da condição é realizado no início da construção.
No que se refere à inicialização da variável, a construção Repita também difere da construção Enquanto, pois, na construção Repita, a variável pode ser lida inicialmente dentro do laço.
Sintaxe
Veja, a seguir, esta estrutura representada pelo diagrama de blocos:
Figura 10.6
10.3.2. Laços contados ou repetição com variável de controle
Esses laços são benéficos quando se conhece antecipadamente o número correto de vezes que se quer executar determinado conjunto de comandos. Pode se dizer que este tipo de laço é uma estrutura constituída de métodos próprios para calcular o número de vezes em que o laço será executado.
Notifica-se então que a principal característica deste tipo de estrutura é que se deve saber com antecipação o número de vezes em que a instrução ou bloco verdade se repetirá.
Sintaxe
A seguir, veja melhor como é a definição da sintaxe anterior:
1. É atribuído à <variável> o valor numérico <valor inicial>.
2. Faz-se uma comparação entre o valor da <variável> com o valor numérico <valor final>. Caso a <variável> seja menor ou igual a <valor final>, então vá para o passo 3; senão, execute o comando ou bloco de comandos após o FIM-PARA.
3. Execute os comandos 1 a n.
4. 0 valor da variável de uma unidade é incrementado.
5. Retorne ao passo 2.
Note que a incrementação é realizada pela própria estrutura, dependendo do valor do <incremento> fornecido pelo PASSO. 0 <incremento> é o valor acrescentado ao valor da <variável> ao final de cada repetição.
Existe uma particularidade desta estrutura que se dá quando a cláusula PASSO<incremento> não está presente: para este evento o valor assumido para o incremento é um.
Figura 10.7
10.4. Exercícios resolvidos
1. Faça um algoritmo que leia um número e escreva se o mesmo é maior que 30. Faça na forma de representação pseudocódigo e diagrama de bloco.
Resolução:
Para a resolução deste exercício utilizaremos a estrutura de decisão simples. Veja a seguir:
• Diagrama de bloco:
Figura 10.8
2. Faça um algoritmo que leia um número e escreva se o mesmo é maior que 30. Faça na forma de representação pseudocódigo e diagrama de bloco. Utilize a estrutura de decisão composta.
Resolução:
· Pseudocódigo:
· Diagrama de bloco:
Figura 10.9
3. Faça um algoritmo que calcule a média aritmética entre doisvalores e que determine se será possível fazer compras ou não. Utilize a estrutura de decisão composta.
Resolução:
4. Uma loja de presentes resolveu dar um bônus de 30% do valordo salário a seus funcionários com tempo de trabalho na loja igual ou superior a quatro anos e de 15% ao restante. Faça um algoritmo que calcule e mostre o valor do bônus.
Resolução:
Será usada a forma de representação pseudocódigo.
5. Utilizando a estrutura seqüencial, faça a soma entre dois números quaisquer.
Resolução:
6. Usando a estrutura de decisão encadeada, calcule a média aritmética semestral entre quatro notas bimestrais e exiba se o aluno foi aprovado, reprovado ou permaneceu de exame. Para a condição de aprovado, a nota tem de ser maior ou igual 7, e se a nota ficar entre 5 e 7 o aluno permanece de exame, abaixo disso, o aluno está reprovado.
Resolução:
7. Por meio da seleção de múltipla escolha faça um algoritmo que simule uma calculadora simples de números inteiros.
Resolução:
8. Este exercício será para você praticar a estrutura de laços condicionais com teste no início. Faça um algoritmo que escreva os números maiores que 0, entretanto que sua soma não ultrapasse 200. Para fixar melhor seus conceitos, faça na forma de representação pseudocódigo e de diagrama de bloco.
Resolução:
· Pseudocódigo:
· Diagrama de bloco:
Figura 10.10
9. Este exercício será para você praticar a estrutura de laços condicionais com teste no final. Faça um algoritmo que leia um número não determinado de vezes e escreva o valor e o seu quadrado até que seja digitado um valor par.
Resolução:
10. Tem-se um grupo de pessoas, então crie um algoritmo queache a maior idade desse grupo e o percentual de indivíduos do sexo masculino com idade entre 16 e 28 anos, diferenciando olhos azuis e cabelos pretos.
Resolução:
Obs.: o (-1) inicializa algumas variáveis.
Capítulo 11
Dados
Iremos estudar alguns conceitos importantes sobre dados na lógica de programação. Neste capítulo, aprenderemos o que são consistência de dados, arquivos de dados, entre outros.
11.1. Consistência de dados
Consistência de dados em um algoritmo é fazer a verificação se o dado digitado no instante da entrada de dados é válido ou não; entendendo melhor, consistência significa fazer a verificação dos dados, se eles se encontram dentro dos limites estabelecidos.
Exemplo: suponha que suas compras tenham de ficar entre um valor de 100 e 200 reais e que não possam aceitar valores fora desta faixa como 99 ou 201.
A consistência dos dados é utilizada para conferir a validade dos mesmos de maneira que possa garantir uma correta execução do algoritmo. E caso aconteça uma entrada errada de dados, o algoritmo terá que aceitar uma nova entrada até que os mesmos fiquem dentro das especificações necessárias. Para que isso ocorra pode-se usar uma estrutura de repetição com teste no final.
11.2. Arquivos de dados
Ao criarem-se programas de computadores é freqüente necessitarmos armazenar informações para uma futura recuperação. Tal recuperação das informações pode ser realizada minutos, dias, meses ou anos depois do armazenamento inicial. Com isso, os dados que necessitam ser armazenados por um tempo indeterminado ficam guardados em arquivos.
Arquivos de dados servem para armazená-los e manipulá-los. Os dados que são usados ficam apenas na memória, e após a execução do diagrama são perdidos. Os arquivos servem para que não haja a perda desses dados. Para que você possa entender melhor tal conceito, é preciso rever alguns outros, tais como: registros, campos e arquivos.
•Campo: espaço reservado na memória para receber dados. Exemplo: campo fone, nome, endereço.
Campo na memória
Figura 11.1
• Registro: conjunto de campos. Exemplo: registro de fornecedores.
Tabela fornecedor
Figura 11.2
• Arquivo: conjunto de registros. Exemplo: arquivo de fornecedor da empresa. Em tais arquivos encontram-se guardados todos os dados de fornecedores.
Arquivo fornecedor
Figura 11.3
11.2.1. Operações simples com arquivos e registros de arquivos
Para usarmos a estrutura de dados do tipo arquivo, praticamosa utilização de operações simples, tais como: abrir, fechar, apagar, copiar e renomear. A seguir, veja a definição de cada operação.
11.2.1.1. Como abrir arquivos
Quando for preciso trabalhar com arquivo, você deve inicialmente ABRIR o mesmo. Abrir o arquivo significa alocar o periférico (disco) onde ele se encontra e deixá-lo livre para leitura/gravação.
Sintaxe
Onde:
arquivo é a variável de arquivo previamente determinada.
A seguir, veja o símbolo:
Figura 11.4
11.2.1.2. Leitura de arquivos
Quando você abre um arquivo é preciso fazer a leitura dos dados que estão em disco e realizar a sua transferência para a memória. Tal transferência é realizada por registro. Esse método é gerenciado pelo sistema operacional.
Quando o arquivo é aberto, o ponteiro é posicionado no primeiro registro, ou seja, no início do arquivo. Para que se possa trabalhar com os dados é preciso saber onde está o ponteiro do registro. Isso pode ser feito testando se o ponteiro está no início ou no final do arquivo.
Sintaxe
Onde:
arquivo é o nome da variável do tipo de arquivo determinado
previamente.
registro é o nome da variável do tipo de registro determinado
anteriormente.
A seguir, a simbologia para a leitura de arquivos.
Obs.: Usa-se BOF (Begin ofFile) para o ponteiro no início e EOF (End of File) para o ponteiro no final do arquivo.
Figura 11.5
11.2.1.3. Como fechar arquivos
No tópico 11.2.1.1 você viu como abrir um arquivo e que esse arquivo aberto necessita ser fechado, para que seus dados não sejam danificados ou violados. Fechar um arquivo quer dizer liberar o periférico que estava sendo usado.
Sintaxe
Veja a seguir o símbolo usado para fechar um arquivo:
Figura 11.6
11.2.1.4. Como movimentar um registro
Quando o arquivo se encontra aberto, o ponteiro está no primeiro registro e isso foi mostrado anteriormente para você. 0 ponteiro se movimenta para o próximo registro a cada leitura do arquivo. Isso significa movimentar um registro.
A seguir, temos uma tabela que mostra o início, o fim e o registro de um arquivo:
Figura 11.7
11.2.1.5. Como gravar arquivos
A gravação de registros em um arquivo é feita de forma semelhante a que os registros são lidos. A gravação consiste na transferência de um registro da memória para um periférico (disco).
Sintaxe
Veja, a seguir, o símbolo utilizado:
Figura 11.8
11.3. Organizando arquivos
0 comando feito com registros em uma estrutura de dados do tipo arquivo é a inclusão de um novo registro, consulta de um registro do arquivo, alteração dos dados guardados no arquivo ou exclusão de um registro do arquivo.
Tem-se duas maneiras diferentes de acessar os registros de um arquivo:
· Acesso seqüencial: quando se deseja acessar informações de umdeterminado registro, mas não se sabe onde ele se encontra no arquivo, deve-se procurá-lo no mesmo arquivo do início ao fim, caso necessário. Tal comando terá que ser repetido seqüencialmente, isto é, avançando pelos registros guardados até que se encontre o registro que procura. Isso quer dizer que para acessar um determinado registro, precisa-se obedecer a ordem com que os registros foram guardados no arquivo, o que implica percorrer todos os registros que o antecipam.
· Acesso randômico ou direto: para acessar o registro que deseja é preciso que se saiba sua posição física'. Dessa maneira, é aceitável se posicionar instantaneamente no registro que você quer, sem ter que andar por todos os registros que o antecipam. Entretanto, é preciso que um campo do registro guarde o dado do número da posição física do registro dentro do arquivo. Tal campo é denominado de chave2.
11.4. Manipulação de registros (comandos e funções)
Utilizamos o seguinte comando para colocar o apontador de registros onde a posição física seja igual à chave:
Onde: arquivo é o nome da variável do tipo arquivo.
chave é o número inteiro (constante ou variável) que mostra a
posição do registro que se deseja acessar.
Usamos para mover o apontador de registros para o próximo registro o seguinte comando:
A função FDA( ) indica o final do arquivo que retorna verdadeiro quando o apontador de registros encontrar-se apontando para o próximo registro após o último:
Usamos o comando tamanho para indicar quantos registros estão gravados no arquivo:
11.5. Exercícios resolvidos
1. Considere um arquivo de pessoas que já possui registros gravados. Tal arquivo possui organização seqüencial e guarda os seguintes dados: RA, nome, endereço e telefone de diversas pessoas. Faça um algoritmo que aceite a consulta do telefone de uma determinada pessoa quando o seu nome é dado.
Resolução:
2. Faça um algoritmo que aceite a inclusão, consulta, alteração eexclusão (lógica) de registros de um arquivo que já exista usando o acesso direto.
Resolução:
Preste bastante atenção na resolução deste exercício, pois ele é mais complexo. Veja que ele possui em sua resolução muitos conceitos os quais já foram mostrados.
3. Escreva um algoritmo que faça uma cópia de backup de umarquivo já existente. Tal registro do arquivo guarda as seguintes informações: código, preço e situação.
Resolução:
11.6. Estruturas de dados homogêneos
Estas estruturas aceitam agrupar vários dados dentro de uma mesma variável. Elas acontecerão sempre satisfazendo o mesmo tipo de dado, e, por isso mesmo, são nomeadas como estruturas homogêneas.
0 uso deste tipo de estrutura recebe vários nomes, tais como: variáveis compostas, variáveis indexadas, variáveis subscritas, matrizes, arranjos, vetores, tabelas em memória ou arrays. Os mais utilizados para as estruturas homogêneas são: matrizes
(bidimensional) e vetores (unidimensional).
11.6.1. Vetores
Conjunto de variáveis no qual cada uma pode guardar um dado diferente, mas todas compartilham o mesmo nome. A esse nome são associados índices, que representam as posições do vetor, aceitando, assim, diferenciar os elementos do conjunto e sendo conhecido também como variável indexada, tabela ou array. Sua característica é determinar uma única variável vinculada com um determinado tamanho. Sua dimensão é estabelecida por constantes inteiras e positivas. Elas são nomeadas da mesma forma que as variáveis simples; seguem a mesma regra. A seguir, uma pequena demonstração de um vetor na memória de um computador:
Exemplo: vetor
Figura 11.9
Cada elemento dos arrays pode ser referenciado por meio de índices.
Sintaxe
Onde:
1. <nomedavariável>: nomes das variáveis que você quer declarar;
2. <coluna - inicial>: limite inferior do intervalo de variação do índice;
3. <coluna _ final>: limite superior do intervalo de variação do índice;
4. <tipo de dado>: tipo dos elementos da variável.
11.6.2. Matrizes
Matrizes são estruturas de dados (arrays) que precisam de dois índices para individualizar um elemento do conjunto. 0 primeiro índice representa as linhas e o segundo as colunas.
Exemplo: matriz
Figura 11.10
Cada elemento dos arrays pode ser referenciado por meio de índices.
Sintaxe
Onde:
<nomedavariável>: nomes de variáveis que você quer declarar;
2. <linha - inicial>: limite inferior do intervalo de variação do primeiro índice;
3. <linha - final>: limite superior do intervalo de variação do primeiro índice;
4. <coluna inicial>: limite inferior do intervalo de variação do segundo índice;
5. <coluna _ final>: limite superior do intervalo de variação do segundo índice;
6. <tipo de dado>: tipo dos componentes da variável.
11.7. Exercícios resolvidos
1. Tem-se um vetor D determinado com D : VETOR [1..99] DEinteiro. Preenchê-lo com o valor 20.
Resolução:
2. Faça um algoritmo que leia um vetor T contendo 50 númerosinteiros. Calcule e mostre o maior elemento, o índice do maior elemento.
3. Faça um algoritmo que leia 30 números, calcule a média e mostre os números que estiverem acima da média.
Resolução:
4. Faça um algoritmo que leia uma matriz 4 x 5 de números inteiros e, após ter multiplicado cada elemento por 2, exiba-a.
Resolução:
5. Tem-se uma matriz de 4 x 5 elementos inteiros. Calcule a somade cada linha, de cada coluna e de todos os seus elementos. Use um vetor para guardar o resultadoda soma de cada linha e outro vetor para a soma de cada coluna.
Resolução:
 
Capítulo 12
Modularização
A modularização é um processo usado para tornar mais fácil a criação de programas maiores. É um método de programação que consiste em dividir o algoritmo complexo em várias partes pequenas com funções bem definidas, gerenciado por módulos ou subalgoritmos. A parte inicial, onde inicia a execução do algoritmo, é nomeada de algoritmo principal e as outras partes de subalgoritmos.
Vantagens em usar subalgoritmos:
· facilita o entendimento, pois algoritmos mais complexos são subdivididos;
· facilita na detecção de erros e na documentação de sistemas;
· o código é menor;
· facilidade de modificação do código, caso necessite;
· generalidade de código com a utilização de parâmetros.
Nota: existem duas formas de subalgoritmos que são procedimento e função.
12.1. Procedimento
É um programa que para ser executado tem de ser chamado pelo algoritmo principal que o constitui, ou por outro subalgoritmo. É um subalgoritmo que é ligado através da colocação de seu nome em qualquer lugar no programa. Sendo assim, quando o nome de um procedimento é localizado, acontece um desvio no programa para que os comandos do subalgoritmo sejam realizados. Quando o subalgoritmo é finalizado, a execução retornará ao ponto seguinte à chamada do procedimento. Também são utilizadas pelos procedimentos todas as variáveis declaradas no início do programa.
Sintaxe
Onde:
<nome> é o identificador ligado ao procedimento.
Exemplo:
12.2. Função
As funções, ainda que muito parecidas com os procedimentos, têm uma particularidade especial de retornar ao programa que as chamou um valor ligado ao seu nome. Tal particularidade aceita uma relação com o conceito de função da matemática.
A função é também um bloco de programa que possui Início e Fim, sendo identificada por um nome, por meio do qual também será referenciada em qualquer parte do programa principal.
Sintaxe
Onde:
<nome> é o identificador ligado à função.
<tipo> é o modelo da função.
12.3. Variáveis globais e variáveis locais
As variáveis que são declaradas no início de um algoritmo são chamadas de globais e são determinadas após o comando var do algoritmo principal. Elas são consideradas visíveis, pois podem ser usadas no algoritmo principal e também por todos os subalgoritmos.
As variáveis que são declaradas no início de um subalgoritmo são chamadas de locais, podendo ser usadas dentro do subalgoritmo que as declarou. Não são usadas em hipótese alguma por outro subalgoritmo ou pelo programa principal.
É aceitável determinar variáveis globais e locais usando o mesmo nome, sendo que qualquer alteração na variável local não comprometerá o conteúdo da variável global.
Sintaxe
Definição da sintaxe anterior:
1. Declarações globais: definida anteriormente.
2. Algoritmo principal: inicia a execução do algoritmo.
3. Declarações locais: definida anteriormente.
4. Corpo do algoritmo: conjunto de comandos.
5. Definição dos algoritmos ou subalgoritmos: refere-se a um cabeçalho nomeado como algoritmo seguido de um nome, declarações locais e o corpo do subalgoritmo.
Exemplo:
12.4. Parâmetros
Utiliza-se a passagem de parâmetros quando se quer escrever um subalgoritmo que seja possivelmente o mais genérico. Parâmetros são caminhos onde se constitui uma comunicação bidirecional entre um subalgoritmo e o algoritmo chamador "algoritmo principal ou outro subalgoritmo"; também aceita que um subalgoritmo seja usado com operando diferente, isso depende do que o mesmo quer.
A passagem de parâmetros pode ser de dois tipos: passagem de parâmetros por valor e passagem de parâmetros por referência.
Exemplo: neste caso, A e B são parâmetros formais da função Média, enquanto 5 e 7 são parâmetros reais do algoritmo principal que substituirão A e B quando da chamada da função Média.
12.4.1. Passagem de parâmetros por valor
Na passagem de parâmetros por valor, as mudanças ocorrem nos parâmetros formais, dentro do subprograma, e não se refletem nos parâmetros reais.
As alterações realizadas nos dados do parâmetro não retornam ao algoritmo chamador. Esse tipo de parâmetro guarda um espaço diferente em memória para os parâmetros sejam copiados e assim não gerar nenhuma alteração em seus dados originais.
Nota: parâmetros formais são nomes simbólicos colocados no cabeçalho de subalgoritmos. Da mesma maneira como se trabalha com variáveis globais e locais dentro de um subalgoritmo, trabalha-se com os parâmetros formais.
Parâmetros formais são de grande utilidade apenas na determinação do subalgoritmo; já os parâmetros reais substituemnos a cada chamada do subalgoritmo. Os parâmetros reais podem ser diferentes a cada chamada de um subalgoritmo.
Exemplo 1: neste exemplo, A e B são parâmetros formais da função Média.
12.4.2. Passagem de parâmetros por referência
Na passagem de parâmetros por referência, toda mudança realizada em um parâmetro formal corresponde à mesma mudança realizada no seu parâmetro real associado. Sendo assim, quando a passagem é por referência, isto quer dizer que o parâmetro é de entrada-saída e o de valor é apenas de entrada.
Nota: parâmetros reais são aqueles que trocam os parâmetros formais quando existe a chamada de um subalgoritmo.
Exemplo:
12.5. Exercícios resolvidos
1. Faça um algoritmo que calcule a média aritmética entre duas notas, sem o uso de procedimentos, e, na seqüência, faça o mesmo algoritmo 	usando 	procedimentos. 	Quando 	finalizar, 	faça 	a comparação entre os dois.
Resolução:
· Sem a utilização de procedimentos
· Com a utilização de procedimentos
2. Faça um algoritmo em que um procedimento é utilizado paraescrever o valor dos componentes de um vetor.
Resolução:
3. Faça um algoritmo utilizando função para calcular o valor de um número elevado ao quadrado.
Resolução:
Observe que a função Quad toma T como parâmetro do tipo real, retorna um valor do tipo real e possui c como uma variável local real. 0 comando que chama a função Quad surge ao meio de uma expressão no comando de atribuição dentro do algoritmo principal.
4. Faça um algoritmo que calcule a média dos elementos de umvetor, sem o uso de procedimentos ou funções, e na seqüência faça o mesmo algoritmo usando um procedimento para ler os valores do vetor e uma função para efetuar o cálculo da média.
Resolução:
· Sem a utilização de procedimentos ou funções
· Com a utilização de procedimentos ou funções
S. Faça um subalgoritmo para determinar se um dado número é ou não ímpar.
Resolução:
6. Faça um subalgoritmo para obter a escrita de um vetor de xcomponentes reais (x <= 90).
7. Faça um subalgoritmo para realizar a leitura de um vetor de Tcomponentes reais (n <= 90).
S. Faça uma função chamada MAIOR que receba dois números inteiros e retorne o maior deles. Escreva um algoritmo para ler dois números inteiros e, usando a função MAIOR, calcule e mostre o maior valor entre os números lidos.
 
Capítulo 13
Exercícios de Fixação
Este capítulo contém mais exercícios resolvidos para que o leitor reforce os conceitos sobre Lógica de Programação que foram expostos ao longo do livro.
1. Faça um algoritmo que verifica se um número inteiro e positivoinformado é primo ou não.
2. Elabore um algoritmo que calcule os 20 primeiros termos daSérie de Fibonacci, que é formada pela seguinte seqüência: 1, 1 ,2,
3, 5, 8, 13, ... etc.
3. Determine o maior e o menor valor de um conjunto de númerosinteiros positivos. Considere que o conjunto de dados de entrada termina quando é fornecido o número -1.
Resolução:
4. Implemente um algoritmo que leia n números inteiros e determine se cada um deles pertence ou não à Série de Fibonacci.
Resolução:
S. Faça um algoritmo que leia dados contendo Sexo, Data de Nascimento e Estado Civil (Casado/ Solteiro/Divorciado/Outros) de um grupo de 10 pessoas e determine, ao final: a) Média de idade das mulheres.
b) Estado Civil de maior e menor ocorrência.
Resolução:
6. Escreva um algoritmo que retorne o fatorial de um número lido.
Resolução:
7. Faça um algoritmo recursivo(que faz a chamada dele mesmoem seu código), que calcule o fatorial de um número.
Resolução:
1 Instruções: comandos dados ao computador para execução de operações.
2 Portugol é proveniente da aglutinação de Português + Algol (nomede uma linguagem de programação utilizada no final da década de 1950).
3 Definição encontrada no Dicionário Eletrônico Houaiss de LínguaPortuguesa.
1 Posição física: posição do registro no arquivo no instante da gravação.
2 Chave: a chave de um registro deve ser única, pois nunca doisregistros diferentes poderão ter a mesma localização.