Estrutura Seqüencial em Algoritmos

Prévia do material em texto

1 
LINGUAGEM E TÉCNICA DE PROGRAMAÇÃO I 
 
Profa. Gisele Busichia Baioco 
gisele@ft.unicamp.br 
 
 
Algoritmos Estruturados e 
Linguagem de Programação Estruturada 
 
Estrutura Seqüencial em Algoritmos 
1 Formato Geral da Estrutura Seqüencial em Algoritmos 
Algoritmo 
início 
 declaração-de-variáveis 
 comandos 
fim 
2 Declaração de Variáveis em Algoritmos 
Pode-se imaginar uma variável como o nome de um local na memória do computador 
onde se pode colocar qualquer valor do conjunto de valores possíveis do tipo de dados 
associado a variável. O nome da variável é um identificador que segue as regras válidas para a 
formação de identificadores (formado por letras, dígitos e sublinhados, começando 
obrigatoriamente por uma letra ou sublinhado). 
 
 
soma 
valor da variável soma 
 
 
As variáveis só podem armazenar valores de um mesmo tipo de dados, de maneira 
que, também são classificadas como sendo numéricas inteiras, numéricas reais, lógicas e 
caracteres. 
Para indicar o nome e o tipo de uma ou mais variáveis é usada uma declaração de 
variáveis. No momento em que se declara uma variável, é feita a associação do nome 
escolhido, com a respectiva porção de memória (dependendo do tipo de dado) que o mesmo 
passe a simbolizar. 
Uma vez declarada uma variável, qualquer referência que se faça ao seu identificador 
implica a referência do conteúdo do local da memória representada pelo mesmo. 
Formato geral de declaração de variáveis: 
 
declare lista-de-identificadores: tipo-de-dado; 
 
onde: 
declare: é uma palavra reservada do algoritmo que indica a seção de declaração de variáveis; 
lista-de-identificadores: são os nomes (identificadores) escolhidos para as variáveis, que 
devem estar separados por vírgula; 
 2 
tipo-de-dado: é um dos tipos de dados a ser associado às variáveis da lista-de-identificadores. 
Os tipos possíveis são numérico inteiro, numérico real, lógico e caractere. 
 
Exemplos: 
 
declare codigo, X_5: numérico inteiro; 
declare nota: numérico real; 
 declare teste: lógico; 
 declare nome, ender: caractere; 
 
Caso as declarações de variáveis do exemplo anterior pertençam a um mesmo 
algoritmo, coloca-se apenas uma vez a palavra declare, como mostrado a seguir: 
 
declare codigo, X_5: numérico inteiro; 
 nota: numérico real; 
 teste: lógico; 
 nome, ender: caractere; 
3 Comando de Atribuição em Algoritmos 
O comando de atribuição permite que se forneça um valor a uma variável, sendo que 
esse valor tem de ser compatível com o tipo de dado da variável na qual está sendo 
armazenado. 
 Formato geral de um comando de atribuição: 
 
identificador ←←←← expressão; 
 
onde: 
identificador: é o nome da variável à qual está sendo atribuído o valor; 
← : é o símbolo de atribuição; 
expressão: pode ser expressão aritmética, expressão lógica ou relacional. 
 
Exemplos de atribuições válidas: 
 
K ← 1; 
media ← soma / N; 
cor ← “verde”; 
codigo ← N2 + 5; 
teste ← F; 
S ← X = 0 e Y ≠ 2; 
A ← B; 
TOTAL ← X2 + Y; 
 
Algoritmo exemplo: 
 
Algoritmo 
início 
 declare X,Y,Z: numérico inteiro; 
 X ← 10; 
 Y ← 20; 
 Z ← X + Y; 
fim 
 3 
4 Comandos de Entrada e Saída em Algoritmos 
Sabe-se que as unidades de entrada e saída são os dispositivos que possibilitam a 
comunicação entre o usuário e o computador. 
Como e quem determina o momento da entrada dos dados para o programa e a saída 
dos resultados obtidos para o usuário? Isso é tarefa do programador que quando está 
desenvolvendo algoritmos, descreve as ações a serem executadas pelo computador. Os 
comandos de entrada e saída são as ferramentas para essa finalidade. 
Formato geral do comando de entrada: 
 
leia(lista-de-identificadores); 
 
Formato geral do comando de saída: 
 
escreva(lista-de-identificadores e/ou constantes); 
 
onde: 
leia e escreva: são palavras reservadas para entrada e saída, respectivamente; 
lista-de-identificadores: são os nomes das variáveis, separados por vírgula, a serem lidas; 
lista-de-identificadores e/ou constantes: são os nomes das variáveis e/ou valores constantes, 
separados por vírgula, a serem mostrados ao usuário. 
 
Algoritmo exemplo: 
 
Algoritmo 
início 
declare X,Y: numérico inteiro; 
escreva(“Digite um número: “); 
leia(X); 
 escreva(“Digite outro número: “); 
leia(Y); 
 escreva(“O primeiro número digitado foi:”, X); 
 escreva(“O segundo número digitado foi:”, Y); 
