Programação com Pascal

Transcrição

Lógica de Programação
com Pascal
Teoria e Prática
Este material visa auxiliar no aprendizado da
programação com Pascal através de exemplos práticos.
Edeyson Andrade Gomes
IFBA – 2016
4ª Edição – Revisão 04.2016
SUMÁRIO
1 __________________________________________________________________ 10
INTRODUÇÃO À PROGRAMAÇÃO ________________________________________ 10
Linguagem Natural ________________________________________________________ 13
Fluxogramas ______________________________________________________________ 16
Início e Fim de Fluxo ______________________________________________________________ 16
Entrada Manual de Dados _________________________________________________________ 17
Exibição ________________________________________________________________________ 17
Processo _______________________________________________________________________ 18
Sequencia ______________________________________________________________________ 18
Decisão ________________________________________________________________________ 19
Repetição_______________________________________________________________________ 26
Exemplos ________________________________________________________________ 33
Exemplo 1: calculo da raiz de uma equação do primeiro grau. ____________________________ 33
Exemplo 2: Determinar os tipos dos triângulos em função da quantidade de lados. ___________ 34
Exemplo 3: Ler 2 valores inteiros e distintos do teclado e ordená-los. ______________________ 36
Exemplo 4: Imprimir o número 5 dez vezes. ___________________________________________ 37
Exemplo 5: Imprimir todos os números naturais entre 1 e N. _____________________________ 38
Exemplo 6: Determinar todos os divisores naturais de um número natural N. ________________ 40
2 __________________________________________________________________ 42
A LINGUAGEM PASCAL ________________________________________________ 42
2.1 Estrutura de um Programa Pascal __________________________________________ 42
2.1.1 Cabeçalho __________________________________________________________________ 42
2.1.2 Área de Declarações _________________________________________________________ 43
2.2.3 Corpo do Programa __________________________________________________________ 46
Identificadores ____________________________________________________________ 51
Palavras Reservadas ______________________________________________________________ 52
Comentários ____________________________________________________________________ 52
2.1 Variáveis______________________________________________________________ 52
2.2 Constantes ____________________________________________________________ 53
2.3 Tipos de Dados_________________________________________________________ 53
Inteiros ________________________________________________________________________ 53
Reais __________________________________________________________________________ 55
Caracteres ______________________________________________________________________ 57
Tipos Lógicos ____________________________________________________________________ 61
3 __________________________________________________________________ 64
EXPRESSÕES _________________________________________________________ 64
3.1 Prioridades das Operações _______________________________________________ 64
3.2 Tipos de Expressões _____________________________________________________ 65
3.3 Tipos de Operadores ____________________________________________________ 65
Operador de Atribuição ___________________________________________________________ 65
Operadores Aritméticos ___________________________________________________________ 66
Operador de Concatenação ________________________________________________________ 69
Operadores Relacionais ___________________________________________________________ 69
Operadores Lógicos ______________________________________________________________ 73
4 __________________________________________________________________ 77
ESTRUTURAS DE DECISÃO ______________________________________________ 77
4.1 IF .. THEN _____________________________________________________________ 78
4.2 IF .. THEN .. ELSE _______________________________________________________ 80
4.3 CASE _________________________________________________________________ 88
4.4 EXERCÍCIOS ___________________________________________________________ 92
5 __________________________________________________________________ 95
ESTRUTURAS DE REPETIÇÃO ____________________________________________ 95
5.1 FOR __________________________________________________________________ 96
5.1.1 Exemplos de Uso do FOR _____________________________________________________ 104
5.2 WHILE .. DO __________________________________________________________ 109
5.3 REPEAT .. UNTIL _______________________________________________________ 116
6. Arrays ___________________________________________________________ 120
Apêndice B – Exercícios _______________________________________________ 127
Apêndice C – Exemplos de Código _______________________________________ 135
C1 - Tipos, Variáveis e Constantes ___________________________________________ 135
C3 - Condicionais_________________________________________________________ 144
C4 - For ________________________________________________________________ 146
LISTAGENS
Listagem 2.1 - Cabeçalho de programa Pascal. ........................................................................... 43
Listagem 2.2 – Utilização de Unit. ............................................................................................... 44
Listagem 2.3 – Declaração de Variáveis. ..................................................................................... 46
Listagem 2.4 – Programa que lê 2 números e calcula a soma. ................................................... 47
Listagem 2.5 - Programa que lê 3 variáveis e calcula a média. ................................................... 50
Listagem 2.6 – Exemplo de uso de Inteiros ................................................................................. 55
Listagem 2.7 – Uso de Reais em Pascal ....................................................................................... 56
Listagem 2.3 – Exemplo com Strings ........................................................................................... 59
Listagem 2.4 – Exemplo com Char .............................................................................................. 60
Listagem 2.5 – Exemplo com Boolean......................................................................................... 61
Listagem 2.6 – Exemplo com Variáveis e Constantes ................................................................. 62
Listagem 3.1 – Operador de Atribuição ...................................................................................... 65
Listagem 3.2 – Uso de DIV e MOD .............................................................................................. 67
Listagem 3.3 – Uso de DIV e MOD com Unidade, Dezena e Centena ......................................... 68
Listagem 3.4 - Concatenação de Strings ..................................................................................... 69
Listagem 3.5 – Operadores Relacionais com Integer .................................................................. 70
Listagem 3.6 – Operadores Relacionais com String .................................................................... 71
Listagem 3.7 – Operadores Relacionais com Reais ..................................................................... 72
Listagem 3.8 – Operadores Lógicos............................................................................................. 74
Listagem 4.1 – Seleção com uma Via – IF .. THEN ....................................................................... 79
Listagem 4.2 – Seleção com 2 Vias – IF .. THEN .. ELSE .............................................................. 81
Listagem 4.3 - Seleção com duas Vias ......................................................................................... 82
Listagem 4.4 - Calcula Desconto 1............................................................................................... 86
Listagem 4.5 – Algoritmo URA 01 Case ....................................................................................... 90
Listagem 4.6 – Programa Triângulos. .......................................................................................... 93
www.edeyson.com.br
Listagem 4.7 – Programa Paridade. ............................................................................................ 94
Listagem 5.1 – Uso de For para repetir 100 teste de notas. ....................................................... 99
Listagem 5.2 – For Simples com 8 passos. ................................................................................ 100
Listagem 5.3 – Exemplo do FOR com 2 passos. ........................................................................ 102
Listagem 5.4 – Exemplo de FOR com alteração do contador. .................................................. 103
Listagem 5.5 – Divisores de N. ................................................................................................. 105
Listagem 5.6 – Conta Divisores de N. ....................................................................................... 107
Listagem 5.5 – Listagem de números de 1 a 10 ........................................................................ 109
Listagem 5.9 – While ................................................................................................................. 114
Listagem 5.10 – Listagem de números de 1 a 10 ...................................................................... 117
Listagem 5.11 – Listagem de números de 1 a 10 ...................................................................... 118
TABELAS
Tabela 2.1 – Tipos Inteiros .......................................................................................................... 53
Tabela 2.2 - Tipos Reais ............................................................................................................... 55
Tabela 3.1 – Precedência de Operadores ................................................................................... 64
Tabela 3.2 – Operadores Relacionais .......................................................................................... 70
www.edeyson.com.br
FIGURAS
Figura 1.1 – Símbolos de um Fluxograma ................................................................................... 16
Figura 1.2 – Início e Fim de Fluxo ................................................................................................ 16
Figura 1.3 – Símbolo de Entrada Manual de Dados .................................................................... 17
Figura 1.4 – Símbolo de Exibição de Dados ................................................................................. 17
Figura 1.5 – Símbolo de Processo em Fluxograma...................................................................... 18
Figura 1.6 –Fluxograma de Sequencia ........................................................................................ 18
Figura 1.7 – Decisão em Fluxograma .......................................................................................... 19
Figura 1.8 – Cálculo de média de duas notas .............................................................................. 20
Figura 1.9 – Decisão com 1 via em Fluxograma ......................................................................... 21
Figura 1.10 – Exemplo de Decisão com 1 via ............................................................................. 22
Figura 1.11 – Decisão com 2 vias em Fluxograma ...................................................................... 23
Figura 1.12 – Exemplo de Decisão com 2 vias ............................................................................ 24
Figura 1.13 – Decisão com 2 vias em Fluxograma....................................................................... 24
Figura 1.14 – Exemplo de Decisão com N vias ........................................................................... 25
Figura 1.15 – Exemplo de Repetição .......................................................................................... 27
Figura 1.16 – Fluxograma de Repetição ..................................................................................... 27
Figura 1.17 Repetição com Teste Antecipado ............................................................................. 29
Figura 1.18 Exemplo de Repetição com Teste Antecipado ......................................................... 30
Figura 1.19 Repetição com Teste Postergado ............................................................................. 31
Figura 1.20 Exemplo de Repetição com Teste Postergado ......................................................... 32
Figura 1.21 Exemplo de Equação do 1º Grau .............................................................................. 33
Figura 1.22 Exemplo do Algoritmo Triângulos ............................................................................ 35
Figura 1.23 - Fluxograma: Ordenar 2 números ........................................................................... 36
Figura 1.24 - Fluxograma: Imprimir o número 5 dez vezes ......................................................... 38
Figura 1.25 - Fluxograma: Números naturais entre 1 e N ........................................................... 39
Figura 1.26 - Fluxograma: Divisores naturais de N...................................................................... 41
Figura 2.1 - Fluxograma: Soma de a e b. ..................................................................................... 48
Figura 2.2 - Fluxograma: Média de 3 números. .......................................................................... 49
Figura 2.3 – Abstração de memória. ........................................................................................... 51
Figura 2.4 – Alocação de variáveis. ............................................................................................. 54
Figura 2.5 – Fluxograma do programa InteirosEmPascal. ........................................................... 54
Figura 2.6 – Fluxograma do programa ReaisEmPascal................................................................ 56
Figura 2.7 – Alocação de Strings. ................................................................................................ 57
Figura 3.1 – Divisão de Inteiro..................................................................................................... 66
Figura 4.1 – Fluxograma de sequência ........................................................................................ 77
Figura 4.2 – Fluxograma da seleção com uma Via ..................................................................... 78
Figura 4.3 – Fluxograma da seleção com duas Vias .................................................................... 80
Figura 4.4 - Fluxograma da seleção com duas Vias ..................................................................... 83
Figura 4.5 – Fluxograma do Algoritmo Calcula Desconto 1 ........................................................ 85
Figura 4.6 - Fluxograma do Algoritmo Calcula Desconto 2 ......................................................... 87
Figura 4.7 - Fluxograma do algoritmo URA 01 CASE ................................................................... 89
Figura 4.8 - Fluxograma do algoritmo Triângulos ....................................................................... 92
Figura 4.9 - Fluxograma do algoritmo Paridade .......................................................................... 94
Figura 5.1 – Fluxograma FOR ...................................................................................................... 97
Figura 5.2 – Fluxograma RepeteTesteNotas ............................................................................... 98
Figura 5.3 – Fluxograma do ForSimples .................................................................................... 100
Figura 5.4 – Fluxograma Divisores de N .................................................................................... 104
Figura 5.5 – Fluxograma Contadores de Divisores de N. .......................................................... 106
Figura 6.AA – While com Contador ........................................................................................... 111
Figura 7.BB – Pares entre 1 e 10 com WHILE ............................................................................ 112
www.edeyson.com.br
Figura 8.CC................................................................................................................................. 113
Figura 9.DD – While................................................................................................................... 114
Figura 10.EE – Repeat Until de 1 a 10 ....................................................................................... 117
Figura 11.FF ............................................................................................................................... 119
Figura 12.XYZ ............................................................................................................................. 120
Figura 13 .................................................................................................................................... 121
10
1
INTRODUÇÃO À PROGRAMAÇÃO
Um dos maiores desafios para um professor de programação é fazer com que seus
alunos consigam descrever detalhadamente uma solução para um problema. Por
exemplo: quais os passos necessários para calcular a idade média de uma coleção de
pessoas?
Fazê-los entender um problema não é o mais difícil, todavia, fazê-los organizar uma
linha de raciocínio lógico e bem estruturado para uma solução que seja coerente, efetiva
e eficaz não é trivial.
As principais dificuldades apresentadas estão na abstração do problema e da solução,
pois:
a) O aluno precisa compreender o problema para poder resolvê-lo;
b) A descrição da solução deve ser textualmente bem detalhada;
c) É difícil prover uma descrição da solução que seja completa.
Comumente, encontram-se soluções de alunos que omitem passos que são considerados
óbvios, embora não sejam a leitores que desejam entender tais soluções.
Este livro tem como objetivo ajudar o aluno a desenvolver a habilidade de descrever
soluções computacionais coerentes, sem ambiguidades e completas. Para isto, foca-se o
desenvolvimento do raciocínio lógico baseando-se num universo de problemas da
matemática e física do ensino médio.
Alunos do ensino médio são confrontados com problemas como a extração de raízes de
uma equação do segundo grau. Para a solução, aprendem um conjunto ordenado de
passos. São estes passos que compõem um algoritmo.
Um algoritmo deve descrever detalhadamente uma sequência finita e ordenada de
passos necessários à solução de um determinado problema ou uma classe de problemas.
É uma forma de descrever possíveis soluções a problemas do mundo real, objetivando
sua implementação no mundo computacional.
A maioria dos problemas pode ser resolvida por um algoritmo que deve possuir 5
características essenciais:
1. Finitude: Todo algoritmo deve sempre terminar após um número finito
de passos.
2. Definição: Cada passo de um algoritmo deve ser definido de forma clara.
a.
As ações devem ser definidas rigorosamente e sem ambiguidades
para que não sejam cometidos erros durante a resolução do
problema.
b.
www.edeyson.com.br
Introdução à Programação
3. Entradas: Um algoritmo deve ter zero ou mais entradas.
a. Por exemplo, uma equação do segundo grau precisa informar os
valores de a, b e c, pois sua forma é ax2 + bx + c e são estes
valores que diferenciam as equações.
4. Saídas: Um algoritmo deve ter uma ou mais saídas.
a. Por exemplo, uma equação de segundo grau tem duas raízes: x’ e
x’’.
5. Efetividade: Um algoritmo deve ser efetivo.
a. Todas as operações devem ser suficientemente básicas de modo
que possam ser executadas com precisão em um tempo finito por
um humano usando papel e lápis.
b. Cada passo da solução deve ser simples, embora sua composição
leve a solução de algo complexo.
A elaboração de um algoritmo deve seguir 6 passos fundamentais:
1. Compreender o problema, descrevendo-o de forma clara e precisa.
a. Um problema só pode ser resolvido se for bem entendido, o que
requer uma descrição compreensível e clara.
2. Identificar os dados de entrada e saída.
a. Todo problema tem 0 ou mais dados de entrada.
i. Por exemplo, uma equação do segundo grau requer 3 dados
de entrada (a, b e c).
b. Todo problema tem 0 ou mais dados de saída.
i. Por exemplo, uma equação do segundo grau onde delta é
menor que zero não possui raízes, logo, não tem dados de
saída. Em caso contrário, tem duas saídas: x’ e x’’.
3. Determinar o que é preciso para transformar dados de entrada em
dados de saída:
a. Definição de uma sequência de passos que permitam a solução de
maneira automática e repetitiva.
i. Usar a estratégia top-down1, sempre buscando passos simples
que sejam compostos na solução;
1
A estratégia top-down consiste em dividir um problema em partes menores e extremamente simples
(subproblemas) de modo que seja mais fácil a sua resolução.
11
12
ii. Observar regras e limitações (como exceções ao problema);
iii. Identificar todas as ações a realizar, usando sempre passos
simples para a solução.
iv. Eliminar possíveis ambiguidades.
4. Construir o algoritmo.
5. Testar o algoritmo.
6. Executar o algoritmo.
Um algoritmo bem definido e estruturado garante sua compreensão por terceiros em
qualquer linguagem de programação.
Um grave problema que se destaca na elaboração de algoritmos é que se ele não for
descrito de forma padronizada e estruturada, possivelmente não será compreendido por
outras pessoas, apenas por seus criadores. Para evitar esse possível problema,
algoritmos costumam ser representados de três formas, como seguem:
1. Linguagem Natural: Os algoritmos são descritos detalhadamente em
linguagem natural. Por exemplo, em português estruturado.
2. Fluxograma: Os algoritmos são representados graficamente.
a. Usam-se formas geométricas padronizadas para descrever ações e
decisões na resolução do problema.
3. Pseudo-linguagem: Os algoritmos são descritos através de uma linguagem
intermediária entre a linguagem natural e uma linguagem de programação.
www.edeyson.com.br
Linguagem Natural
Um exemplo de uso de Linguagem Natural está na especificação de como criar um
XBurger. Uma possível solução está a seguir:
1. Início do Algoritmo XBurger.
a. Pegar um pão;
b. Abrir o pão ao meio;
c. Passar manteiga no pão;
d. Colocar queijo no pão;
e. Colocar presunto no pão;
f. Colocar ovo frito no pão;
g. Fechar o pão.
2. Fim do Algoritmo XBurger.
Algumas perguntas que podem surgir ao leitor são:
1. Onde estavam a manteiga, o queijo e o presunto?
2. Quem fritou o ovo? Isso faz parte do algoritmo?
3. Podemos definir um algoritmo fritar ovo e reusá-lo?
A especificação de um algoritmo deve ser tão detalhada quanto possível para evitar
dúvidas ou ambiguidades. Tais perguntas deveriam ser respondidas numa especificação
mais clara e detalhada do Algoritmo XBurger. Por exemplo, pode-se definir que o
algoritmo tem como entradas: um pão, um ovo frito (logo, não faz parte do algoritmo
fritar o ovo), manteiga, queijo e presunto. Como dado de saída tem-se o sanduíche.
Outro exemplo em Linguagem Natural é como extrair as raízes de uma equação do
segundo grau na forma ax2 + bx + c. Sabe-se que:
𝒙=
−𝒃 ± √∆
𝟐𝒂
i.
∆ = b2 - 4ac
ii.
x1 = (-b + √∆) / 2a
iii.
x2 = (-b - √∆) / 2a
iv.
a deve ser diferente de 0, senão a equação é de 1º grau.
v.
∆ deve ser maior que zero para ter raízes reais.
A definição do algoritmo, em linguagem natural, para extrair as raízes de uma equação
do segundo grau pode ser a seguinte:
13
14
1. Início do Algoritmo Raízes
a. Obter os coeficientes a, b e c (dados de entrada).
b. Se a é igual a zero:
i. Informar que esta é uma equação de 1º grau e terminar
o algoritmo.
c. Caso contrário:
i. Calcular delta = b2 - 4ac
ii. Se delta for negativo:
1. Informar que a equação não tem raízes reais e
terminar o algoritmo.
iii. Caso contrário:
1. Calcular:
a. x1 = (-b + √∆) / 2a
b. x2 = (-b - √∆) / 2a
2. Fornecer como resultado x1 e x2
3. Terminar o algoritmo.
2. Fim do Algoritmo Raízes
Vale ressaltar os dados de entrada e saída do algoritmo. Pela definição, uma equação de
segundo grau precisa dos seguintes dados de entrada: a, b e c. Como dados de saída,
provê os valores de x1 e x2 (x’ e x’’, respectivamente). E delta? É dado de entrada ou
de saída?
Na solução de um problema é comum o uso de dados temporários que auxiliam os
cálculos, armazenando valores intermediários. Dados como delta são comumente
denominados, em programação, de variáveis. A variável delta é, então, um dado
necessário ao cálculo das raízes da equação do segundo grau.
Como se pode notar, a definição do Algoritmo Raízes especifica detalhadamente como
calcular as raízes de uma equação do segundo grau.
Observação:
1. O Algoritmo Raízes foi escrito usando um recurso textual que facilita sua
legibilidade, que é a indentação. Note que as ações que compõem blocos ficam
indentados.
Outra forma de representação de um algoritmo é via o uso de uma linguagem de
programação de alto nível, ou Pseudocódigo. Neste caso, aproxima-se bastante da
programação formal em computadores, mas distancia-se da linguagem escrita e falada
comumente pelos humanos.
A programação consiste na codificação precisa de um algoritmo (em qualquer
representação adotada) segundo uma linguagem de programação específica. Um
programa é uma formalização de um algoritmo em uma determinada linguagem de
www.edeyson.com.br
programação, segundo suas regras de sintaxe e semântica, de forma a permitir que o
computador possa entender sua sequencia de ações.
A proposta deste material é ensinar algoritmos e programação através de múltiplos
meios de representação e usando as linguagens de programação Pascal.
15
16
Fluxogramas
Um Fluxograma é um diagrama que representa o esquema de solução de
um problema. Ele apresenta a linha de raciocínio lógico independente de linguagem de
programação e é inteligível por humanos e computadores.
Sua representação gráfica é feita por símbolos como na Figura 1.1.
Início e Fim de
Fluxo
Processo
Entrada Manual de
Dados
Exibição
Decisão
Figura 1.1 – Símbolos de um Fluxograma
Fluxogramas representam diversas estruturas de controle, detalhadas a seguir.
Início e Fim de Fluxo
Todo Algoritmo precisa informar em sua representação onde ele inicia e onde termina.
Embora o símbolo de início e fim seja o mesmo, seu rótulo é que os diferencia, como
apresenta a Figura 1.2.
Exemplo de Algoritmo:
1. Início do Algoritmo
2. Fim do Algoritmo
Início
Fim
Figura 1.2 – Início e Fim de Fluxo
www.edeyson.com.br
Entrada Manual de Dados
Uma entrada manual de dados representa a obtenção de ou mais dados de entrada
para a execução do algoritmo, como mostra a Figura 1.3.
a. Entrada manual de dados:
i. Ler os valores de a, b e c numa equação do 2º grau
(dados de entrada);
2. Fim do Algoritmo
Início
Fim
a, b, c
Figura 1.3 – Símbolo de Entrada Manual de Dados
O uso de [Ler os valores de a, b e c] significa que os valores de a, b e c terão de ser
fornecidos ao algoritmo. É uma condição necessária a seu funcionamento.
Exibição
Uma exibição apresenta (em tela, impresso, etc) um ou mais dados de saída da
execução do algoritmo, como se pode ver na Figura 1.4.
i. Ler os valores de a, b e c numa equação do 2º grau
(dados de entrada);
b. Exibir os valores de a, b e c
2. Fim do Algoritmo
Início
a, b, c
a, b, c
Figura 1.4 – Símbolo de Exibição de Dados
Fim
17
18
Processo
Um processo representa a transformação de um ou mais dados de entrada em dados
temporários (intermediários) ou de saída, como apresenta a figura 1.5.
a. Entrada manual de dados: Ler um valor inteiro para n1
(dados de entrada);
b. Processo:
i. Calcular delta = b2 - 4ac
c. Exibir o valor de delta.
2. Fim do Algoritmo
Início
a, b, c
delta = (b * b) –
(4 * a * c)
Fim
delta
Figura 1.5 – Símbolo de Processo em Fluxograma
Sequencia
Uma Sequencia representa a execução de um conjunto de ações em série. Não existe a
possibilidade de alteração da ordem de processamento das ações.
Por exemplo:
Entrada
Ação 1
Ação 2
Saída
Figura 1.6 –Fluxograma de Sequencia
Na Figura 1.6, apresenta-se uma sequência onde as Ações 1 e 2 ocorrerão sempre e na
mesma ordem.
Observação:
1. Pode-se inferir uma Sequencia na Figura 1.5, onde a leitura de a, b e c antecede o
cálculo de delta que, por sua vez, antecede sua exibição.
www.edeyson.com.br
Decisão
Uma Decisão representa a avaliação de uma condição (expressão lógica) que pode ser
Verdadeira ou Falsa e seu símbolo permite dois caminhos possíveis à sequência de
ações. Como exemplo de algoritmo que usa decisão, voltemos ao cálculo das raízes de
uma equação do segundo grau, cujo fluxograma é ilustrado na Figura 1.7:
1. Início do Algoritmo Raízes
a. Obter o coeficiente a (dado de entrada).
b. Se a é igual a zero: (decisão 1)
i. Informar que esta é uma equação de 1º grau e terminar
o algoritmo.
c. Caso contrário:
i. Obter os coeficientes b e c (dados de entrada).
ii. Calcular delta = b2 - 4ac
iii. Se delta for negativo: (decisão 2)
1. Informar que a equação não tem raízes reais e
iv. Senão:
1. Calcular:
a. x1 = (-b + √∆) / 2a
b. x2 = (-b - √∆) / 2a
2. Fornecer como resultado x1 e x2
3. Terminar o algoritmo.
2. Fim do Algoritmo Raízes
Início
a
a=0
SIM
A Equação é
do 1º grau.
NÃO
b, c
delta = b2 – 4ac
delta >= 0
NÃO
A Equação
não tem
raízes reais
SIM
x1 = (-b + √∆)/(2a)
x2 = (-b – √∆)/(2a)
Exibe x1 e
x2
Figura 1.7 – Decisão em Fluxograma
Fim
19
20
Como visto no exemplo anterior, a descrição do algoritmo exige duas tomadas de
decisão: uma para testar o valor de a e a outra para testar o valor de delta. Com base no
resultado, toma-se um de dois caminhos possíveis. Existem vários tipos de decisão que
podemos tomar num algoritmo e os descreveremos a seguir.
Vamos testar o algoritmo usando 2 exemplos:
1. Equação : 3x + c
a. Obter o coeficiente a
i. Neste caso, a = 0. Logo, o algoritmo vai informar que esta
é uma equação de 1º grau e terminar.
2. Equação : x2 - 2x – 3
a. Obter o coeficiente a
i. Neste caso, a = 1. Logo, o algoritmo prossegue.
b. Obter os coeficientes b e c
i. Neste caso, b = -2 e c = -3.
c. Calcular delta = b2 - 4ac
i. delta = (–2)² – 4 * 1 * (–3) = 4 + 12 = 16
d. Como delta >= 0, o algoritmo continua.
e. Calcular x1 e x2:
i. X1 = (2 + 4) / 2 = 3
ii. X2 = (2 – 4) / 2 = -1
f. Exibe 3 e -1
Decisão com 1 Via
Imagine um algoritmo que deva calcular a média aritmética de duas avaliações [media =
(nota1 + nota2)/2] e a imprima. Temos um fluxo linear único que é: obter as notas (n1 e
n2), calcular a média e imprimi-la. A seguir, o fluxograma que o descreve.
Figura 1.8 – Cálculo de média de duas notas
www.edeyson.com.br
Uma alteração possível a este algoritmo é: caso a média calculada seja maior ou igual a
6, imprima parabéns e continue o fluxo normal. Note que inserimos uma tomada de
decisão (o teste da média). O fluxo será alterado (teremos uma adição de passos) SE a
nota for maior ou igual a 6. Neste caso, teremos uma adição ao comportamento inicial
do algoritmo.
Uma Decisão com uma Via representa uma tomada de decisão (testa-se uma condição)
que permite alterar o fluxo de processamento executando ou não uma Ação 1.
Normalmente é construída em Linguagem Natural assim: Se expressão lógica é
verdadeira então execute a Ação 1.
Por exemplo, na Figura 1.9 a Ação 1 só será executada se o resultado da decisão
(avaliação de uma expressão lógica) for verdadeiro. Em caso contrário a Ação 1 não
será executada.
Entrada
Decisão
Verdade
Ação 1
Falso
Saída
Figura 1.9 – Decisão com 1 via em Fluxograma
O uso de Decisão com 1 Via para imprimir Parabéns se a média for maior ou igual a 6 é
exemplificado no Algoritmo a seguir, representado na Figura 1.10:
1. Início do Algoritmo.
i.
Ler dois números n1 e n2 (dados de entrada);
b. Processo:
i.
Calcular a média aritmética de n1 e n2 e atribuir à
variável média;
c. Decisão com 1 Via:
i.
Se a média for maior ou igual a 6, imprimir
“Parabéns!”.
d. Exibição:
i.
Exibir a média (dado de saída).
2. Fim do Algoritmo.
21
22
Figura 1.10 – Exemplo de Decisão com 1 via
Observa-se que neste exemplo, apresentado na Figura 1.10, a exibição de Parabéns
ocorrerá se e somente se a média for maior ou igual a 6.
www.edeyson.com.br
Decisão com 2 Vias
Suponha que o algoritmo anterior deve ser alterado para avaliar a média dos alunos e
determinar se o mesmo está aprovado (média >=6) ou reprovado (média < 6). Neste
caso, têm-se apenas dois resultados possíveis e distintos na análise da média, ou seja, 2
Vias na tomada de decisão.
Uma Seleção com duas Vias representa uma tomada de decisão que resulte num fluxo
de processamento que segue por 1 das 2 vias possíveis, dependendo do valor lógico da
expressão avaliada no início da estrutura.
Por exemplo, na Figura 1.11 a Ação 1 só será executada se o resultado da decisão for
verdadeiro. Em caso contrário, a Ação 2 será executada. Assim, as ações 1 e 2 são
mutuamente exclusivas.
Normalmente é construída em Linguagem Natural assim: Se expressão lógica é
verdadeira então execute a Ação 1, senão, execute a Ação 2.
Entrada
Decisão
Verdade
Falso
Ação 1
Ação 2
Saída
Figura 1.11 – Decisão com 2 vias em Fluxograma
Exemplo de Algoritmo (representado na Figura 1.11):
a. Entrada manual de dados: Ler dois números n1 e n2
(dados de entrada);
b. Processo: calcular a média aritmética de n1 e n2 e
atribuir à variável média;
c. Decisão com 2 Vias:
i. Se a média for maior ou igual a 6, imprimir
“Aprovado!”.
ii. Senão, imprimir “Reprovado!”
d. Exibição: Exibir a média (dado de saída).
23
24
Figura 1.12 – Exemplo de Decisão com 2 vias
Decisão com N Vias
A Decisão com várias (N) Vias apresenta uma tomada de decisão onde o fluxo de
processamento segue por 1 das N vias, dependendo do valor lógico da expressão
avaliada no início da estrutura. Ou seja, o valor testado na tomada de decisão pode ter N
resultados.
Por exemplo, na Figura 1.13, uma das ações será executada em função do valor da
condição avaliada. As condições são mutuamente exclusivas.
Entrada
Avalia
Condição
Caso 1
Ação 1
Caso 2
Caso 3
Ação 2
Caso N
Ação 3
...
Ação N
Saída
Figura 1.13 – Decisão com 2 vias em Fluxograma
www.edeyson.com.br
Como exemplo, propomos um algoritmo que deve receber como entrada o código da
operadora de telefonia móvel / celular e imprimir o nome desta operadora (representado
na Figura 1.14). Se a operadora tiver código 1, imprima Oi; se for 2, imprima Claro; se
for 3, imprima Tim, e assim, sucessivamente para todas as operadoras cadastradas.
Observa-se que a tomada de decisão baseia-se na avaliação do código, que pode ter N
valores possíveis. Assim, necessita-se de uma Decisão com N vias.
i. Ler um valor para codigo (dado de entrada);
b. Decisão com N Vias:
i. Selecione o valor de codigo.
Caso:
1. atribua à operadora o valor “Oi”;
2. atribua à operadora o valor “Claro”;
3. atribua à operadora o valor “Tim”;
4. atribua à operadora o valor “Vivo”;
ii. Qualquer outro valor, termine o algoritmo.
c. Exibição: Exibir a operadora (dado de saída).
Início
codigo
1
codigo
4
2
3
operadora =
Oi
operadora =
Vivo
operadora =
Claro
operadora =
Tim
Outro Valor
operadora
Fim
Figura 1.14 – Exemplo de Decisão com N vias
25
26
Repetição
Imagine um problema que requer a impressão de todos os números inteiros entre 1 e 5,
ou seja, o intervalo [1, 5]. O algoritmo para resolver isso pode ser o seguinte:
1. Início do Algoritmo 1 a 5.
a. Exibir 1;
b. Exibir 2;
c. Exibir 3;
d. Exibir 4;
e. Exibir 5;
2. Fim do Algoritmo 1 a 5.
Várias questões podem ser apresentadas para provar que a solução anterior não é
eficiente:
1. Como imprimir todos os números entre 1 e 10.000? Usar 10.000 linhas de
código?
2. Como imprimir os números entre a e b, sendo estes dois inteiros? Neste
caso, a e b serão dados de entrada.
3. Como imprimir os números maiores que c entre a e b? Esta alteração vai
necessitar de uma Decisão com 1 Via.
Para resolver tais questões, quando o problema original requer um conjunto de
comandos que se repete, usam-se as estruturas de repetição (também chamada de
laço). Uma nova solução para o Algoritmo de 1 a 5 pode ser:
a. i = 1;
b. Repita 5 vezes:
i. Exibir i;
ii. i = i + 1;




