Lógica de Programação

Transcrição

ESCOLA
Lógica
de Programação
1
Escola Alcides Maya - Primeiro Módulo
Sumário
1 INTRODUÇÃO................................................................................................................................ 4
1.1 Definições básicas........................................................................................................................................................... 4
1.2 Necessidade do uso da lógica......................................................................................................................................... 4
1.3 Uso da lógica no desenvolvimento de programas........................................................................................................... 4
1.4 Diferenciação de nomenclaturas..................................................................................................................................... 5
2 INTRODUÇÃO À LÓGICA........................................................................................................... 6
2.1 Princípios de resolução de problemas............................................................................................................................. 6
2.2 Particularidades entre lógicas......................................................................................................................................... 6
2.2.1 Técnica Modular.......................................................................................................................................................... 7
2.2.2 Portugês Estruturada.................................................................................................................................................... 7
3 Técnicas Básicas de Programação.................................................................................................. 8
3.1 Tipos de Informação....................................................................................................................................................... 8
3.2 Tipos de Dados................................................................................................................................................................ 8
3.3 O Uso de Variáveis.......................................................................................................................................................... 8
3.4 O Uso de Constantes....................................................................................................................................................... 9
3.5 Os Operadores Aritméticos............................................................................................................................................. 9
3.6 As Expressões Aritméticas ou Fórmulas Matemáticas.................................................................................................. 9
3.7 Instruções Básicas....................................................................................................................... 10
3.7.1 Entrada, Processamento e Saída................................................................................................................................ 10
3.8 Exercícios de Aula....................................................................................................................................................... 13
3.9 Exercícios de Fixação................................................................................................................................................... 15
4 Estruturas de Controle – A Tomada de Decisões........................................................................ 16
4.1 Desvio Condicional Simples......................................................................................................................................... 17
4.1.1 Exercício de Aula....................................................................................................................................................... 18
4.2 Operadores Relacionais............................................................................................................................................... 18
4.3 Desvio Condicional Composto.................................................................................................................................... 18
4.5 Desvio Condicional Encadeado.................................................................................................................................... 21
4.7 Operadores Lógicos...................................................................................................................................................... 23
4.7.1 Operador Lógico: .e................................................................................................................................................... 24
4.7.1.1 Exercício de Aula.................................................................................................................................................... 24
4.7.2 Operador Lógico: .ou................................................................................................................................................. 25
4.7.3 Operador Lógico: .não............................................................................................................................................... 27
5 Estruturas de Controle – Laços de Repetição............................................................................ 32
5.1 Repetição do tipo: Teste Lógico no início do looping.................................................................................................. 33
5.1.1.1 Exercícios de Fixação............................................................................................................................................. 35
5.1.2 Exercícios de Fixação................................................................................................................................................ 36
5.2 Repetição do tipo: Teste Lógico no fim do looping...................................................................................................... 37
5.2.2 Exercício de Aula...................................................................................................................................................... 38
5.3 Repetição do tipo: Variável de Controle....................................................................................................................... 39
5.3.2 Exercícios de Fixação................................................................................................................................................ 40
6 Estruturas de Dados Homogêneas I............................................................................................. 42
6.1 Matrizes de uma dimensão ou vetores.......................................................................................................................... 43
2
6.2 Operações básicas com Matrizes de uma dimensão.................................................................................................... 44
6.2.1 Atribuição de uma Matriz......................................................................................................................................... 45
6.2.2 Leitura de dados de uma Matriz................................................................................................................................. 45
6.2.3 – Escrita dos dados de uma Matriz............................................................................................................................ 45
6.3 Exercício de Aula.......................................................................................................................................................... 46
7 Estruturas de Dados Homogêneas II........................................................................................... 49
7.1 Matrizes com mais de uma dimensão........................................................................................................................... 49
7.2 Operações básicas com matrizes de duas dimensões................................................................................................... 50
7.2.1 – Atribuição de uma Matriz....................................................................................................................................... 51
7.2.2 – Leitura de dados de uma Matriz.............................................................................................................................. 51
7.3 Exercício de Aula.......................................................................................................................................................... 52
7.4 Exercícios de Fixação.................................................................................................................. 53
8 Procedimentos e Funções ............................................................................................................. 54
3
1 INTRODUÇÃO
1.1 Definições básicas
Muitas pessoas gostam de falar ou julgar que possuem e sabem usar o raciocínio lógico, porém, quando
necessitam do mesmo, perdem esta linha de raciocínio, pois este depende de inúmeros fatores para completálo, tais como: calma, conhecimento, vivência, versatilidade, experiência, criatividade, ponderação,
responsabilidade, entre outros.
Para usar a lógica, é necessário ter domínio sobre o pensamento, bem como saber pensar, ou seja, possuir
a “Arte de Pensar”.
Lógica é a ciência que estuda as leis e critérios de validade que regem o pensamento e a
demonstração, ou seja, ciência dos princípios formais do raciocínio.
1.2 Necessidade do uso da lógica
Usar a lógica é um fator a ser considerado por todos, principalmente pelos profissionais da área de tecnologia
de informação, ou seja, pelos profissionais de informática.
Estes profissionais, no seu dia-a-dia dentro das organizações, têm a incumbência de solucionar problemas e
atingir os objetivos apresentados por seus usuários com eficiência e eficácia, utilizando recursos computacionais
e/ou automatizados.
Neste treinamento vamos mostrar como desenvolver e aperfeiçoar melhor esta técnica, lembrando que
para isto você deverá ser persistente e praticá-la constantemente, chegando à exaustão sempre que julgar
necessário.
1.3 Uso da lógica no desenvolvimento de programas
É comum aos bons programadores, na preparação de um novo programa, iniciar com um diagrama de
blocos para demonstrar sua linha de raciocínio lógico. Este diagrama também é chamado de fluxograma, e
estabelece a seqüência de operações a se efetuar em um programa.
Esta técnica permite uma posterior codificação em qualquer linguagem de programação.
A técnica mais importante no projeto de lógica de programas é chamada Programação Estruturada, a qual
consiste em uma Metodologia de Projeto, objetivando:
•
•
•
•
Agilizar a codificação do programa;
Facilitar a depuração do programa;
Permitir a verificação de possíveis falhas;
Facilitar as alterações e atualizações dos programas.
E deve ser composta por quatro passos fundamentais:
• Escrever as instruções em seqüências lógicas;
• Escrever instruções em grupos pequenos;
• Distribuir módulos de programa entre diferentes programadores para que trabalhem sob a supervisão de
um programador sênior;
• Revisar o trabalho executado, em reuniões regulares.
4
1.4 Diferenciação de nomenclaturas
Vamos identificar as diferenças entre as seguintes nomenclaturas:
Fluxograma: é uma ferramenta usada e desenvolvida pelo profissional que está envolvido diretamente
com programação, tendo como objetivo descrever o método e a seqüência do processo dos planos num
computador.
Português Estruturado: é uma ferramenta de representação textual de um determinado algoritmo
computacional. Este método é utilizado com a finalidade de apresentar uma codificação simples que seja de fácil
tradução para outras linguagens de programação de computador.
Algoritmo: é um processo de cálculo matemático ou de resolução de um grupo de problemas semelhantes.
Pode-se dizer, também, que são regras formais para obtenção de um resultado ou da solução de um problema,
englobando fórmulas de expressões aritméticas.
1.5 Formas de representação gráfica
É uma maneira simples e concisa de representar dados sobre uma superfície plana, por meio de diferentes
formas, de modo a facilitar a visualização completa e imediata de dados ou fenômenos tabulados.
1.6 Simbologias básicas
Estes são alguns dos símbolos mais utilizados ao longo dos anos pelos profissionais de Processamento de
Dados:
Terminal – símbolo utilizado como ponto para indicar o início e/ou fim do fluxo de um programa
Seta de fluxo de dados – permite indicar o sentido do fluxo de dados.
Processamento – Símbolo ou bloco que se utiliza pra indicar cálculos a efetuar, atribuições
de valores ou qualquer manipulação de dados que tenha um bloco específico para sua descrição.
Entrada e saída de dados – símbolo em função de um dispositivo qualquer de entrada ou
saída de dados, como fornecedor de informações para processamento, gravação e outros.
Decisão – indica a decisão que deve ser tomada indicando a possibilidade de desvio para
outros pontos do fluxo, dependendo do resultado de comparação e de acordo com situações variáveis.
5
Conector – utilizado quando é preciso particionar o fluxograma. Quando ocorrer mais de uma
partição, é colocada uma letra ou número dentro do símbolo de conexão para identificar os pares de ligação.
Conector – específico para indicar conexão do fluxo em outra página.
Módulo de sub-rotina
2 INTRODUÇÃO À LÓGICA
2.1 Princípios de resolução de problemas
Nós programadores que somos solucionadores de problemas, devemos entender que problema é uma
questão que foge a uma determinada regra, ou melhor, é o desvio de um percurso, o qual impede de atingir com
sucesso um determinado objetivo com eficiência e eficácia.
Portanto para resolver um problema de lógica usamos um procedimento de desenvolvimento para o fluxo de
informações.
Vamos usar como exemplo uma Escola Técnica de Informática, em que o cálculo da média é realizado por
quatro notas bimestrais que determinam a aprovação ou reprovação dos seus alunos. Considere que o valor da
média deva ser maior ou igual a 7 para que ocorra a aprovação.
A primeira etapa apresenta um detalhamento no que se refere à entrada e saída, ou seja, deve-se entrar
com as quatro notas bimestrais para se obter, como resultado, o cálculo da média e assim definir a aprovação
ou reprovação do aluno.
A segunda etapa consiste em trabalhar o termo: “determinar a aprovação”. Para ser possível determinar
algo, é necessário estabelecer uma condição. Assim sendo, uma condição envolve uma decisão a ser tomada
segundo um determinado resultado. No caso, a média. Desta forma, a condição de aprovação: média maior ou
igual a 7 deve ser considerada no algoritmo.
2.2 Particularidades entre lógicas
Como um Arquiteto desenha e escreve especificações para descrever como uma construção de um edifício
deverá ser efetuada e o engenheiro de projeto desenvolve um esquema detalhado das atividades de construção,
um especialista em informação desenvolve um plano, que será comunicado a outros, de como o problema de
processamento de dados deve ser resolvido.
Para auxiliarmos na sua compreensão, mostraremos como estes conceitos de estruturas, bem como as
particularidades de conexões e dos procedimentos entre o método lógico, encaixam-se ou não para resolução
dos problemas de processamento de dados. A seguir, são apresentados alguns tipos de procedimentos
individualmente.
6
2.2.1 Técnica Modular
Esta técnica deve ser elaborada como uma estrutura de partes independentes, denominada de módulos, cujo
procedimento é controlado por um conjunto de regras, onde suas metas são as seguintes:
• Decompor o problema em partes independentes;
• Dividir um problema complexo em problemas menores e mais simples;
• Verificar a correção de um módulo de blocos, independentemente de sua utilização como uma unidade em
processo maior.
A modularização deve ser desenvolvida, se possível, em diferentes níveis. Ela pode ser utilizada para separar
um problema em sistemas, um sistema em programas e um programa em módulos.
O modelo padrão de um módulo consiste em três partes: Entrada, Processamento e Saída.
Dados de
Entrada
Processo de
transformação
Dados de
Saída
2.2.2 Portugês Estruturada
É uma técnica narrativa denominada pseudocódigo, também conhecida como português estruturado ou
chamado por alguns de portugol.
Esta técnica de é baseada em uma PDL – Program Design Language (Linguagem de Projeto de Programação)
e é utilizada como referência genérica para uma linguagem de projeto de programação, tendo como
finalidade mostrar uma notação para elaboração de algoritmos, os quais serão utilizados na
definição, criação e desenvolvimento de uma linguagem computacional (Clipper, C, Pascal, Delphi) e
sua documentação. A seguir, é apresentado um exemplo deste tipo de algoritmo:
início
caractere: resultado;
real: n1, n2, n3, n4;
real: soma, media;
leia n1, n2, n3, n4;
soma  n1 + n2 + n3 + n4;
media  soma / 4;
se ( media >= 7 ) então
resultado  “Aprovado”;
senão
resultado  “Reprovado”;
fim_se
escreva “Nota 1: “, n1;
escreva “Soma: “, soma;
escreva “Média: “, media;
escreva “Resultado: “, resultado;
fim
7
A diferença entre uma linguagem de programação de alto nível utilizada em computação e uma PDL é que
esta não pode ser compilada em um computador.
3 Técnicas Básicas de Programação
A partir deste momento vamos ter um contato direto com a parte prática da Lógica de Programação.
Na parte anterior tivemos uma introdução teórica básica de alguns pontos e desta parte em diante teremos um
contato mais com a aplicação prática dos algoritmos, testes de mesa e por fim a codificação em pseudocódigo:
“Português estruturado”. Mas ainda são necessários alguns conceitos.
3.1 Tipos de Informação
Antes de iniciar o estudo de programação, é necessário considerar que um computador nada mais é do que
uma ferramenta utilizada para solucionar problemas que envolvam a manipulação de informações, sendo que
essas informações classificam-se em dois tipos básicos: dados e instruções.
3.2 Tipos de Dados
Os dados são representados pelas informações a serem tratadas (processadas) por um computador. Essas
informações estão caracterizadas por três tipos de dados, a saber: dados numéricos (inteiros e reais), dados
caracteres e dados lógicos.
Tipo de Dado
Inteiro
Descrição
São caracterizados como tipos inteiros os dados numéricos
positivos ou negativos, excluindo-se deste qualquer número
fracionário.
Exemplos
Real
São caracterizados como tipos reais os dados numéricos
positivos, negativos e números fracionários.
35
1.2
-45.897
Caracteres
São caracterizados como tipos caracteres às seqüências
contendo letras, números e símbolos especiais. Uma
seqüência de caracteres deve ser indicada entre aspas (“”).
Este tipo de dado é também conhecido como: alfanumérico,
string, literal ou cadeia.
“PROGAMAÇÃO”,
“Rua Alfa, 52 apto 1”
“Fone: 574-9988”
“90387-456”
“77”
Lógicos
São caracterizados como tipos lógicos os dados com
valores verdadeiro e falso, sendo que este tipo de dado
poderá representar apenas um dos dois valores. Ele também
é chamado de tipo booleano. Para facilitar a citação de um
dado do tipo lógico, fica declarado que estes deverão ser
apresentados e delimitados pelo caractere ponto (.).
.Falso.
.F.
.Verdadeiro.
.V.
35
0
-56
3.3 O Uso de Variáveis
Tem-se como definição de variável tudo aquilo que é sujeito a variações, que é incerto, instável ou inconstante.
E quando se fala de computadores, temos que ter em mente que o volume de informações a serem tratadas é
grande e diversificado. Desta forma, os dados a serem processados serão bastante variáveis.
Todo dado a ser armazenado na memória de um computador deve ser previamente identificado, ou seja,
primeiro é necessário saber qual o seu tipo para depois fazer o seu armazenamento adequado. Estando
armazenado o dado desejado, ele poderá ser utilizado e manipulado a qualquer momento.
8
Para utilizar o conceito de variável, imagine que a memória de um computador é um grande arquivo com
várias gavetas, sendo que cada gaveta pode armazenar apenas um único valor (Seja ele: numérico, lógico ou
caractere). Se for um grande arquivo com várias gavetas você há de concordar que é necessário identificar
com um nome a gaveta que se pretende utilizar. Desta forma o valor armazenado pode ser utilizado a qualquer
momento.
O nome de uma variável é utilizado para sua identificação e posterior uso em um programa. Sendo assim, é
necessário estabelecer algumas regras de utilização de variáveis:
•
•
•
•
•
Nomes de uma variável poderão ser atribuídos com um ou mais caracteres;
O primeiro caractere do nome de uma variável deverá ser uma letra;
O nome de uma variável não poderá possuir espaços em branco;
Não pode ser uma palavra reservada a uma instrução de programa;
Não poderão ser utilizados outros caracteres a não ser letras e números.
São nomes válidos de variáveis: nomeusuario, nome_cliente, fone1, delta25, z4, entre outros.
Devemos ainda considerar que dentro de um programa uma variável pode exercer dois papéis. Um de ação,
quando é modificada ao longo de um programa para apresentar um determinado resultado, e o segundo de
controle, a qual poderá ser “vigiada” e controlada durante a execução de um programa.
3.4 O Uso de Constantes
Tem-se como definição de constante tudo aquilo que é fixo ou estável.
Existirão vários momentos em que este conceito deverá estar em uso. Por exemplo, o valor 1.23 da fórmula
seguinte é uma constante: resultado = entrada * 1.23
3.5 Os Operadores Aritméticos
Tanto variáveis como constantes poderão ser utilizadas na elaboração de cálculos matemáticos, ou seja, na
elaboração de expressões aritméticas, desde que sejam estabelecidas como do tipo real ou inteira, e para que
isto ocorra é necessário à utilização de operadores aritméticos.
Veja a seguir a tabela dos operadores aritméticos
Operador
Operação
Tipo de resultado
h
Exponenciação
Inteiro ou Real
/
Divisão
Real
Div
Divisão
Inteiro
*
Multiplicação
Inteiro ou Real
+
Adição
Inteiro ou Real
-
Subtração
Inteiro ou Real
3.6 As Expressões Aritméticas ou Fórmulas Matemáticas
Será muito comum trabalharmos com expressões aritméticas ou fórmulas matemáticas, uma vez que a maior
parte do trabalho computacional está relacionada com a utilização de cálculos. Estas expressões são definidas
pelo relacionamento existentes entre variáveis e constantes numéricas por meio da utilização dos operadores
aritméticos.
Considere a fórmula: area = PI . raio² para o cálculo da área de uma circunferência, em que estão presentes
as variáveis área e raio, a constante PI (pi = 3.14159) e os operadores aritméticos de multiplicação e também a
operação de potência, elevando o valor da variável raio ao quadrado.
As expressões aritméticas em computação são escritas de uma forma um pouco diferente da forma conhecida
em matemática, por exemplo, a expressão: x = {43 . [55 : (30 + 2) ] } será escrita na forma computacional como:
x  (43 * (55 / (30 +2))).
9
Perceba que as chaves e colchetes são abolidos, utilizando-se em seu lugar apenas os parênteses. É também
substituído o sinal de (=) igual pelo sinal de () implicando ou atribuindo.
O sinal de atribuição () é utilizado para indicar que o valor de uma expressão aritmética ou fórmula está
sendo armazenado em uma variável. No caso da fórmula para o cálculo da área de uma circunferência, ela
poderia ser escrita da seguinte maneira: area  3.14159 * raio h2 ou area  3.14159 * raio * raio
3.7 Instruções Básicas
As instruções são representadas pelo conjunto de palavras-chave de uma determinada linguagem de
programação, que tem por finalidade comandar o computador.
Para a lógica de programação podemos utilizar o Português Estruturado.
Agora teremos contato com algumas instruções como: início, fim, var, programa, enquanto, se, então,
senão, escreva, leia, etc.
3.7.1 Entrada, Processamento e Saída
Para criar um programa que seja executável dentro de um computador, deve-se ter em mente três pontos
de trabalho: a entrada de dados, o seu processamento e a saída deles. Sendo assim todo programa estará
trabalhando com estes três conceitos.
O processo de execução de um programa ocorre após a entrada de dados com a instrução leia e a sua saída
com a instrução escreva. O processamento será uma conseqüência da manipulação das variáveis de ação.
Uma entrada e uma saída poderão ocorrer dentro de um computador de diversas formas. Por exemplo, uma
entrada poderá ser feita via teclado, modem, leitores óticos, disco, entre outros. Uma saída poderá ser feita em
vídeo, impressora, disco, entre outras formas. Devido a esta grande variedade, nossos programas escritos em
português estruturado farão menção às instruções leia e escreva.
Considere o seguinte exemplo de um problema: “Deverá ser criado um programa que efetue a leitura
de dois valores numéricos. Faça a operação de soma entre os dois valores e apresente o resultado
obtido”.
Note: Sempre estaremos diante de um problema, o qual deverá ser resolvido primeiro por nós, para que
depois seja resolvido por um computador. O que queremos dizer é que primeiro você deve entender bem o
problema, para depois buscar a sua solução dentro de um computador, ou seja, você deverá ensinar a máquina
a resolver o seu problema, por meio de um programa. Desta forma, o segredo de uma boa lógica está na
compreensão adequada do problema a ser solucionado.
Com relação ao problema proposto, deverá ser primeiro muito bem interpretado. Isto ocorre com o auxílio de
uma ferramenta denominado algoritmo, que deverá estabelecer todos os passos necessários a serem cumpridos
na busca de uma solução para um problema. Lembre-se de que um algoritmo é na verdade uma “receita” de
como fazer.
Para tanto, observe a estrutura do algoritmo com relação ao problema da leitura dos dois valores (que não
conhecemos e também não precisamos conhecer, pois neste caso utilizaremos duas variáveis para trabalhar
estas incógnitas A e B) e a sua respectiva soma (conseqüência dos valores informados, a qual também é uma
incógnita e depende dos valores fornecidos; utilizaremos para esta a variável X).
Algoritmo
1 – Ler dois valores, no caso as variáveis A e B;
2 – Efetuar a soma das variáveis A e B, atribuindo o seu resultado para a variável X;
3 – Apresentar o valor da variável X após a operação de soma dos dois valores fornecidos
Perceba que o algoritmo é a interpretação passo a passo de um determinado problema. É como ter um
problema matemático: “João foi à feira com R$ 20,00, comprou uma dúzia de laranjas por R$ 5,00. com quanto
João voltou para casa?”. Na verdade, o que interessa não é o fato ocorrido com João e sim efetuar os cálculos
necessários para se saber quanto sobrou na mão de João. Em processamento de dados é parecido, pois
precisamos somente efetuar o levantamento das variáveis e saber o que fazer com elas.
10
Fluxograma
Completada a fase de interpretação do problema e da definição das variáveis a serem utilizadas, passa-se
para a fase de diagramação do algoritmo, que é o fluxograma.
Inicio
Ler A
Ler B
X <-- A + B
Escrever X
Fim
Figura 3.1 – Fluxograma para leitura, soma de dois valores
e apresentação do resultado.
Observe a indicação de Início e Fim do fluxograma com o símbolo Terminal. Este símbolo deverá estar
sempre presente, indicando o ponto de início e fim de um fluxograma. Note também a existência de uma seta na
linha que liga um símbolo ao outro. Isto é necessário, pois desta forma sabe-se a direção que o processamento
de um programa deverá seguir.
O símbolo retângulo significa Processamento e será utilizado para representar diversas operações,
principalmente os cálculos matemáticos executados por um programa.
Português Estruturado
Podemos utilizar outra forma de representação da lógica do programa, através de uma representação textual
chamada: Português Estruturado.
A seguir escrevemos o programa nesta forma de representação:
início
inteiro: A, B, X;
leia A;
leia B;
X  A + B;
escreva X;
fim
11
Desta forma, são utilizadas três variáveis: A, B e X, estabelecendo-se assim o seu respectivo tipo.
Tendo relacionado todas as variáveis que serão utilizadas no programa, passa-se para a fase de montagem
do que está estabelecido no fluxograma, ou seja, de tudo que está relacionado entre os símbolos Terminal
(Indicação de início e fim do fluxograma)
Observe que o bloco de instruções de programa, indicado entre as instruções início e fim é apresentado
deslocado um pouco para a direita. Este estilo de escrita deve ser obedecido, para facilitar a leitura de um bloco
de programa, recebendo o nome de endentação.
Após a leitura dos valores para as variáveis A e B, eles serão somados e atribuídos na variável X, a qual será
apresentada com o valor da soma processada.
Codificação em Pascal
Para exemplificar vamos codificar o algoritmo que soma os números na linguagem Pascal:
program soma_num;
var
X : integer;
A : integer;
B : integer;
begin
readln (A);
readln (B);
X := A + B;
writeln (X);
end.
Depois de codificar o programa (escrever o programa em uma linguagem) você deve compilar o programa
fonte.
O que significa compilar? Compilar é: “Transformar a linguagem fonte do programa em um programa
executável”, ou seja, transformar o programa na linguagem de máquina.
Como compilamos? “Compilamos utilizando um programa especial que faz este trabalho”
Observação: Se houver problemas de sintaxe, se você escreveu alguma instrução errada, o compilador não
irá gerar o programa executável, ele apenas irá emitir uma mensagem de erro de sintaxe.
Se não houver erro na compilação, teremos o programa executável, também chamado de aplicativo, que será
utilizado para testar o programa, verificando se o mesmo faz o que o fluxograma determinou.
Resumindo: Para fazer o computador resolver um problema qualquer temos que:
1 – Fazer o algoritmo do problema
2 – Codificar o programa em uma linguagem de programação
3 – Compilar este programa para verificar erros de sintaxe e criar o programa executável
4 – Testar o programa executável
12
Codificação em Linguagem C
Agora vamos codificar o algoritmo que soma os números na linguagem C.
main( )
{
int X;
int A;
int B;
scanf(“%d”, &A);
scanf(“%d”, &B);
X = A + B;
printf(“%d”, X);
}
Depois de codificar este programa, você deverá também compilar, para verificar possíveis erros de sintaxe,
e testar o programa.
3.8 Exercícios de Aula
Abaixo são apresentados exemplos que aplicam os conceitos até aqui estudados. Sendo assim, olhe
atentamente cada exemplo para perceber os seus detalhes.
Trabalharemos apenas com o Português Estruturado, pois na disciplina de Fundamentos de Programação
você irá codificar o programa na linguagem C.
Primeiro exemplo
Desenvolver a lógica para um programa que efetue o cálculo da área de uma circunferência, apresentando
a área calculada.
Algoritmo
Para efetuar o cálculo da área de uma circunferência é necessário conhecer a fórmula que executa este
cálculo sendo esta: A = pR², em que A é a variável que conterá o resultado do cálculo da área, p é o valor de pi
(3.14159), sendo uma constante na fórmula e R o valor do raio. Sendo assim, basta estabelecer:
1 – Ler um valor para o raio, no caso a variável R;
2 – Estabelecer que PI possua o valor 3,14159;
3 – Efetuar o cálculo da área, elevando ao quadrado o valor de R e multiplicando por PI;
4 – Apresentar o valor da variável A.
A fórmula para o cálculo da área passará a ser escrita como: A  3.14159 * Rh2 ou se você preferir poderá
escrever da seguinte forma: A  3.14159 * R * R.
13
início
real: A, R;
escreva “Digite o valor do raio: “;
leia R;
A  3.14159 * R * R;
escreva “A área ´: “, A;
fim
Segundo exemplo
Construir um programa que efetue o cálculo do salário líquido de um professor. Para fazer este programa, você
deverá possuir alguns dados, tais como: valor da hora aula, número de horas trabalhadas no mês e percentual de
desconto do INSS. Em primeiro lugar, deve-se estabelecer qual será o seu salário bruto para efetuar o desconto
e ter o valor do salário líquido.
Algoritmo
1 – Estabelecer a leitura da variável HT (Horas trabalhadas no mês);
2 – Estabelecer a leitura da variável VH (valor hora aula);
3 – Estabelecer a leitura da variável PD (Percentual de desconto de INSS);
4 – Calcular o salário bruto (SB), sendo este a multiplicação das variáveis HT e VH;
5 – Calcular o total de desconto (TD) com base no valor de PD dividido por 100;
6 – Calcular o salário líquido (SL), deduzindo o desconto do salário bruto;
7 – Apresentar os valores dos salários bruto e líquido: SB, TD e SL.
início
inteiro: HT;
real : VH, PD, TD, SB, SL ;
escreva “Digite a quantidade de horas trabalhadas: “;
leia HT;
escreva “Digite o valor da hora: “;
leia VH;
escreva “Digite o percentual de desconto do INSS: “;
leia PD;
SB  HT * VH;
TD  ( PD / 100 ) * SB;
SL  SB – TD;
escreva “Valor do salário bruto....................: “, SB;
escreva “Total de desconto de INSS...........: “ , TD;
escreva “Valor do salário líquido..................: “ , SL;
fim
14
3.9 Exercícios de Fixação
1 – Indique com um X quais dos dados abaixo são do tipo Inteiro.
( ) 1000
( ) “0”
( ) “-900”
( ) .Verdadeiro.
( ) -456
( ) 34
( ) “Casa 8”
( )0
( ) .Falso.
( ) –1.56
2 – Indique com um X quais dos dados abaixo são do tipo Real.
( ) -678
( ) “0.87”
( ) “-9.12”
( ) .Verdadeiro.
( ) -456
( ) –99.8
( ) “Cinco”
( ) 45.8976
( ) .Falso.
( ) –1.56
3 – Indique com um X quais dos dados abaixo são do tipo Literal.
( ) 678
( ) “0.87”
( ) “-9.12”
( ) “Verdadeiro”
( ) -456
( ) –99.8
( ) “Cinco”
( ) 45.8976
( ) .Falso.
( ) –1.56
4 – Indique com um X quais dos dados abaixo são do tipo Lógico.
( ) -678
( ) “0.87”
( ) “-9.12”
( ) .Verdadeiro.
( ) -456
( ) .V.
( ) “Cinco”
( ) .Falso.
( ) .F.
( ) –1.56
15
5 Desenvolva os programas a seguir em português estruturado:
a) Ler dois valores numéricos. Calcular e apresentar o produto entre eles.
b) Ler três valores numéricos. Calcular e apresentar a média entre eles.
c) Ler a idade de uma pessoa. Calcular e apresentar a existência desta pessoa em número de dias, em
número de horas, em número de minutos e em número de segundos.
d) Ler uma temperatura em graus Fahrenheit e apresenta-la convertida em graus Celsius. A fórmula de
conversão é C  ( F – 32 ) * ( 5 / 9 ), sendo F a temperatura em Fahrenheit e C a temperatura em Celsius.
e) Calcular e apresentar o valor do volume de uma lata de óleo, utilizando a fórmula: VOLUME 
3.14159 * RAIO h 2 * ALTURA.
f) Efetuar o cálculo da quantidade de litros de combustível gasta em uma viagem, utilizando um automóvel
que faz 12 KM por litro. Para obter o cálculo, o usuário deve fornecer o tempo gasto (TEMPO) e a velocidade
média (VELOCIDADE) durante a viagem. Desta forma, será possível obter a distância percorrida com a fórmula
DISTÂNCIA  TEMPO * VELOCIDADE. Possuindo o valor da distância, basta calcular a quantidade de litros
de combustível utilizada na viagem com a fórmula LITROS_USADOS  DISTÂNCIA / 12. Ao final o programa
deve apresentar os valores da velocidade média (VELOCIDADE), tempo gasto na viagem (TEMPO), a distância
percorrida (DISTÂNCIA) e a quantidade de litros (LITROS_USADOS) utilizada na viagem.
g) Efetuar o cálculo e a apresentação do valor de uma prestação em atraso, utilizando a fórmula PRESTAÇÃO
 VALOR + (VALOR * (TAXA / 100) * TEMPO).