fim 
5 Comentários 
Um comentário é um texto ou simplesmente uma frase, que aparece sempre 
delimitado por /* */. 
Os comentários podem ser colocados em qualquer ponto do algoritmo onde se façam 
necessários. Sua funcionalidade é documentar o algoritmo, ou seja, torná-lo mais claro. 
No exemplo a seguir, é mostrado um conjunto de declarações onde foram introduzidos 
comentários com o intuito de explicar o significado de cada uma das variáveis. 
 
 declare mat, /* número de matrícula do aluno */ 
 cod /* código do curso */: numérico inteiro; 
 nome, /* nome completo do aluno */ 
 end, /* endereço do aluno */ 
 C /* conceito final */: caractere; 
 4 
6 Exemplos de Algoritmos 
1) Faça um algoritmo que leia quatro números inteiros, calcule e mostre a soma desses 
números. 
Solução: 
Entrada: quatro números inteiros n1, n2, n3, n4 
Processo: soma = n1 + n2 + n3 + n4 
Saída: resultado da soma 
 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare n1, n2, n3, n4, soma: numérico inteiro; 
 /* Entrada de dados */ 
 escreva(“Digite quatro números inteiros: “); 
 leia(n1); 
leia(n2); 
leia(n3); 
leia(n4); 
/* Processo – cálculo da soma */ 
soma ← n1 + n2 + n3 + n4; 
/* Saída de dados */ 
escreva(“Soma = “, soma); 
fim 
 
2) Escreva um algoritmo que receba três notas e seus respectivos pesos, calcule e mostre 
a média ponderada dessas notas. 
Solução: 
Entrada: três notas nota1, nota2, nota3 e três pesos peso1, peso2, peso3 
Processo: média = (nota1*peso1+nota2*peso2+nota3*peso3)/(peso1+peso2+peso3) 
Saída: resultado da média ponderada 
 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare nota1, nota2, nota3, /* notas */ 
 media: numérico real; 
 peso1, peso2, peso3 /* pesos */: numérico inteiro; 
 /* Entrada de dados */ 
 escreva(“Entre com a primeira nota e seu peso: “); 
 leia(nota1); 
 leia(peso1); 
escreva(“Entre com a segunda nota e seu peso: “); 
 leia(nota2); 
 leia(peso2); 
escreva(“Entre com a terceira nota e seu peso: “); 
 leia(nota3); 
 leia(peso3); 
 /* Processo – cálculo da média ponderada */ 
 media ← (nota1*peso1+nota2*peso2+nota3*peso3)/(peso1+peso2+peso3); 
 /* Saída de dados */ 
 escreva(“Média ponderada = “, media); 
fim 
 
 5 
3) Faça um algoritmo que receba o salário de um funcionário e o percentual de aumento, 
calcule e mostre o valor do aumento e o novo salário. 
Solução: 
 Entrada: salário e percentual de aumento 
 Processo: aumento = valor do salário * percentual de aumento/100 
 novo salário = salário + aumento 
 Saída: aumento e novo salário 
 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare sal, /* salário */ 
 perc_aumento, /* percentual de aumento */ 
 aumento, /* valor do aumento */ 
 novo_sal /* novo salário */: numérico real; 
 /* Entrada de dados */ 
 escreva(“Entre com o salário: “); 
 leia(sal); 
 escreva(“Entre com o percentual de aumento: “); 
 leia(perc_aumento); 
 /* Processo – cálculo do valor do aumento e do novo salário */ 
 aumento ← sal * perc_aumento/100; 
 novo_sal ← sal + aumento; 
 /* Saída de dados */ 
 escreva(“O aumento é de: “, aumento); 
 escreva(“O salário com aumento é de: “, novo_sal); 
fim 
 
7 Exercícios de Fixação 
1) Faça um algoritmo que leia três notas, calcule e mostra a média aritmética entre elas. 
2) Escreva um algoritmo que receba o salário de um funcionário, calcule e mostre o novo 
salário, sabendo-se que o salário teve um aumento de 25%. 
3) Escreva um algoritmo que receba um número positivo e maior que zero, calcule e 
mostre: 
a) o número ao quadrado; 
b) o númeroao cubo; 
c) a raiz quadrada do número; 
d) a raiz cúbica do número. 
4) Sabe-se que: 
1 pé = 12 polegadas 
1 jarda = 3 pés 
1 milha = 1760 jardas 
Faça um algoritmo que receba uma medida em pés, faça as conversões necessárias e 
mostre os resultados em polegadas, jardas e milhas. 
5) O custo ao consumidor de um carro novo é a soma do preço de fábrica com o 
percentual de lucro do distribuidor e dos impostos aplicados ao preço de fábrica. Faça 
um algoritmo que leia o preço de fábrica de um veículo, o percentual de lucro do 
distribuidor e o percentual de impostos, calcule e mostre: 
a) o valor correspondente ao lucro do distribuidor; 
b) o valor correspondente aos impostos; 
c) o preço final do veículo.