valor inicial do intervalo [1,5].
são 5 valores no conjunto.
exibe o valor atual de i.
i assume seu valor anterior
acrescido de 1.
Vamos ver como seria a execução do algoritmo (como ilustra a Figura 1.15): iniciamos
o algoritmo com i = 1 (primeiro valor do intervalo).
Observação:
1. i é uma variável temporária que armazena o valor a ser impresso.
2. Note que executar i = i + 1 significa: atribua a i seu valor anterior acrescido de 1.
www.edeyson.com.br
Passo 1
Passo 2
Passo 3
Passo 4
Passo 5
•i = 1;
•exibe 1;
•i = 1 + 1
•exibe 2;
•i = 2 + 1
•exibe 3;
•i = 3 + 1;
•exibe 4;
•i = 4 + 1;
•exibe 5;
•i = 5 + 1;
Figura 1.15 – Exemplo de Repetição
O fluxograma padrão para Repetição é apresentado na Figura 1.16. Observa-se uma
Condição (um teste feito) que determina se a repetição chegou ao fim ou não. Caso não,
os comandos são novamente executados.
Figura 1.16 – Fluxograma de Repetição
O exemplo anterior (Algoritmo 1 a 5) funciona bem para imprimir todos os números
num intervalo conhecido previamente. No exemplo, o intervalo inteiro [1, 5]. Sabemos
o início do intervalo (1), seu final (5) e o total de números a imprimir (5). Este total é
que limita a repetição (Repita 5 vezes).
Para imprimir os números entre 10 e 20, intervalo [10, 20], a alteração é a seguinte:
1. Início do intervalo = 10;
2. Final do intervalo = 20;
3. Total de números no intervalo: 11;
a. [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].
27
28
a. i = 10;

b. Repita 11 vezes:

i. Exibir i;

ii. i = i + 1;

valor inicial do intervalo.
são 11 valores no conjunto.
exibe o valor atual de i.
i assume seu valor anterior
acrescido de 1.
Vamos a um desafio: como imprimir os números maiores que c entre 10 e 50? Dica:
Esta alteração vai necessitar de uma Decisão com 1 Via.
1. Início do intervalo = 10;
2. Final do intervalo = 50;
3. Total de números no intervalo: 51;
a. [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20... 49, 50].
Apresentaremos uma solução ao desafio:
1. Início do Algoritmo DesafioIntervalo.
i. Ler um valor para c (dado de entrada);
b. i = 10;
c. Repita 51 vezes:
i. Decisão com 1
ii. Se i > c então
1. Exibir i;
iii. i = i + 1;
 valor inicial do intervalo.
 são 51 valores no conjunto.
Via:
 exibe o valor atual de i.
 i assume seu valor anterior