h) Ler dois valores (inteiros, reais ou caracteres) para as variáveis A e B, e efetuar a troca dos valores de
forma que a variável A passe a possuir o valor da variável B e a variável B passe a possuir o valor da variável A
. Apresentar os valores trocados.
i) Elaborar um programa que calcule e apresente o volume de uma caixa retangular por meio da fórmula
VOLUME  COMPRIMENTO * LARGURA * ALTURA.
j) Efetuar a leitura de um número inteiro e apresentar o resultado do quadrado desse número
k) Elaborar um programa que leia as 4 notas escolares de um aluno. Calcular e apresentar a média do
aluno.
l) Elaborar um programa que leia a idade de duas pessoas. Calcular e apresentar a diferença das idades.
m)Elaborar um programa que leia de um vendedor o salário fixo, o valor total de vendas por ele efetuadas na
loja e o percentual de comissão que ganha pelas vendas. Calcular e apresentar o valor da comissão que ele vai
receber e o salário total.
n) Elaborar um programa que calcula a área de um triângulo. O programa deve ler o valor da base e o valor
da altura do triângulo. A fórmula da área é: area = (base * altura) / 2. Após o calculo apresentar a área.
4 Estruturas de Controle – A Tomada de Decisões
Foi visto anteriormente como trabalhar com entrada, processamento e saída utilizando variáveis, constantes
e operadores aritméticos. Apesar de já se conseguir solucionar problemas e transformá-los em programas, os
recursos até aqui estudados são limitados, pois haverá momentos em que um determinado valor dentro de um
programa necessitará ser tratado para se efetuar um processamento mais adequado.
Imagine a seguinte situação: Um programa que apresente a média de um aluno e a informação se ele está
aprovado ou reprovado. Observe que será necessário verificar a média do aluno para tomar uma decisão no
sentido de apresentar a sua real situação: aprovado ou reprovado.
16
4.1 Desvio Condicional Simples
Para solucionar o problema proposto, é necessário trabalhar uma nova instrução: se...então...fim_se.
Fluxograma
Observe no fluxograma a existência das letras S e N, além das linhas com seta indicando a direção do
processamento, colocada juntamente com o símbolo de Decisão.
O S representa o sim e está posicionado para indicar que um determinado bloco de operações será executado
quando a condição atribuída for verdadeira.
O N está para não e será executado quando a condição for falsa.
O símbolo do losango, ou melhor, dizendo, Decisão deverá ser utilizado em situações em que haja necessidade
de usar uma decisão dentro do programa.
Uma decisão será tomada sempre com base em uma pergunta, como Resposta = sim, e é esta pergunta que
deverá estar indicada dentro do símbolo de losango.
Condição
Instruções executadas
quando a condição for
verdadeira
S
N
quando a condição for
falsa ou após ser
verdadeira
se (condição) então
< instruções para condição verdadeira >
fim_se
Sendo a condição verdadeira, serão executadas todas as instruções que estejam entre a instrução se...então
e a instrução fim-se.
Sendo a condição falsa, serão executadas as instruções que estejam após o comando fim_se.
17
4.1.1 Exercício de Aula
Primeiro exemplo
Desenvolver a lógica para um programa que leia dois valores numéricos. Efetuar a adição e apresentar o seu
resultado caso o valor somado seja maior que 10.
Algoritmo
1 – Ler um valor para a variável A e outro valor para a variável B;
2 – Efetuar a soma dos valores incógnitos A e B, atribuindo o valor da soma na variável X;
3 – Apresentar o valor da soma contido na variável X, caso o valor de X seja maior que 10.
início
inteiro: A, B, X;
escreva “Digite um número: “;
leia A;
escreva “Digite outro número: “;
leia B;
X  A + B;
se ( X > 10 ) então
escreva X;
fim se
fim
4.2 Operadores Relacionais
Ao utilizarmos os desvios condicionais necessitamos dos operadores relacionais.
Operador
>
>=
<
<=
=
Ação
maior que
maior ou igual a
menor que
menor ou igual a
igual a
Exemplo
5>2
5 >= 7
5<7
5 <= 7
5=7
Resultado
V
F
V
V
F
<>
Diferente
5<>7
V
4.3 Desvio Condicional Composto
Vamos aprender agora a fazer uso da instrução se...então...senão...fim_se.
Fluxograma.
18
Condição
quando condição
verdadeira
S
N
quando condição for
falsa
Figura 4.3 – Estrutura do símbolo para instrução se...então...senão...fim-se
se (condição) então
< instruções para condição verdadeira >
senão
< instruções para condição falsa >
fim se
Sendo a condição verdadeira, serão executadas todas as instruções que estejam posicionadas entre o se...
então e a instrução senão.
Sendo a condição falsa, serão executadas as instruções que estejam entre o senão e a instrução fim se.
Primeiro exemplo
Desenvolver a lógica para um programa que leia dois valores numéricos e efetue a adição destes valores.
Caso o valor somado seja maior ou igual a 10, deverá ser apresentado somando a ele mais 5; caso o valor
somado não seja maior ou igual a 10, este deverá ser apresentado subtraindo 7.
Algoritmo
1 – Ler um valor para a variável A e outro valor para a variável B;
2 – Efetuar a soma dos valores incógnitos A e B, atribuindo o valor da soma na variável X;
3 – Verificar se X é maior ou igual a 10; caso seja verdadeiro, calcule R  x + 5. Senão calcule R  X – 7
19
início
inteiro: A, B, X, R;
leia A;
escreva “Digite outro número: “;
leia B;
X  A + B;
se ( X >= 10 ) então
R  X + 5;
senão
R  X – 7;
fim se
escreva “O resultado é: “ , R;
fim
Observe que após a definição dos tipos de variáveis, é solicitada a leitura dos valores para as variáveis A e
B, depois esses valores são atribuídos na variável X, a qual possui o resultado da adição dos dois valores. Neste
ponto, é questionada no programa uma condição que permitirá escrever o resultado da soma adicionado de 5,
caso esta seja maior ou igual a 10, e não sendo, o programa apresentará o resultado subtraindo 7.
Vamos fazer alguns exercícios:
a) Faça um Programa que leia dois números quaisquer, e escreva o maior deles.
b) Faça um Programa que leia um número inteiro. Informar se o número é “PAR” ou “ÍMPAR”.
c) Faça um Programa que leia dois números quaisquer, e escreva o resultado do cálculo do maior dividido
pelo menor.
d) Faça um Programa que leia a receita e a despesa de uma empresa e apresente se ela está com LUCRO
ou com PREJUÍZO.
e) Faça um Programa que leia 4 notas escolares de um aluno. Calcule e apresente a média. Sabendo-se que
a média de aprovação da escola é 7, apresente a informação se o aluno foi APROVADO ou REPROVADO.
f) Faça um Programa que leia dois números e apresente o sinal do produto entre eles. Considere que
somente números diferentes de zero serão digitados.
g) Faça um Programa que leia um número e escreva “maior do que 100”, se o número digitado for maior que
100 e escreva “menor do que 100”, se o número for menor do que 100.
h) Faça um Programa que leia um código:1 – sinal vermelho, 2 – sinal verde. Baseado no código digitado
diga para o pedestre que está esperando no sinal:“SIGA” ou “ESPERE”
i) Faça um Programa que leia a quantidade de vitórias e a quantidade de derrotas de um time de futebol.
Escrever BOM se o número de vitórias for maior que o número de derrotas, caso contrário escrever RUIM.
20
4.5 Desvio Condicional Encadeado
Existem casos em que é necessário estabelecer a verificação de condições sucessivas, em que uma
determinada ação poderá ser executada se um conjunto anterior de instruções ou condições for satisfeito.
Sendo a ação executada, ela poderá ainda estabelecer novas condições. Isto significa utilizar uma condição
dentro de outra condição. Este tipo de estrutura poderá possuir diversos níveis de condição, sendo chamadas
de encadeamentos.
Fluxograma
Condição1
quando condição 1
verdadeira
S
N
Condição2
quando condição 1 é
falsa, mas a condição 2
é verdadeira
S
N
quando condição 1 e
condição 2 são falsas
21
Figura 4.5 – Estrutura condicional composta ou encadeada.
se (condição 1) então
< instruções para condição 1 verdadeira >
senão
se (condição 2) então
< instruções para condição 2 verdadeira >
senão
< instruções para condição 1 e condição 2 falsa >
fim se
fim se
Primeiro exemplo
Desenvolver a lógica para um programa que efetue o cálculo do reajuste de salário de um funcionário.
Considere que o funcionário deverá receber um reajuste de 15% caso seu salário seja menor ou igual a 500. Se
o salário for maior que 500, mas, menor ou igual a 1000, seu reajuste será de 10%; caso seja ainda maior que
1000, o reajuste deverá ser de 5%”.
Algoritmo
Perceba que o problema em questão estabelece três condições para calcular o reajuste do salário do
funcionário, sendo:
• Salário <= 500, reajuste de 15%
• Salário > 500, mas <= 1000, reajuste será de 10%
• Salário > 1000, reajuste será de 5%
Estas condições deverão ser encadeadas, pois todas as possibilidades de reajuste deverão ser cercadas.
Sendo assim, observe o algoritmo abaixo:
1 – Definir uma variável para o salário reajustado: novo_salario;
2 – Ler um valor para a variável salário;
3 – Verificar se o valor de salario <= 500, se sim reajustar em 15%;
4 – Verificar se o valor de salario <= 1000, se sim reajustar em 10%;
5 – Verificar se o valor de salario > 1000, se sim reajustar em 5%;
6 – Apresentar o valor reajustado, atribuindo a novo_salário.
início
real: salário, novo_salario;
escreva “Digite o valor do salário: “;
leia salario;
se ( salario <= 500 ) então
novo_salário  salário * ( 15 / 100 );
senão
se ( salario <= 1000 ) então
senao
22
fim se
fim se
escreva “O valor do novo salário é: “ ,novo_salario;
fim
Vamos fazer alguns exercícios
a) Faça um Programa que leia o valor do salário hora, a quantidade de horas trabalhadas e a quantidade
de filho menores de 14 anos de um funcionário. Calcular o valor do salário bruto. Para calcular o valor do salário
família levar em consideração o seguinte:
• Se o salário bruto for até R$ 500,00 o salário família será de R$ 10,50 por cada filho;
• Se o salário bruto for acima de R$ 500,00 até R$ 1.000,00 o salário família será de R$ 6,50 por cada
filho;
• Se o salário bruto for acima de R$ 1.000,00 o salário família será de R$ 1,50 por cada filho.
No final apresentar o valor do salário bruto e o valor do salário família a ser recebido.
b) Faça um Programa que leia o salário bruto de uma pessoa e calcule o desconto do INSS levando em
consideração o seguinte:
• Para salários até R$ 500,00 a alíquota de INSS será de 8%
• Para sal.acima de R$ 500,00 até R$ 1.000,00 a alíquota de INSS será de 10%
• Para sal.acima de R$ 1.000,00 a alíquota de INSS será de 12%.
No final deverá ser apresentado:
•
•
•
•
Salário bruto
Taxa de INSS
Valor de INSS
Salário líquido
c) Faça um Programa que leia o código de uma mercadoria e que escreva o nome do produto conforme
tabela abaixo:
1 – Sabão
2 – Vassoura
3 – Detergente
4.7 Operadores Lógicos
Pode ser que você necessite, em algum momento, trabalhar com o relacionamento de duas ou mais condições
ao mesmo tempo na mesma instrução se, efetuando desta forma testes múltiplos. Para estes casos é necessário
trabalhar com a utilização dos operadores lógicos.
Os operadores lógicos mais comuns são: .e., .ou. e .não., e serão representadores em português estruturado
sempre entre pontos.
Em alguns casos, o uso de operadores lógicos evita a utilização de instruções se encadeadas.
23
4.7.1 Operador Lógico: .e.
O operador do tipo .e. é utilizado quando dois ou mais relacionamentos lógicos de uma determinada condição
necessitam ser verdadeiros.
Condição 1
Condição 2
Resultado
Falsa
Falsa
Falso
Verdadeira
Falsa
Falso
Verdadeira
Verdadeira
Verdadeiro
Para facilitar a compreensão deste operador imagine que você possua dois fios ligados a uma lâmpada e a
uma bateria. A lâmpada somente acenderá se você tiver ligado ambos os fios aos pólos da bateria. Acompanhe
esse exemplo no seguinte diagrama:
Fio Vermelho Ligado
Fio Preto Ligado
Lâmpada Acende
Falso
Falso
Falso
Verdadeiro
Falso
Falso
Falso
Verdadeiro
Falso
Verdadeiro
Verdadeiro
Verdadeiro
se (condição 1) .e. (condição 2) então
< instruções executadas se condição 1 e condição 2 verdadeiras >
fim_se
O operador .e. faz com que somente seja executada uma determinada operação se todas as condições
mencionadas forem simultaneamente verdadeiras.
4.7.1.1 Exercício de Aula
Primeiro exemplo
Desenvolver a lógica para um programa que leia um número. Informar se o número digitado está na faixa de
20 a 90.
Algoritmo
1 – Ler um valor para a variável num;
2 – Se o valor digitado estiver na faixa de 20 a 90 apresentar uma mensagem informando.
início
inteiro: num;
leia num;
se ( num >= 20 ) .e. ( num <= 90 ) então
escreva “O número está na faixa de 20 a 90”;
senão
escreva “O número está fora da faixa de 20 a 90”;
fim se
fim
24
O exemplo mostra, por meio da utilização do operador .e. que somente será apresentada a mensagem “O
número está na faixa de 20 a 90”, caso o valor fornecido para a variável num seja entre 20 e 90. Qualquer valor
fornecido fora da faixa definida apresentará a mensagem “O número não está na faixa de 20 a 90”.
Segundo exemplo
Desenvolver a lógica para um programa que leia um ângulo (entre 0º e 360º) e que escreva o quadrante ao
qual pertence. Ignorar os eixos.
Algoritmo
1 – Ler um valor para a variável angulo;
2 – Verificar se o ângulo digitado é > 0 e < 90, se for verdade: “ângulo está no primeiro quadrante”
3 – Verificar se o ângulo digitado é > 90 e < 180, se for verdade: “ângulo está no segundo quadrante”
4 – Verificar se o ângulo digitado é > 180 e < 270, se for verdade: “ângulo está no terceiro quadrante”
5 – Verificar se o ângulo digitado é > 270 e < 360, se for verdade: “ângulo está no quarto quadrante”
início
inteiro: ângulo;
escreva “Digite um ângulo: “;
leia angulo;
se ( angulo > 0 ) .e. ( angulo < 90 ) então
escreva “Ângulo está no primeiro quadrante”;
senão
escreva “Ângulo está no segundo quadrante”;
senão
escreva “Ângulo está no terceiro quadrante”;
senão
escreva “Ângulo está no quarto quadrante”;
fim se
fim se
fim se
fim se
fim
O programa acima não se preocupa se o usuário digitar um valor indevido, ou seja, se não estiver na faixa
ou estiver em um dos eixos. Este exemplo foi feito desta forma para que possamos nos concentrar apenas no
operador lógico .e.
4.7.2 Operador Lógico: .ou.
O operador do tipo .ou. é utilizado quando pelo menos um dos relacionamentos lógicos (quando houver mais
de um relacionamento) de uma condição necessita ser verdadeiro. Abaixo, é apresentada a tabela de decisão
para este tipo de operador:
Condição 1
Condição 2
Resultado
Falsa
Falsa
Falso
Verdadeira
Falsa
Verdadeiro
Falsa
Verdadeira
Verdadeiro
Verdadeira
Verdadeira
Verdadeiro
Considere agora, como exemplo, que você deseja escrever uma carta. Se você tiver uma máquina de escrever
25
ou (OR) um microcomputador, pode tranqüilamente satisfazer seu desejo. Acompanhe o diagrama em seguida:
Tem Máquina
Tem Computador
Pode Escrever
Falso
Falso
Falso
Verdadeiro
Falso
Verdadeiro
Falso
Verdadeiro
Verdadeiro
Verdadeiro
Verdadeiro
Verdadeiro
se (condição 1) .ou. (condição 2) então
< instruções executadas se condição 1 ou se condição 2 for verdadeiras >
fim_se
O operador .ou. faz com que seja executada uma determinada operação se pelo menos uma das condições
mencionadas for verdadeira.
Primeiro exemplo
Desenvolver a lógica para um programa que leia o código relativo ao sexo (masculino=1 ou feminino=2). Se
for digitado um código correto informar que o código é válido, caso contrário informar que o código é inválido.
Algoritmo
1 – Ler um código numérico para a variável codigo;
2 – Se o código digitado for igual a 1 ou igual a 2 apresentar uma mensagem informando que o código é válido
caso contrário informar que o código é inválido.
início
inteiro: código;
escreva “ Digite um código: “;
leia código;
se ( codigo = 1 ) .ou. ( código = 2 ) então
escreva “O código do sexo é válido”;
senão
escreva “O código do sexo é inválido” ;
fim se
fim
O exemplo mostra, por meio da utilização do operador .ou. que somente será apresentada a mensagem “O
código do sexo é válido”, caso o valor fornecido para a variável codigo seja 1 ou 2. Qualquer outro valor fornecido
apresentará a mensagem: “O código do sexo é inválido”.
26
4.7.3 Operador Lógico: .não.
O operador do tipo .não. é utilizado quando houver necessidade de estabelecer a inversão do resultado
lógico de uma determinada condição. Se a condição for verdadeira, será considerada falsa. Se a condição for
falsa, será considerada verdadeira. Abaixo, é apresentada a tabela de decisão para este tipo de operador:
Condição
Resultado
Falsa
Verdadeiro
Falsa
Verdadeiro
Considere agora, como exemplo, que se você possui um carro e o pneu está furado, você não (NOT) pode
viajar. É o que mostra a tabela abaixo:
Peneu Está furado
Resultado
Falso
Verdadeiro
Verdadeiro
Falso
se .não. (condição) então
< instruções executadas se condição não for verdadeira >
fim se
O operador .não. faz com que seja executada uma determinada operação se a condição não for verdadeira,
portanto, considerada falsa ou vice-versa.
Primeiro exemplo
Desenvolver a lógica para um programa que somente efetue o cálculo de C  (A + B) * X, se o valor da
variável X não for maior que 5. Qualquer valor de 5 para baixo efetuará o cálculo C  (A + B) * X.
Se forem informados os valores 5, 1 e 2, respectivamente, para as variáveis A, B e X, resultará para a
variável C o valor 12, pois o valor 2 da variável X é controlado pela instrução se .não. (X > 5) então, como
sendo verdadeiro, uma vez que não é maior que 5. Sendo assim, os valores 5 e 1 são somados resultando 6 e
multiplicados por 2 resultando 12.
Mas se forem informados os valores 5, 1 e 6, respectivamente, para as variáveis A, B e X, resultará para a
variável C o valor 24, pois o valor 6 da variável X é controlado pela instrução se. não. (X > 5) então, como sendo
falso. Sendo assim, os valores 5 e 1 são subtraídos resultando 4 e multiplicados por 6 resultando 24.
Algoritmo
1 – Ler um valor numérico para a variável A ,B, X;
2 – Se .não. (X > 5) então calcular: C  (A + B) * X caso contrário calcular: C  (A – B) * X
3 - Apresentar o valor do resultado do cálculo.
início
inteiro: A, B, C, X;
leia A, B, X;
se .não. ( X > 5 ) então
C  (A + B) * X;
senão
C  (A – B) * X;
fim se
27
escreva C;
fim
Segundo exemplo
Ler três valores para os lados de um triângulo, considerando lados como: A, B e C. Verificar se os lados
fornecidos formam realmente um triângulo, e se for esta condição verdadeira, deverá ser indicado qual tipo de
triângulo foi formado: isósceles, escaleno ou eqüilátero.
Algoritmo
Para estabelecer este algoritmo, é necessário em primeiro lugar saber o que realmente é um triângulo. Se
você não souber o que é um triângulo, conseqüentemente não conseguirá resolver o problema.
Triângulo é uma forma geométrica (polígono) composta por três lados, sendo que cada lado é menor que
a soma dos outros dois lados. Perceba que isto é uma regra (uma condição) e deverá ser considerada. É um
triângulo quando A<B+C, quando B<A+C e quando C<A+B.
Tendo certeza de que os valores informados para os três lados formam um triângulo, serão então analisados
os valores para estabelecer qual tipo de triângulo será formado: isósceles, escaleno ou eqüilátero.
Um triângulo é isósceles quando possui dois lados iguais e um diferente, sendo A=B ou A=C ou B=C; é
escaleno quando possui todos os lados diferentes, sendo A<>B e B<>C e é eqüilátero quando possui todos os
lados iguais, sendo A=B e B=C.
1 – Ler três valores para os lados de um triângulo: A, B e C;
2 – Verificar se cada lado é menor que a soma dos outros dois lados. Se sim, saber se A=B e B=C, sendo
verdade o triângulo é eqüilátero.
Se não, verificar se A=B ou A=C ou B=C, sendo verdade o triângulo é isósceles; caso contrário, o triângulo
é escaleno.
3 – Caso os lados fornecidos não caracterizem um triângulo, avisar a ocorrência.
início
real: A, B, C ;
leia A, B, C;
se ( A < B + C ) .e. ( B < A + C ) .e. ( C < A + B ) então
se ( A = B ) .e. ( B = C ) então
escreva “Triângulo Eqüilátero”;
senão
se ( A = B ) .ou. ( A = C ) .ou. ( C = B ) então
escreva “Triângulo Isósceles”;
senão
escreva “Triângulo Escaleno”;
fim se
fim se
senão
escreva “As medidas não formam um triângulo”;
fim se
fim
28
1. Faça um Programa que leia as coordenadas de um ponto no plano (x,y) e escreva o quadrante ao qual
pertence o ponto no plano. No primeiro quadrante x e y são positivos. No segundo quadrante y é positivo. No
terceiro quadrante nem x nem y é positivo. No quarto quadrante x é positivo.
Y
Segundo
Quadrante
Primeiro
Quadrante
X
Terceiro
Quadrante
Quarto
Quadrante
2. Faça um Programa que leia o QI de uma pessoa e escreva uma mensagem baseada na tabela abaixo.
Observe que os colchetes identificam um intervalo fechado e os parênteses identificam um intervalo aberto.
[ 000, 030 ) -
[ 030, 050 ) -
[ 050, 070 ) -
[ 070, 100 ) -
[ 100, 150 ] -
Outros
-
Ameba
Débil Mental
Regular
Normal
Gênio
QI inválido
3. Faça um Programa que leia três notas de uma pessoa. Calcular a média e apresentar um conceito
conforme a tabela abaixo:
[ 10, 09 ]-
( 09, 07 ]-
( 07, 04 ]-
( 04, 00 ]-
A
B
C
D
4. A empresa XYZ & Cia Ltda decidiu conceder um aumento de salários a seus funcionários de acordo com
a tabela abaixo:
SALÁRIO ATUAL
ÍNDICE DE AUMENTO
De 0 até 400
15%
Acima de 400 até 700
12%
10%
7%
4%
Acima de 2500
0%
29
Faça um Programa que leia o número do funcionário, o seu salário atual. Calcular e apresentar o valor do
salário já corrigido.
5. Determine o resultado lógico das expressões mencionadas, assinalando se são verdadeiras ou falsas..
Considere para as repostas os seguintes valores: X = 1, A = 3, B = 5, C = 8 e D = 7.
a) .não. ( X > 3 )
Verdadeiro ( )
Falso ( )
b) ( X < 1 ) .e. ( B > D)
Verdadeiro ( )
Falso ( )
c) ( D < 0 ) .e. ( C > 5 ) Verdadeiro ( )
Falso ( )
d) ( X > 3 ) .ou. ( C < 7 ) Verdadeiro ( )
Falso ( )
e) ( A > B ) .ou. ( C > B ) Verdadeiro ( )
Falso ( )
f) ( X >= 2 )
Verdadeiro ( )
Falso ( )
g) ( X < 1 ) .e. ( B >= D ) Verdadeiro ( )
Falso ( )
h) ( D < 0 ) .ou. ( C > 5 ) Verdadeiro ( )
Falso ( )
i) .não. ( D > 3 )
Verdadeiro ( )
Falso ( )
j) ( A > B ) .ou. ( C < B ) Verdadeiro ( )
Falso ( )
6. Indique a saída dos trechos de programa em português estruturado, mostrado abaixo. Para as saídas
considere os seguintes valores: A=2, B=3, C=5 e D=9. Não é necessário calcular os valores de X. Marque na
resposta apenas a fórmula que será executada de acordo com a condição.
a – Resposta: ____________________________________________________________________
se ( D > 5 ) então
X(A+B)*D
senão
X(A–B)/C
fim se
escreva X
b – Resposta: ____________________________________________________________________
se ( A > 2 ) .e. ( B < 7 ) então
X(A+2)*(B–2)
senão
X(A+B)/D*(C+D)
fim se
escreva X
c – Resposta: ____________________________________________________________________
se ( A = 2 ) .ou. ( B < 7 ) então
X(A+2)*(B–2)
senão
X(A+B)/D*(C+D)
fim se
escreva X
30
d – Resposta: ____________________________________________________________________
se ( A > 2 ) .ou. ( B < 7 ) então
X A+B -2
senão
X A–B
fim se
escreva X
e – Resposta: ____________________________________________________________________
se .não. ( A > 2 ) .ou. .não. ( B < 7 ) então
XA+B
senão
XA/B
fim se
escreva X
f – Resposta: ____________________________________________________________________
se ( A > 3 ) .e. ( B < 5 ) então
XA+D
senão
XD/B
fim se
escreva X
g – Resposta: ____________________________________________________________________
se ( C >= 2 ) .e. ( B <= 7 ) então
X(A+B)/2
senão
XD*C
fim se
escreva X
h – Resposta: ____________________________________________________________________
se ( A >= 2 ) .ou. ( C <= 1 ) então
X(A+D)/2
senão
X A*C
fim se
escreva X
31
7. Desenvolva os algoritmos em português estruturado dos seguintes programas:
a) Ler dois valores numéricos inteiros e apresentar o resultado da diferença do maior pelo menor valor.
b) Efetuar a leitura de um valor inteiro positivo ou negativo e apresentar o número lido como sendo um valor
positivo, ou seja, o programa deverá apresentar o módulo de um número fornecido. Lembre-se de verificar se o
número fornecido é menor que zero; sendo, multiplique-o por –1.
c) Ler quatro valores referentes a quatro notas escolares de um aluno e escrever uma mensagem dizendo
que o aluno foi aprovado, se o valor da média escolar for maior ou igual a 7. Se o aluno não for aprovado indicar
uma mensagem informando esta condição. Apresentar junto das mensagens o valor da média do aluno para
qualquer condição.
d) Ler quatro valores referentes a quatro notas escolares de um aluno e escrever uma mensagem dizendo
que o aluno foi aprovado, se o valor da média escolar for maior ou igual a 7. Se o valor da média for menor do
que 7, solicitar a nota de exame, somar com o valor da média e obter nova média. Se a nova média for maior ou
igual a 5, apresentar uma mensagem dizendo que o aluno foi aprovado em exame. Se o aluno não foi aprovado,
indicar uma mensagem informando esta condição. Apresentar com as mensagens o valor da média do aluno,
para qualquer condição.
e) Efetuar a leitura de três valores (variáveis A, B e C) e efetuar o cálculo da equação completa de segundo
grau, apresentando as duas raízes, se para os valores informados for possível efetuar o referido cálculo. Lembrese de que a variável A deve ser diferente de zero.
f) Efetuar a leitura de três valores (variáveis A, B e C) e apresenta-los dispostos em ordem crescente. Para
solucionar o problema, utilizar os conceitos da propriedade distributiva e troca de valores entre variáveis.
g) Efetuar a leitura de quatro números inteiros e apresentar os números que são divisíveis por 2 e 3.
h) Efetuar a leitura de cinco números inteiros e identificar o maior e o menor valores.
i) Elaborar um programa que efetue a leitura de um número inteiro e apresentar uma mensagem informando
se o número é par ou ímpar.
j) Elaborar um programa que efetue a leitura de um valor que esteja entre a faixa de 1 a 9. Após a leitura
do valor fornecido pelo usuário, o programa deverá indicar uma de duas mensagens: “O valor está na faixa
permitida”, caso o usuário forneça o valor nesta faixa, ou a mensagem “O valor está fora da faixa permitida”, caso
o usuário forneça valores menores que 1 ou maiores que 9.
k) Elaborar um programa que efetue a leitura de um número inteiro e efetue a sua apresentação, caso o valor
não seja maior que três.
5 Estruturas de Controle – Laços de Repetição
Existem ocasiões em que é necessário efetuar a repetição de um trecho de programa um determinado
número de vezes. Neste caso, poderá ser criado um looping que efetue o processamento de um determinado
trecho, tantas vezes quantas forem necessárias. Os loopings também são chamados de laços de repetição.
Supondo que um programa deva executar um determinado trecho de instruções por cinco vezes. Com o
conhecimento adquirido até este momento, você iria escrever o mesmo trecho, repetindo-o o número de vezes
necessárias.
Por exemplo, imagine um programa que peça a leitura de um valor para a variável num, multiplique esse valor
por 3, colocando a resposta na variável result e apresente o valor obtido, repetindo esta seqüência por cinco
vezes, conforme mostrado abaixo:
início
inteiro: num, result;
leia num;
result  num * 3;
escreva result;
leia num;
32
result  num * 3;
escreva result;
leia num;
result  num * 3;
escreva result;
leia num;
result  num * 3;
escreva result;
leia num;
result  num * 3;
escreva result;
fim
Para estes casos existem comandos apropriados para efetuar a repetição de determinados trechos de
programas o número de vezes que for necessário. A principal vantagem deste recurso é que o programa passa
a ter um tamanho menor, podendo sua amplitude de processamento ser aumentada sem alterar o tamanho do
código de programação. Desta forma, pode-se determinar repetições com números variados de vezes.
5.1 Repetição do tipo: Teste Lógico no início do looping
Caracteriza-se por uma estrutura que efetua um teste lógico no início de um looping, verificando se é permitido
executar o trecho de instruções subordinado a esse looping. A estrutura em questão é denominada de enquanto,
sendo conseguida com a utilização do conjunto de instruções enquanto...faça...fim_enquanto.
A estrutura enquanto...faça...fim_enquanto tem o seu funcionamento controlado por decisão. Sendo assim,
poderá executar um determinado conjunto de instruções enquanto a condição verificada for Verdadeira. No
momento em que esta condição se torna Falsa, o processamento da rotina é desviado para fora do looping. Se
a condição for Falsa logo de início, as instruções contidas no looping são ignoradas.
33
No início desta aula fizemos um programa que fazia a leitura de um valor para a variável num, multiplicava
esse valor por 3, colocando a resposta na variável result e apresentava o valor obtido, repetindo esta seqüência
por cinco vezes, porque não conhecíamos a estrutura enquanto...faça...fim_enquanto, agora vamos fazer o
mesmo exemplo utilizando a estrutura para o controle do laço de repetição.
Fluxograma
Cuidado para não confundir esta nova estrutura com a estrutura de decisão usada anteriormente. Aqui existe
um retorno à condição após a execução do bloco de operações, até que a condição se torne falsa.
Condição
N
S
Instruções
executadas enquanto
a condição é
verdadeira
Figura 5.2 – Fluxograma da instrução enquanto...faça...fim_enquanto
Primeiro exemplo
Desenvolver a lógica para um programa que faça a leitura de um valor para a variável num, multiplique esse
valor por 3, colocando a resposta na variável result e apresentar o valor obtido, repetindo esta seqüência por
cinco vezes.
Algoritmo
1 – Criar uma variável para servir de contador com valor inicial 1;
2 – Enquanto o valor do contador for menor ou igual a 5, processar os passos 3, 4, 5 e 6
4 – Efetuar a multiplicação do valor de num por 3, atribuindo o resultado em result;
5 – Apresentar o valor calculado contido na variável result;
6 – Acrescentar +1 a variável do tipo contador, definida no passo 1;
7 – Quando contador for maior que 5, encerrar o processamento do looping.
34
início
inteiro: cont;
cont  1;
enquanto ( cont <= 5 ) faça
leia num;
result  num * 3;
escreva result;
cont  cont + 1;
fim enquanto
fim
Além da utilização das variáveis num e result, foi necessário criar uma terceira variável (cont) para controlar
a contagem do número de vezes que o trecho de programa deverá ser executado.
Logo após o início do programa, a variável contador é atribuída com o valor 1 (cont  1). Em seguida, a
instrução enquanto (cont <= 5) faça efetua a checagem da condição estabelecida, verificando que a condição é
verdadeira, pois o valor da variável cont que neste momento é 1, é realmente menor ou igual a 5, e enquanto for
deverá processar o looping.
Sendo assim, tem início a execução da rotina de instruções contidas entre as instruções enquanto
e a instrução fim enquanto.
Depois de efetuar a primeira leitura, cálculo e apresentação do valor calculado, o programa encontra a linha
cont  cont + 1, reinicializando o conteúdo da variável contador. Observe que a variável cont possui neste
momento o valor 1 e somado a mais 1 esta passa a ter o valor 2, ou seja, cont  cont + 1, sendo assim cont 
1 + 1 que resultará cont = 2.
Agora que a variável cont possui o valor 2, o processamento do programa volta para a instrução enquanto
(cont <= 5 ) faça, uma vez que o valor da variável cont é menor ou igual a 5.
Será então executada a rotina de instruções, só que desta vez a variável cont passará a possuir o valor 3.
Desta forma o programa processará novamente a rotina de instruções, passando o valor de cont para 4 que
será verificado e sendo menor ou igual a 5, será executada mais uma vez a mesma rotina de instruções. Neste
ponto, a variável cont passa a possuir o valor 5. Perceba que a instrução enquanto (cont <= 5) faça irá efetuar
a checagem do valor da variável cont que é 5 com a condição cont <= 5. Veja que 5 não é menor que 5, mas é
igual. Sendo esta condição verdadeira, deverá a rotina ser executada mais uma vez.
Neste momento, o valor da variável cont passa a ser 6, que resultará para a instrução enquanto uma condição
falsa. E por conseguinte, desviará o processamento para a primeira instrução após a instrução fim_enquanto que
no caso é a instrução fim, dando o encerramento do programa.
5.1.1.1 Exercícios de Fixação
1. Faça um Programa que escreva na tela os números de 0 até 20.
2. Faça um Programa que escreva na tela os números pares de 0 até 20.
3. Faça um Programa que escreva na tela os números de 20 até 0
4. Faça um Programa que leia 10 valores inteiros e escreva no final a soma dos valores lidos.
5. Faça um Programa que leia 10 valores inteiros e escreva no final a média dos valores lidos.
6. Faça um Programa que leia 20 valores e escreva no final a soma dos valores positivos e a média dos
negativos.
5.1.2 – Exercício de Aula
35
Segundo exemplo
Para ilustrar de forma um pouco diferente, imagine que o primeiro exemplo deverá ser executado enquanto
o usuário queira. Desta forma, em vez de possuir dentro da rotina um contador de vezes, pode-se possuir uma
instrução pedindo que o usuário informe se deseja continuar ou não.
Algoritmo
1 – Criar uma variável para ser utilizada como resposta;
2 – Enquanto a reposta for sim, executar os passos 3, 4 e 5.
6 – Quando a resposta for diferente de sim, encerrar o processamento do looping.
início
caractere: resp;
resp  ‘S’;
enquanto ( resp = ‘S’ ) faça
leia num;
result  num * 3;
escreva result;
escreva “Deseja continuar ?”;
leia resp;
fim enquanto
fim
Veja que o contador foi substituído pela variável resp, que enquanto for igual a ‘S’ executará a rotina existente
entre as instruções enquanto e fim_enquanto.
Neste caso, o número de vezes que a rotina irá repetir será controlado pelo usuário e será encerrada somente
quando alguma informação diferente de ‘S’ for fornecida para a variável resp.
5.1.2 Exercícios de Fixação
1. Faça um Programa que leia números até que o usuário não queira
escrever a soma dos valores lidos.
escrever a média dos valores lidos.
escrever a soma dos valores positivos e a soma dos valores negativos.
escrever a soma dos valores positivos e a média dos valores negativos.
36
mais digitar os números. No final
5.2 Repetição do tipo: Teste Lógico no fim do looping
Caracteriza-se por uma estrutura que efetua um teste lógico no fim de um looping.
Esta estrutura é parecida com a enquanto. A estrutura em questão é denominada de repita, sendo conseguida
com a utilização do conjunto de instruções repita...até_que.
A estrutura repita...até_que tem o seu funcionamento controlado por decisão. Porém, irá efetuar a execução de
um conjunto de instruções pelo menos uma vez antes de verificar a validade da condição estabelecida. Diferente
da estrutura enquanto que executa somente um conjunto de instruções, enquanto a condição é verdadeira.
Desta forma repita tem seu funcionamento em sentido contrário a enquanto, pois sempre irá processar um
conjunto de instruções no mínimo uma vez até que a condição se torne verdadeira. Para a estrutura repita um
conjunto de instruções é executado enquanto a condição se mantém Falsa até que ela seja Verdadeira.
Primeiro exemplo
cinco vezes. É o mesmo exemplo utilizado na estrutura enquanto para que você possa fazer uma comparação
entre as estruturas.
Algoritmo
1 – Criar uma variável para servir de contador com valor inicial 1;
5 – Acrescentar +1 a variável do tipo contador, definida no passo 1;
6 – Repita os passos 2, 3, 4 e 5 até que o contador seja maior que 5.
início
inteiro: cont;
cont  1;
repita
leia num;
result  num * 3;
escreva result;
cont  cont + 1;
até que ( cont > 5 )
fim
Logo após o início do programa, a variável contador é atribuída com o valor 1 ( cont 1 ). Em seguida a instrução
repita indica que todo trecho de instruções situado até a instrução até_que deverá ter o seu processamento
repetido até que a condição cont > 5 seja satisfeita.
Sendo assim, tem início a execução da rotina de instruções contidas em ter as instruções repita e até_que.
Depois de efetuar a primeira execução das instruções, o programa encontra a linha cont  cont + 1 ; neste
momento a variável cont é somada a mais 1, passando a ter o valor 2. Em seguida é encontrada a linha com a
instrução até_que ( cont > 5 ) , que efetuará o retorno à instrução repita para que seja reprocessada a seqüência
de comandos, até que o valor da variável cont seja maior que 5 e encerre o looping.
37
2. Faça um Programa que escreva na tela os números ímpares de 0 até 20.
3. Faça um Programa que escreva na tela os números de 10 até -5
4. Faça um Programa que leia 10 valores inteiros e escreva no final a soma dos valores lidos.
5. Faça um Programa que leia 10 valores inteiros e escreva no final a média dos valores lidos.
negativos.
segundo exemplo
A seguir, é apresentado o exemplo em que não se utiliza o contador como forma de controle de execução
de uma rotina em uma estrutura de repetição. Considere que será o usuário que encerrará o processamento
segundo a sua vontade.
Algoritmo
1 – Criar uma variável para ser utilizada como resposta;
5 – Repetir os passos 2, 3, 4 e 5 até que a resposta do usuário seja não.
início
caractere: resp;
repita
leia num;
result  num * 3;
escreva result;
escreva “Deseja continuar ?”;
leia resp;
até que ( resp < > ‘S’ )
fim
Veja que a variável resp não precisou ser inicializada com algum valor, pois mesmo que o tivesse feito, não
exerceria influência direta sobre a estrutura repita, uma vez que no mínimo são sempre executadas as instruções
constantes no looping, para somente no final ser verificada a condição, no caso resp <> ‘S’
escrever a soma dos valores lidos.
escrever a média dos valores lidos.
escrever a soma dos valores positivos e a soma dos valores negativos.
escrever a soma dos valores positivos e a média dos valores negativos.
38
5.3 Repetição do tipo: Variável de Controle
Anteriormente, foram vistas duas formas de elaborar looping. Uma usando o conceito enquanto e a outra
usando o conceito repita. Foi visto também como elaborar rotinas que efetuaram a execução de um looping um
determinado número de vezes com a utilização de um contador (por meio de uma variável de controle).
Porém, existe uma possibilidade de facilitar o uso de contadores finitos sem fazer uso das duas estruturas
anteriores, deixando-as para utilização de loopings em que não se conhece de antemão o número de vezes que
uma determinada seqüência de instruções deverá ser executada. Os loopings que possuem um número finito de
execuções poderão ser processador por meio de estrutura de laços contados do tipo para, sendo conseguida
com a utilização do conjunto de instruções para...de...até...passo...faça...fim_para.
A estrutura para...de...até...passo...faça...fim_para tem o seu funcionamento controlado por uma variável
denominada contador. Sendo assim, poderá executar um determinado conjunto de instruções um determinado
número de vezes.
Fluxograma
Com relação ao fluxograma, será indicada a variável a ser controlada com a implicação dos valores de início,
fim e incremento, separados por vírgula. Para representar esta operação em um fluxograma, será utilizado o
símbolo denominado Processamento predefinido ou Preparação, representado pela figura de um hexágono.
Figura 5.7 – Estrutura do símbolo da instrução para...fim_para
para <variável> de <início> até <fim> passo <incremento> faça
<instruções>
fim_para
Primeiro exemplo
cinco vezes. É o mesmo exemplo utilizado na estrutura enquanto para que você possa fazer uma comparação
entre as estruturas.
Algoritmo
1 – Definir um contador, variando de 1 a 5;
5 – Repitir os passos 2, 3, 4 e 5 até que o contador seja encerrado.
início
inteiro: cont;
para cont de 1 até 5 passo 1 faça
leia num;
result  num * 3;
escreva result;
fim para
fim
39
Será executado o conjunto de instruções entre a instrução para e a instrução fim_para, sendo a variável cont
(variável de controle) inicializada com valor 1 e incrementada de mais 1 por meio da instrução passo até o valor
5. Esse tipo de estrutura de repetição poderá ser utilizada todas as vezes que houver a necessidade de repetir
trechos finitos, em que se conhecem os valores inicial e final.
Segundo exemplo
Desenvolver a lógica para um programa que escreva na tela os números de 1 até 10.
Repare que estamos desejando escrever os números na seguinte seqüência: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10.
Vamos utilizar a estrutura para...de...até...passo...faça...fim_para mas com o passo incrementando o valor da
variável contadora.
Algoritmo
2 – Apresentar o valor contido na variável contador;
5 – Repitir o passo 2 até que o contador seja encerrado.
início
inteiro: cont;
para cont de 1 até 10 passo 1 faça
escreva cont;
fim para
fim
Terceiro exemplo
Desenvolver a lógica para um programa que escreva na tela os números de 10 até 1.
Repare que estamos desejando escrever os números na seguinte seqüência: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1.
Vamos utilizar a estrutura para...de...até...passo...faça...fim_para mas com o passo decrementando o valor
da variável contadora.
Algoritmo
2 – Apresentar o valor contido na variável contador;
5 – Repitir o passo 2 até que o contador seja encerrado.
início
inteiro: cont;
para cont de 10 até 1 passo -1 faça
escreva cont;
fim para
fim
5.3.2 Exercícios de Fixação
6. Faça um Programa que escreva na tela os números ímpares de 20 até 0.
40
Desenvolva a codificação em português estruturado dos seguintes programas:
1. Faça um Programa que escreva a soma dos números de 1 até 100, ou seja, quanto é
1+2+3+...+98+99+100.
2. Faça um Programa que leia 10 valores e escreva no final a soma dos valores lidos.
negativos.
4. Faça um Programa que leia valores e escreva no final a soma dos valores positivos e a média dos
negativos. Neste programa o usuário é quem vai determinar o fim da leitura dos números, ou seja, você deverá
perguntar ao usuário se ele deseja continuar digitando valores.
5. Faça um Programa que leia 4 notas escolares de 15 alunos. Para cada um dos alunos calcular e apresentar
a média.
6. Faça um Programa que leia 4 notas escolares de “n” alunos. Para cada um dos alunos calcular e apresentar
a média. Sabendo-se que a média da escola é 7, informar também se o aluno foi “Aprovado” ou “Reprovado”.
Neste programa o usuário é quem vai determinar o fim da leitura das notas, ou seja, você deverá perguntar ao
usuário se ele deseja continuar digitando notas.
7. Faça um Programa que leia dois números inteiros quaisquer. No final escrever os números entre eles. Por
exemplo, se forem digitados 6 e 2, deverá escrever 6, 5, 4, 3 , 2. Mas se forem digitados 2 e 6, deverá escrever
2, 3, 4, 5, 6.
8. Faça um Programa que leia 20 vezes o código de um produto. Os produtos podem ser:
1 – Panela
2 – Chaleira
3 – Prato
Outro – Código inválido
Ao final escrever o total digitado de cada código, inclusive a quantidade de códigos inválidos digitados.
9. Faça um Programa que leia 4 notas escolares dos alunos de uma escola. Para cada um dos alunos
calcular e apresentar a média e informar o conceito do aluno baseado na informação abaixo:
[0 – 4) - Conceito D
[4 – 7)
- Conceito C
[7 – 9)
- Conceito B
[9 – 10]
- Conceito A
Os colchetes marcam o intervalo fechado e os parênteses marcam um intervalo aberto.
Neste programa o usuário é quem vai determinar o fim da leitura das notas, ou seja, você deverá perguntar
ao usuário se ele deseja continuar digitando notas.
10. Faça um Programa que leia códigos e execute tarefas, conforme tabela abaixo:
0 – Encerra o programa
1 – Inclui uma unidade no estoque
2 – Exclui uma unidade no estoque
3 – Mostra o total disponível no estoque
4 – Mostra o total de entradas no estoque
5 – Mostra o total de saídas no estoque
Outro código escrever: “Código Inválido”
11.Faça um Programa para controlar o acesso de pessoas a um restaurante. O restaurante possui uma
capacidade de 40 vagas, que não poderá ser ultrapassada. O controle se dará através de códigos, conforme a
tabela:
0 – FIM
1 – ENTRA UMA PESSOA (escrever: “Entrou”)
41
2 – SAI UMA PESSOA (escrever: “Saiu”)
3 – MOSTRAR QUANTOS LUGARES ESTÃO DISPONÍVEIS
4 – MOSTRAR O TOTAL DE PESSOAS QUE ENTRARAM
5 – MOSTRAR O TOTAL DE PESSOAS QUE SAÍRAM
Outro código escrever: “Código Inválido”
12. Faça um Programa que calcule o desconto do imposto de renda. O programa deverá perguntar quando
a pessoa deseja encerrar o programa (“Deseja fazer outro cálculo? (S/N)”). O programa deve pedir o valor
do salário, calcular e apresentar o valor do desconto baseado na seguinte informação:
Salário até R$ 900,00 é isento (Não paga imposto de renda)
Salário acima de R$ 900,00 até R$ 1.800,00 para 15% de imposto de renda
Salário acima de R$ 1.800,00 para 27% de imposto de renda
13. Faça um Programa que leia o peso das pessoas que querem entrar em um elevador. A capacidade
máxima do elevador é de 15 pessoas ou 800 Kg, o que ocorrer primeiro. O programa deve ler o peso da pessoa
que deseja entrar, se a sua entrada não fizer com que seja ultrapassado qualquer um dos limites, deverá escrever:
“PODE ENTRAR”, caso contrário, ou seja, ultrapassando os limites, deverá escrever: “NÃO PODE ENTRAR:
ELEVADOR LOTADO” e encerrar o programa, mostrando o número de pessoas transportadas e o peso total
transportado.
14. Faça um Programa que leia dois números e a operação desejada ( + , - , * , / ) e que escreva na tela
o resultado da operação. O programa depois de apresentar o resultado deverá perguntar quando a pessoa
deseja encerrar o programa (“Deseja fazer outro cálculo? (S/N)”). Se a reposta for S deverá pedir outros
números e a operação desejada, se a resposta for N deverá encerrar o programa.
15. Em uma fábrica de chocolates, foi designado ao programador, fazer um programa que calcule o desconto
de INSS dos funcionários. Este programa deve ler o nome do funcionário e o valor do salário bruto. Calcular o
desconto do INSS levando em consideração o seguinte:
a) Para salários até R$ 500,00 a alíquota de INSS será de 8%
b) Para salários acima de R$ 500,00 até R$ 1.000,00 a alíquota de INSS será de 10%
c) Para salários acima de R$ 1.000,00 a alíquota de INSS será de 12%
Para cada funcionário deverá ser apresentado na tela:
a) Nome do Funcionário
b) Salário Bruto
c) Taxa de INSS
d) Valor de INSS
e) Salário Líquido
Após estas apresentações o programa deverá fazer uma pergunta: “Deseja fazer mais algum cálculo? (S/N)”,
se a resposta for afirmativa o programa deverá continuar com os dados do próximo funcionário, caso contrário
deverá ser terminado.
16. Faça um Programa que possibilite calcular a área total de uma residência (sala, cozinha, banheiro,
quartos, área de serviço, quintal, garagem, etc). O programa deve solicitar a entrada do nome, a largura e
o comprimento de um determinado cômodo. Em seguida, deve apresentar a área do cômodo lido e também
uma mensagem solicitando do usuário a confirmação de continuar calculando novos cômodos. Caso o usuário
responda que “NÃO”, o programa deve apresentar o valor total acumulado da área residencial.
6 Estruturas de Dados Homogêneas I
Durante os pontos estudados em Desvios condicionais e Estruturas de repetição, percebeu-se que o poder de
programação tornou-se maior, antes limitado somente ao que foi estudado em técnicas básicas de programação.
Porém, tendo o domínio das técnicas anteriores, ainda correr-se-á o risco de não conseguir resolver alguns tipos
de problemas, pois foram trabalhadas até aqui apenas variáveis simples que somente armazenam um valor por
vez.
Vamos agora apresentar uma técnica de programação que permitirá trabalhar como o agrupamento de várias
informações dentro de uma mesma variável, sendo sempre do mesmo tipo de dado, e por esta razão é chamado
de estrutura de dados homogênea.
42
A utilização deste tipo de estrutura de dados recebe diversos nomes, como: variáveis indexadas, variáveis
compostas, variáveis subscritas, arranjos, vetores, matrizes, tabelas em memória ou arrays (do inglês). São
vários os nomes encontrados, a que nós iremos tratar por matrizes.
Vamos trabalhar com estes dados direcionados para a linguagem “C”, pois a escola irá tratar na disciplina
de Fundamentos de Programação com esta linguagem. Portanto vamos adaptar a estrutura lógica para esta
linguagem, facilitando assim o entendimento de nossos alunos.
6.1 Matrizes de uma dimensão ou vetores
Este tipo de estrutura é conhecida como matrizes unidimensionais ou também de vetor. Caracteriza-se por
ser definida uma única variável dimensionada com um determinado tamanho. A dimensão de uma matriz é
constituída por uma constante inteira positiva. Os nomes dados às matrizes seguem as mesmas regras de
nomes utilizados para identificar as variáveis simples.
Para ter uma idéia de como utilizar matrizes em uma determinada situação considere o seguinte problema:
“Em uma Escola Técnica de Informática, há um professor que faz 6 avaliações durante o semestre. Gostaríamos
de fazer um programa que leia as 6 notas de um aluno. No final calcular e apresentar a média do aluno”.
Desta forma será necessário somar as 6 notas de cada aluno e calcular a sua média. A tabela a seguir
apresenta um aluno, suas notas bimestrais e a coluna da média do aluno que deverá ser calculada.
Aluno
1
Nota 1
4.0
Nota 2
5.0
Nota 3
Nota 4
5.0
3.0
Nota 5
7.5
Nota 6
4.0
Média
?
Agora basta escrever um programa para efetuar o cálculo da média de cada aluno.
Vamos começar pelo cálculo da média de cada aluno, iremos representar as notas de cada aluno pelas
variáveis: nota1, nota2, nota3, nota4, nota5, nota6, e para o cálculo da média a variável media, todas do tipo
real.
Algoritmo
1 – Ler as notas do aluno para as variáveis nota1, nota2, nota3, nota4, nota5, nota6;
2 – Efetuar a soma das notas e a divisão delas por 6, atribuindo o seu resultado para a variável media;
3 – Apresentar o valor da variável media após a operação de soma e divisão dos valores fornecidos.
Com o conhecimento adquirido até este momento, seria então elaborado um programa que efetuaria a leitura
de cada nota, a soma delas e a divisão do valor da soma por 6, obtendo-se desta forma a média do aluno.
43
início
real: nota1;
real: nota2;
real: nota3;
real: nota4;
real: nota5;
real: nota6;
real: nota7;
real: soma;
real: media;
leia nota1;
leia nota2;
leia nota3;
leia nota4;
leia nota5;
leia nota6;
soma  nota1 + nota2 + nota3 + nota4 + nota5 + nota6;
media  soma / 6;
escreva media;
fim
Perceba que para receber as notas foram utilizadas 6 variáveis. Com a técnica de matrizes poderia ter sido
utilizada apenas uma variável com a capacidade de armazenar 6 valores.
6.2 Operações básicas com Matrizes de uma dimensão
Uma matriz de uma dimensão ou vetor será representada por seu nome e seu tamanho (dimensão) entre
colchetes. Desta forma seria uma matriz nota[6], sendo seu nome nota, possuindo um tamanho de 6.
Isto significa que poderão ser armazenados em nota até 6 elementos. Perceba que na utilização de variáveis
simples existe uma regra: uma variável somente pode conter um valor por vez. No caso das matrizes, poderão
armazenar mais de um valor por vez, pois são dimensionadas exatamente para este fim. Desta forma poderse-á manipular uma quantidade maior de informação com pouco trabalho de processamento. Deve-se apenas
considerar que com relação à manipulação dos elementos de uma matriz, eles ocorrerão de forma individualizada,
pois não é possível efetuar a manipulação de todos os elementos do conjunto ao mesmo tempo.
No caso do exemplo do cálculo da média do aluno, ter-se-ia então uma única variável indexada (a matriz)
contendo todos os valores das 8 notas. Isto seria representado da seguinte forma:
nota[0] = 4.0
nota[1] = 6.0
nota[2] = 5.0
nota[3] = 3.0
nota[4] = 7.5
nota[5] = 4.0
Observe que o nome é um só. O que muda é a informação indicada dentro dos colchetes.
A esta informação dá-se o nome de índice, sendo este o endereço em que o elemento está armazenado. É
necessário que fique bem claro que o elemento é o conteúdo da matriz, neste caso os valores das notas. No caso
de nota[0] = 4.0, o número 0 é o índice; o endereço onde cujo elemento é 4.0 está armazenado.
44
6.2.1 Atribuição de uma Matriz
Anteriormente, foram utilizadas várias instruções para poder definir e montar um programa. No caso da
utilização de matrizes, será definida a instrução conjunto que indicará em português estruturado a utilização
de uma matriz, tendo como sintaxe: <tipo de dado> conjunto[<dimensão>], sendo que <dimensão> será a
indicação do tamanho do vetor e <tipo de dado> se o vetor em questão utilizar valores reais, inteiros, lógicos ou
caracteres.
6.2.2 Leitura de dados de uma Matriz
A leitura de uma matriz é processada passo a passo, um elemento por vez. A instrução de leitura é leia
seguida da variável mais o índice. A seguir, é apresentado a codificação em português estruturado da leitura das
notas dos alunos, cálculo da média e a sua apresentação.
início
real: nota[6];
real: soma, media;
inteiro: índice;
soma  0;
para índice de 0 até 5 passo 1 faça
leia nota[índice];
soma  soma + nota[índice];
fim para
media  soma / 6;
escreva media;
fim
Veja que o programa ficou mais compacto, além de possibilitar uma mobilidade maior, pois se houver a
necessidade de efetuar o cálculo para um número maior de alunos, basta dimensionar a matriz e mudar o valor
final da instrução para. Observe que a leitura é processada uma por vez. Desta forma, a matriz é controlada pelo
número do índice que faz com que cada entrada aconteça em uma posição diferente da outra. Assim sendo, a
matriz passa a ter todas as notas. A tabela a seguir, mostra como ficarão os valores armazenados na matriz:
Matrícula:
Indice
Elemento
0
4.0
1
6.0
2
5.0
3
3.0
4
7.5
5
4.0
6.2.3 – Escrita dos dados de uma Matriz
O processo de escrita de uma matriz é bastante parecido com o processo de leitura de seus elementos. Para
esta ocorrência deverá ser utilizada a instrução escreva seguida da indicação da variável e seu índice.
45
Supondo que após a leitura das 6 notas, houvesse a necessidade de apresenta-las antes da apresentação
do valor da média. Abaixo é apresentada a codificação em português estruturado da escrita das 6 notas antes de
ser apresentado o cálculo da média.
início
real: nota[6];
real: soma, media;
inteiro: índice;
soma  0;
leia nota[índice];
soma  soma + nota[índice];
fim para
media soma / 6;
escreva nota[índice];
fim_para
escreva media;
fim
6.3 Exercício de Aula
Para demonstrar a utilização de uma matriz em um exemplo um pouco maior, considere como problemas os
exemplos apresentados em seguida:
Primeiro exemplo
Desenvolver um programa que efetue a leitura de dez elementos de uma matriz A tipo vetor. Construir uma
matriz B de mesmo tipo, observando a seguinte lei de formação: se o valor do índice for par, o valor deverá ser
multiplicado por 5, sendo ímpar, deverá ser somado com 5. Ao final mostrar o conteúdo da matriz A e B
Algoritmo
Este exemplo de resolução estará mostrando como fazer o tratamento da condição do índice.
1 – Iniciar o contador de índice, variável índice como 0 em um contador até 9;
2 – Ler os 10 valores, um a um;
3 – Verificar se o índice é par se sim multiplica por 5, se não soma 5. Criar a matriz B;
4 – Apresentar o conteúdo das duas matrizes.
Deverá ser verificado se o valor do índice em um determinado momento é par (ele será par quando dividido
por 2 obtiver resto igual a zero). Sendo a condição verdadeira, será atribuído na matriz B[índice] a multiplicação
do elemento da matriz A[índice] por 5. Caso o valor do índice seja ímpar, será atribuído na matriz B[índice] a
soma do elemento da matriz A[índice] por 5.
46
início
inteiro: matrizA[10];
inteiro: matrizB[10];
inteiro: indice, resp;
leia matrizA[índice];
fim_para
resp  indice mod 2;
se ( resp = 0 ) então
matrizB[índice]  matrizA[índice] * 5;
senão
matrizB[índice]  matrizA[índice] + 5;
fim_se
fim_para
escreva matrizA[índice];
fim_para
escreva matrizB[índice];
fim_para
fim
Segundo exemplo
Desenvolver um programa que efetue a leitura de dez elementos de uma matriz A do tipo vetor. No final,
apresente o total da soma de todos os elementos que sejam ímpares.
Algoritmo
Perceba que em relação ao primeiro exemplo, este apresenta uma diferença: o primeiro pedia para verificar
se o índice era par ou ímpar. Neste exemplo, está sendo solicitado que analise a condição do elemento e não
do índice. Já foi alertado anteriormente para se tomar cuidado para não confundir elemento com índice. Vamos
a solução:
1 – Iniciar o contador de índice, variável índice como 0 em um contador até 9;
2 – Ler os 10 valores, um a um;
3 – Verificar se o elemento é ímpar; se sim efetuar a soma dos elementos;
4 – Apresentar o total somado de todos os elementos ímpares da matriz.
Observe que quando se faz menção ao índice indica-se a variável que controla o contador de índice, e no
caso do exemplo anterior, a variável índice. Quando se faz menção ao elemento, indica-se matrizA[índice] pois
desta forma está se pegando o valor armazenado e não a sua posição de endereço.
47
inicio
inteiro: matriz[10];
inteiro: indice, resp, soma;
soma  0;
para indice de 0 até 9 passo 1 faça
leia matrizA[índice];
fim_para
para indice de 0 até 9 passo 1 faça
resp  matrizA[indice] mod 2;
se ( resp = 1 ) então
soma  soma + matrizA[indice] ;
fim_se
fim_para
escreva soma;
fim
1 – Desenvolva a codificação em português estruturado dos seguintes programas:
a) Faça um programa para ler 10 elementos de uma matriz tipo vetor e apresenta-los.
b) Faça um programa para ler duas matrizes A e B com 20 elementos. Construir uma matriz C, onde cada
elemento de C é a soma do elemento correspondente de A com B. Apresentar a matriz C.
c) Faça um programa que leia 15 elementos de uma matriz A do tipo vetor. Construir uma matriz B de mesmo
tipo, observando a seguinte lei de formação: “Todo elemento de B deverá ser o quadrado do elemento de A
correspondente”. Apresentar as matrizes A e B.
d) Faça um programa para ler uma matriz A do tipo vetor com 15 elementos. Construir uma matriz B de
mesmo tipo, sendo que cada elemento da matriz B seja o fatorial do elemento correspondente da matriz A.
Apresentar as matrizes A e B.
e) Faça um programa para ler duas matrizes A e B com 15 elementos cada. Construir uma matriz C, sendo
esta a junção das duas outras matrizes. Desta forma C deverá ter o dobro de elementos, ou seja, 30. Apresentar
a matriz C.
f) Faça um programa para ler 20 elementos de uma matriz A tipo vetor e construir uma matriz B de mesma
dimensão com os mesmos elementos da matriz A, sendo que deverão estar invertidos. Ou seja, o primeiro
elemento de A passa a ser o último de B, o segundo elemento de A passa a ser o penúltimo de B e assim por
diante. Apresentar as matrizes A e B.
g) Faça um programa para ler uma matriz A tipo vetor com 10 elementos. Construir uma matriz B de mesmo
tipo, sendo que cada elemento de B deverá ser a metade de cada elemento de A . Apresentar os elementos das
matrizes A e B.
h) Ler 20 elementos (valores reais) para temperaturas em graus Celsius em uma matriz A de uma dimensão
do tipo vetor. O programa deverá apresentar a menor, a maior e a média das temperaturas lidas.
i) Ler 25 elementos (valores reais) para temperaturas em graus Celsius em uma matriz A de uma dimensão
do tipo vetor. Construir uma matriz B de mesmo tipo e dimensão, em que cada elemento da matriz B deverá
ser a conversão da temperatura em graus Fahrenheit do elemento correspondente da matriz A . Apresentar os
elementos das matrizes A e B.
j) Ler 12 elementos inteiros para uma matriz A de uma dimensão do tipo vetor. Construir uma matriz B de
mesmo tipo e dimensão, observando a seguinte lei de formação: “Todo elemento da matriz A que for ímpar deverá
48
ser multiplicado por 2 e armazenado na matriz B; caso contrário, o elemento da matriz A deverá ser armazenado
na matriz B sem nenhum cálculo”. Apresentar os elementos das matrizes A e B.
k) Faça um programa que leia uma matriz numérica de 10 elementos. No final apresentar quantos números
são positivos e quantos são negativos
l) Faça um programa que leia uma matriz numérica de 10 elementos. No final encontrar nesta matriz o maior
valor lido, apresentando a sua posição na matriz e o seu valor.
m)Faça um programa que leia uma matriz numérica de 10 elementos. No final encontrar nesta matriz o maior
valor lido e o menor valor lido
n) Em uma Escola Técnica de Informática, há um professor que faz 6 provas. Faça um programa que leia as
notas destas provas para um vetor notas. No final calcular e apresentar a média do aluno e o resultado obtido
conforme a tabela a seguir:
[00,05)
- Reprovado
[05,07)
- Recuperação
[07,09)
- Satisfatório
[09,10]
- Ótimo
7 Estruturas de Dados Homogêneas II
No capítulo anterior trabalhamos com o agrupamento de várias informações dentro de uma mesma variável,
de mesmo tipo de dado, chamada de estrutura de dados homogênea, ou seja, matrizes, do tipo vetor. Agora
iremos trabalhar com uma estrutura um pouco mais complexa, também chamada de matrizes, mas de mais de
uma dimensão.
7.1 Matrizes com mais de uma dimensão
Anteriormente, houve contato com o uso de uma única variável indexada com apenas uma dimensão (uma
linha e várias colunas), quando foi utilizado o exemplo para efetuar o cálculo da média do aluno. A partir deste
ponto, serão apresentadas tabelas com mais colunas, sendo assim, teremos variáveis no sentido horizontal e
vertical.
Com o conhecimento adquirido até este ponto, você tem condições suficientes para elaborar um programa
que leia as notas dos alunos, calcule a média de cada aluno e no final apresente a média de toda a turma,
utilizando-se de matrizes bidimensionais.
Porém, cuidado, é necessário manter um controle de cada índice em cada matriz para um mesmo aluno.
Para facilitar o trabalho com estruturas deste porte é que serão utilizadas matrizes com mais dimensões. A
mais comum é a matriz de duas dimensões por se relacionar diretamente com a utilização de tabelas.
Matrizes com mais de duas dimensões são utilizadas com menos freqüência, mas poderão ocorrer em
momentos em que se necessite trabalhar com um número maior de dimensões, porém estas são fáceis de
utilizar, se estivermos dominando bem a utilização de uma matriz com duas dimensões.
É importante considerar que na manipulação de uma matriz unidimensional é utilizada uma única instrução
de looping. No caso de matrizes com mais dimensões, deverão ser utilizadas o número de loopings relativo ao
tamanho de sua dimensão. Desta forma, uma matriz de duas dimensões deverá ser controlada com dois loopings
de três dimensões deverá ser controlada por três loopings e assim por diante.
Em matrizes de mais de uma dimensão os seus elementos são também manipulados de forma individualizada,
sendo a referência feita sempre por meio de dois índices; o primeiro para indicar a linha e o segundo para indicar
a coluna.
Para você ter uma idéia de como utilizar matrizes de duas dimensões vamos utilizar o mesmo exemplo
que usamos no capítulo anterior, mas agora com um número maior de alunos: “Em uma Escola Técnica de
Informática, há um professor que faz 4 avaliações durante o semestre. Gostaríamos de fazer um programa que
leia as 4 notas de cada aluno da turma (turma com 8 alunos), calcule e apresente a média de cada aluno.”.
49
Veja como ficaria nossa tabela com as notas e as médias de cada aluno:
Aluno
1
2
3
4
5
6
7
8
NOTA 1
4.0
6.0
9.0
3.0
4.0
7.0
8.0
6.0
NOTA 2
6.0
7.0
8.0
5.0
6.0
7.0
7.0
7.0
NOTA 3
5.0
5.0
9.0
4.0
6.0
7.0
6.0
2.0
NOTA 4
3.0
8.0
6.0
2.0
8.0
7.0
5.0
9.0
7.2 Operações básicas com matrizes de duas dimensões
Uma matriz de duas dimensões está sempre fazendo referência a linhas e a colunas e é representada por
seu nome e seu tamanho (dimensão) entre colchetes.
Desta forma é uma matriz de duas dimensões nota[8][4], onde seu nome é nota, possuindo um tamanho de
8 linhas e 4 colunas, ou seja, é uma matriz de 8 por 4 (8 x 4). Isto significa que podem ser armazenados em nota
até 32 elementos.
Para armazenar as 4 notas do primeiro aluno deveríamos fazer algo como visto abaixo:
nota[0] [0] = 4.0
nota[0] [1] = 6.0
nota[0] [2] = 5.0
nota[0] [3] = 3.0
Observe que o nome é um só. O que muda é a informação indicada dentro dos colchetes. No primeiro
colchete está a informação da linha e no segundo colchete está a informação da coluna.
Para armazenar as 4 notas do segundo aluno deveríamos fazer o seguinte:
nota[1] [0] = 6.0
nota[1] [1] = 7.0
nota[1] [2] = 5.0
nota[1] [3] = 8.0
Para armazenar as 4 notas do terceiro aluno deveríamos fazer o seguinte:
nota[2] [0] = 9.0
nota[2] [0] = 8.0
nota[2] [0] = 9.0
nota[2] [0] = 6.0
E assim sucessivamente até que se armazene as notas de todos os oito alunos.
50
7.2.1 – Atribuição de uma Matriz
Uma matriz de duas dimensões é atribuída pela instrução conjunto já utilizada para definir o uso de uma
matriz de uma dimensão, sendo bastante parecidas em sua referência.
A sintaxe é: <tipo de dado> : conjunto[<dimensão1>][<dimensão2>], sendo que <dimensão1> e <dimensão2>
são a indicação do tamanho da tabela e <tipo de dado> o tipo da matriz, que poderá ser formada por valores
reais, inteiros, lógicos ou caracteres.
7.2.2 – Leitura de dados de uma Matriz
A leitura de uma matriz de duas dimensões, assim como das matrizes de uma dimensão é processado passo
a passo, um elemento por vez. A instrução de leitura é leia seguida da variável mais os seus índices. A seguir,
são apresentados o fluxograma e a codificação em português estruturado da leitura das notas dos alunos, cálculo
da média e a sua apresentação.
Observe que está sendo considerada a leitura de 4 notas de 8 alunos. Assim sendo, a tabela em questão
armazena 32 elementos. Um detalhe a ser considerado é a utilização de duas variáveis para controlar os dois
índices de posicionamento de dados na tabela. Anteriormente, utilizamos a variável índice para controlar as
posições dos elementos dentro da matriz, ou seja, a posição em nível de linha. Neste exemplo a variável índice
passa a ser tratada como lin, controlando a posição da linha, e a segunda variável será tratada como col,
controlando a posição da coluna. Muitos programadores utilizam i no lugar de lin e utilizam j no lugar de col.
Analisando o fluxograma, temos a inicialização das variáveis lin e col como 0, ou seja, a leitura será efetuada
na primeira linha da primeira coluna. Em seguida é iniciado em primeiro lugar o looping da variável lin para
controlar a posição em relação às linhas e depois é iniciado o looping da variável col para controlar a posição em
relação às colunas.
Veja que, ao serem iniciados os valores para o preenchimento da tabela, eles são colocados na posição
nota[0][0], lembrando que o primeiro valor dentro dos colchetes representa a linha e o segundo representa a
coluna.
Será digitado então, para o primeiro aluno a primeira nota. Depois é incrementado mais 1 em relação à
coluna, sendo colocada para a entrada a posição nota[0][1], linha 0 coluna 1. Desta forma, será digitado para o
primeiro aluno a segunda nota.
Quando o contador de coluna atingir o valor 4, ele será encerrado e será efetuado o cálculo e a apresentação
da média. Em seguida o contador da variável lin será incrementado com mais 1, tornando-se 1. Será então
inicializado novamente o contador col em 0, permitindo que seja digitado um novo dado na posição nota[1][0].
O mecanismo de preenchimento estender-se-á até que o contador de linhas atinja o seu último valor, no
caso 8. Esse looping é o principal, tendo a função de controlar o posicionamento na tabela por aluno. O segundo
looping, mais interno, controla o posicionamento das notas.
início
real : nota[8][4];
real : soma, media;
inteiro : lin, col ;
para lin de 0 até 7 passo 1 faça
soma  0;
para col de 0 até 3 passo 1 faça
leia nota[lin][col];
soma  soma + nota[lin][col];
fim_para
media  soma / 4;
escreva media;
fim_para
fim
51
7.3 Exercício de Aula
Para demonstrar a utilização de uma matriz de duas dimensões, considere o exemplo apresentado a seguir:
Primeiro exemplo
Desenvolver um programa que efetue a leitura das receitas e despesas dos primeiros 6 meses de uma
empresa. Calcular e armazenar o resultado mensal da empresa.
Algoritmo
1 – Ler as receitas de cada mês
2 – Ler as despesas de cada mês
3 – Calcular o resultado de cada mês subtraindo a receita da despesa
4 – Apresentar as receitas, as despesas e o resultados de cada mês
Pela característica do programa a ser desenvolvido, seria ideal utilizarmos uma matriz 3 x 6, para armazenar
estes dados. Nas colunas teremos os meses, nas linhas teremos respectivamente receitas, despesas e resultados,
veja o desenho a seguir:
Janeiro
Fevereiro
Março
Abril
Receitas
Despesas
Resultados
início
real : caixa[3][ 6];
inteiro: lin, col;
lin  1;
escreva ‘Digite a receita do mês’;
leia caixa[lin][col];
fim_para
lin  2;
escreva ‘Digite a despesa do mês’;
leia caixa[lin][col];
fim_para
caixa[2][col]  caixa[0][col] - caixa[1][col];
fim_para
escreva ‘A receita do mês’, caixa[0][col];
escreva ‘A despesa do mês’,caixa[1][col];
escreva ‘O resultado do mês’,caixa[2][col];
fim_para
fim
52
Maio
Junho
1 – Desenvolva a codificação em português estruturado dos seguintes programas:
a) Faça um programa para ler duas matrizes A e B, cada uma de duas dimensões com 5 linhas e 3 colunas.
Construir uma matriz C de mesma dimensão, que é formada pela soma dos elementos da matriz A com os
elementos da matriz B. Apresentar a matriz C.
b) Faça um programa para ler duas matrizes A e B, cada uma com 7 elementos. Construir uma matriz C, de
duas dimensões, em que a primeira coluna deverá ser formada pelos elementos da matriz A e a segunda coluna
deverá ser formada pelos elementos da matriz B. Apresentar a matriz C.
c) Faça um programa para ler 20 elementos para uma matriz qualquer, considerando que ela tenha o tamanho
de 4 linhas por 5 colunas, em seguida apresentar a matriz.
d) Faça um programa para ler uma matriz A de uma dimensão com 10 elementos. Construir uma matriz
C de duas dimensões com três colunas, em que a primeira coluna da matriz C é formada pelos elementos da
matriz A somados com mais 5, a segunda coluna é formada pelo valor do cálculo da fatorial de cada elemento
correspondente da matriz A e a terceira e última coluna deverá ser formada pelos quadrados dos elementos
correspondentes da matriz A . Apresentar a matriz C.
e) Faça um programa para ler duas matrizes A e B, cada uma com uma dimensão pra 12 elementos. Construir
uma matriz C de duas dimensões, sendo que a primeira coluna da matriz C deverá ser formada pelos elementos
da matriz A multiplicados por 2 e a segunda coluna deverá ser formada pelos elementos da matriz B subtraídos
de 5. Apresentar a matriz C.
f) Faça um programa para ler uma matriz A de duas dimensões com 5 linhas e 4 colunas. Construir uma matriz
B de mesma dimensão, onde cada elemento da matriz B deverá ser o fatorial de cada elemento correspondente
da matriz A . Apresentar ao final as matrizes A e B.
g) Faça um programa para ler uma matriz A de duas dimensões com 5 linhas e 5 colunas. Construir uma
matriz B de mesma dimensão, sendo que cada elemento da matriz B deverá ser o dobro de cada elemento
correspondente da matriz A, com exceção para os valores situados na diagonal principal (posições B[1,1], B[2,2],
B[3,3], B[4,4] e B[5.5] ) os quais deverão ser o triplo de cada elemento correspondente da matriz A . Apresentar
ao final a matriz B.
h) Faça um programa para ler uma matriz A de duas dimensões com 7 linhas e 7 colunas. Construir uma
matriz B de mesma dimensão, sendo que cada elemento da matriz B deverá ser o somatório de cada elemento
correspondente da matriz A, com exceção para os valores situados na diagonal principal (posições B[1,1], B[3,3],
B[5.5] e B[7,7] ) os quais deverão ser o fatorial de cada elemento correspondente da matriz A . Apresentar ao final
a matriz B.
i) Faça um programa para ler uma matriz A de duas dimensões com 6 linhas e 5 colunas. Construir uma
matriz B de mesma dimensão, que deverá ser formada do seguinte modo: para cada elemento par da matriz A
deverá ser somado 5 e para cada elemento ímpar da matriz A deverá ser subtraído 4. Apresentar ao final a matriz
A e B.
j) Faça um programa para ler uma matriz A de duas dimensões com 4 linhas e 4 colunas. Apresentar o
somatório dos elementos situados na diagonal principal (posições A[1,1], A[2,2], A[3,3], A[4.4] ) da referida
matriz.
k) Faça um programa que leia uma matriz A de duas dimensões com 15 linhas e 15 colunas. Apresentar o
somatório dos elementos pares situados na diagonal principal da referida matriz.
l) Faça um programa que leia uma matriz A de duas dimensões com 7 linhas e 7 colunas. Ao final apresentar
o total de elementos pares existentes dentro da matriz.
m)Faça um programa que leia uma matriz de duas dimensões com 7 linhas e 7 colunas. Ao final apresentar
o total de elementos positivos, o total de elementos negativos e o total de elementos cujo valor é zero.
n) Faça um programa que leia uma matriz numérica de duas dimensões de 5 linhas e 8 colunas. No final
encontrar e apresentar desta matriz o maior valor lido e o menor valor lido.
o) Faça um programa que leia uma matriz de duas dimensões com 5 linhas e 5 colunas. Apresentar o
somatório dos elementos positivos situados na diagonal principal da referida matriz.
53
8 Procedimentos e Funções
A partir deste momento vamos aprender o conceito da técnica de sub-rotinas.
Estas sub-rotinas também são conhecidas pela denominação de módulos, sub-programas, ou subalgoritmos.
Na linguagem C as sub-rotinas são tratadas como FUNÇÕES.
Na realidade, não importa como são chamadas, o que importa é a forma como funcionam e como devem ser
aplicadas em um programa, e é isto que iremos aprender a partir deste momento.
Iremos rever o conceito de criação estruturada de programas, pois para escrever um programa de computador
necessita-se de estudo (levantamento de todas as necessidades e detalhes do que deverá ser feito) e metodologia
(regras básicas que deverão ser seguidas).
Sem a aplicação de métodos não será possível resolver grandes problemas; quando muito, pequenos
problemas.
As Sub-rotinas
No geral, problemas complexos exigem algoritmos complexos. Mas sempre é possível dividir um problema
grande em problemas menores. Desta forma, cada parte menor tem um algoritmo mais simples, e é esse trecho
menor que é chamado de sub-rotina. Uma sub-rotina é na verdade um programa, e sendo um programa poderá
efetuar diversas operações computacionais (entrada, processamento e saída) e deverá ser tratada como foram
os programas projetados até este momento. As sub-rotinas são utilizadas na divisão de algoritmos complexos,
permitindo assim possuir a modularização de um determinado problema, considerado grande e de difícil
solução.
Quando trabalhamos com esta técnica, pode-se deparar com a necessidade de dividir uma sub-rotina em
outras tantas quantas forem necessárias, buscando uma solução mais simples de uma parte do problema maior.
O processo de dividir sub-rotinas em outras é denominado Método de Refinamento Sucessivo.
O Método Top-Down
Desde muito tempo este é um dos processos mais simples e mais utilizados pelos programadores.
O processo de programar um computador torna-se bastante simples quando aplicado o método de utilização
de sub-rotinas (módulos de programas). Porém, a utilização dessas sub-rotinas deverá ser feita com aplicação
do método top down.
Um método bastante adequado para a programação de um computador é trabalhar com o conceito de
programação estruturada, pois a maior parte das linguagens de programação utilizadas atualmente também é, o
que facilita a aplicação deste processo de trabalho.
O método mais adequado para a programação estruturada é o Top-Down (De cima para baixo) o qual se
caracteriza basicamente por:
• Antes de iniciar a construção do programa, o programador deverá ter em mente as tarefas principais que
este deverá executar. Não é necessário saber como funcionarão, somente saber quantas são.
• Conhecidas todas as tarefas a serem executadas, tem-se em mente como deverá ser o programa principal,
o qual vai controlar todas as outras tarefas distribuídas em suas sub-rotinas.
• Tendo definido o programa principal, é iniciado o processo de detalhamento para cada sub-rotina. Desta
forma são definidos vários algoritmos, um para cada rotina em separado, para que se tenha uma visão do que
deverá ser executado em cada módulo de programa. Existem programadores que estabelecem o número máximo
de linhas de programa que uma rotina deverá possuir. Se o número de linhas ultrapassa o limite preestabelecido,
a rotina em desenvolvimento é dividida em outra sub-rotina (é neste ponto que se aplica o método de refinamento
sucessivo).
O método Top-Down faz com que o programa tenha uma estrutura semelhante a um organograma.
A utilização do método “de cima para baixo” permite que seja efetuado cada módulo de programa em
separado. Desta forma, cada um pode ser testado separadamente garantindo que o programa completo esteja
sem erro ao seu término.
Outro detalhe a ser considerado é que muitas vezes existem em um programa trechos de códigos que são
repetidos várias vezes. Esses trechos poderão ser utilizados como sub-rotinas, proporcionando um programa
menor e mais fácil de ser alterado num futuro próximo.
54
A utilização de sub-rotinas e o uso do método Top-Down na programação permitem ao programador elaborar
rotinas exclusivas. Por exemplo, uma rotina somente para entrada, outra para a parte de processamento e outra
para saída dos dados.
Aplicação prática do uso de Sub-Rotinas
As sub-rotinas podem ser subdivididas em dois tipos: Procedimentos e Funções. Entre estes dois tipos de
sub-rotinas existem algumas diferenças, mas o conceito é o mesmo para ambas.
Um Procedimento é um bloco de programa contendo início e fim e será identificado por um nome, por meio
do qual será referenciado em qualquer parte do programa principal ou do programa chamador da rotina.
Quando uma sub-rotina é chamada por um programa, ela é executada e ao seu término o controle de
processamento retorna automaticamente para a primeira linha de instrução após a linha que efetuou a chamada
de sub-rotina.
Uma função também é um bloco de programa, como são os procedimentos, contendo inicio e fim e sendo
identificada por um nome, por meio do qual também será referenciada em qualquer parte do programa principal.
Uma sub-rotina de função é na verdade muito parecida com uma sub-rotina de procedimento. A sua principal
diferença está no fato de uma função retornar um determinado valor.
As funções formam o alicerce da programação em C. Você faz toda a programação C dentro de uma função,
porque todos os programas devem incluir main, que é uma função.
Em outras linguagens como Pascal, são utilizados procedimentos e funções, FORTRAN utiliza somente
funções e a linguagem Assembly utiliza somente procedimentos.
A linguagem C utiliza somente funções com e sem retorno de valores, tornando-se um pouco diferente na
qualificação de sub-rotinas e funções, conforme a lógica de programação.
Mas, não se preocupe, isto não irá mudar a forma como você vai trabalhar na linguagem C.
Exercício de Aula
Vamos criar um programa de calculadora que apresente um menu de seleções no programa principal. Esse
menu deverá dar ao usuário a possibilidade de escolher uma entre quatro operações aritméticas. Escolhida a
opção desejada, deverá ser solicitada à entrada de dois números e depois de processada a operação, deverá
ser exibido o resultado.
Este programa deverá ser um conjunto de cinco rotinas, sendo uma principal e quatro secundárias. A rotina
principal efetuará o controle das quatro rotinas secundárias que, por sua vez, pedirão a leitura de dois valores,
farão a operação e apresentarão o resultado obtido. A figura a seguir apresenta um organograma com a idéia de
hierarquização das rotinas do programa. A quinta opção não se caracteriza por ser uma rotina, apenas a opção
que vai encerrar o looping de controle do menu.
Tendo uma idéia da estrutura geral do programa, será escrito em separado cada algoritmo com os seus
detalhes de operação. Primeiro o programa principal e depois as outras rotinas, de preferência na mesma ordem
em que estão mencionadas no organograma.
É ideal que você codifique o programa aos poucos, como por exemplo: na definição do programa acima,
primeiro vamos testar o menu e ver se a interação entre as partes funciona.
Veja no programa a seguir:
55
inicio
character: opcao;
opcao <- 0;
enquanto opcao <> ‘5’ faça
escrever “1 – Adição”;
escrever “2 - Subtracao”;
escrever “3 - Multiplicacao”;
escrever “4 – Divisão”;
escrever “5 - Fim do programa”;
escrever “Escolha uma opcao: “;
leia opcao;
se opcao = ‘1’ entao
somar;
senão
se opcao = ‘2’ entao
subtrair;
senão
se opcao = ‘3’ então
multiplicar;
senão
se opcao = ‘4’ então
dividir;
senão
se opcao = ‘5’; então
escrever “Encerrando o programa”;
senão
escrever “Opcao invalida”;
fim_se
fim_se
fim_se
fim_se
fim_se
fim_enquanto
fim
procedimento somar
inicio
real: valorA, valorB, result;
escrever “Rotina de Soma”;
escrever “Digite um valor para A: “;
leia valorA;
escrever “Digite um valor para B: “;
leia valorB;
56
result <- valorA + valorB;
escrever “A soma de A com B e: “ , result;
fim [somar]
procedimento subtrair
inicio
escrever “Rotina de Subtração”;
leia valorA;
leia valorB;
result <- valorA - valorB;
escrever “A subtração de A com B e: “ , result;
fim [subtrair]
procedimento multiplicar
inicio
escrever “Rotina de Multiplicação”;
leia valorA;
leia valorB;
result <- valorA * valorB;
escrever “A multiplicação de A com B e: “ , result;
fim [multiplicar]
procedimento dividir
inicio
escrever “Rotina de Divisão”;
leia valorA;
leia valorB;
result <- valorA / valorB;
57
escrever “A subtração de A com B e: “ , result;
fim [dividir]
Funções
As funções podem ser utilizadas da forma mais simples possível, como as que não recebem nenhuma
informação e também não retornam nenhuma informação. Mas podem ser um pouco mais sofisticadas podendo
receber informações de quem as chamou e se for necessário retornar uma informação para a função que a
chamou.
A principal diferença existente entre uma sub-rotina do tipo procedimento e uma sub-rotina do tipo função é a
capacidade que uma função tem de retornar sempre um valor.
Vamos ver um exemplo através da função somar:
função inteiro somar ( )
inicio
escrever “Rotina de Soma”;
leia valorA;
leia valorB;
result <- valorA + valorB;
return result;
fim [somar]
No programa acima podemos perceber o comando return que retorna o valor da variável result.
58
Exercícios de Fixação
1. Faça um programa que efetue o cálculo de uma prestação em atraso. Para tanto, utilize a fórmula PREST
= VALOR + (VALOR * (TAXA / 100) * TEMPO). O programa deverá chamar uma função que faça a entrada
dos dados e o cálculo da prestação e retorne o valor deste cálculo para a função principal (main). Finalmente
apresentar o valor da prestação.
2. Faça um programa que possua uma função que efetue e permita apresentar o somatório dos N primeiros
números inteiros. (1+2+3+4+5+6+...+N). Esta função deverá receber da função principal (main) o número N e
no final esta mesma função deverá retornar o valor do somatório, que deverá ser apresentado ao usuário pela
função principal (main).
3. Faça um programa que possua uma função para calcular e apresentar o valor de uma potência de um
número qualquer. Ou seja, ao informar para a função o número e sua potência, deverá ser apresentado o
seu resultado. Por exemplo, se for mencionado no programa principal a função POTENCIA(2,3), deverá ser
apresentado o valor 8.
4. Faça um programa que possua uma função para calcular e apresentar a série de Fibonacci de N termos.
A série de Fibonacci é formada pela seqüência: 1, 1, 2, 3, 5, 8, 13, 21, 34,...etc. Está série caracteriza-se pela
soma de um termo posterior com o seu anterior subseqüente. A função main deve apenas chamar a função que
calcula a série de Fibonacci.
5. Faça um programa que efetua a leitura de um número inteiro e apresente uma mensagem informando se
o número é par ou ímpar. Usar uma função que identifique se o número é par ou ímpar.
6. Faça um programa que apresente um menu com as seguintes opções de cálculos:
• Calcular a área do quadrado
• Calcular a área do retângulo
• Calcular a área do circulo
• Encerrar o programa
Estes cálculos devem ser realizados em funções, ou seja, deverá ter uma função para cada tipo de cálculo.
Cada função deverá ter entrada de dados (digitação dos dados para o cálculo), processamento dos dados
(cálculos propriamente ditos) e a saída de dados (apresentação dos resultados dos cálculos).
7. Faça um programa que apresente um menu com as seguintes opções e efetue os respectivos cálculos
através de funções:
• Calcular o volume de uma lata de óleo
• Calcular o volume de uma caixa
8. Em uma Escola Técnica de Informática, há um professor que faz 6 provas. Faça um programa para
calcular a média dos alunos de uma escola. O programa deverá ter um menu com as seguintes informações:
• Calcular a média
O cálculo da média deverá ser realizado em uma função onde deverá ser solicitado o valor das 6 notas
escolares, efetuar o cálculo da média e apresentar no final o resultado obtido conforme a tabela a seguir:
[00,05)
- Reprovado
[05,07)
- Recuperação
[07,09)
- Satisfatório
[09,10]
- Ótimo
59
9. Faça um programa para ler uma temperatura em graus Celsius. Criar uma função que converte a
temperatura de Celsius para Fahrenheit. A fórmula de conversão é F  ( 9 * C + 160 ) / 5, sendo F a temperatura
em Fahrenheit e C a temperatura em Celsius. A função de conversão deve receber como entrada de dados
a temperatura em Celsius em tipo de dado float, fazer a conversão e retornar o valor convertido em graus
Fahrenheit.
10. Faça um programa para ler uma temperatura em graus Fahrenheit. Criar uma função que converte a
temperatura de Fahrenheit para Celsius. A fórmula de conversão é C  ( F – 32 ) * ( 5 / 9 ), sendo F a temperatura
em Fahrenheit e C a temperatura em Celsius. A função de conversão deve receber como entrada de dados a
temperatura em Fahrenheit em tipo de dado float, fazer a conversão e retornar o valor convertido em graus
Celsius.
11.Faça um programa que leia um caracter do teclado. Criar uma função que irá converter esta letra para uma
letra minúscula e retorna-la.
12. Faça um programa que leia dois números. Criar uma função chamada potencia que eleva o primeiro
número a uma potência inteira do segundo número e retorna o valor calculado. Por exemplo, se for lido os
números 2 e 3, a função irá calcular 2³ ou seja 2 * 2 * 2
13. Faça um programa que leia e calcule a área de um retângulo. O programa deverá ter uma função que
leia a base e a altura do retângulo, calcule a área e retorne o valor do resultado que deverá ser apresentada na
função main. Fórmula: Área do retângulo = base * altura.
14. Faça um programa que leia e calcule a área de um triângulo. O programa deverá ter uma função que
leia a base e a altura do retângulo, calcule a área e retorne o valor do resultado que deverá ser apresentada na
função main. Fórmula: Área do triângulo = (base * altura) / 2.
15. Faça um programa que leia e calcule a área de um trapézio. O programa deverá ter uma função que leia
a base maior, a base menor e a altura do trapézio, calcule a área e retorne o valor do resultado que deverá ser
apresentada na função main. Fórmula: Área do trapézio = ((base maior + base menor) /2) * altura.
16. Faça um programa que leia e calcule a área de um círculo. O programa deverá ter uma função que
leia o raio do círculo, calcule a área e retorne o valor do resultado que deverá ser apresentada na função main.
Fórmula: Área do círculo =  * r².
Anotações:____________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
60
Bibliografia utilizada:
1. MANZANO, JOSÉ AUGUSTO N. G. – Algoritmos: Lógica para Desenvolvimento de Programação, Editora
Érica, São Paulo, 2000.
2. MANZANO, JOSÉ AUGUSTO N. G. – Lógica estruturada para Programação, Editora Érica, São Paulo,
2001.
3. BOHI, MARILYN – Guia para programadores, Editora Campus, Rio de Janeiro, 1988.
4. ALCIDES MAYA - Polígrafo Técnicas de Programação – Porto Alegre, 2001
5. ALCIDES MAYA - Polígrafo Algoritmo – Porto Alegre, 2001
6. REIS, ANTONIO – Manual Básico de Linguagem C, Porto Alegre, 2000.
7. Outras fontes – Internet, Revistas e Periódicos.
61

Lógica de Programação

Transcrição

Documentos relacionados

Campeão, skatista Wacson Mass é homenageado pela Câmara

Simulado Prova Brasil 009 D12 ––––––––– QUESTÃO 01 D15

Matemática - 1 Trimestre – 1ºs anos – Profª Kelly Exercícios

Port. 7º ano - Secretaria Municipal da Educação de Quixadá

GRADUADO EM EDUCAÇÃO SECUNDÁRIA PROVA LIVRE

Sinónimas, Antónimas, Homónimas, Homófonas, Homógrafas e

Atividade de Férias 2º Ano do Ensino Fundamental

Polly Pocket - Momentos inesquecíveis

caderno_C0608

caderno_C0605