acrescido de 1.
2. Fim do Algoritmo DesafioIntervalo.
Observe que i só será exibido se seu valor for maior que c. Isso é garantido pelo teste Se
i > c então ... o que está aninhado com o então (Exibir i) só será executado
se a condição for verdadeira.
Na maioria das vezes o uso de Repetição requer um teste ou avaliação de condição para
executar ou não um bloco de comandos. Comumente, as repetições usam testes
Antecipados ou Postergados.
Usamos a Repetição com Teste Antecipado quando há a necessidade de tomar uma
decisão que determine se uma ação será executada, repetindo-a se necesário.
Normalmente é construída em Linguagem Natural assim: Enquanto a expressão lógica
é verdadeira, execute a Ação 1.
Por exemplo: enquanto o valor da variável a for menor que 10 some 1 à variável a.
Neste caso, quando variável a for maior ou igual a 10 a repetição da ação (some 1 à
variável a) se encerra.
Nota-se que, se antes do teste a variável a já for maior ou igual a 10 nenhuma ação será
tomada, pois o teste da expressão lógica precede a ação. O teste funciona como uma
condição de parada das repetições.
www.edeyson.com.br
No exemplo da Figura 1.17 a Ação 1 será executada sempre que, e apenas se, o Teste
de Condição retornar um valor verdadeiro.
Entrada
Teste de
Condição
V
Ação 1
F
Saída
Figura 1.17 Repetição com Teste Antecipado
O algoritmo a seguir, representado no fluxograma da Figura 1.18, imprime todos os
valores inteiros entre um valor de início x e 10 (intervalo [x, 10]). Note que se o valor
inicial de x for maior que 10, nenhum valor será impresso, pois o teste iniciará falso.
a. Entrada de dados:
i. Ler um valor para x (dado de entrada);
b. Repetição com Teste Antecipado:
i. Enquanto o valor de x <= 10:
1. Exibição:
a. Exibir o valor de x (dado de saída).
2. Some 1 a x.
Note que se a linha 2 (Some 1 a x) não for colocada no algoritmo, a repetição ocorrerá
para sempre (isso é chamado de laço infinito). Imagine que o usuário digite o valor 1
para x. Sem a linha 2 o teste (enquanto x <= 10) sempre será verdadeiro.
29
30
Figura 1.18 Exemplo de Repetição com Teste Antecipado
A Repetição com Teste Postergado é semelhante à Repetição com Teste Antecipado,
mudando apenas quando efetuar o teste.
Usa-se a Repetição com Teste Postergado quando há a necessidade de executar uma
ação e somente após determinar se tal ação será executada novamente. Neste caso, a
ação será executada ao menos uma vez.
Normalmente é construída em Linguagem Natural assim: Repita a Ação 1 até que a
expressão lógica torne-se verdadeira.
Por exemplo: some 1 à variável a até que seu valor seja maior que 10. Nota-se que a
ação que muda o valor de a sempre será executada uma vez, independente do seu valor
inicial, como ilustra a Figura 1.19.
www.edeyson.com.br
Entrada
Ação 1
V
Teste de
Condição
F
Saída
Figura 1.19 Repetição com Teste Postergado
O algoritmo a seguir, representado na Figura 1.20, imprime todos os valores inteiros
entre um valor de x e 10. Note que mesmo se o valor de x for maior que 10 ao menos
um valor será impresso, pois o teste ocorre após a ação.
a. Entrada de dados:
i. Ler um valor para x (dado de entrada);
b. Repetição com Teste Postergado:
i. Repita
1. Exibição:
a. Exibir o valor de x (dado de saída).
2. Some 1 a x.
ii. Até que o valor de x seja > 10.
31
32
Figura 1.20 Exemplo de Repetição com Teste Postergado
Os recursos vistos até agora – linguagem natural e fluxogramas – são a base do
aprendizado para o bom desenvolvimento de programas. A lógica pode ser explorada
independente da codificação esperada.
www.edeyson.com.br
Exemplos
Apresentaremos um conjunto de exemplos para fixação dos conceitos vistos neste
capítulo. Cada um conterá uma descrição em Linguagem Natural e seu Fluxograma.
Exemplo 1: calculo da raiz de uma equação do primeiro grau.
Sabe-se que a forma da equação de 1º grau é: y = ax + b
A descrição da solução em linguagem natural pode ser:
1.
2.
Início do Algoritmo Raiz 1º Grau
a. Obter o coeficiente a (dado de entrada).
b. Se a é igual a zero:
i. Informar que não há raízes para a equação e
c. Obter o coeficiente b (dado de entrada).
d. Calcular o valor de x : x = -b / a
e. Exibir o valor de x
f. Terminar o algoritmo.
Fim do Algoritmo Raiz 1º Grau
O Fluxograma da solução proposta é apresentado na Figura 1.21.
Início
a
a=0
SIM
NÃO
b
Não há raiz
para a
equação
x = -b/a
x
Fim
Figura 1.21 Exemplo de Equação do 1º Grau
33
34
Exemplo 2: Determinar os tipos dos triângulos em função da quantidade de lados.
1. Equilátero: todos os lados são iguais.
2. Isósceles: pelo menos dois lados são iguais.
3. Escaleno: os três lados são diferentes.
Para esta solução combinaremos 2 Decisões de 1 Via e usaremos a estrutura:
SE (condição1 é verdadeira) ENTÃO
Ação 1
SENÃO
SE (condição 2 é verdadeira) ENTÃO
Ação 2
SENÃO
Ação 3
Nesta estrutura a Ação 1 só será executada se a condição1 for verdadeira. Neste caso,
não entra no SENÃO. Se a condição1 for falsa, e apenas neste caso, será feita a
avaliação da condição 2. Se esta for verdadeira, executa a Ação 2. Em caso das duas
condições testadas serem falsas, executa a Ação 3.
A descrição da solução em linguagem natural pode ser:
1. Início do Algoritmo Triângulos
a. Obter os lados a, b e c
b. Se os três lados são iguais:
i. Exibir Equilátero.
c. Senão:
i. Se dois lados são iguais:
1. Exibir Isósceles.
ii. Senão:
1. Exibir Escaleno.
2. Fim do Algoritmo Triângulos
O Fluxograma da solução proposta é apresentado na Figura 1.22.
www.edeyson.com.br
Início
a, b, c
a=beb=c
V
Equilátero
F
a=b
ou a = c
ou b = c
V
F
Isósceles
Triângulo
Escaleno
Fim
Figura 1.22 Exemplo do Algoritmo Triângulos
35
36
Exemplo 3: Ler 2 valores inteiros e distintos do teclado e ordená-los.
Quais os passos do Algoritmo que se deseja? Vejamos:
1. Pensemos assim:
a. n1 e n2 serão dados de entrada: inteiros providos pelo usuário ao
algoritmo.
b. maior e menor serão dados de saída: informarão qual o maior e o
menor valor de entrada, respectivamente.
2. Só há duas opções a testar: Ou n1 é o maior dos dois (passo 2.a) ou não é
(passo 2.b).
a. Se (n1 > n2), então maior = n1 e menor = n2.
b. Senão (em caso contrário, n1 < n2), maior = n2 e menor = n1.
3. Imprime os valores menor e maior.
Observação:
1. Os dados de saída menor e maior são necessários? A resposta é: eles foram usados
apenas para facilitar a legibilidade do algoritmo.
Vejamos o Algoritmo em Linguagem Natural:
a. Início do Algoritmo
1. Ler valores para n1 e n2.
2. Se n1 > n2, então:
1. atribuir n1 a maior e n2 a menor.
3. Senão:
1. atribuir n2 a maior e n1 a menor.
4. Imprimir os valores menor e maior.
b. Fim do Algoritmo
A Figura 1.23 ilustra o Fluxograma do algoritmo proposto.
Início
n1, n2
V
n1 > n2
F
maior = n2
menor = n1
maior = n1
menor = n2
menor,
maior
Fim
Figura 1.23 - Fluxograma: Ordenar 2 números
www.edeyson.com.br
Exemplo 4: Imprimir o número 5 dez vezes.
A solução deste problema cai no que chamamos de repetição. Devemos repetir a
impressão do número 5 dez vezes. Uma solução trivial, embora pouco eficiente, seria:
Início do Algoritmo
1. Imprimir o número
Fim do Algoritmo
5
5
5
5
5
5
5
5
5
5
O algoritmo proposto acima está correto e faz o que se pede. Porém, como seria a
solução caso se deseje imprimir o número 5 um milhão de vezes? O algoritmo terá um
milhão de linhas? A solução ideal é usar a linguagem natural para informar a repetição
de algo, como segue:
1. Repetir 10 vezes
a. Imprimir o número 5
Fim do Algoritmo
Note que um laço Repetir comandos N vezes (comandos pode ser um único comando
ou um bloco com vários comandos) pode ser criado assim num Fluxograma:
1. Cria-se uma variável de controle iniciada com 1.
2. Testa-se se a variável de controle é menor ou igual a N. (Pois a repetição
será de N vezes).
3. Executa-se o comando ou bloco de comandos.
4. Incrementa-se a variável de controle.
5. Volta-se ao passo 2 (esta volta é que constrói o laço).
Vejamos isso no Fluxograma ilustrado na Figura 1.24.
37
38
Início
Conta é a
variável de
controle
Este teste controla
quantas vezes o
laço será executado
Conta = 1
Conta <= 10
F
Fim
V
5
Conta = Conta
+1
O incremento em 1
garante
que Conta mude de
valor
Figura 1.24 - Fluxograma: Imprimir o número 5 dez vezes
Exemplo 5: Imprimir todos os números naturais entre 1 e N.
A solução deste problema necessita de um laço de repetição. Devemos repetir a
impressão de um número contido no intervalo [1, N]. Uma solução possível é:
a. Ler N
b. Faça a variável valor variar entre todos os valores no intervalo [1 e N]
i.
Imprima valor
Fim do Algoritmo
Note que necessitaremos novamente de um laço Faça algo N vezes (algo aqui será a
impressão de um número natural). O problema é bem parecido com o anterior, pois
inicia em 1 e varia até N. Logo, vamos à mesma solução:
1. Cria-se uma variável de controle iniciada com 1.
2. Testa-se se a variável de controle é menor ou igual a N, pois se desejam os
números entre 1 e N, inclusive.
3. Imprime-se o valor da variável de controle, pois ela será o próprio número no
intervalo.
4. Incrementa-se a variável de controle em 1, pois tem-se uma sequência de
números naturais.
5. Volta-se ao passo 2 (esta volta é que constrói o laço).
www.edeyson.com.br
Uma revisão do algoritmo em linguagem natural é a seguinte:
a. Leia um valor inteiro para N
b. Faça valor igual a 1
c. Enquanto valor <= N Faça:
i. Imprima valor
ii. valor = valor + 1
2. Fim do Algoritmo
Vamos testar o Algoritmo e seus passos:
1. Ler N – suponha que N seja 5
2. Faça a variável valor variar entre todos os valores no intervalo [1 e 5] –
logo, valor assumirá os seguintes valores {1, 2, 3, 4, 5}
3. Serão impressos os valores 1, 2, 3, 4, 5
4. Quando valor for igual a 6 o teste (valor <= N) falha, pois N=5.
Início
n
valor = 1
valor <= n
N
Fim
V
valor = valor + 1
valor
Figura 1.25 - Fluxograma: Números naturais entre 1 e N
Notem que neste fluxograma há um Laço de repetição de N vezes. O controle do laço é
feito no teste (valor <= n), ou seja, valor inicia com 1 e varia até n. O teste garante que
valor não será maior que n. Se valor for menor ou igual a n, imprime-se o valor e
soma-se um a ele para que este assuma o próximo número no intervalo [1, N].
39
40
Exemplo 6: Determinar todos os divisores naturais de um número natural N.
O objetivo do algoritmo proposto é: dado um valor inteiro N qualquer, imprimir
todos os seus divisores.
Por exemplo, supondo N = 12, como saber seus divisores? Uma solução é testar
todos os números entre 1 e 12. O teste é para saber se algum destes números
divide 12, ou seja, se o resto da divisão de 12 por cada um deles é zero.
Observação:
1. Cabe lembrar que A é divisor de N se o resto da divisão de N por A é zero.
2. Em muitas linguagens de programação este teste é feito pela operação MOD. Se N
MOD A = 0, então A divide N.
a. Ler N
b. Faça a variável Divisor variar entre todos os valores no
intervalo [1 e N]
c. Para cada valor de Divisor faça:
1. Atribua à variável Resto o resto da divisão de N por
Divisor.
2. Se Resto = 0, então imprima o valor de Divisor
2. Fim do Algoritmo
Veja que a letra c do algoritmo faz com que todos os números entre 1 e N sejam
testados. Outra forma de escrever o algoritmo, mais próximo da programação, é:
a. Leia um valor inteiro para N
b. Faça Divisor igual a 1
c. Enquanto Divisor <= N Faça
i. Resto = N MOD Divisor
ii. SE (Resto = 0) ENTÃO
1. Imprima Divisor
iii. Divisor = Divisor + 1
2. Fim do Algoritmo
Note que o passo b do algoritmo (Faça a variável Divisor variar entre todos os valores
no intervalo [1 e N]) é destacado no fluxograma, ilustrado na Figura 1.26.
www.edeyson.com.br
Início
N
Divisor = 1
F
Divisor <= N
Fim
V
Resto = resto da divisão
de N por Divisor
Resto = 0
V
Divisor
F
Divisor =
Divisor + 1
Figura 1.26 - Fluxograma: Divisores naturais de N
41
42
2
A LINGUAGEM PASCAL
A linguagem Pascal foi desenvolvida no início da década de 1970 por Nicklaus Wirth,
na Universidade Técnica de Zurique, Suíça. O primeiro compilador para a linguagem
foi disponibilizado em 1970.
O objetivo do Pascal é ser uma linguagem de programação de alto nível voltada ao
ensino da programação estruturada. Por ser simples, é ideal para a introdução à
programação.
2.1 Estrutura de um Programa Pascal
Todo programa em Pascal é dividido em três áreas distintas: cabeçalho, área de
declarações e corpo.
cabeçalho
área de declarações
corpo
2.1.1 Cabeçalho
O cabeçalho é uma área utilizada para que se possa identificar um programa através de
um nome (instrução program).
{Sintaxe:}
program nomeDoPrograma;
Exemplo:
program adicionaNumeros;
www.edeyson.com.br
A LINGUAGEM PASCAL
área de declarações
corpo
Observações:
1. O nome de um programa é um identificador e deve ser único neste.
O programa da Listagem 1.1, chamado de adicionaNumeros, iniciaria assim:
1. program adicionaNumeros;
2. {Programa que lê 2 números e imprime sua soma.}
Listagem 2.1 - Cabeçalho de programa Pascal.
Note que no trecho de programa da Listagem 2.1 anterior, a linha 2 apresenta um
comentário, pois o texto está entre { }. A linha 1 usa a instrução program para dar
nome ao programa. No caso, adicionaNumeros.
Observações:
1. Nossos programas sempre aparecerão em caixas como a da Listagem 1.1.
2. O uso de { } serve para definir comentários: descrições ou informações, em texto livre,
que auxiliem no entendimento do código.
2.1.2 Área de Declarações
A Área de Declarações de um programa é utilizada para criar identificadores que não
sejam predefinidos.
Toda variável (dado de entrada, temporário ou de saída) que quisermos usar num
programa precisa ser identificado por um nome único. Um cuidado que se deve ter é que
Pascal reserva alguns nomes como integer, real, boolean, etc.
Observação:
1. O uso de variáveis e sua nomenclatura serão detalhados durante o texto.
A área de declarações pode ser subdividida em sete subáreas: uses, label, const, type,
var, procedure e function.
43
44
Utilização de Units
As units são conjuntos de funções que já estão prontas para serem usadas pelo
programador. Por exemplo, se quisermos limpar a tela ou ler o teclado já existem
funções prontas para isso nas units, evitando o trabalho de reescrevê-las. São elas:
1. CRT: possui a maior parte das rotinas e variáveis de geração de som, controle
de vídeo e teclado;
2. DOS: possui as rotinas que envolvem a utilização do sistema operacional;
3. GRAPH: possui rotinas destinadas a manipulações gráficas;
4. OVERLAY: possibilita gerenciar as atividades de um programa economizando
memória;
5. PRINTER: permite declarar um arquivo tipo texto com o nome LST e associálo à impressora;
6. SYSTEM: possui a maior parte das rotinas padrão da linguagem Pascal e é
usada de forma automática.
Para se fazer uso de units é necessário o uso da instrução uses antes da declaração da
instrução var.
{Sintaxe:}
uses nomeDaUnidade;
Nosso programa continuaria como apresenta a Listagem 1.2.
1. program adicionaNumeros;
2. {Programa que lê 2 números e imprime sua soma.}
3.
4. {Usa a biblioteca CRT onde está a função ReadKey; esta serve para ler
uma tecla digitada pelo usuário}
5. uses crt;
Listagem 2.2 – Utilização de Unit.
Note que no programa da Listagem 2.2 as linhas 2 e 4 apresentam comentários, pois
estão entre { }.
A linha 1 usa a instrução program para dar nome ao programa (adicionaNumeros). A
linha 5 usa a instrução uses para habilitar as funções da biblioteca CRT.
www.edeyson.com.br
A LINGUAGEM PASCAL
Observações:
1. Na Listagem 1.2, as linhas 2 e 4 apresentam comentários.
2. Comentários são textos livres, escritos dentro do código-fonte para explicar e
detalhar algo. Não são compilados e não contam como linha de código – LOC (Line
of Code).
Declaração de Variáveis
Nos problemas comuns da matemática e física nos deparamos com variáveis – símbolos
(comumente letras ou nomes) que representam valores ou expressões. Por exemplo,
uma equação do segundo grau2 possui a forma: ax2 + bx + c. Logo, são exemplos de
equação do segundo grau: x2 + 2x + 1 e 2x2 + 3x + 4.
Cabe-nos observar que as equações do 2º grau variam, entre si, sempre num aspecto: os
valores de a, b e c. Para a matemática, a, b e c são constantes (coeficientes), pois a
equação 2x2 + 3x + 4 já tem tais valores definidos (a = 2, b = 3 e c = 4).
Para a programação, se quisermos montar uma equação do segundo grau a partir da
fórmula ax2 + bx + c, precisamos saber a parte que varia entre elas, ou seja, as
variáveis para o algoritmo: a, b e c. Pode-se afirmar que a, b e c serão dados de entrada
do algoritmo e as raízes (x’ e x’’), os de saída.
Da mesma forma, na física temos a equação da velocidade na forma: v = vo + at2.
Para sabermos a velocidade final de um corpo, precisamos conhecer os valores das
variáveis: velocidade inicial (vo), aceleração (a) e tempo (t).
Sempre que tivermos um problema a resolver num mesmo domínio de aplicação, o que
mudar entre um problema e outro similar são variáveis para o algoritmo.
Para a programação, variáveis são áreas de memória que possuem nome e podem
armazenar valores de tipos predeterminados. Assim, um programador pode criar uma
variável média, do tipo real, e ela pode armazenar valores reais durante a execução do
programa. Onde a variável média será alocada na memória cabe ao Sistema Operacional
saber (e a apenas ele).
Observações:
1. É muito mais fácil recordar o nome de uma variável que seu endereço na
memória.
2. Por exemplo, se uma máquina tem 4GB de memória, teremos endereços
possíveis entre 0 e 4294967296. É mais fácil lembrar-se do nome média que do
endereço 2134567112.
3.
2
Toda equação da forma ax² + bx + c = 0, em que a, b e c são números reais com a ≠ 0, é chamada de
equação do 2° grau. Quando b = 0 ou c = 0 tem-se uma equação do 2º grau incompleta.
45
46
Para a solução de problemas como os citados são necessárias variáveis declaradas num
programa, o que é feito via a instrução var. Cada variável tem um nome único no
programa (identificador) e um tipo (inteiro, real, lógico, etc).
{Sintaxe:}
var nomeDaVariável
: tipo de dado;
nomeDeOutraVariável : tipo de dado;
Observações:
1. Após o nome de cada variável deve ser utilizado o símbolo dois-pontos ( : ) seguido pelo
tipo de dado que a variável irá receber, seguido de ponto-e-vírgula.
2. Caso as variáveis sejam de mesmo tipo, estas poderão ser relacionadas separadas por
vírgula. Por exemplo: var a, b, c : integer; Isso define as variáveis a, b e c como sendo do
tipo integer (inteira).
Nosso primeiro programa continuaria como apresenta a Listagem 2.3.
1 program adicionaNumeros;
2 {Programa que lê 2 números e imprime sua soma.}
4 {Usa a biblioteca CRT onde está a função ReadKey}
5 uses crt;
7 {Declara a, b e soma como variáveis inteiras}
8 var
9
a, b : integer;
10
soma : integer;
Listagem 2.3 – Declaração de Variáveis.
Note que na Listagem 1.3 a linha 8 apresenta a instrução var iniciando uma área de
declaração de variáveis. A linha 9 define duas variáveis inteiras chamadas a e b e a
linha 10 define uma variável do tipo inteira (integer) chamada soma.
2.2.3 Corpo do Programa
Após o Cabeçalho e a Área de Declarações, temos o programa em Pascal escrito numa
área denominada Corpo do Programa, que tem início com a instrução begin e é
finalizada pela instrução end, seguida do símbolo ponto ( . ). O uso destas instruções
caracteriza o que é chamado de bloco de comandos, como indicado abaixo:
{Sintaxe:}
begin
bloco de comandos;
end.
www.edeyson.com.br
A LINGUAGEM PASCAL
Observações:
1. O corpo do programa pode conter vários blocos de comandos.
Nosso programa continuaria como apresenta a Listagem 1.4.
1 program adicionaNumeros;
2 {Programa que lê 2 números e imprime sua soma.}
4 {Usa a biblioteca CRT onde está a função ReadKey}
5 uses crt;
7 {Declara a, b e soma como variáveis inteiras}
8 var
9
a, b : integer;
10
soma : integer;
12 begin
13
{limpa a tela}
14
clrscr;
16
{escreve na tela (prompt de comandos)}
17
writeln('Insira o valor de a: ');
19
{espera que o usuário digite algo e atribui o que for digitado à
variável a}
20
readln(a);
22
23
writeln('Insira o valor de b: ');
readln(b);
25
26
27
{soma a com b e atribui o resultado a soma}
soma := a + b;
writeln('A soma de ', a, ' com ', b, ' eh ', soma);
29
{para o programa até que alguma tecla seja pressionada}
30
readkey;
31 end.
Listagem 2.4 – Programa que lê 2 números e calcula a soma.
Descrição do primeiro programa exemplo
O objetivo do programa da Listagem 2.4 é efetuar a leitura de dois valores numéricos
(variáveis a e b), fazer a operação de adição entre elas, atribuir o resultado à variável
soma e apresentar o resultado obtido. Destaca-se o seguinte:
1.
2.
3.
4.
O corpo do programa está delimitado pelas linhas 12 (begin) e 31 (end.).
A linha 14 apresenta uma instrução (clrscr) usada para limpar a tela.
As linhas 17, 22 e 27 usam uma instrução (writeln) para imprimir na tela.
As linhas 20 e 23 usam uma instrução (readln) para ler um valor do teclado
e associar a uma variável.
5. A instrução da linha 30 (readkey) para o programa até que algo seja
teclado.
47
48
Outra forma de representar o algoritmo adicionaNumeros é usando a Linguagem
Natural, como segue:
1. Início do Algoritmo adicionaNumeros
a. Declarar as variáveis a, b e soma;
b. Solicitar ao usuário para inserir o valor de a;
c. Ler um valor para a variável a;
d. Solicitar ao usuário para inserir o valor de b;
e. Ler um valor para a variável b;
f. Efetuar a soma das variáveis a e b, colocando o resultado na
variável soma;
g. Apresentar o valor resultante da variável soma;
h. Aguardar até que algo seja pressionado.
2. Fim do Algoritmo adicionaNumeros.
O fluxograma que representa o algoritmo adicionaNumeros está representado na Figura 2.1.
Início
Insira o valor
de a:
a
Insira o valor
de b:
b
soma = a + b
Fim
'A soma de ',
a, ' com ', b, '
eh ', soma
Figura 2.1 - Fluxograma: Soma de a e b.
Observações:
1. Os comandos read e readln são responsáveis por entrada de dados, como leitura pelo
teclado.
a. ReadLn(var) lê um valor do teclado e atribui à variável var.
b. O programa fica parado até que a tecla ENTER seja pressionada. Tudo o que
for digitado antes de ENTER será colocado na variável (var).
2. Os comandos write e writeln são responsáveis por saída de dados, como impressão na
tela.
a. WriteLn(var) imprime o valor da variável (var) na tela.
3. O uso de LN (acrônimo para New Line – Nova Linha) indica que uma nova linha deve ser
usada após o comando.
www.edeyson.com.br
A LINGUAGEM PASCAL
Vamos a outro exemplo comentado que serve para calcular a média aritmética de 3
valores. Ele deve ler três variáveis numéricas (a, b e c) e calcular a média aritmética
destas, apresentando o resultado obtido.
Algoritmo usado em Linguagem Natural:
1. Início do Algoritmo Média de 3 Números
a. Solicitar ao usuário para digitar o valor da variável a;
b. Ler um valor para a variável a;
c. Solicitar ao usuário para digitar o valor da variável b;
d. Ler um valor para a variável b;
e. Solicitar ao usuário para digitar o valor da variável c;
f. Ler um valor para a variável c;
g. Calcular a média como a soma de a, b e c dividida por 3.
h. Imprimir os três valores lidos e a média.
2. Terminar o Algoritmo Média de 3 Números.
O fluxograma que ilustra o Algoritmo |Média de 3 Números está ilustrado na Figura 2.2
a seguir:
Início
Digite o valor
de a:
a
Digite o valor
de b:
b
Digite o valor
de c:
Fim
'A media entre
', a, ', ', b, ' e ',
c, ' eh: '
média = (a + b +
c) / 3
c
Figura 2.2 - Fluxograma: Média de 3 números.
A implementação do Algoritmo Média de 3 Números é apresentada na Listagem 2.5.
49
50
1 {O programa deve ler 3 variáveis inteiras, calcular a media
aritmética e atribuir a uma variável media.
2 Qual deve ser o tipo da variável media? Por quê?
3 }
4 program media3N;
6 uses crt;
8 var
9
a, b, c : integer;
10
media : real;
12 begin
13
writeln('Digite o valor de a: ');
14
readln(a);
16
17
writeln('Digite o valor de b: ');
readln(b);
19
20
writeln('Digite o valor de c: ');
readln(c);
22
23
24
media := (a + b + c) / 3;
write('A media entre ', a, ', ', b, ' e ', c, ' eh: ');
writeln(media:3:2);
26
readkey;
27 end.
Listagem 2.5 - Programa que lê 3 variáveis e calcula a média.
No programa da Listagem 2.5 destaca-se o seguinte:
1. O cabeçalho do programa está entre as linhas 1 e 4.
2. As declarações do programa estão entre as linhas 8 e 10.
3. O corpo do programa está delimitado pelas linhas 12 e 27.
4. As linhas 13, 16, 19, 23 e 24 usam instruções – writeln e write – para
imprimir na tela.
5. As linhas 14, 17 e 20 usam uma instrução para ler os valores de a, b e c,
respectivamente.
6. Na linha 22 calcula-se a média aritmética de a, b e c, atribuindo-a à variável
media.
7. A linha 24 imprime a média formatada com 3 dígitos decimais e 2
decimais. Por isso a variável media é seguida por :3:2, respectivamente.
Observações:
1. A variável media precisa ser real, pois a divisão de inteiros nem sempre é um inteiro. Por
exemplo, 7/3.
2. O uso de media:3:2 na impressão significa que o resultado será formatado com 3
dígitos antes da vírgula e 2 dígitos depois.
www.edeyson.com.br
A LINGUAGEM PASCAL
Identificadores
A memória do computador pode ser abstraída como um enorme armário de gavetas,
onde cada gaveta possui uma identificação numérica única, sequencial, e só pode
armazenar um caractere (alfanumérico) ou um número entre 0 e 255, como ilustra a
Figura 2.3, que representa uma memória com 1024 posições (bytes).
Figura 2.3 – Abstração de memória.
As máquinas modernas trabalham com bilhões de bytes de armazenamento, o que torna
difícil memorizar o endereço de cada elemento armazenado. Para facilitar o trabalho do
programador, cada região de memória que armazene algo pode receber um nome identificador.
Os identificadores servem para definir variáveis, constantes, tipos de dados,
procedimentos e funções e estes precisam de um nome que forneça uma identificação
única.
Nomes (identificadores) em Pascal devem seguir as seguintes regras de construção:
1. Iniciar sempre por uma letra (a - z, A - Z) ou um sublinhado (_);
2. O restante do identificador deve conter apenas letras, sublinhado ou dígitos (09). Não pode conter outros caracteres; e
3. Pode ter qualquer tamanho, desde que os primeiros 63 caracteres sejam
significativos.
Não existe distinção entre letras maiúsculas e minúsculas no nome de um
identificador. Por exemplo, os nomes ALPHA, alpha e Alpha são equivalentes para o
Pascal.
Observações:
1. CamelCase é a denominação em inglês para a prática de escrever palavras compostas,
ou frases, onde cada palavra é iniciada com Maiúsculas e unidas sem espaços.
a. É um padrão largamente utilizado em diversas linguagens de programação,
como Java, Ruby e Python.
b. Exemplos: NomeDoCliente, TipoDePeça, MediaPonderada, MediaDe3Numeros.
51
52
Palavras Reservadas
Pascal reconhece certo grupo de palavras como sendo reservadas. Elas têm
significado especial e não podem ser usadas como identificadores em um programa
para objetos criados pelo programador.
São elas: absolute, and, array, asm, begin, case, const, constructor, destructor, div, do,
downto, else, end, file, for, function, goto, if, implementation, in, inherited, inline,
interface, label, mod, nil, not, object, of, on, operator, or, packed, procedure,
program, record, reintroduce, repeat, self, set, shl, shr, string, then, to, type, unit,
until, uses, var, while, with, xor.
Comentários
Comentários são textos escritos dentro do código-fonte para explicar ou descrever
alguns aspectos relativos ao mesmo ou para esclarecer detalhes de programação que
podem não ficar claros. Seu principal objetivo é adicionar informação textual ao código,
facilitando seu entendimento por leitores.
A sintaxe requerida aos comentários permite o uso de chaves como em: {
comentário } ou de parêntesis e asteriscos, como em: (* comentário *).
2.1 Variáveis
Uma variável é uma região da memória, identificada através de um nome, cujo valor
pode mudar durante a execução do programa. Como Pascal é uma linguagem fortemente
tipada, cada variável precisa obrigatoriamente de um tipo de dados predeterminado
(informando se é inteiro, real, caractere, texto, etc.).
{Sintaxe:}
var
variável : tipo de dado;
variável1, variável2 : tipo de dado2;
Nesta especificação de sintaxe, variável tem seu tipo definido por tipo de dado. Note
que variável1 e variável2 são definidas juntas, separadas por vírgulas e atribuindo-lhes
um único tipo de dados. Isso pode ser feito para qualquer número de variáveis que
compartilhem um mesmo tipo de dados.
www.edeyson.com.br
A LINGUAGEM PASCAL
2.2 Constantes
Uma constante é uma região rotulada da memória através de um nome cujo valor não
pode mudar durante a execução do programa. Um exemplo de uso de constantes em
programas é o uso de π (3,1415926...) para aplicações da matemática.
{Sintaxe:}
const
nomeDaConstante = expressão;
2.3 Tipos de Dados
Um tipo de dado especifica as características, ou seja, quais os possíveis valores e
operações que um dado possui. Por exemplo, um valor inteiro pode ser somado a outro,
subtraído, multiplicado, etc.
Variáveis, como apresentado em sua sintaxe, requerem um tipo de dado em sua
definição.
A linguagem Pascal fornece ao programador um conjunto de tipos de dados
predefinidos e que serão descritos a seguir.
Inteiros
Inteiros são valores numéricos positivos ou negativos, excluindo-se qualquer número
fracionário. Em Pascal, este tipo de dado pode ser referenciado por um dos seguintes
identificadores: Byte, Shortint, Smallint, Word, Integer, Cardinal, Longint,
Longword, Int64 e QWord.
Tabela 2.1 – Tipos Inteiros
Tipo
Valores
Byte
Shortint
Smallint
Word
Integer
Cardinal
Longint
Longword
Int64
0..255
-128 .. 127
-32768 .. 32767
0 .. 65535
Smallint ou Longint
Longword
-2147483648 .. 2147483647
0 .. 4294967295
-9223372036854775808 ..
9223372036854775807
0 .. 1844674473709551615
QWord
Tamanho
em Bytes
1
1
2
2
2 ou 4
4
4
4
8
8
A Tabela 2.1 apresenta o nome de cada tipo, quantos bytes necessitam para ser
armazenados e seus limites de valores.
53
54
Retornando à memória do computador, seus endereços são sequenciais e contíguos.
Assim, a declaração da variável alfa do tipo Longint vai reservar 4 bytes na memória e
associar ao nome alfa apenas o primeiro deles.
Figura 2.4 – Alocação de variáveis.
Desta forma, se a variável alfa for alocada no endereço n+2, ele e os 3 próximos (4
bytes contíguos) ficam reservados para armazenar seu valor, mas alfa fica associada
apenas ao primeiro endereço (n+2).
A definição de variáveis inteiras é feita com a seguinte sintaxe:
{Sintaxe:}
variável : integer;
O Fluxograma da Figura 2.5 apresenta um exemplo de uso de Inteiros baseado na
segunda lei de Newton, que determina a relação entre força, massa e aceleração: Força
= massa * aceleração. Conhecidas a massa e a aceleração, qual a força, em newtons?
Início
massa = 100
aceleracao = 2
forca = massa * aceleracao
'A forca eh: ',
forca
Fim
Figura 2.5 – Fluxograma do programa InteirosEmPascal.
A implementação do algoritmo do fluxograma da Figura 2.5 está na Listagem 2.6,
descrito a seguir.
www.edeyson.com.br
A LINGUAGEM PASCAL
1 program InteirosEmPascal;
2 {Este programa vai demonstrar o uso de Inteiros em Pascal.}
4 uses crt;
6 var
7
forca : integer;
8
massa, aceleracao : integer;
9 begin
10
massa := 100;
11
aceleracao := 2;
12
forca := massa * aceleracao;
13
writeln ('A forca eh: ', forca);
14
readkey;
15 end.
Listagem 2.6 – Exemplo de uso de Inteiros
1. Na linha 7 declara-se a variável forca do tipo integer.
2. A linha 8 apresenta a declaração de duas variáveis inteiras: massa e
aceleração. Embora as três variáveis pudessem ter sido declaradas numa
única linha, optou-se por duas declarações separadas para exemplificação.
3. Na linha 10 atribui-se o valor 100 à variável massa, enquanto na linha 11
atribui-se 2 à variável aceleração.
4. Na linha 12 atribui-se à variável forca o produto entre massa e aceleração.
5. A linha 13 imprime o valor resultante da forca.
A execução do programa imprimirá:
A forca eh: 200
Reais
O tipo de dado real permite trabalhar com números fracionários, tanto positivos como
negativos, sendo sua capacidade de armazenamento maior que dos números inteiros.
Vejamos os tipos: Real, Single, Double, Extend, Comp e Currency.
Tabela 2.2 - Tipos Reais
Tipo
Valores
Real
Single
Double
Extended
Comp
Currency
Depende da Plataforma
1.5E-45 .. 3.4E38
5.0E-324 .. 1.7E308
1.9E-4932 .. 1.1E4932
-2E64+1 .. 2E63-1
Dígitos
Signific.
7-8
15-16
19-20
19-20
A definição de variáveis reais é feita com a seguinte sintaxe:
Tamanho
em Bytes
4 ou 8
4
8
10
8
55
56
{Sintaxe:}
variável : real;
O Fluxograma da Figura 2.7 representa o algoritmo que calcula a massa de um corpo
sabendo-se a força aplicada ao mesmo e sua aceleração. Como a massa é calculada pela
razão entre força e aceleração (massa = força / aceleração), seu resultado pode resultar
num número não inteiro. Assim, um tipo real é requerido.
Início
forca = 235
aceleracao = 2
massa = forca / aceleracao
‘A massa eh:
', massa:3:2
Fim
Figura 2.6 – Fluxograma do programa ReaisEmPascal.
A implementação do algoritmo do fluxograma da Figura 2.6 está na Listagem 2.7,
descrito a seguir.
1 program ReaisEmPascal;
2 {Este programa vai demonstrar o uso do tipo Real em Pascal.}
4 uses crt;
6 var
7
forca : real;
8
massa, aceleracao : real;
9 begin
10
forca := 235;
11
aceleracao := 2;
12
massa := forca / aceleracao;
13
writeln ('A massa eh: ', massa:3:2);
14
readkey;
15 end.
Listagem 2.7 – Uso de Reais em Pascal
1. Na linha 7 declara-se a variável forca do tipo real.
www.edeyson.com.br
A LINGUAGEM PASCAL
2. A linha 8 apresenta a declaração de duas variáveis reais: massa e aceleração.
Embora as três variáveis pudessem ter sido declaradas numa única linha,
optou-se por duas declarações separadas para exemplificação.
3. Na linha 10 atribui-se o valor 235 à variável forca, enquanto na linha 11
atribui-se 2 à variável aceleração.
4. Na linha 12 atribui-se à variável massa a razão entre forca e aceleração.
5. A linha 13 imprime o valor resultante da massa.
A massa eh: 117.50
Observações:
1. Write e WriteLn permitem que sejam definidos formatos aos números.
a. Estes formatos são úteis na impressão de números reais para evitar a forma
com exponenciação.
b. O formato é: numero:tamanho:precisão
i. numero é o número que se quer imprimir.
ii. tamanho informa a largura da saída.
iii. precisão informa com quantos dígitos o numero será impresso.
Caracteres
String
Strings são sequências contendo letras, números e símbolos especiais e devem ser
representadas entre delimitadores (apóstrofos, em Pascal). Este tipo de dado é
referenciado pelo identificador string, podendo armazenar de 1 até 255 caracteres.
Retornando à memória do computador, uma string, assim como os demais tipos
primitivos, ocupa endereços contíguos na memória. Logo, a declaração da variável
nome do tipo String precisa reservar tantos bytes quanto for o seu tamanho. Por
exemplo: suponha a variável nome do tipo string e que seu valor seja ‘Edeyson’.
Necessitam-se de 7 bytes contíguos de memória para armazenar a variável nome.
Figura 2.7 – Alocação de Strings.
57
58
Supondo que na memória representada na Figura 2.7 a variável nome esteja no
endereço n+2 (note que há 7 bytes contíguos reservados para isso) de memória e a
variável alfa, do tipo Longint, esteja no endereço n+9, o que acontecerá se mudarmos o
valor de nome para ‘Edeyson Gomes’? O novo valor de nome necessita de mais 6
bytes contíguos. Ressalta-se que os 4 bytes iniciados em n+9 já estão reservados.
A solução usada pelo gerenciamento de memória é mudar nome de lugar, encontrando
um espaço contíguo livre que o caiba, alterando seu endereço. Logo, alterar o conteúdo
de uma String, aumentando sua quantidade de caracteres, leva a uma movimentação
daquela na memória, mudando o endereço da variável. O ponto positivo disso é que é
totalmente transparente ao programador.
Para definir uma variável do tipo string, cujo conteúdo pode ter até 255 caracteres, usase a seguinte sintaxe:
{Sintaxe:}
variável : string;
Como a sintaxe anterior não especifica um tamanho, a variável definida sempre ocupará
255 bytes na memória, pois o Pascal na tem como saber quantos bytes realmente serão
necessários.
Para o caso de variáveis string que o programador conheça o tamanho máximo, pode-se
usar a seguinte sintaxe para determiná-lo:
{Sintaxe:}
variável : string[tamanho];
O uso de colchetes determina que a variável tenha um conteúdo de até tamanho
caracteres. A Listagem 2.3 apresenta um exemplo de uso de Strings.
1 program StringsEmPascal;
2 {Este programa vai demonstrar o uso de String em Pascal.}
4 uses crt;
6 var
7
endereco : string;
8
nome : string[30];
9
CPF : string[11];
{endereço é uma cadeia com 0 a 255 caracteres.}
{O uso de [] delimita o número de caracteres.
Neste caso CPF tem 11 caracteres.}
11 begin
12
endereco := 'Rua dos Alferes, 1234, Ap. 1001, Barra, Salvador, Bahia CEP: 40.130.280';
13
nome:= 'Jose da Silva Santos';
14
CPF := '12345678901';
15
writeln('Endereco: ', endereco, ' Cliente: ', nome, ' CPF: ', cpf);
16
readkey;
17 end.
www.edeyson.com.br
A LINGUAGEM PASCAL
Listagem 2.3 – Exemplo com Strings
No programa da Listagem 8 destaca-se o seguinte:
1. Na linha 7 declara-se a variável endereco que terá até 255 caracteres (é o
limite máximo de uma string),
2. A linha 8 apresenta a declaração da variável nome que terá, no máximo, 30
caracteres.
3. A linha 8 apresenta a declaração da variável CPF que terá, no máximo, 11
caracteres.
4. Na linha 12 atribui-se um valor à variável endereço. Note que atribuição de
string requer o uso de apóstrofos.
5. A linha 15 faz-se a impressão das três variáveis e seus valores.
Endereco: Rua dos Alferes, 1234, Ap.
1001, Barra, Salvador, Bahia - CEP:
40.130.280 Cliente: Jose da Silva
Santos CPF: 12345678901
Observações:
1. Write e WriteLn permitem imprimir múltiplos valores separando-os por vírgulas.
a. A impressão de constantes string é feita colocando-as entre apóstrofos.
b. O comando writeln('Endereco: ', endereco); imprimirá Endereco: seguido pelo
valor da variável endereco.
59
60
Char
Pascal suporta o tipo Char, que ocupa exatamente 1 byte e contém um caractere ASCII
(American Standard Code for Information Interchange). Para definir uma variável do
tipo char usa-se a seguinte sintaxe:
{Sintaxe:}
variável : char;
A Listagem 2.4 apresenta um exemplo de uso de char.
1 program CharEmPascal;
2 {Este programa vai demonstrar o tipo Char do Pascal}
3
4 uses crt;
5
6 var
7
letraAMinuscula, letraAMaiuscula : char;
8
letraBMinuscula, letraBMaiuscula : char;
9
sexo : char;
{char representa um único caracter. Neste caso
sexo pode ser 'M' ou 'F'}
10
11 begin
12
{Atribuições de valores às variáves}
13
sexo := 'M';
14
letraAMinuscula := 'a';
15
letraAMaiuscula := #65;
16
17
letraBMinuscula := #98;
18
letraBMaiuscula := 'B';
19
20
writeln('Sexo: ', sexo);
21
writeln('Letras Maiusculas: ', letraAMaiuscula, letraBMaiuscula);
22
writeln('Letras Minusculas: ', letraAMinuscula, letraBMinuscula);
23
readkey;
24 end.
Listagem 2.4 – Exemplo com Char
Nas linhas 7, 8 e 9 definem-se variáveis do tipo char.
Um caractere pode ser especificado colocando-o entre delimitadores (apóstrfos), como
'a' ou 'B', por exemplo, nas linhas 14 e 18. Também pode ser especificado pelo seu valor
de caracteres (normalmente um código ASCII), precedendo o valor ordinal com o
símbolo (#). Por exemplo, na linha 15, especificando #65 é o mesmo que 'A'. O
resultado da execução do programa é:
Sexo: M
Letras Maiusculas: AB
Letras Minusculas: ab
www.edeyson.com.br
A LINGUAGEM PASCAL
Tipos Lógicos
No Capítulo 1 apresentamos o símbolo de fluxograma para decisão usado sempre que é
necessária a avaliação de uma condição (que pode ser Verdadeira ou Falsa) para uma
tomada de decisão: a escolha de um dos caminhos possíveis à sequência de ações.
Comumente, as linguagens de programação apresentam o tipo Boolean, com dois
possíveis valores predefinidos: true e false. Qualquer expressão que resulte em um
valor booleano (verdadeiro ou falso) também pode ser atribuída a um tipo booleano.
Para definir uma variável do tipo boolean usa-se a seguinte sintaxe:
{Sintaxe:}
variável : char;
A Listagem 2.5 apresenta exemplos de uso do tipo boolean.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
program BooleanEmPascal;
{Este programa vai demonstrar o tipo boolean do Pascal}
uses crt;
var
aprovado : boolean; {Variáveis lógicas - podem ser TRUE ou FALSE}
maior, menor, igual : boolean;
begin
aprovado := true;
{Atribui TRUE a aprovado}
maior := 2 > 1;
{Atribui o resultado do teste: 2 > 1? a maior}
igual := 2 = 1;
{Atribui o resultado do teste: 2 > 1? a igual}
menor := 2 < 1;
{Atribui o resultado do teste: 2 > 1? a menor}
writeln('Aprovado: ', aprovado);
writeln('2 > 1? eh: ', maior);
writeln('2 = 1 eh: ', menor);
writeln('2 = 1 eh: ', igual);
readkey;
end.
Listagem 2.5 – Exemplo com Boolean
O resultado da execução do programa é:
Aprovado: TRUE
2 > 1? eh: TRUE
2 = 1 eh: FALSE
2 < 1 eh: FALSE
61
62
A linha 11 atribui diretamente o valor TRUE à variável aprovado. As linhas 12 a 14
atribuem o valor lógico do teste às variáveis maior, igual e menor.
Note que uma atribuição tem duas partes: uma antes do := e outra depois. No caso da
linha 12 estamos atribuindo à variável maior o resultado da expressão que avalia se 2 é
maior que 1, o que é verdade (TRUE). As linhas 13 e 14 seguem o mesmo princípio,
atribuindo a igual e a menor o resultado dos respectivos testes lógicos.
A Listagem 2.6 a seguir apresenta um exemplo com variáveis e constantes que serve
para calcular a área de um círculo com a fórmula πR2, onde R representa o raio.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
program VariaveisEConstantes;
{Este programa vai demonstrar variáveis e constantes no Pascal}
uses crt;
var
area, raio : real;
{Declara area e raio como variáveis REAIS}
const
pi = 3.1415926536;
{Declara pi como uma constante}
begin
raio := 10;
area := pi * raio * raio;
writeln('A area do circulo de raio 10 eh: ', area:3:4);
raio := 15;
writeln('A area do circulo de raio 15 eh: ', area:3:4);
{pi := 10;}
readkey;
end.
Listagem 2.6 – Exemplo com Variáveis e Constantes
O programa VariaveisEConstantes declara na linha 7 as variáveis área e raio do tipo
REAL. Como o nome já informa, as variáveis podem mudar de valor durante a
execução do programa, mas as constantes, como pi, não. As linhas 14, 15, 18 e 19
exemplificam isso, mudando os valores de raio e área.
Para um novo valor do raio é calculada a área de um círculo usando-se a fórmula: area =
π * raio2 (calculado como raio * raio).
A constante matemática π é representada no programa pela constante pi, cujo valor é
atribuído na própria declaração, como é visto na linha 10.
O resultado da execução do programa da Listagem 2.6 é:
www.edeyson.com.br
A LINGUAGEM PASCAL
A area do circulo de raio 10 eh: 314.1593
A area do circulo de raio 15 eh: 706.8583
63
64
3
EXPRESSÕES
Expressões são arranjos de operandos (variáveis, constantes ou valores gerados por
funções) e operadores (operações a serem efetuadas sobre os operandos) que ocorrem
nas atribuições ou em testes e produzem um valor de um determinado tipo. Um exemplo
de expressão é: ax2 + bx + c, que em linguagem de programação é representada
comumente como: a*x*x + b*x + c.
Um operador pode ser binário, ou seja, requer 2 operandos (como em X / Y e em A * B)
ou unário, isto é, exige apenas um argumento (como em -X).
Cada tipo de dados possui um conjunto de operadores relacionados. Cada
linguagem traz símbolos para operadores como adição, a subtração, a
multiplicação, a divisão, a potenciação, etc.
3.1 Prioridades das Operações
Se vários operadores aparecerem em uma mesma expressão, sua ordem de execução
(precedência) será dada segundo os seguintes critérios:
1. Pelo emprego explícito de parênteses;
2. Pela ordem de precedência existente entre os operadores; e
3. Se existirem operadores de mesma ordem de precedência, a avaliação será feita
da esquerda para a direita.
Como exemplo do uso de precedência, qual o resultado da expressão: 3 + 2 * 5? A
resposta será 25 ou 13?
Na matemática, a multiplicação precede a soma. Logo, a expressão pode ser lida assim:
3 + (2 * 5), o que resulta em 13. O uso de parêntesis facilita a leitura de expressões com
múltiplos operadores, explicitando sua precedência.
A Tabela 3.1 apresenta a ordem de precedência dos operadores (da maior para a menor):
Tabela 3.1 – Precedência de Operadores
ORDEM DE
OPERADOR
PRECEDÊNCIA
not, @
1
*, /, div, mod, and, shl, shr,
as
+, -, or, xor
2
<, <>, >, <=, >=, in, is
4
3
www.edeyson.com.br
EXPRESSÕES
3.2 Tipos de Expressões
As expressões podem ser divididas em três grupos:

Numérica - quando os operandos e o resultado são numéricos (inteiros ou reais).

Literal - quando os operandos e o resultado são literais do tipo string (não pode
ser char). Só existe um operador para expressões literais: Concatenação ( + ).

Lógica - quando seu resultado é do tipo boolean (TRUE ou FALSE).
3.3 Tipos de Operadores
Existem vários operadores para a realização de expressões em Pascal, como detalhado a
seguir.
Operador de Atribuição
O operador de atribuição é utilizado para atribuir o valor de uma expressão a uma
variável.
{Sintaxe:}
nomeDaVariável := expressão;
A Listagem 3.1 apresenta exemplos de atribuições documentados no código via
comentários.
1 program VariaveisPascal;
2
3 var
4
a, b, c : integer; {Declara a, b e c como variáveis inteiras}
5
media : real;
{Declara media do tipo real}
6
7
endereco : string; {endereço é uma cadeia com 0 a 255 caracteres.}
8
CPF : string[11];
{O uso de [] delimita o número de caracteres.}
9
sexo : char;
{char representa um único caracter.}
10
11 begin
12
13
endereco := 'Rua dos Alferes, 1234, Ap. 1001, Barra, Salvador,
Bahia - CEP: 40.130.280';
14
15
CPF := '12345678901';
16
17
sexo := 'M';
18
a := 7;
19
b := a + 2;
20
c := 8;
21
media := (a + b + c) / 3;
22
readkey;
23 end.
Listagem 3.1 – Operador de Atribuição
65
66
Das linhas 13 a 21, exceto a linha 16, temos atribuições de valores às variáveis de
diversos tipos. Note que o que está após o := é uma expressão.
Operadores Aritméticos
Os operadores aritméticos são utilizados para efetuar operações aritméticas com
números inteiros e reais (e seus subtipos). São eles: Subtração (-), Adição (+) e
Multiplicação (*). São exemplos de expressões onde a, b e c podem ser inteiros ou
reais:
1. a := a * 3;
2. b := 7 + 15;
3. c := 10 – 1;
A (/) é chamada de Divisão Real, pois sempre resultará num número real. Não se pode
garantir que a divisão de dois inteiros resultará num número inteiro, como é o caso da
divisão de 10 por 3.
Por exemplo, suponha uma variável com nome total do tipo real. A expressão
total := 16 / 3 atribuirá como resultado a total o valor 5,3333.
Observações:
1. Suponha que se deseja saber se um número inteiro a é múltiplo de 2. Para isto, necessitase saber o resto da divisão de a por 2. Apenas se o resto for 0, a é múltiplo de 2.
2. Para resolver tal problema, o operador MOD fornece o resto inteiro da divisão.
3. Ainda há o operador DIV para obter a parte inteira da divisão entre inteiros.
Figura 3.1 – Divisão de Inteiro.
A Figura 3.1 ilustra a divisão de um número inteiro a por 2. Assim, as seguintes
expressões retornam o quociente e o resto inteiros da divisão.
1. resto := a MOD 2;
2. quociente := a DIV 2;
A listagem 3.2 apresenta um código que ilustra o uso de DIV e MOD apresentando o
dividendo, divisor, quociente e resto numa divisão inteira e a Listagem 3.3 demonstra
como extrair todos os dígitos de um número com 3 dígitos.
www.edeyson.com.br
EXPRESSÕES
1 program UsoDivMod;
2 {Este programa demonstra o uso de DIV e MOD como operadores de
inteiros.}
3
4 uses crt;
5
6 var
7
dividendo, divisor, quociente, resto : integer;
8
quocienteReal : real;
9
10 begin
11
dividendo := 10;
12
divisor := 3;
13
quociente := dividendo div divisor;
14
quocienteReal := dividendo / divisor;
15
16
resto := dividendo mod divisor;
17
18
writeln('Dividendo: ', dividendo:3, '
Divisor: ', divisor:3);
19
writeln('Quociente: ', quociente:3, '
Resto : ', resto:3);
20
writeln('Quociente Real: ', quocienteReal:3:4);
21
22
readkey; {Para o programa até que algo seja teclado}
23 end.
Listagem 3.2 – Uso de DIV e MOD
Na Listagem 3.2, as linhas 7 e 8 definem as variáveis dividendo, divisor, quociente e
resto como inteiros e quocienteReal como real. Tais variáveis representarão os
elementos numa divisão.
As linhas 11 e 12 iniciam o dividendo com 10 e o divisor com 3. A divisão entre 10 e 3
é uma dízima periódica 3.333, que será o valor de quocienteReal calculado na linha 14.
Pensando-se numa divisão com todos os fatores inteiros, quociente (linha 13) assumirá
o valor 3 e resto (linha 16) assumirá o valor 1. Vale lembrar que 10 dividido por 3 é
igual a 3 com resto 1 (10 = 3 * 3 + 1).
Dividendo: 10
Divisor: 3
Quociente: 3
Resto : 1
Quociente Real: 3.3333
67
68
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
program UsoDivMod2;
{Este programa vai demonstrar o uso de DIV e MOD.}
uses crt; {Usa a biblioteca CRT onde está readkey}
var
numero, centena, dezena, unidade, resto : integer;
{Operações sobre Inteiros: +, -, *, DIV e MOD}
begin {inicia o programa}
numero := 367;
{XYZ = X * 100 + YZ}
centena := numero div 100; {centena = X}
resto := numero mod 100;
{resto = YZ} {YZ = Y * 10 + Z}
dezena := resto div 10;
{dezena = Y}
unidade := resto mod 10;
{unidade = Z}
writeln('Centena: ', centena);
writeln('Dezena: ', dezena);
writeln('Unidade: ', unidade);
readkey; {Para o programa até que algo seja teclado}
end.
{termina o programa}
Listagem 3.3 – Uso de DIV e MOD com Unidade, Dezena e Centena
O objetivo do programa da Listagem 3.3 é apresentar os valores de unidade, dezena e
centena de um número. Na linha 12 atribui-se o valor 367 à variável numero. Note que
367 = 3 * 100 + 67 = (3 * 100) + (6 * 10) + 7.
A linha 13 atribui à variável centena o valor de numero div 100, ou seja, o quociente
inteiro da divisão entre 367 e 100, que resulta em 3.
A linha 14 atribui à variável resto o valor de numero mod 100, o que representa o resto
inteiro da divisão. Como número é igual a 367, resto será 67.
Seguindo o raciocínio do uso de DIV e MOD, a linha 15 atribui 6 a dezena e a linha 16
atribui 7 a unidade.
Centena: 3
Dezena : 6
Unidade: 7
www.edeyson.com.br
EXPRESSÕES
Operador de Concatenação
O operador de concatenação efetua a junção de duas variáveis ou constantes do tipo
string. Por exemplo, suponha as strings nome e sobrenome. Nome armazena
‘Edeyson’ e sobrenome, ‘Gomes’. Como obter uma string com o nome completo?
Variáveis e constantes do tipo string suportam a operação de soma (+) que funciona
com a concatenação (junção).
A Listagem 3.4 exibe um exemplo de concatenação de strings.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
program ConcatenacaoDeStrings;
{Este programa vai demonstrar a Concatenação de Strings em Pascal.}
uses crt;
var
nome
: string[20];
sobrenome
: string[20];
nomeCompleto : string[40];
{Definição de variáveis}
begin
nome := 'Edeyson';
{Atribui Edeyson para a var. nome}
sobrenome:= 'Gomes';
{Atribui Gomes para a var. sobrenome}
nomeCompleto := nome + ' ' + sobrenome;
{Concatena nome,
espaço em branco e sobrenome}
15
writeln('Nome Completo: ', nomeCompleto); {Exibe o nome completo}
16
17
readkey;
18 end.
Listagem 3.4 - Concatenação de Strings
Na Listagem 3.4, as linhas 7, 8 e 9 declaram strings com tamanho fixo. As variáveis
nome e sobrenome só podem armazenar cadeias de caracteres com, no máximo, 20
caracteres. Já a variável nomeCompleto pode armazenar cadeias de até 40 caracteres.
Na linha 12 atribui-se a string ‘Edeyson’ à variável nome. Na linha 13 atribui-se
‘Gomes’ para sobrenome.
Note que na linha 14 faz-se uma operação de concatenação entre strings. Isso significa
que as strings ‘Edeyson’, espaço em branco e ‘Gomes’ serão concatenadas e o
resultado será atribuído à variável nomeCompleto.
O resultado da linha 15 será:
Nome Completo: Edeyson Gomes
69
70
Operadores Relacionais
Os operadores relacionais, apresentados na Tabela 3.2, são utilizados para efetuar a
comparação entre dados de mesmo tipo, por exemplo, se um número inteiro é maior que
outro, se um número real é menor ou igual a outro, se duas strings são iguais, etc.
Tabela 3.2 – Operadores Relacionais
OPERADOR
SÍMBOLO
Maior que
>
Menor que
<
Igual
=
Maior Igual
>=
Menor Igual
<=
Diferente
<>
Exemplo de operadores relacionais:
1 program OperadoresRelacionaisComInteger;
2 {Este programa vai demonstrar Operadores Relacionais
3 uses crt;
4 var
5
valorLogico : boolean; {Variáveis lógicas - podem
6
inteiro1, inteiro2 : integer;
7
8 begin
9
10
inteiro1 := 10;
11
inteiro2 := 20;
12
13
valorLogico := inteiro1 = inteiro2;
14
writeln('Teste se ', inteiro1, ' = ', inteiro2, '
valorLogico);
15
16
valorLogico := inteiro1 < inteiro2;
17
writeln('Teste se ', inteiro1, ' < ', inteiro2, '
valorLogico);
18
19
valorLogico := inteiro1 > inteiro2;
20
writeln('Teste se ', inteiro1, ' > ', inteiro2, '
valorLogico);
21
22
readkey;
23 end.
do Pascal}
ser TRUE ou FALSE}
: ',
: ',
: ',
Listagem 3.5 – Operadores Relacionais com Integer
Na Listagem 3.5 a linha 5 define uma variável valorLogico do tipo boolean, ou seja,
ela só armazena Verdade (TRUE) ou Falso (FALSE). A linha 6 define duas variáveis
inteiras que são inicializadas nas linhas 10 e 11, respectivamente.
A linha 13, valorLogico := inteiro1 = inteiro2, precisa de destaque aos :=, que é o
símbolo de atribuição do Pascal. Este atribui ao símbolo da esquerda do :=, no caso
valorLogico, o valor lógico ou absoluto do que está à direita do símbolo.
A linha 13 é lida assim: o valor do inteiro1 é igual ao valor do inteiro2? Se sim, atribua
TRUE para valorLogico; se não, atribua FALSE.
www.edeyson.com.br
EXPRESSÕES
A linha 14 imprime o resultado do teste lógico. Note que as linhas 16/17 e 19/20 fazem
algo similar às linhas 13/14, apenas mudando o operador relacional.
Teste se 10 = 20 : FALSE
Teste se 10 < 20 : TRUE
Teste se 10 > 20 : FALSE
1 program OperadoresRelacionaisComString;
2 {Este programa vai demonstrar Operadores Relacionais do Pascal}
3 uses crt;
4 var
5
valorLogico : boolean; {Variáveis lógicas - podem ser TRUE ou FALSE}
6
string1, string2 : string;
7
8 begin
9
10
string1 := 'abc';
11
string2 := 'def';
12
13
valorLogico := string1 = string2;
14
writeln('Teste se ', string1, ' eh = a ', string2, ' : ',
valorLogico);
15
16
valorLogico := string1 > string2;
17
writeln('Teste se ', string1, ' eh > que ', string2, ' : ',
valorLogico);
18
19
valorLogico := string1 < string2;
20
writeln('Teste se ', string1, ' eh < que ', string2, ' : ',
valorLogico);
21
22
readkey;
23 end.
Listagem 3.6 – Operadores Relacionais com String
Na Listagem 15, similar a Listagem 14, a linha 5 define uma variável valorLogico do
tipo boolean, ou seja, ela só armazena Verdade (TRUE) ou Falso (FALSE). A linha 6
define duas variáveis do tipo string (cadeias de caracter) que são inicializadas nas
linhas 10 e 11, respectivamente.
A linha 13 é lida assim: o valor da string1 é igual ao valor do string2? Se sim, atribua
TRUE para valorLogico; se não, atribua FALSE.
A linha 14 imprime o resultado do teste lógico. Note que as linhas 16/17 e 19/20 fazem
algo similar às linhas 13/14, apenas mudando o operador relacional. Note que strings
podem ser comparadas com >, <, etc. O resultado da execução do programa da
Listagem 15 é:
71
72
Teste se abc eh = a def : FALSE
Teste se abc eh > que def : FALSE
Teste se abc eh < que def : TRUE
1 program OperadoresRelacionaisComReal;
3 uses crt;
4 var
5
6
real1, real2 : real;
7
8 begin
9
10
real1 := 8/6;
11
real2 := 4/3;
12
13
valorLogico := real1 > real2;
14
writeln('Teste se ', real1:3:4, ' eh > que ', real2:3:4, ' : ',
valorLogico);
15
16
valorLogico := real1 = real2;
17
writeln('Teste se ', real1:3:4, ' eh = a ', real2:3:4, ' : ',
valorLogico);
18
19
valorLogico := real1 < real2;
20
writeln('Teste se ', real1:3:4, ' eh < que ', real2:3:4, ' : ',
valorLogico);
21
22
readkey;
23 end.
Listagem 3.7 – Operadores Relacionais com Reais
A listagem 3.7 é similar a 3.5 e 3.6. Ressaltam-se as linhas 10 e 11 que fazem a
atribuição de números não inteiros às variáveis real1 e real2. Fica como exercício sua
execução e a observação do resultado.
www.edeyson.com.br
EXPRESSÕES
Operadores Lógicos
O Pascal dispõe dos seguintes operadores lógicos: AND (E), OR (OU) e NOT (NÃO,
NEGAÇÃO). Para compreendê-los, vamos fazer uma breve introdução à Lógica.
A lógica é a ciência que estuda a correção do pensamento, do raciocínio. Quando
elaboramos frases como: a) A Lua é maior que a Terra; b) A água do mar é salgada e c)
2 (dois) é o único número primo que é par, podemos determinar a elas um valor lógico
verdadeiro ou falso. Logo, a é falso, b e c são verdadeiros.
Tais frases são chamadas de proposições, pois afirmam fatos, exprimem juízos.
A Lógica Matemática apresenta regras fundamentais do pensamento baseadas em dois
princípios (Axiomas):
a. Princípio da Não Contradição - uma proposição ou é Verdadeira ou é Falsa;
b. Princípio do Terceiro Excluído - toda proposição ou é Verdadeira ou é Falsa apenas esses valores são possíveis.
Nas Listagens 3.5, 3.6 e 3.7 foram elaboradas proposições, por exemplo, em
valorLogico := inteiro1 = inteiro2.
Esta proposição pode ser lida assim: compare o inteiro1 com o inteiro2 e atribua o
resultado assim: verdadeiro se iguais e falso se diferentes.
O valor lógico (verdadeiro ou falso) desta proposição é armazenado na variável
valorLogico e depende dos valores atribuídos a inteiro1 e inteiro2. Como exemplo, se
inteiro1 armazena o valor 10 e inteiro2 armazena o valor 20, valorLogico é FALSO.
As proposições usadas nas Listagens 3.5, 3.6 e 3.7 são ditas Simples ou Atômicas, pois
não contém outra proposição como parte integrante.
Uma proposição é dita Composta quando ela resulta da combinação (via conectivos E
ou OU, por exemplo) de outras proposições. Por exemplo, supondo-se que se queira
saber se um número x pertence ao Intervalo Fechado nos extremos a e b :
x
ϵ [a, b]
={x
ϵ R ; a ≤ x ≤ b }.
Em Pascal necessitamos de uma proposição composta como segue:
valorLogico := (x >= a) AND (x <= b);
Esta proposição é lida da seguinte forma: Teste se x é maior ou igual a a E se x é menor
ou igual a b. Se ambos forem verdade, e apenas neste caso, valorLogico será verdade.
Note o seguinte: supondo o intervalo [1, 5]. Sendo a = 1 e b = 5; se x = 6 o teste 6 >= 1
é verdade, mas 6 <= 5 é falso, logo x = 6 não pertence ao intervalo [1, 5]. Por isso o
valorLogico neste caso é falso.
Uma proposição composta com conectivos AND só é verdade se todas as suas
componentes são verdade.
73
74
Pela teoria básica de conjuntos, define-se A ∩ B por:
A ∩B={x / xϵAex
ϵB}
A
B
Podemos afirmar que x pertence a A ∩ B se, e somente se, x pertence a A AND x
pertence a B, ou seja, pertence aos dois conjuntos simultaneamente. O conectivo AND
opera a interseção entre proposições (e conjuntos).
Vejamos exemplos em Pascal: suponha que A = {1, 2, 3, 4, 5} e B = {4, 5, 6}.
Se x ϵ A, então (x >= 1) AND (x <= 5) é verdade.
Se x ϵ B, então (x >= 4) AND (x <= 6) é verdade.
Se x
ϵ
A ∩ B, então ((x >= 1) AND (x <= 5)) AND ((x >= 4) AND (x <= 6)) é
verdade. Ou seja, x ϵ {4, 5}. De outra forma, x ϵ [1, 5] ∩ [4, 6].
O uso de operadores lógicos é apresentado na Listagem 3.8.
1 program OperadoresLogicos;
2 {Este programa vai demonstrar Operadores Lógicos do Pascal}
3 uses crt;
4 var
5
6
x, inicio, fim : integer;
7
8 begin
9
10
inicio := 0;
11
fim := 10;
12
x := 5;
13
14
valorLogico := (x > inicio) and (x > fim);
15
writeln('Teste se ', x, ' eh > que ', inicio , ' E ', x, ' eh > que
', fim, ' : ', valorLogico);
16
17
valorLogico := (x > inicio) and (x < fim);
18
writeln('Teste se ', x, ' eh > que ', inicio , ' E ', x, ' eh < que
19
20
valorLogico := (x > inicio) or (x > fim);
21
writeln('Teste se ', x, ' eh > que ', inicio , ' OU ', x, ' eh > que
22
23
valorLogico := ((x >= 1) and (x <= 5)) AND ((x >= 4) and (x <= 6));
24
writeln('Teste se ', x, ' esta entre 1 e 5 e se ', x, ' esta entre 4
e 6 simultaneamente : ', valorLogico);
25
26
readkey;
27 end.
Listagem 3.8 – Operadores Lógicos
Na Listagem 3.8, as linhas 5 e 6 definem as variáveis e as linhas 10 a 11 as iniciam.
www.edeyson.com.br
EXPRESSÕES
A linha 14 atribui à variável valorLogico o resultado do teste:
(valorLogico := (x > inicio) and (x > fim));
Ou seja, testa se x é maior que inicio AND x é maior que fim. Logo, x tem de ser maior
que o maior valor. Como inicio e fim foram iniciadas com 0 e 10, respectivamente, o
teste só é verdade se x for maior que 10. Como x foi iniciada com 5, valorLogico é
FALSE na linha 14.
(valorLogico := (x > inicio) and (x < fim));
Ou seja, se x é maior que inicio AND x é menor que fim. Como inicio e fim foram
iniciadas com 0 e 10, respectivamente, o teste só é verdade se x for maior que 0 AND
menor que 10. Como x foi iniciada com 5, valorLogico é TRUE na linha 14.
(valorLogico := (x > inicio) or (x > fim));
Similarmente, o teste só é verdade se x for maior que 0 OR maior que 10.
Diferente do AND, uma proposição composta com OR é verdade se pelo menos uma
das proposições componentes for verdade.
Como x foi iniciada com 5, valorLogico é TRUE, pois 5 é maior que 0, embora 5 seja
menor que 10.
A linha 23 atribui à variável valorLogico o resultado do teste (valorLogico := ( (x >= 1) and
(x <= 5) ) AND ( (x >= 4) and (x <= 6) )), ou seja, x deve estar no conjunto [1, 5] ∩ [4,6].
Note que o AND em maiúsculas só foi usado para destacar os conjuntos na expressão.
Em Pascal não há distinção de maiúsculas e minúsculas.
Como x tem o valor 5, o valorLogico é TRUE na linha 24.
Ainda pela teoria básica de conjuntos, define-se A U B por:
A U B = { x / x ϵ A or x
ϵB}
Podemos afirmar que x pertence a A U B se, e somente se, x pertence a A OR x
pertence a B, ou seja, pertence a um ou ao outro. O conectivo OR opera a união entre
proposições (e conjuntos).
Vejamos um exemplo em Pascal: suponha que A = {1, 2, 3, 4, 5} e B = {4, 5, 6}.
Se x ϵ A, então (x >= 1) AND (x <= 5) é verdade.
Se x ϵ B, então (x >= 4) AND (x <= 6) é verdade.
Se x ϵ A U B, então ((x >= 1) AND (x <= 5)) OR ((x >= 4) AND (x <= 6)) é verdade.
Ou seja, x ϵ {1, 2, 3, 4, 5, 6}. De outra forma, x ϵ [1, 5] U [4, 6].
75
76
Exercícios
1. Elabore um programa que deve:
a. Declarar a variável x como inteira.
b. Solicitar ao usuário para informar um valor para x.
c. Determinar se x pertence aos intervalos:
i. [2, 7] U [10, 15]
ii. [1, 5) U [4, 10) U (20, 26]
iii. [0, 10] ∩ [7, 15]
iv. (0, 10] ∩ (7, 15)
www.edeyson.com.br
4
4
ESTRUTURAS DE DECISÃO
Todos os programas de exemplo elaborados até este capítulo apresentam um conjunto
de ações sequenciais onde todas as ações são executadas numa mesma ordem.
O modelo da Figura 4.1 não é único em programas quotidianos. Normalmente o
programador se depara com ações que serão executadas ou não a depender de uma
determinada situação.
Entrada
Ação 1
Ação 2
Saída
Figura 4.1 – Fluxograma de sequência
Quando uma ou mais ações dependem de uma ou mais condições para sua execução,
são necessárias estruturas de decisão que controlem o fluxo de execução do programa
efetuando tomadas de decisão e desvios de operações.
Em Linguagem Natural podem-se descrever tais estruturas de decisão das seguintes
formas:
1. Seleção com uma via: Se a condição é verdadeira então execute a ação 1.
2. Seleção com duas vias: Se a condição é verdadeira então execute a ação 1.
Senão, execute a ação 2.
Em ambas as formas a ação 1 só será executada se e somente se a condição for
verdadeira.
Na forma 1, seleção com uma via, caso a condição seja verdadeira adiciona-se uma ação
ao fluxo normal do programa. Na forma 2, escolhe-se um caminho a seguir, executando
a ação1 ou a ação 2.
Observações:
1. Uma ação, como descrita no texto, não consiste apenas numa instrução. Ela pode
ser executada por um bloco de comandos – bloco de programa com demarcação de
início e fim (usando-se BEGIN e END) que contém uma ou várias instruções.
2. A instrução Pascal end pode ser finalizado com um ponto-e-vírgula ( ; ) e não
apenas com um ponto. O uso de ponto ao final de um end ocorre somente na
finalização de um programa.
77
78
4.1 IF .. THEN
A instrução do Pascal IF condição THEN ação pode ser lida assim: SE a condição é
verdadeira ENTÃO execute a ação.
IF .. THEN tem por finalidade testar uma condição e tomar uma decisão – é uma
seleção com uma via. Se a condição é verdadeira, um bloco de comandos é executado.
Em caso contrário, esse bloco é ignorado.
{Sintaxe:}
IF condição THEN
bloco de comandos
O fluxograma da Figura 4.2 tem por objetivo é ler uma nota e determinar se ela é maior
ou igual a 6. Em caso verdadeiro, deve imprimir ‘Aluno aprovado’.
Início
nota
Nota >= 6.0
SIM
Aluno
aprovado
Fim
Figura 4.2 – Fluxograma da seleção com uma Via
O programa da Figura 4.2 é assim descrito:
1. Início do Algoritmo Nota;
a. Declarar uma variável nota do tipo real;
b. Solicitar um valor para a nota;
c. Se a nota for maior ou igual a 6.0, então imprimir: Aluno
aprovado.
2. Terminar Algoritmo Nota.
www.edeyson.com.br
A Listagem 4.1 apresenta o código que implementa o Algoritmo Nota proposto na
Figura 4.2 com seleção com uma via através de IF .. THEN.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
program testaNota;
uses crt;
{Declarar uma variável nota do tipo real;}
var nota : real;
begin
{Solicitar um valor para a nota;}
write('Digite uma nota: ');
readln(nota);
{Se a nota for maior ou igual a 6.0, então imprimir: Aluno
aprovado.}
if (nota >= 6.0) then
writeln('Aluno aprovado.');
{Parar o programa até que algo seja pressionado}
readkey;
end.
Listagem 4.1 – Seleção com uma Via – IF .. THEN
Neste programa declara-se uma variável real chamada nota na linha 4. As linhas 7 e 8
solicitam o valor da nota (write) e efetuam sua leitura (readln), respectivamente.
Na linha 10 testa-se se a nota lida é maior ou igual a 6 e, caso seja, e apenas com esta
condição, escreve-se ‘Aluno aprovado’.
Note que se a nota for menor que 6 o programa aguarda uma tecla ser pressionada –
linha 13 – e acaba.
Veja que neste código, após o IF não se colocou o par begin .. end, pois desejava-se
executar uma ação com apenas uma instrução – linha 11.
Caso a ação desejada necessitasse de mais de uma instrução para executar, estas
deveriam estar inseridas em um bloco de comandos (delimitados por begin..end).
79
80
4.2 IF .. THEN .. ELSE
A instrução IF condição THEN ação1 ELSE ação2 tem por finalidade testar uma
condição e tomar uma decisão entre duas possíveis. Se a condição é verdadeira, um
bloco de comandos após o THEN é executado. Se a condição é falsa, um bloco de
comandos após o ELSE é executado.
A instrução IF condição THEN ação1 ELSE ação2 pode ser lida assim: SE a condição
é verdadeira ENTÃO execute a ação1. EM CASO CONTRÁRIO, execute a ação2.
Suponha que no programa da Listagem 4.1 também fosse necessário informar se o
aluno está reprovado. Neste caso, têm-se duas decisões possíveis: Se a nota é maior ou
igual a 6, a decisão é informar ‘Aluno Aprovado’. Senão, se a nota é menor que 6, a
decisão é informar ‘Aluno Reprovado’.
A listagem 4.2 apresenta um código que satisfaz as duas decisões citadas usando IF ..
THEN .. ELSE.
{Sintaxe:}
IF condição THEN
bloco de comandos 1
ELSE
bloco de comandos 2
O fluxograma apresentado na Figura 4.3 apresenta uma solução onde a mensagem
‘Aluno aprovado’ será apresentada se, e somente se, a nota for maior ou igual a seis e
que ‘Aluno aprovado’ será apresentada em caso contrário. Estas são as duas vias
(decisões) possíveis.
Início
nota
NÃO
Nota >= 6.0
Aluno
reprovado
SIM
Aluno
aprovado
Fim
Figura 4.3 – Fluxograma da seleção com duas Vias
www.edeyson.com.br
O programa da Figura 4.3 é assim descrito e implementado na Listagem 4.2:
1. Início do Algoritmo;
b. Solicitar um valor para a nota;
c. Se a nota for maior ou igual a 6.0, então imprimir: Aluno
aprovado.
d. Senão, imprimir: Aluno reprovado.
2. Terminar Algoritmo.
1
2
3
4
5
6
7
8
9
program testaNota;
uses crt;
{Declarar uma variável nota do tipo real;}
var nota : real;
begin
{Solicitar um valor para a nota;}
write('Digite uma nota: ');
readln(nota);
{Se a nota for maior ou igual a 6.0, então imprimir: Aluno
aprovado.}
if (nota >= 6.0) then
writeln('Aluno aprovado.')
else
writeln('Aluno reprovado.');
10
11
12
13
14
15
{Parar o programa até que algo seja pressionado}
16
readkey;
17 end.
Listagem 4.2 – Seleção com 2 Vias – IF .. THEN .. ELSE
Note que o que diferencia as Listagens 4.1 e 4.2 é que nesta a linha 10 testa se a nota
lida é maior ou igual a 6 e, caso seja, e apenas com esta condição, escreve-se ‘Aluno
aprovado’. Em caso contrário - teste da linha 12 - escreve-se se ‘Aluno reprovado’ –
linha 13.
Observações:
1. Observe que a última linha antes de um ELSE não deve possuir ponto-e-vírgula ( ; ),
como ocorre na linha 11.
Outro exemplo do uso de IF..THEN..ELSE está no programa da Listagem 4.3, que
simula um débito numa conta corrente. O débito só é possível se há saldo e/ou limite
disponíveis para isso. O programa é assim descrito:
1. Início do Algoritmo;
a. Definir as variáveis saldo, limite e valorADebitar como real;
b. Atribuir valores a saldo e limite;
c. Solicitar ao usuário o valor a debitar;
81
82
d. Se o saldo somado ao limite for maior que o valor a debitar,
então:
i. subtraia valorADebitar do saldo;
ii. Imprima 'Debito efetuado com sucesso'.
e. Senão:
i. Imprima 'Saldo insuficiente'.
f. Imprima: 'Fim da transacao. Pressione Alguma Tecla';
g. Pare o programa até que uma tecla seja pressionada.
2. Fim do algoritmo.
A Listagem 4.3 exibe o programa que implementa o referido algoritmo.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
program TesteContaCorrente;
{importação da biblioteca CRT}
uses crt;
var
{Definição das variáveis saldo, limite e valorADebitar do tipo real}
saldo, limite, valorADebitar : real;
begin
{limpa a tela}
clrscr;
21
22
23
24
25
26
27
28
29
30
31
32
33 end.
{Atribuição de valores a saldo e limite}
saldo := 200;
limite := 500;
{Solicitar ao usuário o valor a debitar.}
writeln('Qual o valor a debitar?');
readln(valorADebitar);
{Se o saldo somado ao limite for maior que o valor a debitar,
então debite o valorADebitar do saldo}
if (saldo + limite > valorADebitar) then
begin
saldo := saldo - valorADebitar;
writeln('Debito efetuado com sucesso.');
end
{Senão, imprima: 'Saldo Insuficiente'}
else
begin
writeln('Saldo insuficiente.');
end;
writeln('Fim da transacao. Pressione Alguma Tecla');
readkey;
Listagem 4.3 - Seleção com duas Vias
Neste código testa-se na linha 21 se a variável saldo somada à variável limite tem valor
maior que a variável valorADebitar. Se isto é verdade, a linha 23 subtrai do saldo o
valorADebitar e a linha 24 imprime o sucesso do débito.
Observações:
1. Note que as linhas 22 a 25 e 28 a 30 compõem blocos de comandos delimitados por
BEGIN .. END.
www.edeyson.com.br
O fluxograma correspondente ao programa da Listagem 4.3 é apresentado na Figura 4.4.
Início
saldo = 200
limite = 500
valorADebitar
saldo + limite >
valorADebitar
NÃO
SIM
saldo = saldo - valorADebitar
Saldo Insuficiente
Debito efetuado
com sucesso
Fim da transacao.
Pressione Alguma
Tecla
Fim
Figura 4.4 - Fluxograma da seleção com duas Vias
A instrução IF condição THEN ação1 ELSE ação2 tem uma limitação: ela só oferece
dois caminhos alternativos. Se a condição é verdadeira, segue-se o caminho que executa
a ação1. Em caso contrário, segue-se o caminho que executa a ação2.
Suponha o seguinte problema: uma seguradora dá descontos progressivos no seguro de
automóvel em função da faixa etária do cliente. As faixas são as seguintes:
1. 20 a 25 anos: 3% de desconto;
2. 26 a 30 anos: 5% de desconto;
3. 31 a 45 anos: 8 % de desconto;
4. Acima de 45 anos: 10% de desconto.
Como calcular o desconto com estruturas de decisão com uma ou duas vias? Tal
solução requer um recurso denominado de aninhamento – a composição de tomadas de
decisão.
83
84
Uma especificação em Linguagem Natural para o cálculo do desconto pode ser a
seguinte, que chamaremos de Algoritmo Calcula Desconto 1:
1. Início do Algoritmo Calcula Desconto1;
a. Ler um valor para a variável idade;
b. Desconto é iniciado com 0%;
c. Se a idade está entre 20 e 25 anos, então o desconto é de 3%;
d. Senão:
i. Se a idade está entre 26 e 30 anos, então o desconto é
de 5%;
ii. Senão:
1. Se a idade está entre 31 e 45 anos, então o
desconto é de 8%;
2. Senão:
a. Se a idade é maior que 45 anos, então o
desconto é de 10%;
e. Informar o desconto.
2. Fim do algoritmo Calcula Desconto1.
Um erro comum à especificação em Linguagem Natural seria o seguinte, que
chamaremos de Algoritmo Calcula Desconto 2:
1. Início do Algoritmo Calcula Desconto2;
a. Ler um valor para a variável idade;
b. Desconto é de 0%;
c. Se a idade está entre 20 e 25 anos, o desconto é de 3%;
d. Se a idade está entre 26 e 30 anos, o desconto é de 5%;
e. Se a idade está entre 31 e 45 anos, o desconto é de 8%;
f. Se a idade é maior que 45 anos, o desconto é de 10%;
g. Informar o desconto.
2. Fim do algoritmo Calcula Desconto2.
Embora as duas especificações forneçam o mesmo resultado para o desconto, a primeira
(Algoritmo Calcula Desconto 1) o faz de maneira mais eficiente.
Note que uma pessoa encontra-se numa única faixa etária, logo, se uma condição é
satisfeita (verdadeira) as demais não precisam ser testadas, pois sempre serão falsas. O
desconto sempre inicia em 0%, assumindo-se que não haverá desconto (casos de
pessoas com menos de 20 anos).
A segunda especificação (Algoritmo Calcula Desconto 2) obriga a execução de todos os
testes de condição, mesmo que uma condição já tenha sido verdadeira, o que é
desnecessário.
www.edeyson.com.br
85
Início
idade
Desconto = 0%
idade >= 20 e
idade <= 25
NÃO
idade >= 26 e
idade <= 30
NÃO
idade >= 31 e
idade <= 45
SIM
SIM
SIM
Desconto = 3%
Desconto = 5%
Desconto = 8%
NÃO
idade > 45
SIM
Desconto = 10%
Informar
Desconto
Fim
Figura 4.5 – Fluxograma do Algoritmo Calcula Desconto 1
A Figura 4.5 apresenta o fluxograma do algoritmo Calcula Desconto 1.
Como pode ser notado, caso uma condição seja atendida (verdadeira), o algoritmo
determina o novo desconto, informa-o e termina o algoritmo. Caso o teste de uma
condição falhe, testa-se a próxima condição até que uma seja verdadeira, determinando
o novo desconto, informando-o e terminando o algoritmo. Se nehuma condição for
atendida, o desconto será de 0%.
A Listagem 4.4 exibe o programa que implementa o algoritmo Calcula Desconto 1.
86
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
program CalculaDesconto1;
uses crt;
var
{Definição das variáveis idade e desconto como inteiras}
idade, desconto : integer;
begin
{limpa a tela}
clrscr;
{Solicitar ao usuário o valor da idade.}
writeln('Qual sua idade?');
readln(idade);
{Atribuição de valor inicial ao desconto}
desconto := 0;
{Seleçõe aninhadas}
if (idade >= 20) and (idade <= 25) then
desconto := 3
else
desconto := 5
else
desconto := 8
else
if (idade >= 46) then
desconto := 10;
writeln('O desconto eh de ', desconto, '%');
readkey;
end.
Listagem 4.4 - Calcula Desconto 1
Na linha 19 testa-se a idade (se está entre 20 e 25). Se sim, o desconto será de 3%,
senão, abre-se um novo “ninho” de testes. Por isso usa-se o termo aninhamento.
A linha 22 inicia um “ninho” que só será executado se, e somente se, o teste anterior
falhar, o que economiza a quantidade de testes realmente realizados.
A Figura 4.6 apresenta o fluxograma do algoritmo Calcula Desconto 2. Nele, mesmo
que uma condição seja atendida (verdadeira), o algoritmo continua a testar
desnecessariamente as demais condições para determinar o novo desconto, informandoo e terminando.
Embora o Algoritmo Calcula Desconto 1 seja mais eficiente que o 2, ainda há um
problema. Imagine que a seguradora trabalhe com um conjunto com 20 condições de
cálculo de seguro. Com ficaria o fluxograma e o aninhamento? Neste caso, usa-se a
Seleção com Múltiplas Vias.
www.edeyson.com.br
87
Início
idade
Desconto = 0%
idade >= 20 e
idade <= 25
SIM
NÃO
idade >= 26 e
idade <= 30
NÃO
Desconto = 3%
idade >= 31 e
idade <= 45
SIM
NÃO
Desconto = 5%
SIM
idade > 45
Desconto = 8%
SIM
Desconto = 10%
Informar
Desconto
Fim
Figura 4.6 - Fluxograma do Algoritmo Calcula Desconto 2
NÃO
88
4.3 CASE
Embora o aninhamento de IF seja comum quando a condição possui múltiplos
caminhos alternativos, normalmente ela é usada com condições que necessitam de
avaliação de um valor lógico – verdadeiro ou falso.
Em algumas situações, contudo, a condição pode ser avaliada para um conjunto de
valores discretos, sendo estes inteiros ou caracteres. Por exemplo, imagine um sistema
que automatiza uma URA (Unidade de Reconhecimento Audível), comum em
atendimento telefônico pelo sistema 0800. Comumente são oferecidas opções entre 0 e
9. Cada opção leva a uma ação diferente. Por exemplo, vamos analisar o problema URA
01 a seguir.
Uma solução de URA (URA 01) deve oferecer as seguintes opções e ações:
1 – Saldo;
2 – Extrato Parcial;
3 – Extrato da Última Conta;
8 – Falar com atendente;
9 – Menu anterior.
Uma especificação em Linguagem Natural para a URA 01 pode ser a seguinte, que
chamaremos de Algoritmo URA 01 IF:
1. Início do Algoritmo URA 01 IF;
a. Informar ao usuário quais as opções do menu;
b. Solicitar ao usuário qual a opção desejada;
c. Se a opção for 1, apresentar o saldo;
d. Senão:
i. Se a opção for 2, então apresentar o Extrato Parcial;
ii. Senão:
1. Se a opção for 3, então apresentar o Extrato da
Última Conta;
2. Senão:
a. Se a opção for 8, então transferir a
ligação para a atendente;
b. Senão:
i. Se a opção for 9, então desviar
para o menu anterior;
ii. Senão, informar opção inválida.
2. Fim do algoritmo URA 01 IF.
Com esta especificação teremos um fluxograma muito semelhante ao da Figura 4.5.
Todavia, existe a opção de reescrever o algoritmo usando Seleção com Múltiplas Vias
ao invés de Aninhamento de Seleções de Duas Vias. Um exemplo é o seguinte
Algoritmo URA 01 CASE:
www.edeyson.com.br
1. Início do Algoritmo URA 01 CASE;
a. Informar ao usuário quais as opções do menu;
b. Solicitar ao usuário qual a opção desejada;
c. Caso a opção seja:
i. 1 : apresentar o saldo;
ii. 2 : apresentar o Extrato Parcial;
iii. 3 : apresentar o Extrato da Última Conta;
iv. 8 : transferir a ligação para a atendente;
v. 9 : desviar para o menu anterior;
vi. Outra, informar opção inválida.
2. Fim do algoritmo URA 01 CASE.
A Figura 4.7 apresenta o fluxograma do algoritmo URA 01 CASE. Como pode ser
notado, testa-se uma condição em busca de um valor específico (discreto) e desvia-se a
execução para cada caso especificado.
Início
Exibir as
opções
opção
opção
0, 4, 5, 6 ou 7
1
9
2
8
3
Desvia para o
Menu Anterior
Saldo
Extrato Parcial
Transfere ligação
para Atendente
Extrato Última
Conta
Opção Inválida
Fim
Figura 4.7 - Fluxograma do algoritmo URA 01 CASE
A implementação do algoritmo URA 01 CASE deve ser feito com o comando CASE,
cuja sintaxe é descrita a seguir:
89
90
{Sintaxe:}
CASE variável OF
Valor1 : Bloco de Comandos 1;
...
ELSE
Bloco de Comandos n
END;
Observações:
1. A variável do CASE deve ser inteira ou caracter (integer ou char) apenas.
2. O ELSE é usado para tratar uma possível exceção de valor da variável
A Listagem 4.5 exibe o programa que implementa o algoritmo URA 01 CASE.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
program URA01Case;
uses crt;
var
{Definição das variável opção como inteira}
opcao : integer;
begin
{limpa a tela}
clrscr;
{Informar opções ao usuário.}
writeln('Tecle 1 para Saldo');
writeln('Tecle 2 para Extrato Parcial');
writeln('Tecle 3 para Extrato da Ultima Conta');
writeln('Tecle 8 para Transferir ligação para a Atendente');
writeln('Tecle 9 para Retornar ao Menu anterior');
readln(opcao);
case opcao of
1: begin
{código para apresentar saldo}
end;
2: begin
{código para apresentar o Extrato Parcial}
end;
3: begin
{código para apresentar o Extrato da última Conta}
end;
8: {transferir a ligação para a atendente};
9: {desviar para o menu anterior};
else
writeln('Opcao Invalida');
end; {end case}
readkey;
end.
Listagem 4.5 – Algoritmo URA 01 Case
www.edeyson.com.br
Na Listagem 4.5, a linha 6 define a variável opção como inteira. As linhas 12 a 17
exibem as opções da URA e a linha 17 lê a opção escolhida pelo usuário. A tomada de
decisão do que fazer após a seleção da opção está entre as linhas 19 e 33.
O CASE da Listagem 4.5 baseia-se no valor da variável opção. Para cada caso, um
bloco de ações é sugerido. No caso, apenas fez-se a indicação de onde e como o bloco
de comandos deve ser inserido – linhas 20 a 22, por exemplo.
Na linha 31 o ELSE captura qualquer valor de opção que não seja 1, 2, 3, 8 ou 9.
91
92
4.4 EXERCÍCIOS
4.4.1 Escrever um algoritmo em Linguagem Natural, seu fluxograma e seu código em Pascal
que, lendo três lados de um triângulo, determine se o mesmo é equilátero, isósceles ou
escaleno.
Opção 1 de solução em Linguagem Natural:
b. Se os três lados são iguais, então imprima que é Equilátero.
c. Senão:
i. Se dois lados são iguais, então imprima que é Isósceles.
ii. Senão, imprima que é Escaleno.
b. Se a = b e b = c, então imprima que é Equilátero.
c. Senão:
i. Se a = b ou b = c ou a = c, então imprima que é Isósceles.
ii. Senão, imprima que é Escaleno.
O Fluxograma para o Algoritmo Triângulos é apresentado na Figura 4.8.
Início
a=beb=c
Triângulo
Equilátero
V
F
a, b, c
a=b
ou a = c
ou b = c
V
Triângulo
Isósceles
F
Triângulo
Escaleno
Fim
Figura 4.8 - Fluxograma do algoritmo Triângulos
www.edeyson.com.br
O Código do Algoritmo Triângulos é apresentado na Listagem 4.6.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
program Triangulos;
uses crt;
var
lado1, lado2, lado3 : integer;
begin
writeln('Digite o lado 1');
readln(lado1);
readln(lado2);
readln(lado3);
if (lado1 = lado2) and (lado2 = lado3) then
writeln('Triangulo Equilatero')
else
if ((lado1 = lado2) or (lado1 = lado3) or (lado2 = lado3) ) then
writeln('Triangulo Isosceles')
else
writeln('Triangulo Escaleno');
readkey;
end.
Listagem 4.6 – Programa Triângulos.
4.4.2 Escrever um algoritmo em Linguagem Natural, seu fluxograma e seu código em Pascal
que, lendo um inteiro, determine se o mesmo é par ou ímpar.
1. Início do Algoritmo Paridade
a. Obter o valor do inteiro n
b. Se n é divisível por 2 (o resto da divisão de n por 2 é 0), então
imprima que n é PAR.
c. Senão:
i. Imprima que n é ÍMPAR.
2. Fim do Algoritmo Paridade
O problema da Opção 1 é como determinar em linguagem de programação que n é par. Isso
pode ser feito em Pascal usando o operador de inteiros MOD. Assim, temos a opção 2 de
solução em Linguagem Natural:
1. Início do Algoritmo Paridade
b. Se n MOD 2 = 0, então imprima que n é PAR.
c. Senão:
i. Imprima que n é ÍMPAR.
2. Fim do Algoritmo Paridade
93
94
O Fluxograma que atente ao Algoritmo Paridade é apresentado na Figura
Início
n
V
n MOD 2 = 0
F
ÍMPAR
PAR
Fim
Figura 4.9 - Fluxograma do algoritmo Paridade
O Código do Algoritmo Paridade é apresentado na Listagem 4.7.
1 {O programa deve ler 1 variavel inteira e determinar se a
mesma eh par ou impar.}
2
3 program Paridade;
4 uses crt;
5 var
6
n : integer;
7
8 begin
9
writeln('Digite o valor: ');
10
readln(n);
11
12
if (n mod 2 = 0) then
13
writeln(n, ' e PAR')
14
else
15
writeln(n, ' e IMPAR');
16
17
readkey;
18 end.
Listagem 4.7 – Programa Paridade.
www.edeyson.com.br
5
5
ESTRUTURAS DE REPETIÇÃO
Um método recomendado à construção de algoritmos remete à busca de pequenos
passos, simples, que possam ser resolvidos manualmente por um ser humano. A
decomposição de um problema em um conjunto de passos simples é a melhor forma de
construir um algoritmo, por mais complexo que este seja.
Em muitas situações, um conjunto de passos simples é repetido por diversas vezes. Por
exemplo, suponha um problema onde se deseja ler uma coleção de 100 notas e, para
cada uma, determinar se o aluno foi aprovado (nota maior ou igual a seis) ou reprovado
(nota menor que seis).
Os passos que devem ser repetidos são facilmente identificados:
a. Ler a nota;
b. Determinar se o aluno foi aprovado ou não.
O uso de seleção com duas vias pode resolver este problema, contudo, necessita-se
testar uma coleção de 100 notas. Uma solução possível, porém muito pouco eficiente
pela repetição de código, seria assim descrito:
1. Início do Algoritmo Le100Notas;
b. Solicitar um valor para a nota 1;
c. Se a nota 1 for maior ou igual a 6.0, então imprimir: Aluno
aprovado.
d. Senão, imprimir: Aluno reprovado.
e. Solicitar um valor para a nota 2;
f. Se a nota 2 for maior ou igual a 6.0, então imprimir: Aluno
aprovado.
g. Senão, imprimir: Aluno reprovado.
h. ...
i. Solicitar um valor para a nota 100;
j. Se a nota 100 for maior ou igual a 6.0, então imprimir: Aluno
aprovado.
k. Senão, imprimir: Aluno reprovado.
2. Terminar Algoritmo Le100Notas.
Analisando-se o algoritmo Le100Notas, observa-se que um conjunto de passos (ler a
nota, testá-la e tomar uma decisão em duas vias) se repetirá 100 vezes. Imagine repetir o
trecho de código entre a leitura da nota e sua análise 100 vezes. Isso é viável? E se a
coleção fosse muito maior?
Em situações com essas, onde é necessária a repetição de um determinado trecho de
código (ou bloco de código), usam-se estruturas de repetição, também chamadas de
laços.
95
96
Estruturas de repetição de blocos de comandos também são chamadas de Laços. Os
laços dividem-se em dois grupos:
 Laços Finitos: o número de repetições do laço é conhecido;
 Laços Infinitos (indeterminados): o número de repetições do laço é
desconhecido previamente.
5.1 FOR
O comando FOR permite a repetição de um comando, ou bloco de comandos, um
número finito de vezes. Esse número é determinado por uma variável denominada de
contador do FOR. Sua sintaxe é:
{Sintaxe 1:}
for contador := início to fim do
Comando;
{Sintaxe 2:}
for contador := início to fim do
begin
Bloco de Comandos;
end;
Caso o laço contenha um único comando, usa-se a sintaxe 1 ou a 2. Caso seja um bloco
de comandos, usa-se a sintaxe 2, obrigatoriamente.
O fluxo de execução do comando FOR é o seguinte:
1. O FOR inicia o contador com um valor de início.
2. O FOR inicia um laço de execução:
a. O FOR testa se o contador é <= fim (condição de controle);
b. Se sim:
i. executa o Bloco de Comandos;
ii. o FOR incremente automaticamente o contador em um;
iii. volta ao laço (passo 2.a).
c. Senão:
i. Para e termina o laço.
Embora o fluxo de execução do comando FOR indique no passo 2.b.ii que o FOR
incrementa automaticamente o contador, no fluxograma temos de explicitar isso, como
ilustra a Figura 5.1 que apresenta a estrutura genérica do FOR.
www.edeyson.com.br
FOR
contador = início
contador <= fim
F
Fim
V
Bloco de Comandos
contador = contador + 1
Figura 5.1 – Fluxograma FOR
Uma forma mais apropriada de escrever o algoritmo Le100Notas, que chamaremos de
RepeteTesteNotas, é o seguinte:
1. Início do Algoritmo RepeteTesteNotas;
b. Repetir 100 vezes:
i. Solicitar um valor para a nota;
ii. Se a nota for maior ou igual a 6.0, então imprimir:
Aluno aprovado.
iii. Senão, imprimir: Aluno reprovado.
2. Terminar Algoritmo RepeteTesteNotas.
3.
O fluxograma correspondente ao algoritmo RepeteTesteNotas encontra-se na Figura
5.2. Nota-se o uso de teste antecipado do contador de vezes que uma nota foi lida e
testada.
97
98
Início
conta = 0
Fim
F
conta < 100
V
Bloco de Comandos
nota
Aluno
reprovado
F
Nota >= 6
V
Aluno
aprovado
conta = conta + 1
Figura 5.2 – Fluxograma RepeteTesteNotas
No fluxograma da Figura 5.2 inicia-se a variável conta com zero e testa-se se ela é
menor que 100. A variável conta é usada como um contador de vezes que o bloco de
comandos será executado.
Um dos passos do algoritmo no fluxograma é incrementar o valor de conta para indicar
que um passo foi executado. Sem isso, nunca se chegaria ao fim do algoritmo.
Usando o comando FOR, a implementação do algoritmo RepeteTesteNotas fica como
apresentado na Listagem 5.1.
www.edeyson.com.br
1
2
3
4
5
6
7
program RepeteTesteNotas;
{Importa a biblioteca CRT para usar ReadKey}
uses crt;
{Declara as variáveis}
var nota : real;
conta: integer; {Variável que ajudará a contar número de
repetições}
8
9 {Inicia o programa principal}
10 begin
11
for conta := 1 to 100 do
12
begin
13
write('Digite a nota do aluno entre 0 e 10: ');
14
readln(nota);
15
16
if (nota >= 6) then
17
writeln('Aluno aprovado')
18
else
19
writeln('Aluno reprovado');
20
end;
21 end.
Listagem 5.1 – Uso de For para repetir 100 teste de notas.
A linha 11 inicia um laço de repetição de 100 vezes. Ela pode ser lida assim: faça conta
variar de 1 até 100 e, para cada valor de conta neste intervalo faça o que está entre o
bloco de comandos delimitado entre (begin..end;). Ressalta-se que o end só termina
com ponto (end.) ao fim do programa.
Tudo que está entre o begin (linha 12) e o end (linha 20), que compõe um bloco de
comandos, será repetido 100 vezes. Isso é garantido se o programador não mudar
explicitamente o valor de conta (que é incrementado automaticamente pelo FOR).
As linhas 13 e 14 solicitam a digitação de uma nota entre 0 e 10. A linha 16 teste se a
nota digitada é maior ou igual a seis. Em caso verdadeiro, escreve Aluno aprovado
(linha 17). Senão (linha 18), escreve Aluno reprovado (linha 19).
A Listagem 5.2 apresenta outro exemplo do FOR. Veja que a variável contador pode
ter qualquer nome (neste exemplo, n) e é inteira. O programa imprimirá 8 vezes ‘linha’
seguido do número do contador. A linha 11 determina o laço de repetição.
As linhas 11 e 12 podem ser lidas como: faça o n variar entre 1 e 8 e para cada valor
neste intervalo imprima: ‘linha: ‘ concatenado a n.
Neste caso, o FOR não usa o begin..end, pois será executando apenas um comando por
vez (sintaxe 1).
99
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
program ForSimples;
uses crt;
var
n : integer;
begin
clrscr;
for n := 1 to 8 do
writeln('linha: ', n);
readkey;
end.
Listagem 5.2 – For Simples com 8 passos.
A descrição do algoritmo da Listagem 5.2 é o seguinte:
1. Início do Algoritmo ForSimples;
a. Para cada valor de n entre 1 e 8 faça:
i. Imprimir: ‘linha: ‘ concatenado com o valor de n.
2. Terminar Algoritmo ForSimples.
O Fluxograma do ForSimples está na Figura 5.3. Veja que o For é implementado como
uma repetição com teste antecipado.
Início
n=1
Fim
F
n <= 8
V
Bloco de Comandos
100
'linha: ', n
n=n+1
Figura 5.3 – Fluxograma do ForSimples
www.edeyson.com.br
O resultado da execução do programa ForSimples é o seguinte:
linha: 1
linha: 2
linha: 3
linha: 4
linha: 5
linha: 6
linha: 7
linha: 8
Para entender melhor tal resultado, deve-se seguir o Fluxo de Execução para o FOR da
linha 11:
1. Inicie o n com o valor 1.
2. Inicie o Laço (execução do Comando).
a. Teste se o n é <= 8;
b. Se sim:
i. execute o comando: writeln('linha: ', n);;
ii. incremente o n;
iii. Volte ao laço (passo 2.a).
c. Senão:
i. Pare.
O Passo a Passo de execução da Listagem 5.2 é o seguinte:








1: n = 1
2.a: n <= 8?
2.b: sim
o 2.b.i escreva linha: 1
o 2.b.ii n = 2
o 2.b.iii Voltar a 2.a
2.a: n <= 8?
2.b: sim
o 2.b.ii n = 3
2.a: n <= 8?
2.b: sim
...
Uma dúvida comum ao entendimento do fluxograma da Figura 5.3 é o que significa
n := n + 1.
101
102
Em programação (assim como na matemática) toda atribuição se inicia da direita para a
esquerda. Quando se escreve: x = 10 + 5, soma-se 10 com 5 e atribui-se o resultado a x.
Logo, x resultará em 15.
E quando se escreve x = x + 5? Qual o resultado? O que isso significa é: compute o
valor atual de x acrescido de 5 e atribua o resultado à mesma variável x.
Logo, se x era 15, passará a ser 20. Escrever x = x + y significa acumular o valor y ao
de x. O novo valor de x será igual a seu valor antigo acrescido de y.
O FOR se vale disso para fazer o incremento da variável de controle.
1
2
3
4
for conta := 1 to 2 do
begin
writeln('valor de i: ', i);
end;
Listagem 5.3 – Exemplo do FOR com 2 passos.
No trecho de código da Listagem 5.3, o Bloco de Comandos (linhas 2, 3 e 4) vai ser
executado 2 vezes, com conta assumindo os valores 1 e 2. Quando conta for 3, o teste
2.a, do fluxo de execução do FOR, que testa se conta <= 2, informa que o FOR acabou.
O fluxo de execução do FOR para a execução da Listagem 5.3 é o seguinte:








1: conta = 1
2.a: conta <= 2?
2.b: sim
o 2.b.i escreve valor de conta: 1
o 2.b.ii conta = 2
2.a: conta <= 2?
2.b: sim
o 2.b.i escreve valor de conta: 2
o 2.b.ii conta = 3
2.a: conta <= 2?
2.b:não
Termina o Laço.
Observações:
1. Note que se a variável usada como contador for alterada entre 2.a e 2.b.iii, o número de
repetições pode mudar.
Vejamos uma alteração intencional do contador com a mudança do fluxo de repetições:
www.edeyson.com.br
1
2
3
4
5
for i := 3 to 10 do
begin
i := i + 5;
end;
Listagem 5.4 – Exemplo de FOR com alteração do contador.
Note que o contador (no caso, a variável i) pode iniciar em qualquer valor. Neste trecho
de código da Listagem 5.4 (linha 1) ele inicia em 3. O que este trecho de código fará?
Qual será seu resultado?
Veja que neste exemplo o contador i é incrementado no bloco (linha 4) e também
pelo FOR (linha 1) automaticamente.
Neste caso, o Bloco de Comandos (linhas 3 e 4) vai ser executado 2 vezes:
1. Na primeira execução:
a. i foi iniciado com 3;
b. Após a linha 4, i terá valor 8, mas o FOR incrementa o contador
sempre que chega ao end;
c. i sai do primeiro laço com valor 9.
2. Na segunda execução
a. i inicia com 9;
b. Após a linha 4, i terá valor 14, mas o FOR incrementa o contador
sempre que chega ao end;
c. i sai do primeiro laço com valor 15.
O comando FOR apresentado até agora suporta o incremento automático da variável
denominada de contador, o que é chamado de FOR Crescente. Existe, ainda, o FOR
Decrescente, com a única diferença que este decrementa o contador.
{Sintaxe 1:}
for contador := fim downto início do
Comando;
{Sintaxe 2:}
for contador := fim downto início do
begin
Bloco de Comandos;
end;
O raciocínio de uso é o mesmo, a principal diferença é a inversão do início e fim e o
decremento do contador.
103
5.1.1 Exemplos de Uso do FOR
1. Escrever um algoritmo em Linguagem Natural, seu fluxograma e seu código em
Pascal que, lendo um número inteiro positivo, determine todos os seus divisores.
2. Início do Algoritmo Divisores de N
b. Se n > 0, então:
i. Faça divisor variar de 1 até n
ii. Para cada valor de divisor, faça:
1. Se n MOD divisor = 0, então imprima o valor de divisor.
c. Senão
i. Imprima: ‘o número deve ser positivo’.
3. Fim do Algoritmo Divisores de N
O Fluxograma do Algoritmo Divisores de N é apresentado na Figura 5.4 e seu código na
Listagem 5.5.
Teste se n é
positivo
Início
n>0
n
F
V
FOR
divisor = 1
divisor <= n
F
Fim
V
n MOD divisor = 0
Bloco de Comandos
104
V
divisor
F
divisor =
divisor + 1
Figura 5.4 – Fluxograma Divisores de N
www.edeyson.com.br
1 program DivisoresDeN;
2
3 uses crt;
4
5 var
6
n, divisor : integer;
7
8 begin
9
clrscr;
10
11
write('Digite um valor inteiro positivo para n: ');
12
readln(n);
13
14
if (n > 0) then
15
for divisor := 1 to n do
16
begin
17
if (n mod divisor = 0) then
18
writeln('Divisor: ', divisor);
19
end;
20
readkey;
21 end.
Listagem 5.5 – Divisores de N.
Observações:
1. Matematicamente, o algoritmo pode ser bastante melhorado. Fica como desafio
aperfeiçoar a solução apresentada, diminuindo o número de passos do FOR.
Pascal que, lendo um número inteiro positivo, determine todos os seus divisores e
quantos são estes.
A solução a este problema é uma extensão do bloco de comandos do algoritmo anterior
para contar os divisores. Necessitaremos de uma nova variável, que chamaremos de
contaDivisores, inteira, inicialmente com valor 0, pois não se sabe a princípio quantos
divisores o número possui.
Dado que o teste do algoritmo já informa quem é divisor de N, alteraremos tal teste para
também contar os divisores. Assim, teremos um novo algoritmo.
105
1. Início do Algoritmo Contador Divisores de N
b. Iniciar contaDivisores com 0
c. Se n > 0, então:
1. Se n MOD divisor = 0, então:
a. imprima o valor de divisor.
b. Incremente contaDivisores.
d. Senão
i. Imprima: ‘o número deve ser positivo’.
e. Imprima: ‘o número’ + n + ‘possui’ + contaDivisores + ‘divisores’
2. Fim do Algoritmo Contador Divisores de N
O Fluxograma do Algoritmo Contador Divisores de N é apresentado na Figura 5.5 e
seu código na Listagem 5.6.
Teste se n é
positivo
Início
n
contaDivisores = 0
n>0
F
FOR
V
divisor = 1
F
divisor <= n
Fim
V
n MOD divisor = 0
V
Bloco de Comandos
106
divisor
F
contaDivisores =
contaDivisores + 1
divisor =
divisor + 1
Figura 5.5 – Fluxograma Contadores de Divisores de N.
www.edeyson.com.br
Observações:
1. A linha e do algoritmo apresenta uma operação + entre string e inteiro, o que
resultará na concatenação das strings com o literal que representa contaDivisores.
1 program ContaDivisoresDeN;
2
3 uses crt;
4
5 var
6
n, divisor, contaDivisores : integer;
7
8 begin
9
clrscr;
10
11
write('Digite um valor inteiro positivo para n: ');
12
readln(n);
13
contaDivisores := 0;
14
15
if (n > 0) then
16
begin
17
for divisor := 1 to n do
18
begin
19
if (n mod divisor = 0) then
20
begin
21
writeln('Divisor: ', divisor);
22
contaDivisores := contaDivisores + 1;
23
end;
24
end;
25
writeln('O numero ', n, ' possui ', contaDivisores, '
divisores');
26
end;
27
readkey;
Listagem 5.6 – Conta Divisores de N.
Pascal que, para um conjunto de números inteiros entre 1 e 20, determine todos os
seus divisores e quantos são estes.
A solução a este problema é uma modificação simples do anterior, pois não mais
leremos um valor para n. Todavia, necessitaremos de 2 laços:
1. Um laço para obter os números entre 1 e 20;
2. O laço existente que determina e conta os divisores do número do laço
anterior.
107
1. Início do Algoritmo Contador Divisores de 1 a 20
a. Faça n variar de 1 a 20
b. Iniciar contaDivisores com 0
c. Para cada valor de n, faça:
1. Se n MOD divisor = 0, então:
a. imprima o valor de divisor.
b. Incremente contaDivisores.
iii. Imprima: ‘o número’ + n + ‘possui’ + contaDivisores + ‘divisores’
2. Fim do Algoritmo Contador Divisores de 1 a 20
A estrutura desta solução será a seguinte:
Início
n=1
FOR
n <= 20
Bloco de Comandos
108
F
FOR
V
Fim
n=n+1
www.edeyson.com.br
5.2 WHILE .. DO
O comando WHILE .. DO permite a repetição de um comando, ou bloco de comandos,
um número finito ou indeterminado de vezes. O número de repetições é determinado
por uma condição de controle que deve ser testada antes da execução do comando (ou
bloco de comandos).
{Sintaxe 1:}
while condição do
Comando;
{Sintaxe 2:}
while condição do
begin
Bloco de Comandos;
end;
Note que o comando, ou bloco de comandos, só será executado se a condição for
avaliada como verdadeira. Pode-se ler o comando como: ENQUANTO a condição for
verdadeira, FAÇA: executar comando (ou bloco de comandos).
A principal característica do WHILE é efetuar um teste lógico no início de um loop
(laço), verificando se é permitido executar o trecho de instruções abaixo dela. Desta
forma, poderá executar um determinado conjunto de instruções enquanto a condição
verificada permanecer verdadeira. No momento em que a condição se torna falsa, o
processamento da rotina é desviado para fora do laço.
Sendo a condição falsa logo no início do laço, as instruções contidas nele são ignoradas.
Usando o comando WHILE .. DO, vamos elaborar um programa para imprimir todos os
números entre 1 e 10. Para isto, a condição será os números serem maiores que 0 e
menores ou iguais a 10.
Usando o FOR, o programa seria como a Listagem 5.5
1
2
3
4
for i := 1 to 10 do
begin
end;
Listagem 5.5 – Listagem de números de 1 a 10
Note que o FOR controla implicitamente a condição, fazendo o i (controle) variar entre
1 e 10. Para fazer o mesmo com o WHILE, necessitamos de um código similar. Vamos
iniciar uma variável de controle com 1 e fazê-la variar explicitamente de 1 em 1, até
chegar a 10. Por exemplo, vejamos a Listagem 5.6
109
110
1
2
3
4
5
6
7
8
9
10
11
12
13
program whileSimples;
uses crt;
var i : integer;
begin
i := 1;
while (i <= 10) do
begin
i := i + 1;
end;
readkey;
end.
A linha 6 inicia a variável i com 1, pois desejam-se os números entre 1 e 10. Logo, ela
tem de iniciar em 1.
Como o maior valor deve ser o 10, i terá de variar até 10. Isso deve ser garantido pela
condição do WHILE, o que é feito na linha 7.
Tem-se, então, um laço de repetição de 10 vezes. Porém, isso só é verdade se i for
incrementado de 1 em 1, como é feito na linha 10. Isso garante que i será um valor do
conjunto {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}.
Se a linha 10 fosse i := i + 5, i passaria de 1 para 6, por exemplo, não atendendo o que
se deseja.
O código da Listagem 5.6 pode ser lido assim: inicie i em 1, faça i variar de 1 em 1 até
10 e, enquanto i for menor que 10, imprima seu valor.
Tudo que está entre o begin (linha 5) e o end (linha 13), que compõe um bloco de
comandos, será repetido 10 vezes. Isso é garantido se o programador incrementar o
valor de i de 1 em 1.
O fluxograma do programa da Listagem 5,6 é apresentado na Figura 5.AA
www.edeyson.com.br
Início
i =1
i <= 10
NÃO
Fim
SIM
‘Valor de i: ‘
i
i =i +1
Figura 6.AA – While com Contador
Uma alteração interessante a este programa é o seguinte: imprimir todos os número
pares entre 1 e 10. Apresentaremos duas soluções possíveis a este problema.
Na solução 1, exibida na Listagem 5.7, vamos iniciar uma variável de controle com 1 e
fazê-la variar explicitamente de 1 em 1, até chegar a 10. Embora a solução seja similar a
anterior, o bloco de comandos deve filtrar os elementos a exibir.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
program whilePares;
uses crt;
var i : integer;
begin
i := 1;
while (i <= 10) do
begin
if (i mod 2 = 0) then
i := i + 1;
end;
readkey;
end.
A principal alteração da Listagem 5.7 para a 5.6 está na adição da condicional na linha
9. Agora, um número só será impresso se ele for par, ou seja, o resto da divisão de i por
2 é zero (i mod 2 = 0), logo, i é divisível por 2.
O fluxograma desta solução é apresentado na Figura 5.BB
111
112
Início
i =1
i <= 10
NÃO
Fim
SIM
i mod 2 = 0
SIM
‘Valor de i: ‘
Laço do While
NÃO
i
i =i +1
Figura 7.BB – Pares entre 1 e 10 com WHILE
Na solução 2, exibida na Listagem 5.8, vamos usar um pouco de matemática. Como se
desejam os números pares entre 1 e 10, sabe-se que o primeiro número válido é 2. Logo,
pode-se iniciar a variável de controle i com 2.
E, como se desejam apenas os pares, vamos variar explicitamente i de 2 em 2, até
chegar a 10. Assim, teremos {2, 4, 6, 8, 10}. Vejamos a solução
1
2
3
4
5
6
7
8
9
10
11
12
13
program whilePares;
uses crt;
var i : integer;
begin
i := 2;
while (i <= 10) do
begin
i := i + 2;
end;
readkey;
end.
www.edeyson.com.br
A principal alteração da Listagem 5.7 para a 5.6 está no início da variável i e em seu
incremento, agora de 2 em 2 (linha 10). Como i inicia em 2, teremos os valores {2, 4, 6,
8, 10}.
O fluxograma desta solução é apresentado na Figura 5.CC
Início
i =2
i <= 10
NÃO
Fim
SIM
‘Valor de i: ‘
i
Laço do While
i =i +2
Figura 8.CC
Os exemplos apresentados até agora usaram o WHILE com laços finitos, pois havia
uma condição de parada. Todavia, no seguinte problema, teremos um laço infinito
(indeterminado):
Início do Algoritmo WhileQuadrado
1. Solicitar ao usuário para digitar um número.
2. Enquanto o número digitado não for zero, faça:
a. imprimir o quadrado do número;
b. solicitar ao usuário para digitar um número.
Fim do Algoritmo WhileQuadrado
Quando o algoritmo WhileQuadrado chegará ao fim? Isso é indeterminado, pois não se
sabe quando o usuário digitará o número 0.
O fluxograma deste algoritmo está na Figura 5.DD
113
114
Início
i
i <> 0
NÃO
Fim
SIM
i*i
Laço do While
i
Figura 9.DD – While
O código deste algoritmo está na Listagem 5.9
1 program whileQuadrados;
2 uses crt;
3 var i : integer;
4
5 begin
6
writeln('Digite um valor. 0 para terminar.');
7
readln(i);
8
9
while (i <> 0) do
10
begin
11
writeln('O quadrado de : ', i, ' eh: ', i * i);
12
13
writeln(#10, #10, #13, 'Digite um valor. 0 para
terminar.');
14
readln(i);
15
end;
16
readkey;
17 end.
Listagem 5.9 – While
No código da Listagem 5.9, a linha 6 imprime uma mensagem e a 7 lê um valor para i.
A linha 9 inicia um laço que se repetirá enquanto i for diferente de 0 (i <> 0).
Se o usuário iniciar digitando 0, a condição da linha 9 faz com que o laço não seja
executado.
A linha 11 imprime o quadrado do número lido e a 13 solicita outro valor. Destaca-se o
uso de #10 (nova linha) e #13 (retorno de cursor) para criar duas linhas em branco e
posicionar o cursor na coluna da esquerda, na tela.
www.edeyson.com.br
A linha 14 lê um novo valor para i. Note que enquanto i for diferente de 0, o bloco de
comando entre as linhas 10 e 15 se repetirá. Isso é um laço infinito.
Desafios
1. Imprimir todos os múltiplos de 5 entre 1 e 100 usando WHILE e sem usar IF
ou Case.
2. Imprimir todos os múltiplos de 3 e 5 entre 1 e 100 usando WHILE e sem usar
IF ou Case.
3. Imprimir todos os múltiplos de 3 ou 5 entre 1 e 100 usando WHILE e sem usar
IF ou Case.
115
116
5.3 REPEAT .. UNTIL
O comando REPEAT .. UNTIL permite a repetição de um comando, ou bloco de
comandos, um número finito ou indeterminado de vezes. O número de repetições é
determinado por uma condição de controle que deve ser testada após a execução do
comando (ou bloco de comandos).
Note que sua principal diferença para o WHILE..DO está onde o teste será feito. Como
o WHILE executa o teste da condição ANTES do comando, pode ser que este nunca
seja executado (no caso da condição ser falsa). O REPEAT testa a condição APÓS e
execução do comando, o que significa que, ao menos, este será executado uma vez.
{Sintaxe:}
repeat
Bloco de Comandos;
until (condição);
Note que o comando, ou bloco de comandos, será executado até que a condição seja
avaliada como verdadeira, outra diferença para o WHILE, que executa até a condição
ser falsa.
Pode-se ler o comando como: REPITA a execução do bloco de comandos ATÉ QUE a
condição seja falsa.
A principal característica do REPEAT..UNTIL é efetuar um teste lógico ao final de um
loop (laço), verificando se é permitido continuar a execução do trecho de instruções.
Desta forma, poderá executar um determinado conjunto de instruções enquanto a
condição verificada permanecer falsa. No momento em que a condição se torna
verdadeira, o processamento da rotina é desviado para fora do laço.
Usando o comando REPEAT..UNTIL, vamos elaborar um programa para imprimir
todos os números entre 1 e 10. Para isto, a condição será os números serem maiores que
0 e menores ou iguais a 10, tal qual com WHILE..DO.
O Fluxograma encontra-se na Figura 5.EE. Comparando-o com o mesmo fluxograma do
WHILE, Figura 5., nota-se que a única diferença está onde o teste da condição é feito.
www.edeyson.com.br
Início
i =1
‘Valor de i: ‘
i
Laço do Repeat
i =i +1
i > 10
SIM
Fim
Figura 10.EE – Repeat Until de 1 a 10
O código está na Listagem 5.10.
1
2
3
4
5
6
7
8
9
10
11
12
program Repeat1a10;
uses crt;
var i : integer;
begin
i := 1;
repeat
i := i + 1;
until (i > 10);
readkey;
end.
A linha 6 inicia a variável i com 1, pois desejam-se os números entre 1 e 10. Logo, ela
tem de iniciar em 1.
Como o maior valor deve ser o 10, i terá de variar até 10. Isso deve ser garantido pela
condição do REPEAT, o que é feito na linha 10, que pode ser lida: execute os comandos
ATÉ QUE i seja maior que 10. Note que a condição é diferente da do WHILE. Aqui,
informamos quando o laço deve terminar.
Tem-se, então, um laço de repetição de 10 vezes. Porém, isso só é verdade se i for
incrementado de 1 em 1, como é feito na linha 9. Isso garante que i será um valor do
conjunto {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}.
117
118
O código da Listagem 5.10 pode ser lido assim: inicie i em 1 e repita: imprima i e
incremente-o de 1 em 1 até que seja maior que 10.
Observações:
1. O REPEAT..UNTIL já delimita por si só o bloco de comandos, tornando o uso de
BEGIN..END opcional.
2. Note que os comandos entre o REPEAT e o UNTIL compõem o bloco de comandos e
serão repetidos.
Na Listagem 5.11 apresentaremos a conversão do programa da Listagem 5.7 para o uso
de REPEAT..UNTIL.
Os passos para isto são os seguintes:
1. Onde se tem WHILE, substituir por REPEAT;
2. Eliminar, se houver, o begin do início do bloco de comandos e substituir o
end pelo UNTIL; Lembrar que o REPEAT..UNTIL delimita um bloco de
comandos.
3. Negar a condição do WHILE e movê-la para a condição do UNTIL;
a. Neste caso, a negação de (i <= 10) é (i > 10).
1
2
3
4
5
6
7
9
10
11
12
13
14
program repeatPares;
uses crt;
var i : integer;
begin
i := 1;
repeat
if (i mod 2 = 0) then
i := i + 1;
until (i > 10);
readkey;
end.
O fluxograma desta solução é apresentado na Figura 5.FF
www.edeyson.com.br
Início
i =1
i mod 2 = 0
SIM
‘Valor de i: ‘
NÃO
Laço do Repeat
i
i =i +1
i > 10
SIM
Fim
Figura 11.FF
Desafios
4. Imprimir todos os múltiplos de 5 entre 1 e 100 usando REPEAT e sem usar IF
ou Case.
5. Imprimir todos os múltiplos de 3 e 5 entre 1 e 100 usando REPEAT e sem usar
IF ou Case.
6. Imprimir todos os múltiplos de 3 ou 5 entre 1 e 100 usando REPEAT e sem
usar IF ou Case.
119
120
6. Arrays
Um Array, também chamado de vetor, quando unidimensional, ou matriz, quando
bidimensional, é uma estrutura simples de dados.
Arrays mantêm uma coleção de elementos, do mesmo tipo de dados. Elementos
individuais são acessados por sua posição no array, que é determinada por um índice.
{Sintaxe:}
nomeDoVetor : array [início..fim] of tipoDeDados;
Em Pascal, define-se um array informando-se qual o valor de seu primeiro e último
índice (início e fim, respectivamente). Por exemplo, analisemos o seguinte código:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
program TesteArray;
uses crt;
var
a : array[1..2] of integer;
i : integer;
begin
i := 10;
a[1] := -5; {Coloca -5 na posição 1 do vetor a}
a[2] := 2; {Coloca 2 na posição 2 do vetor a}
writeln('i: ', i);
writeln('a[1]: ', a[1]);
writeln('a[2]: ', a[2]);
readkey;
end.
Na linha 5 declara-se a variável a como sendo um array de inteiros e na linha 6 declarase i como um inteiro.
O que diferencia i de a é que i representa um único inteiro, ou seja, um único valor
inteiro. Pode-se atribuir um único valor inteiro para i e acessá-lo diretamente pelo nome
da variável. Imagine que para cada variável, o sistema reserva uma área de memória
com seu nome. Referenciar o nome i significa para o sistema acessar seu conteúdo,
como representa a Figura XYZ.
i
10
Figura 12.XYZ
www.edeyson.com.br
A variável a, contudo, possui índices 1 e 2 (especificado por [1..2], sendo início = 1 e
fim = 2). Logo, a pode armazenar 2 valores distintos. A linha 10 atribui o valor -5 à
posição 1 do array a. A linha 11 atribui 2 à sua segunda posição.
Não se pode acessar a variável a pelo nome, pois ela exige um índice, como representa a
Figura ZZZ.
-5
2
a[1]
a[2]
Figura 13
Imagine que, para cada vetor, o sistema reserva uma área de memória com várias
posições. Logo, apenas o nome (a, por exemplo) não serve para identificar qual posição
se quer acessar. Por isso necessita-se do índice (a[1] e a[2]), que indica a posição correta
dentro da área reservada.
O seguinte problema ilustra o uso de vetores: desejam-se ler 5 valores e, após isso,
imprimir os pares separados dos ímpares. Uma solução está na Listagem 6.XX
121
122
1 program paresImparesSemArray;
2 uses crt;
3 var v1, v2, v3, v4, v5 : integer;
4
5 begin
6
writeln('Problema: ler 5 valores e, apos isso, imprimir os
pares separados dos ímpares');
7
write('Digite o valor 1: ');
read(v1);
8
read(v2);
9
read(v3);
10
read(v4);
11
read(v5);
12
13
writeln(#10, #10, #13, 'Imprimindo os Valores Pares');
14
if (v1 mod 2 = 0) then writeln(v1);
15
16
17
18
19
20
writeln(#10, #10, #13, 'Imprimindo os Valores Impares');
21
22
23
24
25
26
27
readkey;
28 end.
Para minimizar a área da listagem, optou-se por usar comandos compostos numa mesma
linha, como é o caso das linhas 7 a 10, onde a solicitação de um número e sua leitura
estão numa mesma linha de código. Também, os comandos IF, por não conterem blocos
de comando, fazem a escrita logo após o THEN, numa mesma linha. Ressalta-se que
este não é o modelo preferencial de escrita de código, pois minimiza a legibilidade do
mesmo. Ele foi usado apenas para reduzir o espaço da listagem.
Analisando o código, a linha 3 declara 5 variáveis inteiras necessárias ao programa. As
linhas de 7 a 10 fazem a leitura dos 5 números inteiros, solicitando-os ao usuário. Em
seguida, linhas 13 a 18, apenas os números pares são impressos. Após isso, as linhas de
20 a 25 imprimem apenas os números ímpares.
Observações:
1. O uso de #10 (nova linha) e de #13 (retorno do cursor) é feito no WRITE(LN) para saltar
múltiplas linhas.
a. O comando writeln(#10, #10, #13, 'ABC') imprime 2 linhas em branco,
volta o cursos para a primeira coluna e depois imprime ABC.
Imagine a Listagem 6.XX caso o requisito fosse o de leitura de 30 números. Seriam
necessárias mais 75 linhas de código (25 para leitura, 25 para pares e 25 para ímpares).
www.edeyson.com.br
Uma solução com vetores resolveria esse acréscimo de linha por todo o código. A
Listagem 6.YY demonatra isso.
1 program paresImparesComArray;
2 uses crt;
3
4 const tamanhoVetor = 5;
5 var
v : array [1..tamanhoVetor] of integer;
6
i : integer;
7
8 begin
9
writeln('Problema: ler 5 valores e, apos isso, imprimir os
pares separados dos impares');
10
for i := 1 to tamanhoVetor do
11
begin
12
write('Digite o valor ', i, ' : ');
13
read(v[i]);
14
end;
15
16
writeln(#10, #10, #13, 'Imprimindo os Valores Pares');
17
18
if (v[i] mod 2 = 0) then
19
writeln(v[i]);
20
21
writeln(#10, #10, #13, 'Imprimindo os Valores Impares');
22
23
if (v[i] mod 2 = 1) then
24
writeln(v[i]);
25
26
readkey;
27 end.
Na Listagem 6.YY, a linha 4 declara uma constante tamanhoVetor com valor 5. A linha
5 declara v como um vetor com 5 posições inteiras (valor de tamanhoVetor). A linha 6
declara i como um inteiro, que será o controlador do FOR.
As linhas 10-14 efetuam a leitura dos números. Como são 5 números, tem-se um laço
finito com 5 passos (linha 10: FOR com i variando entre 1 e 5). O bloco de comandos
deste laço é composto pelas linhas 11-14, onde é feita a solicitação de um valor e sua
leitura.
A linha 12 solicita um valor, identificando-o pelo controlador do FOR. O usuário sabe
que digitará o i-ésimo número da seqüência de 5.
A linha 13 efetua a leitura de um elemento do vetor, usando i como índice.
As linhas 17 a 19 formam um novo laço com 5 passos. Em cada passo testa-se se um
dos elementos do vetor é par (testa-se se v indexado por i e par: v[i] mod 2 = 0). Cada
elemento só é impresso se a condição for verdadeira. As linhas de 22 a 24 fazem algo
similar, mas para ímpares.
Note que o tamanho do código da Listagem 6.YY não mudará mesmo que a quantidade
de números a ler mude. Para isto, basta alterar a dimensão da constante tamanhoVetor.
123
124
{Exercícios}
Algoritmo A4.1 (Fácil):
1. Declarar idade1 e idade2 como inteiro;
2. Declarar pessoa1 e pessoa2 como string;
3. Ler um valor para a variável idade1 e outro para idade2;
4. Ler um valor para a pessoa1 e outro para a pessoa2;
5. Se (idade1 for maior que a idade2)
a. imprima: pessoa1, ‘ eh mais velha que ‘, pessoa2
a. imprima: pessoa2, ‘ eh mais velha que ‘, pessoa1
7. Se (idade1 for igual a idade2)
a. imprima: pessoa1, ‘ e ‘, pessoa2, ‘ tem a mesma idade’
Algoritmo A4.2 (Fácil):
1. Declarar idade1 e idade2 como inteiro;
2. Declarar pessoa1 e pessoa2 como string;
3. Ler um valor para a variável idade1 e outro para idade2;
4. Ler um valor para a pessoa1 e outro para a pessoa2;
a. imprima: ‘pessoa1’ é mais velha que ‘pessoa2’
6. Senão
a. Se (idade2 for maior que a idade1)
i. imprima: ‘pessoa2’ é mais velha que ‘pessoa1’
b. Senão
i. imprima: ‘pessoa1’ e ‘pessoa2’ tem a mesma idade
Questões:
- Qual a diferença entre A4.1 e A4.2?
- Que linhas executam em A4.1 e não necessariamente executam em A4.2?
Justifique.
www.edeyson.com.br
125
Algoritmo A4.1 (Médio):
1. Declarar numeroDeLados como inteiro;
2. Declarar área, lado1, lado2, lado3 e lado4 como real;
3. Declarar numeroDeAngulosIguais como inteiro;
4. Imprimir: ‘Quantos lados tem a figura geométrica: <3> ou <4>?’
5. Ler um valor para a variável numeroDeLados;
6. Imprimir: ‘Quantos ângulos são iguais: <2>, <3> ou <4>?’
7. Ler um valor para a variável numeroDeAngulosIguais;
8. Ler área, lado1, lado2, lado3 e lado4 como real;
9. Se numeroDeLados for diferente de 3 ou 4
a. Imprima: ‘Numero de lados inválido’.
10. Senão
a. Se numeroDeLados for igual a 3
i. Imprima: ‘Triangulo’
ii. Se todos os lados são iguais
1. Imprima: “Isto eh um triangulo equilatero;
iii. Senão
1. Se dois lados forem iguais e numeroDeAngulosIguais for igual a 2
a. Imprima: “Isto eh um triangulo isosceles;
2. Senão
a. Imprima: “Isto eh um triangulo escaleno;
b.
Senão
i. Imprima ‘Retangulo ou Trapézio’
ii. Se todos os lados são iguais e numeroDeAngulosIguais igual a 4
1. Imprima: “Isto eh um quadrado’;
2. Faça área = lado1 * lado1;
3. Imprima a área do quadrado.
iii. Senão,
1. Se os lados são iguais dois a dois e numeroDeAngulosIguais igual a 2
a. Imprima: “Isto eh um retângulo’;
b. Faça área = lado1 (menor) * lado2 (maior);
c. Imprima: ‘A area do retângulo é’, area.
2. Senão
a. Imprima: Isso é um Trapezio.
126
www.edeyson.com.br
Apêndice B – Exercícios
Observações:
1. Todas as questões trabalham com intervalos fechados. Logo, “entre A e B” corresponde a
[A, B].
1. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que resolve o
seguinte problema:
- Numa escola, decidiu-se fazer o censo de alunos. Criou-se uma base de dados
onde os registros são estruturados da seguinte forma:
Nome | Sexo
- O campo Nome informa o nome do aluno.
- O campo sexo, com valores ‘F’ ou ‘M’, corresponde a Feminino ou Masculino,
respectivamente.
Seu algoritmo deve ler múltiplos registros e informar:
1. Total de meninos;
2. Total de meninas;
3. Total de alunos.
Início de solução:
Iniciar as variáveis TotalMeninos, TotalMeninas e TotalAlunos com zero.
Enquanto houver registros, faça:
Leia Registro
Se sexo = ‘M’ então adicione 1 a TotalMeninos
Senão, adicione 1 a TotalMeninas
TotalAlunos = TotalMeninos + TotalMeninas
Imprima TotalMeninos, TotalMeninas, TotalAlunos
Fim do Algoritmo
seguinte problema:
- Numa escola, decidiu-se fazer o censo de alunos com Miopia. Criou-se uma
base de dados onde os registros são estruturados da seguinte forma:
Nome | Sexo | Miopia
respectivamente.
127
128
- O campo Miopia indica o grau da disfunção. Grau zero indica não haver o
problema.
Seu algoritmo deve ler todos os registros da base de dados e informar:
2. Total de meninos com miopia;
3. Média de miopia entre os meninos;
5. Total de meninas com miopia;
6. Média de miopia entre as meninas;
7. Média geral de miopia.
seguinte problema:
- Numa escola, decidiu-se fazer o censo de alunos com Miopia e Hipermetropia.
Criou-se uma base de dados onde os registros são estruturados da seguinte
forma:
Nome | Sexo | Miopia | Hipermetropia
respectivamente.
- Os campos Miopia e Hipermetropia indicam o grau da disfunção. Grau zero
indica não haver o problema.
Seu algoritmo deve ler todos os registros da base de dados e informar:
2. Total de meninos com miopia;
3. Total de meninos com hipermetropia;
4. Média de miopia entre meninos;
5. Média de hipermetropia entre meninos;
7. Total de meninas com miopia;
8. Total de meninas com hipermetropia;
9. Média de miopia entre meninas;
10. Média de hipermetropia entre meninas.
11. Média geral de miopia.
12. Média geral de hipermetropia.
4. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que imprime
todos os múltiplos de N entre A e B. Note que N, A e B devem ser fornecidos pelo
usuário.
5. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que imprime o
Máximo Divisor Comum de dois números A e B, fornecidos pelo usuário.
Dica por http://www.somatematica.com.br/fundam/mdc.php:
www.edeyson.com.br
Dois números naturais sempre têm divisores comuns.
Por exemplo: os divisores comuns de 12 e 18 são 1, 2, 3 e 6. Dentre eles, 6 é o maior.
Então chamamos o 6 de máximo divisor comum de 12 e 18 e indicamos m.d.c.(12,18)
= 6.
Alguns exemplos:
mdc (6,12) = 6
mdc (12,20) = 4
mdc (20,24) = 4
mdc (12,20,24) = 4
mdc (6,12,15) = 3
CÁLCULO DO M.D.C. PELO PROCESSO DAS DIVISÕES SUCESSIVAS
Nesse processo efetuamos várias divisões até chegar a uma divisão exata. O divisor
desta divisão é o m.d.c. Acompanhe o cálculo do m.d.c.(48,30).
Regra prática:
1º) dividimos o número maior pelo número menor;
48 / 30 = 1 (com resto 18)
2º) dividimos o divisor 30, que é divisor da divisão anterior, por 18, que é o resto da
divisão anterior, e assim sucessivamente;
30 / 18 = 1 (com resto 12)
18 / 12 = 1 (com resto 6)
12 / 6 = 2 (com resto zero - divisão exata)
3º) O divisor da divisão exata é 6. Então m.d.c.(48,30) = 6.
6. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que imprime o
Mínimo Múltiplo Comum de dois números A e B, fornecidos pelo usuário.
Sugestões:
Leia A e B
Enquanto múltiplo de A menor que AxB faça
Se múltiplo de A for divisível por B então
Imprima: MMC é múltiplo de A
Calcule próximo múltiplo de A
Fim do Algoritmo
Leia A e B
Múltiplo = A
Enquanto Múltiplo menor ou igual a AxB faça
Se Múltiplo divisível por B então
Imprima: MMC é Múltiplo
Termine Algoritmo
Múltiplo = Múltiplo + A
Fim do Algoritmo
Dica:
129
130
Dados dois números A e B, encontre os múltiplos de A.
Para cada múltiplo de A, teste se ele é divisível por B.
Se sim, ele é o MMC.
O ideal é achar os múltiplos do maior número entre A e B e testar com o
menor.
Dica em http://www.somatematica.com.br/fundam/mmc.php:
7. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que lê os lados de
um retângulo, calcula e imprime sua área.
8. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que lê o raio de
um círculo, calcula e imprime sua área.
9. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que:
a. Lê o número de lados de um polígono regular. Se o número de lados é
diferente de 3, 4 ou 6, termine o algoritmo.
b. Lê o tamanho do lado.
c. Calcula e imprime a área do polígono e seu nome (triângulo, quadrado ou
hexágono).
Dica: http://www.mundoeducacao.com.br/matematica/area-hexagono-regular.htm
Leia o número de lados do polígono.
Se o número de lados lido for diferente de 3, 4 ou 6, termine o algoritmo.
Senão, Leia o tamanho do lado.
Se número de lados é igual a 3, então área = (fórmula a ser lida). Imprima área
calculada e “triângulo”.
Senão,
Se número de lados é igual a 4, então área = lado2. Imprima área
calculada e “quadrado”.
Senão, área = (fórmula a ser lida). Imprima área calculada e
“hexágono”.
Fim do Algoritmo
10. Usando Linguagem Natural e Fluxograma, descreva um algoritmo que leia um
conjunto de números naturais e determine qual o menor e o maior. A leitura do conjunto
deve ser feita até que um número negativo seja encontrado.
11. Usando Linguagem Natural e Fluxograma, descreva um algoritmo que leia um
número inteiro que representa uma quantidade de segundos, e determine quantas horas,
minutos e segundos estão contidos neste número.
Por exemplo: 3600 segundos correspondem a 1 hora : 00 minutos : 00 segundos
12. Usando Linguagem Natural e Fluxograma, descreva um algoritmo que leia o sexo
de uma pessoa (H ou M) e sua altura e a partir dele calcule seu peso ideal:
a) Para homens (H): (72.7 * altura) - 58
b) Para mulheres (M): (62.1 * altura) – 44.
www.edeyson.com.br
13. Usando Linguagem Natural e Fluxograma, descreva um algoritmo que leia os
valores de X e Y e calcule XY usando apenas a operação de multiplicação.
valores de X e Y e calcule X * Y usando apenas a operação de soma.
Leia X e Y
Resultado = 0
Faça Y vezes
Resultado = Resultado + X
Imprima Resultado
Fim do Algoritmo
15. O fatorial de um número natural n, representado por n!, é o produto de todos os
inteiros positivos menores ou iguais a n. Usando Linguagem Natural e Fluxograma,
descreva um algoritmo leia n e imprima seu fatorial.
todos os números primos entre A e B. Note que A e B devem ser fornecidos pelo
usuário.
todos os divisores de N entre A e B. Note que N, A e B devem ser fornecidos pelo
usuário. Se A for menor que 1 ou se A for maior que B ou se B for maior que N,
termine o algoritmo.
valores de X e Y e calcule X / Y usando apenas a operação de subtração.
todos os múltiplos de N entre A e B. Note que N, A e B devem ser fornecidos pelo
usuário.
20. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que usando
variáveis que armazenam apenas 1 dígito [0..9] escreve todos os número entre 0 e 999.
Dica: serão necessárias 3 variáveis.
21. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que leia algo do
teclado. Enquanto o que for lido for diferente de espaço em branco, imprima o que foi
lido.
22. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que imprima o
número 20 vinte vezes, o número 19 dezenove vezes, o número 18 dezoito vezes, e
assim sucessivamente, até o número 1 uma vez.
23. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que leia um
número N e imprima o número N ene vezes, o número (N-1) ene menos uma vezes, e
assim sucessivamente, até o número 1 uma vez.
131
132
Por exemplo: Se N for 3 deve imprimir: 3 3 3 2 2 1
número N e um número F e imprima o número N ene vezes, o número (N-1) ene menos
uma vezes, e assim sucessivamente, até o número F efe vezes. Se F for maior que N,
encerre o algoritmo
Por exemplo: Se N for 5 e F for 3 deve imprimir: 5 5 5 5 5 4 4 4 4 3 3 3
Sugestão:
Leia N, F
Enquanto N >= F faça
Cont = N
Faça Cont Vezes
Imprima N
N=N-1
Fim do Algoritmo
25. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que leia dois
números, A e B e determine o valor da menor e da maior razão entre eles. Ou seja,
determine se A/B é maior que B/A e imprima-os.
26. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que leia H
(altura) e g (gravidade) e determine a velocidade de um corpo a cada metro percorrido
após ser largado de uma altura H.
Dica: H = gt2/2, onde t é o tempo. Logo, t = √2H/g (raiz quadrada)
V = V0 + at2/2, onde a é a aceleração. Neste caso, a = g.
27. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que leia g
(gravidade) e t (tempo) e determine a altura H percorrida por um corpo em queda.
28. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que leia H
(altura) e g (gravidade) e determine o tempo de queda de um corpo após ser largado de
uma altura H.
29. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que leia V
(velocidade final), a (aceleração) e t (tempo) e determine a velocidade inicial de um
corpo em movimento.
Dica: V = V0 + at2/2, onde a é a aceleração. Neste caso, a = g.
valor N. Se N for maior ou igual a zero, imprimir N e ler outro valor. Se N for menor
que zero, termine o algoritmo.
www.edeyson.com.br
31. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que leia dois
números A e B, sendo B maior que A, e imprima todos os divisores de todos os
números entre A e B.
seguinte problema:
- Numa empresa, decidiu-se fazer o levantamento de consumo de telefone.
Criou-se uma base de dados onde os registros são estruturados da seguinte
forma:
Ramal | Numero Discado | Tempo Ligação
Seu algoritmo deve ler todos os registros da base de dados e informar quais os 5
ramais com maior tempo total de ligação. Existem, na empresa, 10 ramais.
seguinte problema:
- Uma empresa aérea decidiu imprimir uma relação de funcionários nordestinos.
Sabe-se que ela possui uma base de dados onde os registros são estruturados da
seguinte forma:
Nome | DataNascimento | CidadeNascimento |UF
Seu algoritmo deve ler todos os registros da base de dados e gerar tal relação.
UF possui valores como BA, SE, PB, etc.
valor N e imprima todos os número pares entre 1 e N.
número inteiro de até 4 dígitos N e imprima todos os seus dígitos.
Dica: 13 DIV 10 resulta em 1
13 MOD 10 resulta em 3
todos os números de Armstrong entre 1 e 1000. Um número N é dito de Armstrong se a
soma dos cubos de seus dígitos é igual a N.
todos os números simétricos entre 1 e 10000. Um número N é dito simétrico se ele é
lido igualmente da direita para a esquerda e da esquerda para a direita: Exemplo: 232,
1221, etc.
todos os números simétricos e pares entre 1 e 10000.
todos os números simétricos e primos entre 1 e 10000.
133
134
todos os números simétricos entre 1 e 10000 e também todos os seus divisores.
41. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que determina
todas as possíveis combinações de números consecutivos para os números entre 1 e 100.
Para isto, tem-se que pegar um número N e descobrir somas de números consecutivos
que resultem neste número N.
Por exemplo: se o número N é15, o número de combinações consecutivas será:
1 2 3 4 5, pois 1 + 2 + 3 + 4 + 5 = 15
4 5 6, pois 4 + 5 + 6 = 15
7 8, pois 7 + 8 = 15
42. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que determina os
8 primeiros números naturais curiosos. Para isso, dado um número N, deve-se encontrar
seu número de dígitos (nd). Eleve N ao quadrado e pegue os nd dígitos da direita. Se o
número original N é igual ao número formado pelos nd dígitos da direita de N2, N é um
número curioso.
Por exemplo: 25 é um número curioso. Note que nd = 2 (dois dígits em 25). 252= 625.
Os dois dígitos da direita são 25.
43. Usando Linguagem Natural e Fluxograma, descreva o algoritmo que dado um
número real escreva-o por extenso e em Real (moeda).
Por exemplo: dado 1.325,17 escreva: Mil, trezentos e vinte e cinco reais e dezessete
centavos.
www.edeyson.com.br
Apêndice C – Exemplos de Código
C1 - Tipos, Variáveis e Constantes
C.1.1 - Este programa demonstra o uso de variáveis e constantes no Pascal. Seu objetivo
é determinar um valor para o Raio de um círculo e Calcular sua área = πr2.
Como π é uma constante matemática, ela foi definida na linha 12.
Área e Raio são variáveis, pois círculos diferentes têm valores diferentes.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
program VariaveisConstantes;
{Este programa demonstra o uso de variáveis e constantes no Pascal.
Seu objetivo é determinar um valor para o Raio de um círculo e
Calcular sua área.}
uses crt;
var
{Declara area e raio como variáveis REAIS}
area, raio : real;
const
{Declara pi como uma constante}
pi = 3.1415926536;
begin
{Determina o raio do círculo explicitamente.}
raio := 10;
{Calcula a área do círculo = pi * raio ao quadrado}
writeln('A area do circulo de raio ', raio:3:2, ' eh: ', area:3:4);
readkey;
end.
135
136
C.1.2 - Este programa vai demonstrar os tipos de variáveis do Pascal, como lhes atribuir
valores e imprimi-las. Para isto são definidas variáveis inteiras, reais, lógicas, caracter e
texto.
1 program TiposDeVariaveis;
2 {Este programa vai demonstrar os tipos de variáveis do Pascal,
3 como lhes atribuir valores e imprimi-las.}
4
5 uses crt;
6
7 {Tudo que vem após VAR é variável
8 sintaxe:
9
nomeDaVariável : tipo;
10 }
11 var
12
{Declara ai, bi e ci como variáveis INTEIRAS}
13
ai, bi, ci : integer;
14
{Declara ar e br como varáveis REAIS}
15
ar, br : real;
16
{Variáveis lógicas - podem ser TRUE ou FALSE}
17
al, bl : boolean;
18
{Declara bs como String - uma cadeia de caracteres}
19
bs : string;
20
{O uso de [] na declaração de string delimita o número de
caracteres.
21
Neste caso, a variável nome pode ter 10 caracteres no máximo.}
22
nome : string[10];
23
{Char representa um único caracter}
24
caracter : char;
25
26 const
27
pi = 3.1415926536;
28
29 begin
30
{Atribuições de valores às variáveis}
31
ai := 10;
32
bi := ai * 2;
33
ci := 2 * 23;
34
35
caracter := 'A';
36
writeln('A letra eh: ', caracter);
37
caracter := 'B';
38
39
{Atribui a letra pelo valor da Tabela AscII}
40
caracter := #69;
41
42
43
{Teste se 2 é maior que 1 e atribui o resultado para al}
44
al := 2 > 1;
45
writeln('AL: ', al);
46
47
bs := ' Isto eh uma string longa. Pode ser uma frase.';
48
nome := 'Edeyson';
49
writeln(nome, bs);
50
51
readkey;
52 end.
www.edeyson.com.br
C.1.3 - Segunda lei de movimento de Newton ou Princípio da Proporcionalidade ou Lei
de Força: Um ponto material sujeito à ação de uma força F adquire aceleração a, de
mesma direção e sentido que a força e módulo |a| proporcional à intensidade de F; o
coeficiente de proporcionalidade é um escalar essencialmente positivo que 'mede' a
inércia do ponto - sua massa. Assim, calcula-se Força = massa * aceleração.
1 program InteirosEmPascal;
2 {Este programa vai demonstrar o uso de Inteiros em Pascal
3
calculando a Força que incide num ponto material de massa e
aceleração conhecidas.}
4
5 uses crt;
6
7 var
8
forca, massa, aceleracao : integer;
9
10 begin
11
writeln('Qual a massa do ponto material?');
12
readln(massa);
13
14
writeln('Qual a aceleracao do ponto material?');
15
readln(aceleracao);
16
17
forca:= massa * aceleracao;
18
writeln('A Forca aplicada ao ponto material eh: ', forca);
19
readkey;
20 end.
C.1.4 - Segunda lei de movimento de Newton ou Princípio da Proporcionalidade ou Lei
de Força: Cálculo da Massa.
1 program ReaisEmPascal;
2 {Este programa vai demonstrar o uso do tipo Real em Pascal calculando a
massa de um ponto material conhecendo-se a força nele aplicada e sua
aceleração.}
4
5 uses crt;
6
7 var
8
forca, massa, aceleracao : real;
9
10 begin
11
writeln('Qual a forca do ponto material?');
12
readln(forca);
13
14
writeln('Qual a aceleracao do ponto material?');
15
readln(aceleracao);
16
17
massa := forca / aceleracao;
18
writeln('A massa eh: ', massa:3:2);
19
readkey;
20 end.
137
138
C.1.5 – Uso de String e Char em Pascal.
1 program StringChar;
2 uses crt;
3 var
4
endereco, nome : string; {endereço e nome são cadeias com 0 a 255
caracteres.}
5
CPF : string[11];
6
sexo : char;
{char representa um único caracter. Neste caso
sexo pode ser 'M' ou 'F'}
7
8 begin
9
10
endereco := 'Rua dos Alferes, 1234, Ap. 1001, Barra, Salvador, Bahia
- CEP: 40.130.280';
11
12
CPF := '12345678901';
13
sexo := 'M';
14
15
writeln('Endereco: ', endereco);
16
writeln('Cliente: ', nome);
17
writeln('CPF: ', cpf);
18
19
readkey;
20 end.
C.1.6 – Uso de String e Char em Pascal.
1 program StringsEmPascal;
2 {Este programa vai demonstrar o uso de String em Pascal.}
3
4 uses crt;
5
6 var
7
endereco : string; {endereço é uma cadeia com 0 a 255 caracteres.}
8
nome : string[30];
9
CPF : string[11];
10
11 begin
12
endereco := 'Rua dos Alferes, 1234, Ap. 1001, Barra, Salvador, Bahia
- CEP: 40.130.280';
13
14
CPF := '12345678901';
15
16
readkey;
17 end.
www.edeyson.com.br
C.1.7 – Uso de Boolean em Pascal.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
program BooleanEmPascal;
{Este programa vai demonstrar o tipo boolean do Pascal}
uses crt;
var
maior, menor, igual : boolean;
begin
{Atribui TRUE a aprovado}
aprovado := true;
{Atribui o resultado do teste: 2 > 1? a maior}
maior := 2 > 1;
{Atribui o resultado do teste: 2 > 1? a igual}
igual := 2 = 1;
{Atribui o resultado do teste: 2 > 1? a menor}
menor := 2 < 1;
writeln('Aprovado: ', aprovado);
writeln('2 > 1? eh: ', maior);
writeln('2 = 1 eh: ', menor);
writeln('2 = 1 eh: ', igual);
readkey;
end.
C.1.8 – Uso de Char em Pascal.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
program CharEmPascal;
{Este programa vai demonstrar o tipo chardo Pascal}
uses crt;
var
letraAMinuscula, letraAMaiuscula : char;
letraBMinuscula, letraBMaiuscula : char;
{char representa um único caracter.}
sexo : char;
begin
sexo := 'M';
letraAMinuscula := 'a';
letraAMaiuscula := #65;
letraBMinuscula := #98;
letraBMaiuscula := 'B';
writeln('Letras Maiusculas: ', letraAMaiuscula, letraBMaiuscula);
writeln('Letras Minusculas: ', letraAMinuscula, letraBMinuscula);
readkey;
end.
139
140
C2 - Operadores
C.2.1 - Este programa demonstra o uso de operadores de concatenação de Strings.
1 program ConcatenacaoDeStrings;
2 {Este programa vai demonstrar a Concatenação de Strings em Pascal.}
3 uses crt;
4 var
5
nome
: string[20];
{Definição de variáveis}
6
sobrenome
: string[20];
7
nomeCompleto : string[40];
8
9 begin
10
nome := 'Edeyson';
{Atribui Edeyson aa var.
nome}
11
sobrenome:= 'Gomes';
{Atribui Gomes aa var.
sobrenome}
12
nomeCompleto := nome + ' ' + sobrenome;
{Concatena nome e
sobrenome}
13
writeln('Nome Completo: ', nomeCompleto); {Exibe o nome completo}
14
15
readkey;
16 end.
C.2.2 - Este programa demonstra o uso de operadores lógicos.
1 program OperadoresLogicos;
2 {Este programa vai demonstrar Operadores Lógicos do Pascal}
3 uses crt;
4 var
5
6
x, inicio, fim : integer;
7
8 begin
9
10
inicio := 0;
11
fim := 10;
12
x := 5;
13
14
valorLogico := (x > inicio) and (x > fim);
15
writeln('Teste se ', x, ' eh > que ', inicio , ' E ', x, ' eh > que
16
17
valorLogico := (x > inicio) and (x < fim);
18
writeln('Teste se ', x, ' eh > que ', inicio , ' E ', x, ' eh < que
19
20
valorLogico := (x > inicio) or (x > fim);
21
writeln('Teste se ', x, ' eh > que ', inicio , ' OU ', x, ' eh >
que ', fim, ' : ', valorLogico);
22
23
valorLogico := ((x >= 1) and (x <= 5)) AND ((x >= 4) and (x <= 6));
24
writeln('Teste se ', x, ' esta entre 1 e 5 e se ', x, ' esta entre
4 e 6 simultaneamente : ', valorLogico);
25
26
readkey;
27 end.
www.edeyson.com.br
C.2.3 - Este programa demonstra o uso de operadores relacionais com Strings.
1 program OperadoresRelacionaisComString;
3 uses crt;
4 var
5
valorLogico : boolean; {Variáveis lógicas - podem ser TRUE ou
FALSE}
6
string1, string2 : string;
7
8 begin
9
10
string1 := 'abc';
11
string2 := 'def';
12
13
valorLogico := string1 = string2;
14
writeln('Teste se ', string1, ' eh = a ', string2, ' : ',
valorLogico);
15
16
valorLogico := string1 > string2;
17
writeln('Teste se ', string1, ' eh > que ', string2, ' : ',
valorLogico);
18
19
valorLogico := string1 < string2;
20
writeln('Teste se ', string1, ' eh < que ', string2, ' : ',
valorLogico);
21
22
readkey;
23 end.
C.2.4 - Este programa demonstra o uso de operadores relacionais com Inteiros.
141
142
1 program OperadoresRelacionaisComInteger;
3 uses crt;
4 var
5
{Variáveis lógicas - podem ser TRUE ou FALSE}
6
valorLogico : boolean;
7
inteiro1, inteiro2 : integer;
8
9 begin
10
11
inteiro1 := 10;
12
inteiro2 := 20;
13
14
valorLogico := inteiro1 = inteiro2;
15
writeln('Teste se ', inteiro1, ' eh = a ', inteiro2, ' : ',
valorLogico);
16
17
valorLogico := inteiro1 < inteiro2;
18
writeln('Teste se ', inteiro1, ' eh < que ', inteiro2, ' : ',
valorLogico);
19
20
valorLogico := inteiro1 > inteiro2;
21
writeln('Teste se ', inteiro1, ' eh > que ', inteiro2, ' : ',
valorLogico);
22
23
readkey;
24 end.
C.2.5 - Este programa demonstra o uso de operadores relacionais com Reais.
1 program OperadoresRelacionaisComReal;
3 uses crt;
4 var
5
6
real1, real2 : real;
7
8 begin
9
10
real1 := 8/6;
11
real2 := 4/3;
12
13
valorLogico := real1 > real2;
14
writeln('Teste se ', real1:3:4, ' eh > que ', real2:3:4, ' : ',
valorLogico);
15
16
valorLogico := real1 = real2;
17
writeln('Teste se ', real1:3:4, ' eh = a ', real2:3:4, ' : ',
valorLogico);
18
19
valorLogico := real1 < real2;
20
writeln('Teste se ', real1:3:4, ' eh < que ', real2:3:4, ' : ',
valorLogico);
21
22
readkey;
23 end.
www.edeyson.com.br
C.2.6 - Este programa demonstra o uso de operadores lógicos e Tabela Verdade.
No programa são definidas duas proposições simples: p e q. Atribuem-se valores
lógicos a p e q nas linhas 7, 12, 17 e 22. As outras linhas imprimem os resultados da
conjunção e disjunção entre p e q. Vale lembrara que TRUE é Verdade e FALSE é
Falso.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
program TabelaVerdade;
uses crt;
var
p, q : boolean;
begin
p := true; q:= true;
writeln('p:', p, ' e q:', q, ' = ', p and q);
writeln('p:', p, ' ou q:', q, ' = ', p or q);
writeln;
p := true; q:= false;
writeln;
p := false; q:= true;
writeln;
p := false; q:= false;
readkey;
end.
143
144
C3 - Condicionais
C.3.1 - Este programa visa ler uma nota (variável real) e testá-la. Se a nota estiver no
intervalo [0, 3) deve imprimir ‘Sem Rendimento’. Senão, se estiver no intervalo [3, 6)
deve imprimir ‘Medio’. Senão, deve imprimir ‘Superior’.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
program Condicioal01;
uses crt;
var
nota : real;
begin
writeln('Digite uma nota');
readln(nota);
if (nota >= 0) and (nota < 3) then
writeln('Sem Rendimento')
else
if (nota >= 3) and (nota <= 6) then
writeln('Medio')
else
writeln ('Superior');
readkey;
end.
C.3.2 - Este programa deve ler uma variável inteira e determinar se a mesma é par ou
ímpar. Uma variável valor é par quando é divisível por 2, ou seja, se (valor mod 2 = 0).
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
program Paridade;
uses crt;
var
valor : integer;
begin
writeln('Digite o valor: ');
readln(valor);
if (valor mod 2 = 0) then
writeln(valor, ' eh PAR')
else
writeln(valor, ' eh IMPAR');
readkey;
end.
C.3.3 - Este programa deve:
1. Solicitar que o usuário digite o sexo da pessoa.
2. Ler o sexo da pessoa.
3. Solicitar a altura da pessoa em centímetros.
4. Ler a altura da pessoa.
5. Calcular o peso ideal da pessoa.
a) Para homens (H): (72.7 * altura) - 58
www.edeyson.com.br
b) Para mulheres (M): (62.1 * altura) – 44.
8 program pesoIdeal;
9
10 {importação da biblioteca CRT}
11 uses crt;
12
13 var
14
{criação da variável sexo do tipo caracter - ou F ou M}
15
sexo : char;
16
17
{criação da variável altura (em cm) do tipo inteiro}
18
altura : integer;
19
20
{criação da variável peso do tipo real (ponto flutuante)}
21
peso : real;
22
23 begin
24
{limpa a tela}
25
clrscr;
26
27
{escreve no prompt de comando}
28
writeln('Escolha o sexo: (F)eminino ou (M)asculino');
29
30
{esperando que o usuário pressione alguma tecla e atribuindo o
caractere a variável sexo}
31
sexo := readkey;
32
33
{tornando maiúscula(caixa alta), pois o usuário pode digitar em
minúsculas}
34
sexo := upcase(sexo);
35
36
{escreve no prompt do comando}
37
write('Digite a altura em CM: ');
38
39
{esperando queo usuário digite algo e atribua a variável altura}
40
readln(altura);
41
42
{se sexo contiver M faça}
43
if(sexo = 'M') then
44
{realize o cálculo do peso ideal}
45
peso := ((72.7 * altura)/100) - 58
46
{do contrário, se sexo contiver F faça}
47
else
48
if(sexo='F') then
49
{realize o cálculo do peso ideal}
50
peso := ((62.7 * altura)/100) - 48
51
else
52
writeln('Oh, Zeh, não sabe o que eh sexo???');
53
54
{escreva no prompt do comando + o valor da variável com 3 casas
decimais e 2 após o ponto}
55
writeln('Seu peso ideal: ', peso:3:2);
56
57
{espera que algo seja teclado para finalizar o programa}
58
readkey;
59 end.
145
146
C4 - For
C.4.1 - Este programa deve ilustrar o funcionamento do For, imprimindo números de 1
a 10.
1
2
3
4
5
6
7
8
9
10
11
12
13
program ForSimples;
uses crt;
var
i : integer;
begin
for i := 1 to 10 do
begin
writeln('Valor de i: ', i);
end;
readkey;
end.
C.4.2 – Desafio: o que este programa faz?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
program ForSimples;
uses crt;
var
i : integer;
begin
for i := 1 to 10 do
begin
writeln('Valor de i: ', i);
i := i + 5;
end;
readkey;
end.
www.edeyson.com.br
Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
1.1.5 Determinar se um número natural N é primo
A principal diferença deste algoritmo para o anterior (1.1.4) é que não serão impressos
os divisores de um número, e sim, contados (precisamos de uma variável para isso).
Vale lembrar que um número primo tem apenas dois divisores.
a. Definir a variável contaDivisores com valor inicial 0
b. Ler N
c. Faça a variável Divisor variar entre todos os valores no intervalo [1 e
N]
i. Para cada valor de Divisor faça:
1. Atribua à variável Resto o resto da divisão de N por
Divisor.
2. Se Resto = 0, então some 1 a contaDivisores
d. Se contaDivisores > 2, então o número não é primo.
e. Senão, ele é primo.
Fim do Algoritmo
Note que a letra d do Algoritmo só será executada após o laço da letra c ser
concluído (testar todos os divisores no intervalo [1, N].
147
148
Início
contaDivisores = 0
N
Divisor = 1
F
Divisor <= N
contaDivisores > 2
V
N não é
primo
V
de N por Divisor
Resto = 0
V
F
N é primo
contaDivisores =
contaDivisores + 1
Fim
F
Divisor =
Divisor + 1
Figura 1.6 – Fluxograma: Determinar se N é primo
1.1.6 Imprimir todos os múltiplos de 3 compreendidos entre 1 e N (naturais).
a. Ler N
b. Faça a variável Múltiplo variar entre todos os valores no intervalo [1 e
N]
i.
Atribua à variável Resto o resto da divisão de Múltiplo por 3.
ii.
Se Resto = 0, então imprima o valor de Múltiplo.
Fim do Algoritmo
Teste do Algoritmo:
Ler N – suponha que N seja 10
Faça a variável Múltiplo variar entre todos os valores no intervalo [1 e 10]
Serão impressos os valores 3, 6, 9
www.edeyson.com.br
Início
N
Múltiplo = 1
F
Múltiplo <= N
Fim
V
de Múltiplo por 3
Resto = 0
V
Múltiplo
F
Múltiplo =
Múltiplo + 1
Figura 1.7 – Fluxograma: Múltiplos de 3 entre 1 e N
1.3.7 Imprimir todos os múltiplos de 3 e 5 (simultaneamente) compreendidos entre 1 e
N (naturais).
c. Ler N
d. Faça a variável Múltiplo variar entre todos os valores no intervalo [1 e
N]
iii. Atribua à variável Resto3 o resto da divisão de Múltiplo por 3.
iv.
Atribua à variável Resto5 o resto da divisão de Múltiplo por 5.
v.
Se Resto3 = 0 e Resto5 = 0, então imprima o valor de Múltiplo.
Fim do Algoritmo
Teste do Algoritmo:
Ler N – suponha que N seja 30
Faça a variável Múltiplo variar entre todos os valores no intervalo [1 e 30]
Serão impressos os valores 15, 30
149
150
Início
N
Múltiplo = 1
Múltiplo <= N
F
Fim
V
Resto3 = resto da divisão de
Múltiplo por 3
Resto5 = resto da divisão de
Múltiplo por 5
Resto3 = 0
e
Resto5 = 0
V
Múltiplo
F
Múltiplo =
Múltiplo + 1
Figura 1.8 – Fluxograma: múltiplos de 3 e 5 entre 1 e N
1.3.8 Dado um registro com o seguinte leiaute:
Nome
Nota1
Nota2
Nota3
Escreva um algoritmo que leia um arquivo com N registros no leiaute acima e imprima
um relatório com alunos aprovados e outro com alunos reprovados.
Um aluno está aprovado apenas de tiver média (aritmética) das notas maior ou igual a
7,0. Considere em sua solução que só existe uma impressora na execução do algoritmo.
1. Criar uma coleção de alunos aprovados e outra de reprovados
2. Enquanto houver registros no arquivo faça:
a. Ler registro
b. Fazer media = (nota1 + nota2 + nota3) / 3
c. Se média maior ou igual a 7.0, inclua o aluno na coleção de
aprovados, senão coloque-o na coleção dos reprovados
3. Enquanto houver registros na coleção Aprovados faça:
a. Imprima registro
4. Enquanto houver registros na coleção Reprovados faça:
a. Imprima registro
Fim do Algoritmo
www.edeyson.com.br
Problemas:
Robô carteiro
Classificar/guardar candidatos por provas objetivas
Escrever um número por extenso
Cálculo do IRPF
Xadrez / Matrizes / Tabuleiro
Endentar IF / FOR
151

Programação com Pascal

Transcrição

Documentos relacionados

Maior substring em comum

Em uma pizzaria, cada tulipa de chopp custa R$ 0,80 e uma pizza

Fluxograma Direito Noturno - Departamento de Direito PUC-Rio

solução

Contadores, somadores e acumuladores

Introdução a Linguagem Pascal

Excel for Windows

Algoritmo do Método da Bissecção

Lista 4

Introdução