instituto federal de educaÇÃo, ciÊncia e … · ministÉrio da educaÇÃo secretaria de...

MINISTÉRIO DA EDUCAÇÃO

SECRETARIA DE EDUCAÇÃO PROFISSIONAL E TECNOLÓGICA

INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA DO TRIÂNGULO MINEIRO

CAMPUS PARACATU

Algoritmos

Curso Técnico em Informática

Prof. Gustavo Alexandre de Oliveira Silva

Janeiro de 2012

SUMÁRIO

Capítulo 1

Lógica de Programação ..................................................................................................................................... 7

1. Conceitos Básicos de Programação ........................................................................................................... 7

1.1. Linguagens de Programação ............................................................................................................... 8

1.2. Tradutores .......................................................................................................................................... 8

1.3. Tipos de Linguagens de Programação ................................................................................................ 9

1.4. Critérios de Qualidade de um Programa ............................................................................................ 9

2. Paradigmas de Programação ................................................................................................................... 10

2.1. Paradigma Imperativo ...................................................................................................................... 10

2.2. Paradigma Funcional ........................................................................................................................ 10

2.3. Paradigma Lógico .............................................................................................................................. 11

2.4. Paradigma Orientado a Objetos ....................................................................................................... 11

Capítulo 2

Algoritmos ....................................................................................................................................................... 13

1. Conceito de Algoritmo ............................................................................................................................. 13

2. Formas de Representação de Algoritmos ............................................................................................... 14

2.1. Descrição Narrativa .......................................................................................................................... 15

2.2. Fluxograma Convencional ou Diagrama de Blocos .......................................................................... 15

2.3. Diagrama de Chapin ......................................................................................................................... 17

2.4. Pseudocódigo ................................................................................................................................... 17

3. Um Ambiente para Descrever Algoritmos ............................................................................................... 18

3.1. Funcionamento do nosso Computador ............................................................................................ 19

3.2. Resolvendo um Problema ................................................................................................................. 19

4. Desenvolvendo Algoritmos...................................................................................................................... 20

5. Método para Construir um Algoritmo ..................................................................................................... 23

5.1. Fases ................................................................................................................................................. 24

5.2. Exemplo de Algoritmo ...................................................................................................................... 25

5.3. Teste de Mesa ................................................................................................................................... 25

6. Máximas de Programação ....................................................................................................................... 26

Capítulo 3

Tipos de Dados ................................................................................................................................................ 35

1. Variáveis e Constantes ............................................................................................................................. 36

1.1. Armazenamento de Dados na Memória .......................................................................................... 36

1.2. Conceito e Utilidade de Variáveis ..................................................................................................... 36

1.3. Definição de Variáveis em Algoritmos .............................................................................................. 37

1.4. Conceito e Utilidade de Constantes ................................................................................................. 38

1.5. Definição de Constantes em Algoritmos .......................................................................................... 38

Capítulo 4

Operadores e Expressões ................................................................................................................................ 41

1. Operadores .............................................................................................................................................. 41

1.1. Operadores de Atribuição ................................................................................................................ 41

1.2. Operadores Aritméticos ................................................................................................................... 42

1.3. Operadores Relacionais .................................................................................................................... 43

1.4. Operadores Lógicos .......................................................................................................................... 44

1.5. Operadores Literais .......................................................................................................................... 44

2. Expressões ............................................................................................................................................... 45

2.1. Expressões Aritméticas ..................................................................................................................... 45

2.2. Expressões Lógicas ............................................................................................................................ 45

2.3. Expressões Literais ............................................................................................................................ 45

2.4. Avaliação de Expressões ................................................................................................................... 46

Capítulo 5

Instruções Primitivas ....................................................................................................................................... 49

1. Comandos de Atribuição ......................................................................................................................... 49

2. Comandos de Saída de Dados ................................................................................................................. 50

3. Comandos de Entrada de Dados ............................................................................................................. 51

4. Interface com o Usuário .......................................................................................................................... 52

5. Entrada, Processamento e Saída ............................................................................................................. 53

6. Funções Pré-Definidas ............................................................................................................................. 53

6.1. Funções Numéricas, Algébricas e Trigonométricas .......................................................................... 54

6.2. Funções para Manipulação de Cadeias de Caracteres (Strings) ....................................................... 55

Capítulo 6

Estruturas de Controle do Fluxo de Execução ................................................................................................. 63

1. Comandos Compostos ............................................................................................................................. 63

2. Estrutura Sequencial ................................................................................................................................ 63

3. Estruturas de Decisão .............................................................................................................................. 64

3.1. Estruturas de Decisão Simples ( Se ... então ) ................................................................................... 64

3.2. Estruturas de Decisão Composta ( Se ... então ... senão ) ................................................................ 66

3.3. Estruturas de Decisão Múltipla do Tipo Caso ( Escolha... Caso ... Outrocaso ) ................................ 67

4. Estruturas de Repetição .......................................................................................................................... 73

4.1. Laços Contados ................................................................................................................................. 74

4.2. Laços Condicionais ............................................................................................................................ 76

5. Estruturas de Controle Encadeadas ou Aninhadas ................................................................................. 79

Capítulo 7

Estruturas de Dados Homogêneas .................................................................................................................. 91

1. Matrizes de Uma Dimensão ou Vetores .................................................................................................. 92

1.1. Operações Básicas com Vetores ....................................................................................................... 92

1.2. Exemplos de Aplicação de Vetores ................................................................................................... 95

2. Matrizes com Mais de Uma Dimensão .................................................................................................... 99

2.1. Operações Básicas com Matrizes de Duas Dimensões ................................................................... 100

Capítulo 8

Algoritmos: Exercícios ................................................................................................................................... 109

1. Estruturas Sequenciais .......................................................................................................................... 109

2. Estruturas de Decisão ............................................................................................................................ 113

3. Estruturas de Repetição ........................................................................................................................ 120

4. Vetores e Matrizes ................................................................................................................................. 126

Referências Bibliográficas .............................................................................................................................. 133

7

CAPÍTULO 1

LÓGICA DE PROGRAMAÇÃO

A lógica de programação é necessária para pessoas que desejam trabalhar com desenvolvimento de sistemas e programas. Ela permite definir a seqüência lógica para o desenvolvimento.

Então o que é lógica? Lógica de programação é a técnica de encadear pensamentos para atingir determinado objetivo.

Seqüência Lógica

Estes pensamentos podem ser descritos como uma seqüência de instruções, que devem ser seguidas para se cumprir uma determinada tarefa.

Seqüência Lógica são passos executados até atingir um objetivo ou solução de um problema.

Instruções

Na linguagem comum, entende-se por instruções “um conjunto de regras ou normas definidas para a realização ou emprego de algo”. Em informática, porém, instrução é a informação que indica a um computador uma ação elementar a executar.

Convém ressaltar que uma ordem isolada não permite realizar o processo completo, para isso é necessário um conjunto de instruções colocadas em ordem seqüencial lógica. Por exemplo, se quisermos fazer uma omelete de batatas, precisaremos colocar em prática uma série de instruções: descascar as batatas, bater os ovos, fritar as batatas, etc...

É evidente que essas instruções tem que ser executadas em uma ordem adequada – não se pode descascar as batatas depois de fritá-las. Dessa maneira, uma instrução tomada em separado não tem muito sentido; para obtermos o resultado, precisamos colocar em prática o conjunto de todas as instruções, na ordem correta.

Instruções são um conjunto de regras ou normas definidas para a realização ou emprego de algo. Em informática, é o que indica a um computador uma ação elementar a executar.

1. CONCEITOS BÁSICOS DE PROGRAMAÇÃO

Para armazenar um algoritmo na memória de um computador e para que ele possa, em seguida, comandar as operações a serem executadas, é necessário que ele seja programado, isto é, que seja transcrito para uma linguagem que o computador possa entender, direta ou indiretamente.

8

1.1. LINGUAGENS DE PROGRAMAÇÃO

Linguagem é uma maneira de comunicação que segue uma forma e uma estrutura com significado interpretável.

Portanto, linguagem de programação é um conjunto finito de palavras, comandos e instruções, escritos com o objetivo de orientar a realização de uma tarefa pelo computador.

Logicamente, a linguagem que nós utilizamos em nosso cotidiano é diferente da linguagem utilizada pela máquina. A máquina trabalha somente com códigos numéricos (linguagem de máquina), baseados nos números 0 e 1 (sistema binário), que representam impulsos elétricos, ausente e presente.

Assim, qualquer linguagem de programação deve estar situada entre dois extremos: o da linguagem natural do homem (muito clara, porém lenta) e o da linguagem de máquina (muito rápida, porém complexa).

Este é o conceito de nível de linguagem: alto nível para as mais próximas da linguagem humana; baixo nível para as mais semelhantes à linguagem de máquina.

1.2. TRADUTORES

Para que um computador possa "entender" um programa escrito em uma linguagem de alto nível, torna-se necessário um meio de tradução entre a linguagem utilizada no programa e a linguagem de máquina. Este meio pode ser de dois tipos: compilador e interpretador.

Compilador: traduz o programa escrito em linguagem de alto nível (programa-fonte) para um programa equivalente escrito em linguagem de máquina (programa-objeto).

Interpretador: traduz e envia para execução, instrução por instrução e o programa permanece na forma fonte.

9

1.3. TIPOS DE LINGUAGENS DE PROGRAMAÇÃO

Existem diversas linguagens de programação, cada uma com suas características específicas e com níveis de complexidade e objetivos diferentes:

Linguagem de Máquina Única compreendida pelo computador. Específica de cada computador.

Linguagens de Baixo Nível Utilizam mnemônicos para representar instruções elementares Ex.: Assembly

Linguagens de Alto Nível Utiliza instruções próximas da linguagem humana de forma a facilitar o

raciocínio. Exemplos: Uso científico : Fortran

Propósito geral : Pascal, C, Basic Uso comercial : Cobol, Clipper

Uso específico : Lisp, Prolog Visuais : Delphi, Visual Basic, Java

1.4. CRITÉRIOS DE QUALIDADE DE UM PROGRAMA

Integridade: Refere-se à precisão das informações manipuladas pelo programa, ou seja, os resultados gerados pelo processamento do programa devem estar corretos, caso contrário o programa simplesmente não tem sentido.

Clareza: Refere-se à facilidade de leitura do programa. Se um programa for escrito com clareza, deverá ser possível a outro programador seguir a lógica do programa sem muito esforço, assim como o próprio autor do programa entendê-lo após ter estado um longo período afastado dele. O Pascal favorece a escrita de programas com clareza e legibilidade.

Simplicidade: A clareza e precisão de um programa são normalmente melhoradas tornando as coisas o mais simples possível, consistentes com os objetivos do programa. Muitas vezes torna-se necessário sacrificar alguma eficiência de processamento, de forma a manter a estrutura do programa mais simples.

Eficiência: Refere-se à velocidade de processamento e a correta utilização da memória. Um programa deve ter performance SUFICIENTE para atender às necessidades do problema e do usuário, bem como deve utilizar os recursos de memória de forma moderada, dentro das limitações do problema.

Modularidade: Consiste no particionamento do programa em módulos menores bem identificáveis e com funções específicas, de forma que o conjunto desses módulos e a interação entre eles permitem a resolução do problema de forma mais simples e clara.

10

Generalidade: É interessante que um programa seja tão genérico quanto possível de forma a permitir a reutilização de seus componentes em outros projetos.

2. PARADIGMAS DE PROGRAMAÇÃO

Um paradigma se define na forma como o programador lida com um determinado problema. Muitos pensam que as linguagens de programação surgiram em uma escala linear, ou seja, que na primeira geração delas o homem se adaptava às máquinas e, depois de várias outras gerações, as linguagens evoluíram umas das outras e capacitaram as máquinas a fazer as necessidades humanas. Na verdade, as linguagens surgiram em diferentes trajetórias, cada uma seguindo um determinado paradigma. Além disso, não é verdadeira a proposição que diz que uma linguagem qualquer é, sem exceção, a evolução da linguagem anterior (historicamente).

As linguagens existentes hoje foram se adaptando a uma única forma de programação e às linguagens inseridas no mesmo paradigma. Dentre esses paradigmas, vamos conceituar quatro, que são considerados os principais: paradigma imperativo, lógico, funcional e orientado a objetos.

2.1. PARADIGMA IMPERATIVO

“Primeiro faça isso e depois faça aquilo.”

A frase acima resume o paradigma imperativo, também conhecido como paradigma procedural. O problema é analisado até que se encontre uma solução. Basicamente, é uma sequência de comandos que o computador executará, passo-a-passo, modificando dados e variáveis a fim de chegar ao resultado esperado. Algol, Basic, C e Pascal são algumas das linguagens de programação que seguem esse paradigma.

2.2. PARADIGMA FUNCIONAL

“Subdividir o problema em outras funções e resolver cada uma separadamente, pois os resultados encontrados serão utilizados posteriormente.”

Sobre o paradigma funcional, é fácil ilustrar através de um fluxograma. Cada bloco recebe no topo uma entrada de dados e retorna, na base, os dados de saída. A solução geral é dividida em várias funções (daí o nome funcional) que, no final, se associam para mostrar o resultado na tela.

No (clássico) fluxograma ao lado, o problema – fazer a média das notas de N alunos -, é dividido em duas etapas: a soma das N notas e a atribuição da quantidade N de alunos à variável contador. Ambos os resultados, soma das notas e contagem dos alunos, são utilizados na operação final, que é dividir a soma das notas pelo número de alunos. É um exemplo muito simples, mas que, penso eu, foi útil para exemplificar o conceito.

11

2.3. PARADIGMA LÓGICO

“Qual é o problema?”

O paradigma lógico ou declarativo caracteriza-se pelo método preciso de descrever um problema, sem se preocupar com qual algoritmo será utilizado para resolvê-lo. A idéia é criar um algoritmo “universal”, capaz de solucionar qualquer problema. O problema se adapta a esse algoritmo, e não o contrário. É baseado em axiomas (verdades universais) e regras de inferência. Prolog é uma linguagem lógica que ilustra essa definição.

2.4. PARADIGMA ORIENTADO A OBJETOS

“Um conjunto de classes faz a interação entre objetos (instâncias) e, com a troca de mensagens entre eles, forma-se o software como um todo.”

Praticamente tudo é objeto, cada qual com estrutura e comportamento próprios. Esses objetos são classificados em classes e comunicam entre si. Cada uma dessas representa um determinado fenômeno e seus objetos são organizados hierarquicamente. O conjunto de classes faz a interação entre objetos e a troca de mensagens entre eles forma o software como um todo.

Esse paradigma vem ganhando cada vez mais popularidade. Isso se dá devido ao grande número de vantagens em trabalhar com orientação a objeto, como a flexibilidade do código quando se trabalha em sistemas de grande porte e com uma maior equipe de programadores.

EXERCÍCIOS PROPOSTOS

Questão 01:

Defina, com suas palavras, os seguintes termos:

a) programa b) linguagem de programação c) tradutor

Questão 02:

Qual a diferença entre linguagem de baixo nível e linguagem de alto nível?

Questão 03:

Explique a diferença entre compilador e interpretador.

12

Questão 04:

Cite e explique com suas palavras os quatro paradigmas tradicionais de programação.

13

CAPÍTULO 2

ALGORITMOS

O uso de algoritmos é quase tão antigo quanto a matemática. Com o passar do tempo, entretanto, ele foi bastante esquecido pela matemática. Com o advento das máquinas de calcular e mais tarde os computadores, o uso de algoritmos ressurgiu com grande vigor, como uma forma de indicar o caminho para a solução dos mais variados problemas.

Algoritmo não é a solução do problema, pois, se assim fosse, cada problema teria um único algoritmo. Algoritmo é o caminho para a solução de um problema, e em geral, os caminhos que levam a uma solução são muitos.

Ao longo dos anos surgiram muitas formas de representar os algoritmos, alguns utilizando linguagens semelhantes às linguagens de programação e outras utilizando formas gráficas.

O aprendizado de algoritmos não se consegue a não ser através de muitos exercícios.

1. CONCEITO DE ALGORITMO

A automação é o processo em que uma tarefa deixa de ser desempenhada pelo homem e passa a ser realizada por máquinas, sejam estas dispositivos mecânicos (como as máquinas industriais), eletrônicos (como os computadores), ou de natureza mista (como os robôs).

Para que a automação de uma tarefa seja bem-sucedida é necessário que a máquina que passará a realizá-la seja capaz de desempenhar cada uma das etapas constituintes do processo a ser automatizado com eficiência, de modo a garantir a repetibilidade do mesmo. Assim, é necessário que seja especificado com clareza e exatidão o que deve ser realizado em cada uma das fases do processo a ser automatizado, bem como a seqüência em que estas fases devem ser realizadas.

À especificação da seqüência ordenada de passos que deve ser seguida para a realização de uma tarefa, garantindo a sua repetibilidade, dá-se o nome de algoritmo.

Embora esta definição de algoritmo seja correta, podemos definir algoritmo, de maneira informal e completa como:

14

Informalmente, um algoritmo é qualquer procedimento computacional bem definido que toma algum valor ou conjunto de valores como entrada e produz algum valor ou conjunto de valores como saída.

Um algoritmo deve sempre possuir pelo menos um resultado, normalmente chamado de saída, e satisfazer a propriedade da efetividade, isto é, todas as operações especificadas no algoritmo devem ser suficientemente básicas para que possam ser executadas de maneira exata e num tempo finito.

Na prática não é importante ter-se apenas um algoritmo, mas sim, um bom algoritmo. O mais importante de um algoritmo é a sua correção, isto é, se ele resolve realmente o problema proposto e o faz exatamente.

Para se ter um algoritmo, é necessário:

Que se tenha um número finito de passos Que cada passo esteja precisamente definido, sem possíveis ambigüidades Que existam zero ou mais entradas tomadas de conjuntos bem definidos Que existam uma ou mais saídas Que exista uma condição de fim sempre atingida para quaisquer entradas e num tempo

finito.

Para que um computador possa desempenhar uma tarefa é necessário que esta seja detalhada passo a passo, numa forma compreensível pela máquina, utilizando aquilo que se chama de programa. Neste sentido, um programa de computador nada mais é que um algoritmo escrito numa forma compreensível pelo computador.

2. FORMAS DE REPRESENTAÇÃO DE ALGORITMOS

Existem diversas formas de representação de algoritmos, mas não há um consenso com relação à melhor delas.

Algumas formas de representação de algoritmos tratam dos problemas apenas em nível lógico, abstraindo-se de detalhes de implementação muitas vezes relacionados com alguma linguagem de programação específica. Por outro lado, existem formas de representação de algoritmos que possuem uma maior riqueza de detalhes e muitas vezes acabam por obscurecer a idéia principal, o algoritmo, dificultando seu entendimento.

Dentre as formas de representação de algoritmos mais conhecidas, sobressaltam:

a Descrição Narrativa

o Fluxograma Convencional

o Diagrama de Chapin

o Pseudocódigo, também conhecido como Linguagem Estruturada ou Portugol

15

2.1. DESCRIÇÃO NARRATIVA

Nesta forma de representação, os algoritmos são expressos diretamente em linguagem natural. Como por exemplo, têm-se os algoritmos seguintes:

Troca de um pneu furado: Afrouxar ligeiramente as porcas Suspender o carro Retirar as porcas e o pneu Colocar o pneu reserva Apertar as porcas Abaixar o carro Dar o aperto final nas porcas

Cálculo da média de um aluno: Obter as notas da primeira e da segunda prova Calcular a média aritmética entre as duas Se a média for maior ou igual a sete, o aluno foi aprovado, senão ele foi reprovado

Esta representação é pouco usada na prática porque o uso de linguagem natural muitas vezes dá oportunidade a más interpretações, ambigüidades e imprecisões.

Por exemplo, a instrução “afrouxar ligeiramente as porcas” no algoritmo da troca de pneus está sujeita a interpretações diferentes por pessoas distintas. Uma instrução mais precisa seria: “afrouxar a porca, girando-a de 30º no sentido anti-horário”.

2.2. FLUXOGRAMA CONVENCIONAL OU DIAGRAMA DE BLOCOS

É uma representação gráfica de algoritmos onde formas geométricas diferentes implicam ações (instruções, comandos) distintas. Tal propriedade facilita o entendimento das idéias contidas nos algoritmos.

Nota-se que os fluxogramas convencionais preocupam-se com detalhes de nível físico da implementação do algoritmo. Por exemplo, figuras geométricas diferentes são adotadas para representar operações de saída de dados realizadas em dispositivos distintos, como uma unidade de armazenamento de dados ou um monitor de vídeo. A figura abaixo mostra as principais formas geométricas usadas em fluxogramas.

Início e final do fluxograma

Decisão

Operação de entrada de dados

Seta de Fluxo de Dados

16

Operação de saída de dados em

impressora

Conector utilizado quando é preciso

particionar o diagrama, colocando

uma letra ou número no símbolo para

identificar os pares da conexão

Operação de saída de dados em

vídeo

Conector específico para indicar

conexão do fluxo de execução em

outra página

Operações de atribuição e

chamada ou retorno de

subalgoritmo

Preparação – operações que utilizam

uma chave que modifica a execução

do programa

Principais formas geométricas usadas em fluxogramas

De modo geral, o fluxograma se resume a um único símbolo inicial, por onde a execução do algoritmo começa, e um ou mais símbolos finais, que são pontos onde a execução do algoritmo se encerra. Partindo do símbolo inicial, há sempre um único caminho orientado a ser seguido, representando a existência de uma única seqüência de execução das instruções. Isto pode ser mais bem visualizado pelo fato de que, apesar de vários caminhos poderem convergir para uma mesma figura do diagrama, há sempre um único caminho saindo desta. Exceções a esta regra são os símbolos finais, dos quais não há nenhum fluxo saindo, e os símbolos de decisão, de onde pode haver mais de um caminho de saída (normalmente dois caminhos), representando uma bifurcação no fluxo.

Um diagrama de blocos é uma forma de fluxograma usada e desenvolvida por profissionais da programação, tendo como objetivo descrever o método e a seqüência do processo dos planos num computador. Pode ser desenvolvido em qualquer nível de detalhe que seja necessário. Quando se desenvolve um diagrama para o programa principal, por exemplo, seu nível de detalhamento pode chegar até as instruções. Esta ferramenta usa diversos símbolos geométricos, os quais estabelecerão as seqüências de operações a serem efetuadas em um processamento computacional. Após a elaboração do diagrama de bloco, é realizada a codificação do programa.

A figura ao lado mostra a representação do algoritmo de cálculo da média de um aluno sob a forma de um fluxograma.

17

2.3. DIAGRAMA DE CHAPIN

O diagrama foi criado por Ned Chapin a partir de trabalhos de Nassi-Shneiderman, os quais resolveram substituir o fluxograma tradicional por um diagrama que apresenta uma visão hierárquica e estruturada da lógica do programa. A grande vantagem de usar este tipo de diagrama é a representação das estruturas que tem um ponto de entrada e um ponto de saída e são compostas pelas estruturas básicas de controle de seqüência, seleção e repartição. Enquanto é difícil mostrar o embutimento e a recursividade com o fluxograma tradicional, torna-se mais simples mostrá-lo com o diagrama de Chapin, bem como codificá-lo futuramente na conversão de código português estruturado ou pseudocódigos. A figura abaixo apresenta um exemplo do tipo de diagrama de Chapin para o algoritmo de cálculo da média de um aluno.

2.4. PSEUDOCÓDIGO

Esta forma de representação de algoritmos, também conhecida como português estruturado ou portugol, é bastante rica em detalhes e, por assemelhar-se bastante à forma em que os programas são escritos. Ela encontra muita aceitação, sendo, portanto a forma de representação de algoritmos que utilizaremos nesta disciplina.

Na verdade, esta representação é suficientemente geral para permitir que a tradução de um algoritmo nela representado para uma linguagem de programação específica seja praticamente direta.

Representação de Um Algoritmo na Forma de Pseudocódigo

A representação de um algoritmo na forma de pseudocódigo é a seguinte:

algoritmo <nome_do_algoritmo>

<declaração_de_variáveis>

<subalgoritmos>

inicio

<corpo_do_algoritmo>

fimalgoritmo

18

onde:

Algoritmo é uma palavra que indica o início da definição de um algoritmo em forma de pseudocódigo.

<nome_do_algoritmo> é um nome simbólico dado ao algoritmo com a finalidade de distingui-lo dos demais.

<declaração_de_variáveis> consiste em uma porção opcional onde são declaradas as variáveis globais usadas no algoritmo principal e, eventualmente, nos subalgoritmos.

<subalgoritmos> consiste de uma porção opcional do pseudocódigo onde são definidos os subalgoritmos.

Início e Fim são respectivamente as palavras que delimitam o início e o término do conjunto de instruções do corpo do algoritmo.

Como exemplo, a seguir é mostrado a representação do algoritmo de cálculo da média de um aluno na forma de um pseudocódigo.

algoritmo media_aluno

var N1, N2, media

inicio

leia N1, N2

media <- (N1+N2)/2

se media >= 7 entao

escreva “Aprovado”

senao

escreva “Reprovado”

fimalgoritmo

3. UM AMBIENTE PARA DESCREVER ALGORITMOS

Descreveremos uma máquina hipotética para a qual escreveremos nossos algoritmos. O nosso computador hipotético apresentará a seguinte organização:

19

Cada uma das partes constituintes da figura acima tem os seguintes significados:

(1) Dispositivo de entrada (o teclado): meio pelo qual os dados que serão trabalhados pelo algoritmo vão ser introduzidos em nosso computador hipotético;

(2) Unidade Lógica e Aritmética (ULA): parte responsável pelas operações matemáticas e avaliações lógicas;

(3) Unidade de Controle: exerce controle sobre as demais partes do nosso computador. É uma verdadeira gerente que distribui tarefas às outras unidades;

(4) Memória: guarda o algoritmo a ser executado e os dados a serem utilizados pelo mesmo. Todo dado fornecido ao computador e o resultado de suas operações ficam guardados na memória;

(5) Dispositivo de Saída (vídeo e impressora): meio que se dispõe para apresentação dos resultados obtidos.

3.1. FUNCIONAMENTO DO NOSSO COMPUTADOR

Todos os computadores, independentemente dos seus tamanhos, são conceitualmente semelhantes ao esquema da figura anterior (há algumas diferenças, mas não trataremos aqui dos casos especiais).

Resumidamente, podemos afirmar que existem 4 (quatro) operações básicas que qualquer computador pode executar:

a) operações de entrada e saída: ler dados do teclado e escrever dados na tela são exemplos destas operações. Elas servem para introduzir dados na memória do nosso computador e exibir dados que já estejam lá armazenados;

b) operações aritméticas: são utilizadas na realização de operações matemáticas (adição, subtração, multiplicação e divisão);

c) operações lógicas e relacionais: têm aplicabilidade em comparações, testes de condições lógicas (2>6 ? X=Y ?);

d) movimentação de dados entre os vários componentes: as operações aritméticas são executadas na Unidade Lógica e Aritmética, necessitando da transferência dos dados para essa unidade e da volta do resultado final para ser guardado na memória.

3.2. RESOLVENDO UM PROBLEMA

Suponha que queiramos resolver o seguinte problema: a partir de dois números que serão informados, calcular a adição dos mesmos. Se você fosse encarregado de efetuar essa tarefa, seria bem provável que utilizasse os passos a seguir:

a) saber quais são os números;

b) calcular a soma dos números;

c) responder à questão com o valor do resultado.

20

Vejamos como seria resolvido esse mesmo problema em termos das operações básicas citadas anteriormente:

a) operação de entrada de dados dos números ;

b1) movimento do valor dos números entre a memória e a ULA;

b2) operação aritmética de somar os 2 números;

b3) movimentação do resultado da ULA para guardar na memória;

c) operação de saída do resultado, que está guardado na memória, para o dispositivo de saída desejado.

Deve-se salientar que os passos b1 e b3, normalmente, ficam embutidos na operação matemática, não sendo explicitados.

Em resumo, pode-se dizer que escrever algoritmos ou, em última análise, programar consiste em dividir qualquer problema em muitos pequenos passos, usando uma ou mais das quatro operações básicas citadas.

Esses passos que compõem o algoritmo são denominados de comandos. Os comandos de uma linguagem de programação podem estar mais próximos da máquina (linguagens de baixo nível) ou serem mais facilmente entendidos pelo homem (linguagens de alto nível). A seqüência de operações básicas, dada anteriormente, para resolver o problema de adicionar dois números, está em uma linguagem de baixo nível para o nosso computador hipotético. Em uma linguagem de alto nível teríamos um resultado assim:

leia X,Y

SOMA X + Y

escreva SOMA

4. DESENVOLVENDO ALGORITMOS

Algoritmo é formalmente uma seqüência finita de passos que levam a execução de uma tarefa. Podemos pensar em algoritmo como uma receita, uma seqüência de instruções que dão cabo de uma meta específica. Estas tarefas não podem ser redundantes nem subjetivas na sua definição, devem ser claras e precisas. Algoritmo é a lógica necessária para o desenvolvimento de um programa.

Programas de computadores nada mais são do que algoritmos escritos numa linguagem de computador (Pascal, C, Cobol, Fortran, Visual Basic, entre outras) e que são interpretados e executados por uma máquina, no caso um computador. Notem que dada esta interpretação rigorosa, um programa é por natureza muito específico e rígido em relação aos algoritmos da vida real.

Em um modo geral, um algoritmo segue um determinado padrão de comportamento, com objetivo de alcançar a solução de um problema.

21

Padrão de comportamento: imagine a seqüência de números: 1, 6, 11, 16, 21, 26, ... Para determinar qual será o sétimo elemento dessa série, precisamos descobrir qual é a sua regra de formação, isto é, qual é o seu padrão de comportamento. Como a seqüência segue uma certa constância, facilmente determinada, somos capazes de determinar qual seria o sétimo termo ou outro termo qualquer.

Descrevemos então uma atividade bem cotidiana: trocar uma lâmpada. Apesar de parecer óbvia demais, muitas vezes fazemos este tipo de atividade inconscientemente, sem percebermos os pequenos detalhes.

Vejamos como seria descrevê-la passo a passo:

pegar uma escada;

posicionar a escada embaixo da lâmpada;

buscar uma lâmpada nova;

subir na escada;

retirar a lâmpada velha;

colocar a lâmpada nova.

Para se trocar a lâmpada, é seguida uma determinada seqüência de ações, representadas através desse algoritmo. Como isso pode ser seguido por qualquer pessoa, estabelece-se aí um padrão de comportamento. A sequencialização tem por objetivo reger o fluxo de execução, determinando qual ação vem a seguir.

O algoritmo anterior tem um objetivo bem específico: trocar uma lâmpada. E se a lâmpada não estiver queimada? O algoritmo faz com ela seja trocada do mesmo modo, não prevendo essa situação. Para solucionar este problema, podemos efetuar um teste seletivo, verificando se a lâmpada está ou não queimada:

pegar uma escada;

posicionar embaixo da lâmpada;


ligar o interruptor;

se a lâmpada não acender, então:

subir na escada;



Dessa forma, algumas ações estão ligadas à condição (lâmpada não acender). No caso da lâmpada acender, as três linhas não serão executadas.

Em algumas situações, embora o algoritmo resolva o problema proposto, a solução pode não ser a mais eficiente. Exemplo: três alunos devem resolver um determinado problema:

O aluno A conseguiu resolver o problema executando 35 linhas de programa. O aluno B resolveu o problema executando 10 linhas de programa O aluno C resolveu o problema executando 54 linhas de programa.

22

Obviamente, o algoritmo desenvolvido pelo aluno B é menor e mais eficiente que os demais. Isso significa que há código desnecessário nos demais programas.

Dessa forma, podemos otimizar o algoritmo anterior, uma vez que buscamos a escada e a lâmpada sem saber se serão necessárias:



pegar uma escada;



subir na escada;



Podemos considerar ainda que a lâmpada nova pode não funcionar. Nesse caso devemos trocá-la novamente, quantas vezes for necessário, até que a lâmpada acenda:



pegar uma escada;



subir na escada;


colocar a lâmpada nova;


retirar a lâmpada;

colocar outra lâmpada;

se a lâmpada não acender, então: ...

Observamos que o teste da lâmpada nova é efetuado por um conjunto de ações:

se a lâmpada não acender então:

retirar a lâmpada

colocar outra lâmpada

Em vez de escrevermos várias vezes este conjunto de ações, podemos alterar o fluxo sequencial de execução do programa, de forma que, após executar a ação “coloque outra lâmpada”, voltemos a executar a ação “se a lâmpada não acender”.

Precisa-se então determinar um limite para tal repetição, para garantir que ela cesse quando a lâmpada finalmente acender:

enquanto a lâmpada não acender, faça:

retire a lâmpada

coloque outra lâmpada

23

Uma versão final do algoritmo, que repete ações até alcançar o seu objetivo: trocar a lâmpada queimada por uma que funcione, é apresentada abaixo.



pegar uma escada;



subir na escada;


colocar a lâmpada nova;

enquanto a lâmpada não acender, faça:

retirar a lâmpada;

colocar outra lâmpada.

Até agora, estamos efetuando a troca de uma única lâmpada. Todo o procedimento poderia ser repetido 10 vezes, por exemplo, no caso de querermos trocar 10 lâmpadas. Inicialmente, tínhamos um pequeno conjunto de ações que deveriam ser executadas (estrutura sequencial). Através de uma condição, incluímos posteriormente uma estrutura de seleção. Na necessidade de repetir um determinado trecho do algoritmo, construiu-se no final uma estrutura de repetição.

5. MÉTODO PARA CONSTRUIR UM ALGORITMO

Para escrever um algoritmo precisamos descrever a seqüência de instruções, de maneira simples e objetiva. Para isso utilizaremos algumas técnicas:

Usar somente um verbo por frase

Imaginar que você está desenvolvendo um algoritmo para pessoas que não trabalham com informática

Usar frases curtas e simples

Ser objetivo

Procurar usar palavras que não tenham sentido dúbio

Utilizando os conceitos já desenvolvidos, esquematizaremos um método para construir um algoritmo logicamente correto:

24

1. Ler atentamente o enunciado

Deve-se reler o enunciado de um exercício quantas vezes for necessário, até compreendê-lo completamente. A maior parte da resolução de um exercício consiste na compreensão completa do enunciado.

2. Retirar a relação das entradas de dados do enunciado

Através do enunciado, descobrimos quais são os dados que devem ser fornecidos ao programa, via teclado, a partir dos quais são desenvolvidos os cálculos. Obs. Pode haver algum algoritmo que não necessite da entrada de dados (pouco comum).

3. Retirar do enunciado, a relação das saídas das informações

Através do enunciado podemos descobrir quais são as informações que devem ser mostradas para compor o resultado final, objetivo do algoritmo.

4. Determinar o que deve ser feito para transformar as entradas nas saídas especificadas

Nessa fase é que teremos a construção do Algoritmo propriamente dito. Devemos determinar qual sequência de passos ou ações é capaz de transformar um conjunto de dados nas informações de resultado. Para isso, utilizamos os fatores descritos anteriormente, tais como legibilidade, portabilidade, método cartesiano e planejamento reverso, e finalmente podemos construir o algoritmo.

5.1. FASES

Vimos que ALGORITMO é uma seqüência lógica de instruções que podem ser executadas. É importante ressaltar que qualquer tarefa que siga determinado padrão pode ser descrita por um algoritmo, como por exemplo, como fazer arroz doce ou então calcular o saldo financeiro de um estoque.

Entretanto ao montar um algoritmo, precisamos primeiro dividir o problema apresentado em três fases fundamentais.

Onde temos:

ENTRADA: São os dados de entrada do algoritmo

PROCESSAMENTO: São os procedimentos utilizados para chegar ao resultado final

SAÍDA: São os dados já processados

25

Analogia com o homem

5.2. EXEMPLO DE ALGORITMO

Imagine o seguinte problema: Calcular a média final dos alunos da 3ª Série. Os alunos realizarão quatro provas: P1, P2, P3 e P4. Onde:

Para montar o algoritmo proposto, faremos três perguntas:

a) Quais são os dados de entrada?

R: Os dados de entrada são P1, P2, P3 e P4

b) Qual será o processamento a ser utilizado?

R: O procedimento será somar todos os dados de entrada e dividi-los por 4 (quatro)

c) Quais serão os dados de saída?

R: O dado de saída será a média final

Algoritmo:

Receba a nota da prova1

Receba a nota de prova2

Receba a nota de prova3

Receba a nota da prova4

Some todas as notas e divida o resultado por 4

Mostre o resultado da divisão

5.3. TESTE DE MESA

Após desenvolver um algoritmo ele deverá sempre ser testado. Este teste é chamado de TESTE DE MESA, que significa seguir as instruções do algoritmo de maneira precisa para verificar se o procedimento utilizado está correto ou não.

26

Normalmente, montamos uma tabela com os nomes das variáveis utilizadas em nosso algoritmo e seguimos, passo a passo, o que acontece com o conteúdo de cada uma delas. Veja o exemplo:

P1 P2 P3 P4 Média

6. MÁXIMAS DE PROGRAMAÇÃO

“Máximas de Programação” são regras práticas para a elaboração de algoritmos com qualidade. Alguns exemplos são apresentados a seguir.

1. Algoritmos devem ser feitos para serem lidos por seres humanos: tenha em mente que seus algoritmos deverão ser lidos e entendidos por outras pessoas (e por você mesmo), de tal forma que possam ser corrigidos, modificados, ou receber manutenção;

2. Escreva os comentários no momento em que estiver escrevendo o algoritmo: um algoritmo não documentado é um dos piores erros que um programador pode cometer; é sinal de amadorismo. Como o objetivo da escrita de comentários é facilitar o entendimento do algoritmo, eles devem ser tão bem concebidos quanto o próprio algoritmo, e a melhor maneira de conseguir isso é escrevê-los nos momentos de maior intimidade com os detalhes, ou seja, durante a resolução do problema. Lembre-se: é melhor ter um algoritmo sem comentários do que ter um algoritmo com comentários desatualizados;

3. Os comentários deverão acrescentar alguma coisa às pessoas que farão manutenção em seu algoritmo: o conjunto de comandos nos diz o que está sendo feito; os comentários deverão nos dizer o porquê;

4. Use comentários no cabeçalho do algoritmo: todo algoritmo ou procedimento deverá ter comentários em seu início para explicar o que ele faz e fornecer instruções para seu uso. Alguns destes comentários seriam:

a. Uma descrição do que faz o algoritmo;

b. Como utilizá-lo;

c. Explicação dos significados das variáveis mais importantes;

d. Estruturas de dados utilizadas;

27

e. Data da escrita;

f. Autor;

g. Nomes de quaisquer métodos especiais utilizados, como referências nas quais mais informações possam ser encontradas.

5. Utilize espaços em branco para melhorar a legibilidade: espaços em branco, inclusive linhas em branco, são muito valiosos, pois melhoram a aparência de um algoritmo. Veja:

a. Deixar uma linha em branco entre as declarações e o corpo do algoritmo;

b. Deixar uma linha em branco antes e outra depois de um comentário;

c. Separar grupos de comandos que executam funções lógicas distintas por uma ou mais linhas em branco;

d. Utilizar brancos para indicar precedências de operadores. Em vez de “A + B * C” é

bem mais agradável a forma “A + B*C”.

6. Escolha nomes representativos para suas variáveis: os nomes das variáveis deverão identificar o melhor possível as funcionalidades que elas representam. Por exemplo, X <- Y + Z é muito menos claro que PREÇO <- CUSTO + LUCRO. Uma seleção adequada de nomes de variáveis é o princípio mais importante da legibilidade de algoritmos;

7. Um comando por linha é suficiente: a utilização de vários comandos por linha é prejudicial, por várias razões, entre as quais se destacam:

a. O algoritmo pode ficar ilegível;

b. O algoritmo fica mais difícil de ser depurado.

Veja um exemplo:

A <- 14, 2 ; I<-1; enquanto I<10 faça X <- X + 1 ; K<-I*K;I<-I+1

fim-enquanto;

Agora, com cada comando em uma linha:

A <- 14,2

I <- 1

enquanto I<10 faça

X <- X + 1

K <- I * K

I <- I + 1

fim-enquanto;

Caso desejássemos incluir um novo comando dentro do enquanto, seria necessário reescrever toda a linha.

8. Utilize parênteses para aumentar a legibilidade e prevenir-se contra erros.

Veja uns exemplos, primeiro, com pouco parênteses:

28

A * B * C / (D * E * F)

A * B / C * D / E * F

A / B / C / D

X > Y ou Q

A + B < C

Agora, com parênteses extras:

(A * B * C) / (D * E * F)

((((A * B) / C) * D) / E) * F

((A / B) / C) / D

(X > Y) ou Q

(A + B) < C

9. Utilize “identação” para montar a estrutura lógica do algoritmo: a identação não deve ser feita de forma caótica, mas segundo certos padrões estabelecidos;

10. Sempre que for feita uma modificação no algoritmo, os comentários associados devem ser alterados, e não apenas os comandos. Antes não comentar do que deixar um comentário errado.

Para concluir, vamos ver um trecho de um algoritmo mal escrito. A análise das regras de programação violadas será apresentada a seguir.

inicio

inteiro: XPT, I, II, III, IIIII

leia (XPT, IIIII)

I <- 1

enquanto I < XPT faça

se I < IIIII então se IIIII = 20 então II <- XPT + 2 senão III <- IIIII

^ XPT; senão III <- XPT

IIIII <- III + I; fim-se; fim-se; //sem comentários

I <- I + 1

fim-enquanto; imprima (I, II, IIIII, III, XPT); fim.

Esse código fere todas as regras pregadas pelas máximas de programação, sendo que as mais graves são: falta de identação, nomes não significativos para as variáveis e ausência de comentários.

29


Questão 01:

Analise o fluxograma abaixo e explique o que ele faz.

Questão 02:


30

Questão 03:


Questão 04:


31

Questão 05:


Questão 06:

Analise o pseudocódigo abaixo e responda. Considere que C1, C2, C3, C4 e C5 representam comandos quaisquer, e B1, B2 e B3 sejam testes lógicos.

algoritmo “quest06”

var

b1, b2, b3 : logico

inicio

se b1 = verdadeiro entao

C1

senao



C2

senao

C3

Fimse

C4

Fimse

fimse

C5

fimalgoritmo

32

a) Se b1 = verdadeiro, b2 = verdadeiro e b3 = falso, quais comandos serão executados pelo algoritmo?

b) Se b1 = falso, b2 = verdadeiro e b3 = falso, quais comandos serão executados?

c) Quais valores lógicos b1, b2 e b3 devem receber para que somente o comando C5 seja executado?

d) Se b1 = falso, b2 = verdadeiro e b3 = verdadeiro, quais comandos serão executados?

Questão 07:

Qual é o valor de L no final da execução do algoritmo abaixo?


var

a, b, c : logico

x, y, L : real

inicio

a <- falso

b <- veradeiro

c <- falso

x <- 1.5

y <- 3.2

x <- x + 1

se (c ou ((x+y > 5) e (nao (a e b)))) entao

L <- 0;

senao

L <- 1;

fimse

fimalgoritmo

Questão 08:

Escreva um algoritmo em fluxograma que leia um número inteiro e imprima o seu sucessor e o seu antecessor.

Questão 09:

Escreva um programa em fluxograma para calcular a área de um triângulo, sendo dados a sua base e a sua altura.

Questão 10:

Escreva um algoritmo em fluxograma que leia um número qualquer e informe seu quadrado e sua raiz quadrada.

33

Questão 11:

Antes do racionamento de energia der decretado, quase ninguém falava em quilowatts. Mas agora, todos incorporaram essa palavra em seu vocabulário. Sabendo-se que 100 quilowatts de energia custa um sétimo do salário mínimo, faça um algoritmo em fluxograma que receba o valor do salário mínimo e a quantidade de quilowatts gasta por uma residência e calcule:

a) O valor em reais de cada quilowatt

b) O valor em reais a ser pago

c) O novo valor a ser pago por essa residência com um desconto de 10%

Imprima todos os resultados na tela.

Questão 12:

Faça um algoritmo em fluxograma que leia três números quaisquer e informe qual deles é o maior e qual deles é o menor.

Questão 13:

Faça um algoritmo em fluxograma para ler os valores dos três lados de um triângulo. Verificar e mostrar se é um triângulo ou não e qual tipo.

Dica 1: Triângulo é uma forma geométrica composta por três lados, onde cada lado é menor que a soma dos outros dois lados.

Dica 2: Um triângulo é: isósceles (quando possui dois lados iguais e um lado diferente), escaleno (quando possui todos os lados diferentes) ou equilátero (quando possui todos os lados iguais).

Questão 14:

Segundo uma tabela médica, o peso ideal de uma pessoa está relacionado com a altura e o sexo. Faça um algoritmo em fluxograma que receba a altura e o sexo de uma pessoa, calcule e imprima o seu peso ideal, utilizando as seguintes fórmulas:

Para homens (72.7 * alt) – 58

Para mulheres (62.1 * alt) – 44.7

Questão 15:

Faça um algoritmo que leia o percurso de uma viagem em quilômetros e o tipo de carro utilizado. O programa deve apresentar uma estimativa de consumo de combustível, sabendo-se que o carro tipo A faz 12 km com um litro, o tipo B faz 9 km e o tipo C faz 8 km por litro. O programa deve ainda informar o valor estimado da viagem (em reais) sabendo-se que o preço do litro do combustível é R$ 2,80.

34

Questão 16:

Deseja-se calcular a conta de consumo de energia elétrica de um consumidor. Para isto, escreva um programa em fluxograma que leia o código do consumidor, o preço do Kw e a quantidade de Kw consumido, e exiba o código do consumidor e o total a pagar.

total a pagar = preço x quantidade / total a pagar mínimo = R$ 11,20

Questão 17:

Elabore um algoritmo em fluxograma que imprima todos os números inteiros de 1 a 100.

Questão 18:

Faça um programa em fluxograma que leia um número N, some todos os números inteiros de 1 a N, e mostre o resultado obtido.

Questão 19:

A série de Fibonacci é formada pela sequencia: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...

Escreva um algoritmo em fluxograma que gere a sequencia de Fibonacci até um dado termo digitado pelo usuário.

Questão 20:

Supondo que a população de um país A seja da ordem de 80.000 habitantes com uma taxa anual de crescimento de 3% e que a população de B seja 200.000 habitantes com uma taxa de crescimento de 1.5%. Faça um programa em fluxograma que calcule e escreva o número de anos necessários para que a população do país A ultrapasse ou iguale a população do país B, mantidas as taxas de crescimento.

35

CAPÍTULO 3

TIPOS DE DADOS

Todo o trabalho realizado por um computador é baseado na manipulação das informações contidas em sua memória. Estas informações podem ser classificadas em dois tipos:

As instruções, que comandam o funcionamento da máquina e determinam a maneira como devem ser tratados os dados.

Os dados propriamente ditos, que correspondem à porção das informações a serem processadas pelo computador.

A classificação apresentada a seguir não se aplica a nenhuma linguagem de programação específica; pelo contrário, ela sintetiza os padrões utilizados na maioria das linguagens.

TIPOS INTEIROS

São caracterizados como tipos inteiros, os dados numéricos positivos ou negativos. Excluindo-se destes qualquer número fracionário. Como exemplo deste tipo de dado, têm-se os valores: 35, 0, -56, 1024 entre outros.

TIPOS REAIS

São caracterizados como tipos reais, os dados numéricos positivos e negativos e números fracionários. Como exemplo deste tipo de dado, têm-se os valores: 35, 0, -56, 1.2, -45.987 entre outros.

TIPOS CARACTERES

São caracterizados como tipos caracteres, as sequências contendo letras, números e símbolos especiais. Uma sequência de caracteres deve ser indicada entre aspas (“”). Este tipo de dado também é conhecido como alfanumérico, string, literal ou cadeia. Como exemplo deste tipo de dado, têm-se os valores: “Programação”, “Rua Alfa, 52 Apto 1”, “Fone 574-9988”, “04387-030”, “ ”, “7” entre outros.

TIPOS LÓGICOS

São caracterizados como tipos lógicos os dados com valor verdadeiro e falso, sendo que este tipo de dado poderá representar apenas um dos dois valores. Ele é chamado por alguns de tipo booleano, devido à contribuição do filósofo e matemático inglês George Boole na área da lógica matemática.

36

1. VARIÁVEIS E CONSTANTES

1.1. ARMAZENAMENTO DE DADOS NA MEMÓRIA

Para armazenar os dados na memória, imagine que a memória de um computador é um grande arquivo com várias gavetas, onde cada gaveta pode armazenar apenas um único valor (seja ele numérico, caractere ou lógico). Se for um grande arquivo com várias gavetas, é necessário identificar com um nome a gaveta que se pretende utilizar. Desta forma o valor armazenado pode ser utilizado a qualquer momento.

1.2. CONCEITO E UTILIDADE DE VARIÁVEIS

Têm-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.

Como visto anteriormente, informações correspondentes a diversos tipos de dados são armazenadas nas memórias dos computadores. Para acessar individualmente cada uma destas informações, em princípio, seria necessário saber o tipo de dado desta informação (ou seja, o número de bytes de memória por ela ocupados) e a posição inicial deste conjunto de bytes na memória.

Percebe-se que esta sistemática de acesso a informações na memória é bastante ilegível e difícil de se trabalhar. Para contornar esta situação criou-se o conceito de variável, que é uma entidade destinada a guardar uma informação.

Basicamente, uma variável possui três atributos: um nome, um tipo de dado associado à mesma e a informação por ela guardada.

Toda variável possui um nome que tem a função de diferenciá-la das demais. Cada linguagem de programação estabelece suas próprias regras de formação de nomes de variáveis.

Adotaremos para os algoritmos, as seguintes regras:

um nome de variável deve necessariamente começar com uma letra;

um nome de variável não deve conter nenhum símbolo especial, exceto a sublinha (_) e nenhum espaço em branco;

um nome de variável não poderá ser uma palavra reservada a uma instrução de programa.

Exemplos de nomes de variáveis:

Salario correto

1ANO errado (não começou uma letra)

ANO1 correto

a casa errado (contém o caractere branco)

37

SAL/HORA errado (contém o caractere “/”)

SAL_HORA correto

_DESCONTO errado (não começou com uma letra)

Obviamente é interessante adotar nomes de variáveis relacionados às funções que serão exercidas pelas mesmas dentro de um programa.

Outro atributo característico de uma variável é o tipo de dado que ela pode armazenar. Este atributo define a natureza das informações contidas na variável. Por último há o atributo informação, que nada mais é do que a informação útil contida na variável.

Uma vez definidos, os atributos nome e tipo de dado de uma variável não podem ser alterados e assim permanecem durante toda a sua existência, desde que o programa que a utiliza não seja modificado. Por outro lado, o atributo informação está constantemente sujeito a mudanças de acordo com o fluxo de execução do programa.

Em resumo, o conceito de variável foi criado para facilitar a vida dos programadores, permitindo acessar informações na memória dos computadores por meio de um nome, em vez do endereço de uma célula de memória.

1.3. DEFINIÇÃO DE VARIÁVEIS EM ALGORITMOS

Todas as variáveis utilizadas em algoritmos devem ser definidas antes de serem utilizadas. Isto se faz necessário para permitir que o compilador reserve um espaço na memória para as mesmas.

Mesmo que algumas linguagens de programação (como BASIC e FORTRAN) dispensam esta definição, uma vez que o espaço na memória é reservado à medida que novas variáveis são encontradas no decorrer do programa, nos algoritmos usaremos a definição de variáveis por assemelhar-se com as principais linguagens de programação como Pascal e C.

Nos algoritmos, todas as variáveis utilizadas serão definidas no início do mesmo, por meio de um comando de uma das seguintes formas:

VAR <nome_da_variável> : <tipo_da_variável>

ou

VAR <lista_de_variáveis> : <tipo_das_variáveis>

a palavra-chave VAR deverá estar presente sempre e será utilizada um única vez na definição de um conjunto de uma ou mais variáveis;

numa mesma linha poderão ser definidas uma ou mais variáveis do mesmo tipo; para tal, deve-se separar os nomes das mesmas por vírgulas;

variáveis de tipos diferentes devem ser declaradas em linhas diferentes.

38

Exemplos de definição de variáveis:

VAR nome: caracter[35]

idade: inteiro

salário: real

tem_filhos: lógico

No exemplo acima foram declaradas quatro variáveis:

a variável nome, capaz de armazenar dados caractere de comprimento 35 (35 caracteres);

a variável idade, capaz de armazenar um número inteiro;

a variável salário, capaz de armazenar um número real;

a variável tem_filhos, capaz de armazenar uma informação lógica.

1.4. CONCEITO E UTILIDADE DE CONSTANTES

Têm-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, quando desenvolvermos programas.

É comum definirmos uma constante no início do programa, e a utilizarmos no decorrer do programa, para facilitar o entendimento, a programação ou então para poupar tempo no caso de ter que alterar o seu valor, de modo que alterando uma única vez a declaração da constante, todos os comandos e expressões que a utilizam são automaticamente atualizados.

1.5. DEFINIÇÃO DE CONSTANTES EM ALGORITMOS

Nos algoritmos, todas as constantes utilizadas serão definidas no início do mesmo, por meio de um comando da seguinte forma:

CONST <nome_da_constante> = <valor>

Exemplo de definição de constantes:

CONST pi = 3.14159

nome_da_empresa = “Enxuga Gelo SA”

A atribuição de valores a variáveis é feita com o operador <-. Do seu lado esquerdo fica a variável à qual está sendo atribuído o valor, e à sua direita pode-se colocar qualquer expressão (constantes, variáveis, expressões numéricas), desde que seu resultado tenha tipo igual ao da variável.

39

Alguns exemplos de atribuições, usando as variáveis declaradas acima:

a <- 3

Valor1 <- 1.5

Valor2 <- Valor1 + a

vet[1] <- vet[1] + (a * 3)

matriz[3,9] <- a/4 – 5

nome_do_aluno <- "José da Silva"

sinalizador <- FALSO


Questão 01:

O que é constante? Dê dois exemplos.

Questão 02:

O que é variável? Dê dois exemplos.

Questão 03:

Escreva o tipo de dado ideal para se representar as seguintes informações:

a) O número da conta bancária

b) A altura de uma pessoa em metros

c) A placa de um veículo

d) O número de filhos de uma pessoa

e) A população de um país

f) A cor de um objeto

g) O resultado da verificação se um número é par ou não

Questão 04:

Identifique os tipos mais prováveis dos seguintes dados:

a) 'Processamento de Dados'

b) 0.4

40

c) '4.5E10'

d) TRUE

e) '?'

f) ' '

g) -5.3E-02

h) '.05'

i) 'FALSE'

j) 0

Questão 05:

Faça um teste de mesa no diagrama de bloco abaixo e preencha a tabela ao lado com os dados do teste.

Salário Abono Salnovo

600,00 60,00

350,00

41

CAPÍTULO 4

OPERADORES E EXPRESSÕES

1. OPERADORES

Operadores são elementos fundamentais que atuam sobre operandos e produzem um determinado resultado. Por exemplo, a expressão 3 + 2 relaciona dois operandos (os números 3 e 2) por meio do operador (+) que representa a operação de adição.

De acordo com o número de operandos sobre os quais os operadores atuam, os últimos podem ser classificados em:

binários, quando atuam sobre dois operandos. Esta operação é chamada diádica. Ex.: os operadores das operações aritméticas básicas (soma, subtração, multiplicação e divisão).

unários, quando atuam sobre um único operando. Esta operação é chamada monádica. Ex.: o sinal de (-) na frente de um número, cuja função é inverter seu sinal.

Outra classificação dos operadores é feita considerando-se o tipo de dado de seus operandos e do valor resultante de sua avaliação. Segundo esta classificação, os operandos dividem-se em aritméticos, lógicos e literais. Esta divisão está diretamente relacionada com o tipo de expressão onde aparecem os operadores.

Um caso especial é o dos operadores relacionais, que permitem comparar pares de operandos de tipos de dados iguais, resultando sempre num valor lógico.

1.1. OPERADORES DE ATRIBUIÇÃO

Um operador de atribuição serve para atribuir um valor a uma variável.

Em Algoritmo usamos o operador de atribuição: <-

A sintaxe de um comando de atribuição é:

nome_da_variável <- expressão

A expressão localizada no lado direito do sinal é avaliada e armazenado o valor resultante na variável à esquerda. O nome da variável aparece sempre sozinho, no lado esquerdo do sinal de igual deste comando.

42

1.2. OPERADORES ARITMÉTICOS

Os operadores aritméticos se relacionam às operações aritméticas básicas, conforme as tabelas abaixo:

Operadores unários, isto é, são aplicados a um único operando. São os operadores aritméticos de maior precedência. Exemplos: -3, +x. Enquanto o operador unário - inverte o sinal do seu operando, o operador + não altera em nada o seu valor.

+ mais (positivo)

– menos (negativo)

Operador de divisão inteira. Por exemplo, 5 \ 2 = 2. Tem a mesma precedência do operador de divisão tradicional.

\ divisão inteira

Operadores aritméticos tradicionais. Por convenção, * e / têm precedência sobre + e -. Para modificar a ordem de avaliação das operações, é necessário usar parênteses como em qualquer expressão aritmética.

+ adição

– subtração

* multiplicação

/ divisão

Operador de módulo (isto é, resto da divisão inteira). Por exemplo, 8 MOD 3 = 2. Tem a mesma precedência do operador de divisão tradicional.

MOD ou % módulo

Operador de potenciação. Por exemplo, 5 ^ 2 = 25. Tem a maior precedência entre os operadores aritméticos binários (aqueles que têm dois operandos).

^ potenciação

43

A prioridade entre operadores define a ordem em que os mesmos devem ser avaliados dentro de uma mesma expressão.

Operador Tipo Operação Prioridade

+ Binário Adição 4

- Binário Subtração 4

* Binário Multiplicação 3

/ Binário Divisão 3

MOD Binário Resto da Divisão 3

\ Binário Divisão Inteira 3

^ Binário Potenciação 2

+ Unário Manutenção do Sinal 1

- Unário Inversão do Sinal 1

1.3. OPERADORES RELACIONAIS

Os operadores relacionais são operadores binários que devolvem os valores lógicos verdadeiro e falso.

= igual a

< menor que

> maior que

<= menor ou igual a

>= maior ou igual a

<> diferente de

Importante: Em alguns interpretadores, como VisuAlg, as comparações entre strings não diferenciam as letras maiúsculas das minúsculas. Assim, "ABC" é igual a "abc". Valores lógicos obedecem à seguinte ordem: FALSO < VERDADEIRO.

Estes valores são somente usados quando se deseja efetuar comparações. Comparações só podem ser feitas entre objetos de mesma natureza, isto é variáveis do mesmo tipo de dado. O resultado de uma comparação é sempre um valor lógico.

44

Por exemplo, digamos que a variável inteira escolha contenha o valor 7. A primeira das expressões a seguir fornece um valor falso, e a segunda um valor verdadeiro:

escolha <= 5 escolha > 5

1.4. OPERADORES LÓGICOS

Os operadores lógicos ou booleanos são usados para combinar expressões relacionais. Também devolvem como resultado valores lógicos verdadeiro ou falso.

nao Operador unário de negação. nao VERDADEIRO = FALSO, e nao FALSO =

VERDADEIRO. Tem a maior precedência entre os operadores lógicos.

ou Operador que resulta VERDADEIRO quando um dos seus operandos lógicos for verdadeiro.

e Operador que resulta VERDADEIRO somente se seus dois operandos lógicos forem verdadeiros.

xou Operador que resulta VERDADEIRO se seus dois operandos lógicos forem diferentes, e FALSO se forem iguais.

Uma expressão relacional ou lógica retornará falso para o valor lógico falso e verdadeiro para o valor lógico verdade.

Fornecendo dois valores ou expressões lógicas, representadas por expressão1 e expressão2, podemos descrever as quatro operações lógicas a seguir:

expressão1 E expressão2 é verdadeiro somente se ambas, expressão1 e expressão2, forem verdadeiras. Se uma for falsa, ou se ambas forem falsas, a operação E também será falsa.

expressão1 OU expressão2 é verdadeiro se tanto a expressão1 como a expressão2 forem verdadeiras. As operações OU só resultam em valores falsos se ambas, expressão1 e expressão2, forem falsas.

NÃO expressão1 avalia verdadeiro se expressão1 for falsa; de modo contrário, a expressão NÃO resultará em falso, se expressão1 for verdadeira.

1.5. OPERADORES LITERAIS

Os operadores que atuam sobre caracteres variam muito de uma linguagem para outra. O operador mais comum e mais usado é o operador que faz a concatenação de strings: toma-se duas strings e acrescenta-se (concatena-se) a segunda ao final da primeira.

O operador que faz esta operação é: +

Por exemplo, a concatenação das strings “ALGO” e “RITMO” é representada por: “ALGO” + ”RITMO” e o resultado de sua avaliação é: “ALGORITMO”

45

Operador de concatenação de strings (isto é, cadeias de caracteres), quando usado com dois valores (variáveis ou constantes) do tipo "caractere". Por exemplo: "Rio " + " de Janeiro" = "Rio de Janeiro".

+ concatenação de strings

2. EXPRESSÕES

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

2.1. EXPRESSÕES ARITMÉTICAS

Expressões aritméticas são aquelas cujo resultado da avaliação é do tipo numérico, seja ele inteiro ou real. Somente o uso de operadores aritméticos, variáveis numéricas e parênteses é permitido em expressões deste tipo.

2.2. EXPRESSÕES LÓGICAS

Expressões lógicas são aquelas cujo resultado da avaliação é um valor lógico verdadeiro ou falso.

Nestas expressões são usados os operadores relacionais e os operadores lógicos, podendo ainda serem combinados com expressões aritméticas.

Quando forem combinadas duas ou mais expressões que utilizem operadores relacionais e lógicos, os mesmos devem utilizar os parênteses para indicar a ordem de precedência.

2.3. EXPRESSÕES LITERAIS

Expressões literais são aquelas cujo resultado da avaliação é um valor literal (caractere). Neste tipo de expressões só é usado o operador de literais (+).

46

2.4. AVALIAÇÃO DE EXPRESSÕES

Expressões que apresentam apenas um único operador podem ser avaliadas diretamente. No entanto, à medida que as mesmas vão tornando-se mais complexas com o aparecimento de mais de um operando na mesma expressão, é necessária a avaliação da mesma passo a passo, tomando um operador por vez. A seqüência destes passos é definida de acordo com o formato geral da expressão, considerando-se a prioridade (precedência) de avaliação de seus operadores e a existência ou não de parênteses na mesma.

As seguintes regras são essenciais para a correta avaliação de expressões:

1. Deve-se observar a prioridade dos operadores, conforme mostrado nas tabelas de operadores: operadores de maior prioridade devem ser avaliados primeiro. Se houver empate com relação à precedência, então a avaliação se faz da esquerda para a direita.

2. Os parênteses usado em expressões tem o poder de “roubar” prioridade dos demais operadores, forçando a avaliação da subexpressão em seu interior.

3. Entre os quatro grupos de operadores existentes, a saber, aritmético, lógico, literal e relacional, há uma certa prioridade de avaliação: os aritméticos e literais devem ser avaliados primeiro; a seguir, são avaliadas as subexpressões com operadores relacionais e, por último os operadores lógicos são avaliados.


Questão 01:

Dados as variáveis e operações:

v1 <- 32

v2 <- 5 + v1

v1 <- v2 * 2

Como fazer para segurar e mostrar o valor inicial da variável v1 no final das operações?

Questão 02:

Se X possui o valor 15 e foram executadas as seguintes instruções:

X <- X + 3

X <- X - 6

X <- X / 2

X <- 3 * X

Qual será o valor armazenado em X?

47

Questão 03:

Tendo as variáveis SALARIO, IR e SALLIQ, e considerando os valores abaixo. Informe se as expressões são verdadeiras ou falsas.

Questão 04:

Circule a primeira operação executada em cada um dos comandos abaixo e justifique sua escolha.

a) X + Y – Z

b) A + B / C ^ 2

c) (A + B) / C

d) A + B + C * D

e) X + Y + B ^ 2 + R * 3

f) A * B / C * D

Questão 05:

Sabendo que A=127, B=10, C=5, D=falso e E=verdadeiro, informe qual é o valor produzido por cada uma das sentenças abaixo.

a) (A+C) > B

b) B >= (A + 2)

c) C = (B –A)

d) (B + A) <= C

e) (C+A) > B

f) (A + B) >= (B * C)

g) nao D

h) D e E

i) (D e E) ou (A=B)

j) (D ou E) e (A<B)

k) (A>B) ou (B<C)

l) nao (A<B)

m) A+B<C e D ou E e nao D

n) A+B*C/B=3 e nao (D ou E)

48

Questão 06:

Resolva as expressões inteiras seguintes:

a) 16 * 6 – 3 * 2 =

b) (28 + 3 * 4) =

c) 2 ^ 2 * 3 =

d) – 2 ^ 3 =

e) 3 + 2 * (18 – 4 ^ 2) =

f) 8 – 30 / 6 =

Questão 07:

Escreva as seguintes expressões matemáticas como expressões de computador:

a) ( )

( )

b)

(

)

c) ( ) ( )

d) ( ) ( )

( )

e) √

f)

Questão 07:

Como fazer para passar o valor de uma variável para outra e vice-versa?

49

CAPÍTULO 5

INSTRUÇÕES PRIMITIVAS

Como o próprio nome diz, instruções primitivas são os comandos básicos que efetuam tarefas essenciais para a operação dos computadores, como entrada e saída de dados (comunicação com o usuário e com dispositivos periféricos), e movimentação dos mesmos na memória. Estes tipos de instrução estão presentes na absoluta maioria das linguagens de programação.

Antes de passar à descrição das instruções primitiva, é necessária a definição de alguns termos que serão utilizados:

dispositivo de entrada é o meio pelo qual as informações (mais especificamente os dados) são transferidos pelo usuário ou pelos níveis secundários de memória ao computador. Os exemplos mais comuns são o teclado, o mouse, leitora ótica, leitora de código de barras, as fitas e discos magnéticos.

dispositivo de saída é o meio pelo qual as informações (geralmente os resultados da execução de um programa) são transferidos pelo computador ao usuário ou aos níveis secundários de memória. Os exemplos mais comuns são o monitor de vídeo, impressora, fitas e discos magnéticos.

sintaxe é a forma como os comandos devem ser escritos, a fim de que possam ser entendidos pelo tradutor de programas. A violação das regras sintáticas é considerada um erro sujeito à pena do não reconhecimento por parte do tradutor

semântica é o significado, ou seja, o conjunto de ações que serão exercidas pelo computador durante a execução do referido comando.

Daqui em diante, todos os comandos novos serão apresentados por meio de sua sintaxe e sua semântica, isto é, a forma como devem ser escritos e as ações que executam.

1. COMANDOS DE ATRIBUIÇÃO

O comando de atribuição ou simplesmente atribuição, é a principal maneira de armazenar uma informação numa variável. Sua sintaxe é:

<nome_da_variável> <- <expressão>

Exemplos:

nome <- “Genoveva” preco <- 15.85

quant <- 5 total <- preco * quant

50

O modo de funcionamento (semântica) de uma atribuição consiste:

1. na avaliação da expressão

2. no armazenamento do valor resultante na variável que aparece à esquerda do comando.

A seguir temos um exemplo de um algoritmo utilizando o comando de atribuição:

algoritmo “exemplo_comando_de_atriuição”

var preco_unit, preco_tot : real

quant : inteiro

inicio

preco_unit <- 5.0

quant <- 10

preco_tot <- preco_unit * quant

fimalgoritmo

2. COMANDOS DE SAÍDA DE DADOS

Os comandos de saída de dados são o meio pelo qual informações contidas na memória dos computadores são colocadas nos dispositivos de saída, para que os usuários possam apreciá-las.

No diagrama de blocos o comando de saída de dados é representado por:

Há quatro sintaxes possíveis para esta instrução:

ESCREVA (<variável>)

Ex: escreva (X)

ESCREVA (<lista_de_variáveis>)

Ex: escreva (nome, endereco, cidade)

ESCREVA (<literal>)

Ex: escreva (“Algoritmo é o máximo!”)

ESCREVA (<literal>, <variável>, ... ,<literal>, <variável>)

Ex: escreva (“Meu nome é:”, nome, “e meu endereço é:”,

endereco)

51

Daqui por diante, escreva será considerada uma palavra reservada e não mais poderá ser utilizada como nome de variável, de modo que toda a vez que for encontrada em algoritmos, será identificada como um comando de saída de dados.

Uma lista_de_variáveis é um conjunto de nomes de variáveis separados por vírgulas. Um literal é simplesmente um dado do tipo literal (string ou cadeia de caracteres) delimitado por aspas.

A semântica da instrução primitiva de saída de dados é muito simples: os argumentos do comando são enviados para o dispositivo de saída. No caso de uma lista de variáveis, o conteúdo de cada uma delas é pesquisado na memória e enviado para o dispositivo de saída. No caso de argumentos do tipo literal ou string, estes são enviados diretamente ao referido dispositivo.

Há ainda a possibilidade de se misturar nomes de variáveis com literais na lista de um mesmo comando. O efeito obtido é bastante útil e interessante: a lista é lida da esquerda para a direita e cada elemento da mesma é tratado separadamente; se um nome de variável for encontrado, então a informação da mesma é colocada no dispositivo de saída; no caso de um literal, o mesmo é escrito diretamente no dispositivo de saída.

A seguir temos um exemplo de um algoritmo utilizando o comando de saída de dados:

algoritmo “exemplo_comando_de_saída_de_dados”


quant : inteiro

inicio

preco_unit <- 5.0

quant <- 10


escreva (preco_tot)

fimalgoritmo

3. COMANDOS DE ENTRADA DE DADOS

Os comandos de entrada de dados são o meio pelo qual as informações dos usuários são transferidas para a memória dos computadores, para que possam ser usadas nos programas.

No diagrama de blocos o comando de entrada de dados é representado por:

Há duas sintaxes possíveis para esta instrução:

52

LEIA (<variável>)

Ex: leia (X)

LEIA (<lista_de_variáveis>)

Ex: leia (nome, endereco, cidade)

Da mesma forma que escreva, daqui por diante leia será tratada como uma palavra reservada e não mais poderá ser usada como nome variável em algoritmos. A lista_de_variáveis é um conjunto de um ou mais nomes de variáveis separados por vírgulas.

A semântica da instrução de entrada (ou leitura) de dados é, de certa forma, inversa à da instrução de escrita: os dados são fornecidos ao computador por meio de um dispositivo de entrada e armazenados nas posições de memória das variáveis cujos nomes aparecem na lista_de_variáveis.

A seguir temos um exemplo de um algoritmo utilizando o comando de entrada de dados:

algoritmo “exemplo_comando_de_entrada_de_dados”


quant : inteiro

inicio

leia (preco_unit, quant)


escreva (preco_tot)

fimalgoritmo

4. INTERFACE COM O USUÁRIO

Uma preocupação constante de um bom programador deve ser a de conceber um programa “amigo do usuário”. Esta preocupação é traduzida no planejamento de uma interface com o usuário (meio pelo qual um programa e o usuário “conversam”) bastante amigável. Em termos práticos, isto se resume à aplicação de duas regras básicas:

toda vez que um programa estiver esperando que o usuário forneça a ele um determinado dado (operação de leitura), ele deve antes enviar uma mensagem dizendo ao usuário o que ele deve digitar, por meio de uma instrução de saída de dados;

antes de enviar qualquer resultado ao usuário, um programa deve escrever uma mensagem explicando o significado do mesmo.

Estas medidas tornam o diálogo entre o usuário e o programador muito mais fácil.

A seguir temos um exemplo do algoritmo anterior, utilizando as regras de construção de uma interface amigável:

53

algoritmo “exemplo_interface_amigavel”


quant : inteiro

inicio

escreva (“Digite o preço unitário:”)

leia (preco_unit)

escreva (“Digite a quantidade:”)

leia (quant)


escreva (“Preço total: ”, preco_tot)

fimalgoritmo

5. ENTRADA, PROCESSAMENTO E SAÍDA

Para se criar um programa que seja executável dentro de um computador, você deverá ter em mente três pontos de trabalho: a entrada de dados, o seu processamento e a saída dos mesmos. Sendo assim, todo programa estará trabalhando com estes três conceitos. Se os dados forem entrados de forma errada, serão consequentemente processados de forma errada e resultarão em respostas erradas. Desta forma, dizer a alguém que foi erro do computador é ser um tanto "medíocre". E isto é o que mais ouvimos quando nosso saldo está errado e vamos ao banco fazer uma reclamação, ou quando recebemos uma cobrança indevida. Se houve algum erro, é porque foi causado por falha humana. Realmente é impossível um computador errar por vontade própria, pois vontade é uma coisa que os computadores não têm.

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 outras. Uma saída poderá ser feita em vídeo, impressora, disco, entre outras formas.

6. FUNÇÕES PRÉ-DEFINIDAS

Toda linguagem de programação já vem com um grupo de funções que facilitam a vida do programador. Estas funções realizam os cálculos aritméticos, trigonométricos e de manipulação e conversão de dados mais comuns. Assim, o programador não tem que reinventar a roda a cada programa que faz. A este grupo de funções dá-se às vezes o nome de biblioteca.

Como usar uma função? Em termos simples, uma função pode ser usada em qualquer lugar onde uma variável também pode, a não ser, naturalmente, no "lado esquerdo da seta" em um comando de atribuição. Uma função produz (diz-se no linguajar dos programadores retorna) um valor, e não o recebe.

54

Existe uma lista que contém estas funções que são usadas como instruções primitivas. Esta lista é chamada de Lista de funções. A Lista de funções é, então, uma maneira rápida de inserir funções predefinidas em seu algoritmo. Tal lista pode variar dependendo do programa utilizado.

6.1. FUNÇÕES NUMÉRICAS, ALGÉBRICAS E TRIGONOMÉTRICAS

ABS (x) Retorna o valor absoluto de x

ARCCOS (x) Retorna o arco de co-seno de x

ARCSEN (x) Retorna o arco de seno de x

ARCTAN (x) Retorna o arco de tangente de x

COS (x) Retorna o valor do co-seno de x

EXP (x,y) Retorna o valor de x elevado a y

GRAUPRAD (x) Retorna o valor em radianos correspondente ao valor em graus de x

INT (x) Retorna a parte inteira de x

LOG (x) Retorna o logaritmo de x

LOGN (x) Retorna o logaritmo neperiano (base e) de x

PI Retorna o valor de PI (pi = 3.141592)

QUAD (x) Retorna o valor de x elevado ao quadrado

RADPGRAU (x) Retorna o valor em graus correspondente ao valor em radianos de x

RAIZQ (x) Retorna a raiz quadrada de x

RAND Retorna um número real gerado aleatoriamente, maior ou igual a zero e menor que um

RANDL (limite) Retorna um número inteiro gerado aleatoriamente, maior ou igual a zero e menor que limite

SEN (x) Retorna o valor do seno de x

TAN (x) Retorna o valor da tangente de x

Os valores que estão entre parênteses, representados pelas letras como x e y, são os parâmetros, ou como dizem alguns autores, os argumentos que passamos para a função para que realize seus cálculos e retorne um outro, que usaremos no programa. Algumas funções, como PI e RAND, não precisam de parâmetros, mas a maioria tem um ou mais. O valor dos parâmetros naturalmente altera o valor retornado pela função.

A seguir temos alguns exemplos que ilustram o uso destas funções.

55

algoritmo "exemplo_funcoes"

var a, b, c : real

inicio

a <- 2b <- 9escreval( b - a )

// será escrito 7 na tela

escreval( abs( a - b ) )

// também será escrito 7 na tela

c <- raizq( b )

// c recebe 3, a raiz quadrada de b, que é 9

// A fórmula da área do círculo é pi (3.1416) vezes raio ao quadrado...

escreval("A área do circulo com raio " , c , " é " , pi * quad(c) )

// Um pouco de trigonometria...escreval("Um ângulo de 90 graus tem " ,

grauprad(90) , " radianos" )

escreval( exp(a,b) )

// escreve 2 elevado à 9ª, que é 512

escreval( int( b / ( a + c ) ) )

// escreve 1, que é a parte inteira de 1.8, resultado de 9/(3+2)

fimalgoritmo

6.2. FUNÇÕES PARA MANIPULAÇÃO DE CADEIAS DE CARACTERES (STRINGS)

ASC (s : caracter) Retorna um inteiro com o código ASCII do primeiro caracter da expressão.

CARAC (c : inteiro) Retorna o caracter cujo código ASCII corresponde à expressão.

CARACPNUM (c : caracter) Retorna o inteiro ou real representado pela expressão. Corresponde a StrToInt() ou StrToFloat() do Delphi, Val() do Basic ou Clipper, etc.

COMPR (c : caracter) Retorna um inteiro contendo o comprimento (quantidade de caracteres) da expressão.

COPIA (c : caracter ; p, n : inteiro) Retorna um valor do tipo caracter contendo uma cópia parcial da expressão, a partir do caracter p, contendo n caracteres. Os caracteres são numerados da esquerda para a direita,

56

começando de 1. Corresponde a Copy() do Delphi, Mid$() do Basic ou Substr() do Clipper.

MAIUSC (c : caracter) Retorna um valor caracter contendo a expressão em maiúsculas.

MINUSC (c : caracter) Retorna um valor caracter contendo a expressão em minúsculas.

NUMPCARAC (n : inteiro ou real) Retorna um valor caracter contendo a representação de n como uma cadeia de caracteres. Corresponde a IntToStr() ou FloatToStr() do Delphi, Str() do Basic ou Clipper.

POS (subc, c : caracter) Retorna um inteiro que indica a posição em que a cadeia subc se encontra em c, ou zero se subc não estiver contida em c. Corresponde funcionalmente a Pos() do Delphi, Instr() do Basic ou At() do Clipper, embora a ordem dos parâmetros possa ser diferente em algumas destas linguagens.

A seguir temos alguns exemplos que ilustram o uso destas funções.

algoritmo "exemplo_funcoes2"

vara, b, c : caractere

inicio

a <- "2"b <- "9"

escreval( b + a )

// será escrito "92" na tela

escreval( caracpnum(b) + caracpnum(a) )


escreval( numpcarac(3+3) + a )

// será escrito "62" na tela

c <- "Brasil"

escreval(maiusc(c))

// será escrito "BRASIL" na tela

escreval(compr(c))


b <- "O melhor do Brasil"

escreval(pos(c,b))


escreval(asc(c))

// será escrito 66 na tela - código ASCII de "B"

57

a <- carac(65) + carac(66) + carac(67)escreval(a)

// será escrito "ABC" na tela

fimalgoritmo

Nem todas as funções que necessitamos estão prontas e às vezes é necessário utilizar uma fórmula equivalente.


Questão 01:

Exemplifique o uso dos comandos de Atribuição, Entrada e Saída.

Questão 02:

Como podemos orientar o usuário na digitação dos dados? Exemplifique.

Questão 03:

Escreva os comandos necessários para ler:

a) as 3 notas de um aluno

b) o nome, o peso e altura de uma pessoa

Questão 04:

Escreva os comandos necessários para exibir:

a) o conteúdo da variável X

b) o resultado da expressão 2+3

Questão 05:

A ordem das atribuições é importante?

A <- B e C <- A tem o mesmo efeito de C <- A e A <- B ?

58

Questão 06:

Em quais dos seguintes pares é importante a ordem dos comandos?

a) X <- Y b) X <- Y c) X <- Z d) Z <- Y

Y <- X Z <- X X <- Y X <- Y

Questão 07:

Considerando as variáveis inteiras A, B e C, com os valores 3, 16 e 30 respectivamente; as variáveis NOME e PROFISSAO, com os valores “MIRIAM” e “ADVOGADO”, respectivamente; e a variável lógica TESTE, contendo o valor falso, avalie as expressões a seguir:

a) (C div A) – (B mod A)

b) (C mod A) + (C div B)

c) raizq(B) + (B mod C)

d) exp(A,2)

e) (A+B) – pi

f) A+1 >= raizq(B) ou NOME <> “ANA”

g) A+1 >= raizq(B) e PROFISSAO = “MÉDICO”

h) NOME <> “ANA” ou PROFISSAO = “MÉDICO” e A+1 >= raizq(B)

i) PROFISSAO = “MÉDICO” ou TESTE

j) nao TESTE e (A+1 >= raizq(B) ou nao PROFISSAO = “MÉDICO”

k) nao (A+1 >= raizq(B) e TESTE)

Questão 08:

Dado o algoritmo abaixo, responda as perguntas seguintes.


var A, B, C : inteiro

inicio

leia (A,B)

C <- A – B

escreva (“O valor da diferença é: “, C)

fimalgoritmo

a) O que faz o algoritmo acima?

b) Que tipos de variáveis foram usadas?

c) Qual será o valor de C, se as variáveis A e B tiverem os valores 10 e 5, respectivamente?

d) Qual será o valor de C, se as variáveis A e B tiverem os valores 2 e -8, respectivamente?

e) Qual será o valor de C, se as variáveis A e B tiverem os valores 3.5 e 2.1, respectivamente?

59

Questão 09:

Faça o teste de mesa do seguinte algoritmo. Supondo que os números digitados sejam 10 e 50.5, o que será apresentado na tela?


var a, b, c : inteiro

x, y :real

inicio

leia (a)

b <- a * a

leia (x)

y <- x + b

b <- y * 2

escreva (“a= “, a, “b= “, b, “c= “, c)

escreva (“x= “, x, “y= “, y)

fimalgoritmo

Questão 10:

Escreva um programa que leia um número inteiro positivo e exiba o dobro do mesmo.

Questão 11:

Uma P.A. (progressão aritmética) fica determinada pela sua razão (r) e pelo primeiro termo (a1). Escreva um algoritmo que seja capaz de determinar qualquer termo de uma P.A., dado a razão e o primeiro termo.

Questão 12:

Uma P.G. (progressão geométrica) fica determinada pela sua razão (q) e pelo primeiro termo (a1). Escreva um algoritmo que seja capaz de determinar qualquer termo de uma P.G., dado a razão e o primeiro termo.

Questão 13:

Dada a razão de uma P.A. (progressão aritmética) e um termo qualquer, k (ak). Escreva um algoritmo para calcular qualquer outro termo, n, (an).

60

Questão 14:

Dada a razão de uma P.G. (progressão geométrica) e um termo qualquer, k (ak). Escreva um algoritmo para calcular qualquer outro termo, n, (an).

Questão 15:

Em épocas de pouco dinheiro, os comerciantes estão procurando aumentar suas vendas oferecendo desconto. Faça um algoritmo que possa entrar com o valor de um produto e imprima o novo valor tendo em vista que o desconto foi de 9%. Além disso, imprima o valor do desconto.

Questão 16:

Escreva um algoritmo que leia um número inteiro e imprima o seu sucessor e seu antecessor.

Questão 17:

Escreva um algoritmo que leia dois números inteiros e imprima o resultado da soma destes dois valores. Antes do resultado, deve ser impressa a seguinte mensagem “SOMA”.

Questão 18:

Escreva um algoritmo que leia um número real e imprima a terça parte deste número.

Questão 19:

Escreva um algoritmo que leia dois números reais e imprima a média aritmética entre esses dois valores com a seguinte mensagem “MEDIA” antes do resultado.

Questão 20:

Seja uma seqüência A,B,C, ... determinando um Progressão Aritmética (P.A.), o termo médio (B) de uma P.A. é determinado pela média aritmética de seus termos, sucessor (C) e antecessor (A). Com base neste enunciado construa um algoritmo que calcule o termo médio (B) através de A, C.

61

Questão 21:

Criar um algoritmo para calcular e apresentar o valor do volume de uma lata de óleo, utilizando a fórmula:

onde V é o volume, R é o raio e h é a altura.

Questão 22:

Criar um algoritmo que leia o numerador e o denominador de uma fração e transforme esses valores em um número racional.

Questão 23:

Criar um algoritmo que leia o valor de um depósito e o valor da taxa de juros. Calcular e imprimir o valor do rendimento e o valor total depois do rendimento.

Questão 24:

Para vários tributos, a base de cálculo é o salário mínimo. Fazer um algoritmo que leia o valor do salário mínimo e o valor do salário de uma pessoa. Calcular e imprimir quantos salários mínimos essa pessoa ganha.

Questão 25:

Criar um algoritmo que leia dois valores para as variáveis A e B, que efetue a troca dos valores de forma que a variável A passe a ter o valor da variável B e que a variável B passe a ter o valor da variável A. Apresente os valores trocados.

63

CAPÍTULO 6

ESTRUTURAS DE CONTROLE DO FLUXO DE EXECUÇÃO

Até o momento os algoritmos estudados utilizam apenas instruções primitivas de atribuição, e de entrada e saída de dados. Qualquer conjunto de dados fornecido a um algoritmo destes será submetido ao mesmo conjunto de instruções, executadas sempre na mesma sequência.

No entanto, na prática muitas vezes é necessário executar ações diversas em função dos dados fornecidos ao algoritmo. Em outras palavras, dependendo do conjunto de dados de entrada do algoritmo, deve-se executar um conjunto diferente de instruções. Além disso, pode ser necessário executar um mesmo conjunto de instruções um número repetido de vezes. Em resumo é necessário controlar o fluxo de execução das instruções (a sequência em que as instruções são executadas num algoritmo) em função dos dados fornecidos como entrada do mesmo.

De acordo com o modo como o controle do fluxo de instruções de um algoritmo é feito, as estruturas básicas de controle são classificadas em:

Estruturas sequenciais

Estruturas de decisão

Estruturas de repetição

1. COMANDOS COMPOSTOS

Um comando composto é um conjunto de zero ou mais comandos (ou instruções) simples, como atribuições e instruções primitivas de entrada ou saída de dados, ou alguma das construções apresentadas neste capítulo.

Este conceito é bastante simples e será útil e conveniente nos itens seguintes, na definição das estruturas básicas de controle de execução.

2. ESTRUTURA SEQUENCIAL

Na estrutura sequencial os comandos de um algoritmo são executados numa sequência pré-estabelecida. Cada comando é executado somente após o término do comando anterior.

Uma estrutura sequencial é delimitada pelas palavras-reservadas Início e Fim e contém basicamente comandos de atribuição, comandos de entrada e comandos de saída. Os algoritmos do capítulo anterior são algoritmos que utilizam uma única estrutura sequencial.

64

Um algoritmo puramente sequencial é aquele cuja execução é efetuada em ordem ascendente dos números que identificam cada passo. A passagem de um passo ao seguinte é natural e automática, e cada passo é executado uma única vez.

3. ESTRUTURAS DE DECISÃO

Neste tipo de estrutura o fluxo de instruções a ser seguido é escolhido em função do resultado da avaliação de uma ou mais condições. Uma condição é uma expressão lógica.

A classificação das estruturas de decisão é feita de acordo com o número de condições que devem ser testadas para que se decida qual o caminho a ser seguido. Segundo esta classificação, têm-se três tipos de estruturas de decisão:

Estrutura de Decisão Simples (Se ... então)

Estrutura de Decisão Composta (Se ... então ... senão)

Estrutura de Decisão Múltipla do Tipo Escolha (Escolha ... Caso ... Outrocaso)

Os algoritmos puramente sequenciais podem ser usados na solução de um grande número de problemas, porém existem problemas que exigem o uso de alternativas de acordo com as entradas do mesmo.

Nestes algoritmos, as situações são resolvidas através de passos cuja execução é subordinada a uma condição. Assim, o algoritmo conterá passos que são executados somente se determinadas condições forem observadas.

Um algoritmo em que se tem a execução de determinados passos subordinada a uma condição é denominado algoritmo com seleção.

3.1. ESTRUTURAS DE DECISÃO SIMPLES ( SE ... ENTÃO )

Nesta estrutura uma única condição (expressão lógica) é avaliada. Dependendo do resultado desta avaliação, um comando ou conjunto de comandos serão executados (se a avaliação for verdadeira) ou não serão executados (se a avaliação for falsa).

No diagrama de blocos a estrutura para instrução se...entao é representado por:

65

A sintaxe possível para a estrutura de decisão simples é:

se <condição> entao

<sequência_de_comandos>

fimse

A semântica desta construção é a seguinte: a condição é avaliada:

Se o resultado for verdadeiro, então a sequência_de_comandos será executada. Ao término de sua execução, o fluxo do algoritmo prossegue pela instrução seguinte à palavra reservada fimse.

No caso da condição ser falsa, o fluxo do algoritmo prossegue pela instrução seguinte à

palavra reservada fimse, sem executar a sequência_de_comandos.

Exemplo de algoritmo que lê um número e escreve se o mesmo é maior que 10:

algoritmo “exemplo_estrutura_de_decisão_simples”

var X : inteiro

inicio

escreva (“Digite um valor”)

leia(X)

se X > 10 entao

escreva (“X é maior que 10”)

fimse

fimalgoritmo

66

3.2. ESTRUTURAS DE DECISÃO COMPOSTA ( SE ... ENTÃO ... SENÃO )

Nesta estrutura uma única condição (expressão lógica) é avaliada. Se o resultado desta avaliação for verdadeiro, um comando ou conjunto de comandos serão executados. Caso contrário, ou seja, quando o resultado da avaliação for falso, um outro comando ou um outro conjunto de comandos serão executados.

No diagrama de blocos a estrutura para instrução se...entao...senao é representado por:

A sintaxe possível para a estrutura de decisão composta é:

se <expressão-lógica> entao

<seqüência-de-comandos-1>

senao


fimse

A semântica desta construção é a seguinte: a condição é avaliada:

Se o resultado for verdadeiro, então a sequência_de_comandos-1 será executada. Ao término de sua execução, o fluxo do algoritmo prossegue pela instrução seguinte à palavra reservada fimse.

Nos casos em que a condição é avaliada como falsa, a seuêncvia_de_comandos-2 será executada. Ao término de sua execução, o fluxo do algoritmo prossegue pela instrução seguinte à palavra reservada fimse.

Exemplo de algoritmo que lê um número e escreve se o mesmo é ou não maior que 10:

algoritmo “exemplo_estrutura_de_decisão_composta”

var X : inteiro

inicio

leia(X)

se X > 10 entao

escreva(“X é maior que 10”)

67

senao

escreva(“X não é maior que 10”)

fimse

fimalgoritmo

3.3. ESTRUTURAS DE DECISÃO MÚLTIPLA DO TIPO CASO ( ESCOLHA... CASO ... OUTROCASO )

Este tipo de estrutura é uma generalização da construção Se, onde somente uma condição era avaliada e dois caminhos podiam ser seguidos. Na estrutura de decisão do tipo Caso pode haver uma ou mais condições a serem testadas e um comando diferente associado a cada uma destas.

No diagrama de blocos a estrutura para instrução escolha...caso...outrocaso é representado por:

A sintaxe da construção de Caso é:

escolha <expressão-de-seleção>

caso <exp11>, <exp12>, ..., <exp1n>


caso <exp21>, <exp22>, ..., <exp2n>


...

outrocaso

<seqüência-de-comandos-extra>

fimescolha

Seu funcionamento é o seguinte: ao entrar-se numa construção do tipo CASO, uma variável é escolhida e depois testada com a condição expressa em caso <exp>. Se for verdadeira, a sequência-de-comandos-1 é executada e após seu término, o fluxo de execução prossegue pela primeira instrução seguinte à palavra reservada fimescolha. Se esta condição for falsa, o fluxo

68

do programa passa para o próximo caso <exp> e testa a condição seguindo o mesmo

comportamento descrito acima até encontrar a palavra reservada fimescolha.

Um exemplo de aplicação desta construção é o algoritmo para reajustar o salário de acordo com a função. Se for técnico, aumentar o salário 50%, se for gerente, aumentar 30% e se for outro cargo, aumentar 20%.

algoritmo "exemplo_estrutura_do_tipo_escolha"

var

salario, salario_reaj : real

prof : caractere

inicio

escreva("Digite o salário: ")

leia (salario)

escreva("Digite a profissão: ")

leia(prof)

escolha prof

caso "Técnico"

salario_reaj <- 1.5 * salario

caso "Gerente"


outrocaso


fimescolha

escreva("Salário reajustado: ", salario_reaj)

fimalgoritmo


Questão 01:

Qual o valor de L após a execução deste trecho de algoritmo?


var A, B, C : logico

X, Y : real

L : inteiro

inicio

A <- falso

B <- verdadeiro

C <- falso

X <- 1.5

Y <- 3.2

X <- X + 1

se C ou ( ( X + Y > 5 ) ou ( nao A e B ) ) entao

L <- 0

senao

L <- 1

fimse

fimalgoritmo

69

Questão 02:

Os comandos abaixo são equivalentes? Explique por quê. Qual é o tipo da variável A?

(I)

A <- B = C

(II)

se B =C entao

A <- verdadeiro

senao

A <- falso

fimse

Questão 03:

Dado o algoritmo abaixo, onde C1, C2, C3, C4 e C5 representam comandos quaisquer, responda as perguntas seguintes.


var B1, B2, B3 : logico

inicio

se B1 entao

C1

senao

se B2 entao

se B3 entao

C2

senao

C3

C4

fimse

fimse

fimse

C5

fimalgoritmo

a) Se B1 = verdadeiro, B2 = verdadeiro, B3 = falso, quais os comandos que serão executados?

b) Se B1 = falso, B2 = verdadeiro, B3 = falso, quais os comandos que serão executados?

c) Se B1 = falso, B2 = verdadeiro, B3 = verdadeiro, quais os comandos que serão executados?

d) Quais os valores de B1, B2 e B3 para que somente o comando C5 seja executado?

70

Questão 04:

Analise o algoritmo abaixo:


var QUALE : caractere

NUM : inteiro

inicio

leia (NUM)

se NUM = 0 entao

QUALE <- “ZERO”

senao

se NUM > 0 entao

QUALE <- “NÚMERO POSITIVO”

senao

QUALE <- “NÚMERO NEGATIVO”

fimse

fimse

escreva (QUALE)

fimalgoritmo

O que será impresso depois de executado o algoritmo se:

a) NUM = 10

b) NUM = 0

c) NUM = -4

Questão 05:

Considerando o algoritmo abaixo, responda as perguntas seguintes.


var SX : caractere

inicio

leia (SX)

se SX = “F” entao

escreva (“Tipo A”)

senao

se SX <> “M” entao

escreva (“Tipo X”)

senao

escreva (“Tipo B”)

fimse

fimse

fimalgoritmo

a) Qual será a mensagem apresentada se SX =”M”?

b) Qual será a mensagem apresentada se SX = “Fem”?

71

Questão 06:

Considerando o algoritmo abaixo, responda as perguntas seguintes.


var D, E, F : inteiro

inicio

leia (D, E, F)

se D = 0 entao

se E > 0 entao

F <- D + E

senao

F <- 0

fimse

senao

se D > 0 entao

se E > 0 entao

F <- 100

senao

F <- D * E

fimse

senao

F <- D – E

fimse

fimse

fimalgoritmo

a) Se D=10 e E=5, qual será o valor de F ao final do algoritmo?

b) Se D=0 e E=0, qual será o valor de F ao final do algoritmo?

Questão 07:

Dado o algoritmo abaixo e executando-o quatro vezes com os valores 5, 3, 25 e 11, escreva o que será apresentado na tela.


var X : inteiro

inicio

leia (X)

escolha (X)

caso 2, 11

escreva (“Laranja”)

caso 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30

escreva (“Maçã”)

caso 5

escreva (“Pêra”)

escreva (“Morango”)

outrocaso

escreva (“Pêssego”)

fimescolha

escreva (“Uva”)

fimalgoritmo

72

Questão 08:

Escreva um algoritmo que leia um número e o imprima caso ele seja maior que 20.

Questão 09:

Construa um algoritmo que leia dois valores numéricos inteiros e efetue a adição; caso o resultado seja maior que 10, apresenta-lo.

Questão 10:

Construa um algoritmo que determine (imprima) se um dado número N inteiro (recebido através do teclado) é PAR ou ÍMPAR.

Questão 11:

Escreva um algoritmo para determinar se um dado número N (recebido através do teclado) é POSITIVO, NEGATIVO ou NULO.

Questão 12:

Construir um algoritmo que leia dois números e efetue a adição. Caso o valor somado seja maior que 20, este deverá ser apresentado somando-se a ele mais 8; caso o valor somado seja menor ou igual a 20, este deverá ser apresentado subtraindo-se 5.

Questão 13:

Escreva um algoritmo que leia um número e imprima a raiz quadrada do número caso ele seja positivo ou igual a zero e o quadrado do número caso ele seja negativo.

Questão 14:

Escreva um algoritmo que receba um número e imprima uma das mensagens: “é múltiplo de 3” ou “não é múltiplo de 3”.

Questão 15:

Escreva um algoritmo para determinar se um número A é divisível por um outro número B. Esses valores devem ser fornecidos pelo usuário.

Questão 16:

Construa um algoritmo que imprima qual o menor e qual o maior valor de dois números A e B, lidos através do teclado.

73

Questão 17:

Construa um algoritmo que dado quatro valores, A, B, C e D, o algoritmo imprima o maior e o menor valor.

Questão 18:

Escreva um algoritmo que leia as duas notas bimestrais (de 0 a 10) de um aluno e determine a média das notas semestral. Através da média calculada o algoritmo deve imprimir a seguinte mensagem: “Aprovado”, “Reprovado” ou em “Exame” (a média é 7 para Aprovação, menor que 3 para Reprovação e as demais em Exame).

Questão 19:

Criar um algoritmo que leia o um número inteiro entre 1 e 7 e escreva o dia da semana correspondente. Caso o usuário digite um número fora desse intervalo, deverá aparecer uma mensagem informando que não existe dia da semana com esse número.

Questão 20:

Escreva um algoritmo que entre com o valor de x, calcule e imprima o valor de f(x).

( )

4. ESTRUTURAS DE REPETIÇÃO

São muito comuns as situações em que se deseja repetir um determinado trecho de um programa um certo número de vezes. Por exemplo, pode-se citar o caso de um algoritmo que calcula a soma dos números impares entre 500 e 1000 ou então um algoritmo que escreve os números maiores que 0 enquanto a sua soma não ultrapasse 1000.

As estruturas de repetição são muitas vezes chamadas de Laços ou também de Loops.

A classificação das estruturas de repetição é feito de acordo com o conhecimento prévio do número de vezes que o conjunto de comandos será executado. Assim os Laços se dividem em:

Laços Contados quando se conhece previamente quantas vezes o comando composto no interior da construção será executado;

Laços Condicionais quando não se conhece de antemão o número de vezes que o conjunto de comandos no interior do laço será repetido, pelo fato do mesmo estar amarrado a uma condição sujeita à modificação pelas instruções do interior do laço.

74

Todo algoritmo que possui um ou mais de seus passos repetidos um determinado número de vezes denomina-se algoritmo com repetição.

Com a utilização de estruturas de repetição para a elaboração de algoritmos, torna-se necessário o uso de dois tipos de variáveis para a resolução de diversos tipos de problemas: variáveis contadoras e variáveis acumuladoras.

Uma variável contadora é uma variável que recebe um valor inicial, geralmente 0 (zero) antes do início de uma estrutura de repetição, e é incrementada no interior da estrutura de um valor constante, geralmente 1, conforme o exemplo abaixo:

...

cont <- 0

<estrutura_de_repetição>

...

cont <- cont + 1

...

<fim_da_estrutura_de_repetição>

...

Uma variável acumuladora é uma variável que recebe um valor inicial, geralmente 0 (zero) antes do início de uma estrutura de repetição, e é incrementada no interior da estrutura de um valor variável, geralmente a variável usada na estrutura de controle, conforme o exemplo abaixo:

...

soma <- 0

<estrutura_de_repetição_com_variável_x>

...

soma <- soma + x

...

<fim_da_estrutura_de_repetição>

...

4.1. LAÇOS CONTADOS

4.1.1. Laços Contados (Para ... faça )

Os laços contados são úteis quando se conhece previamente o número exato de vezes que se deseja executar um determinado conjunto de comandos. Então, este tipo de laço nada mais é que uma estrutura dotada de mecanismos para contar o número de vezes que o corpo do laço (ou seja, o comando composto em seu interior) é executado.

No diagrama de blocos a estrutura para instrução para...faça é representado por:

75

Uma das sintaxes possíveis usadas em algoritmos para os laços contados é:

para <variável> de <valor-inicial> ate <valor-limite> [passo <incremento>] faca

<seqüência-de-comandos>

fimpara

<variável > É a variável contadora que controla o número de repetições do laço. Deve ser necessariamente uma variável do tipo inteiro, como todas as expressões deste comando.

<valor-inicial> É uma expressão que especifica o valor de inicialização da variável contadora antes da primeira repetição do laço.

<valor-limite > É uma expressão que especifica o valor máximo que a variável contadora pode alcançar.

<incremento > É opcional. Quando presente, precedida pela palavra passo, é uma expressão que especifica o incremento que será acrescentado à variável contadora em cada repetição do laço. Quando esta opção não é utilizada, o valor padrão de <incremento> é 1. Vale a pena ter em conta que também é possível especificar valores negativos para <incremento>. Por outro lado, se a avaliação da expressão <incremento > resultar em valor nulo, a execução do algoritmo será interrompida, com a impressão de uma mensagem de erro.

fimpara Indica o fim da seqüência de comandos a serem repetidos. Cada vez que o programa chega neste ponto, é acrescentado à variável contadora o valor de <incremento >, e comparado a <valor-limite >. Se for menor ou igual (ou maior ou igual, quando <incremento > for negativo), a seqüência de comandos será executada mais uma vez; caso contrário, a execução prosseguirá a partir do primeiro comando que esteja após o fimpara.

Exemplo de um algoritmo que escreve a tabuada de um número específico:

algoritmo "tabuada"

var

i, tab, num : inteiro

inicio

escreval("TABUADA DE MULTIPLICAÇÃO")

escreva("Tabuada: ")

leia(tab)

escreva("Até que número: ")

leia(num)

para i de 1 ate num faca

escreval (i, " x ", tab, " = ", i * tab)

fimpara

fimalgoritmo

76

No exemplo a seguir, os números de 1 a 10 são exibidos em ordem crescente.

algoritmo "Números de 1 a 10"

var j: inteiro

inicio

para j de 1 ate 10 faca

escreva (j:3)

fimpara

fimalgoritmo

Importante: Se, logo no início da primeira repetição, <valor-inicial> for maior que <valor-limite> (ou menor, quando <incremento> for negativo), o laço não será executado nenhuma vez. O exemplo a seguir não imprime nada.

algoritmo "Numeros de 10 a 1 (não funciona)"

var j: inteiro

inicio


escreva (j:3)

fimpara

fimalgoritmo

Este outro exemplo, no entanto, funcionará por causa do passo -1:

algoritmo "Numeros de 10 a 1 (este funciona)"

var j: inteiro

inicio

para j de 10 ate 1 passo -1 faca

escreva (j:3)

fimpara

fimalgoritmo

4.2. LAÇOS CONDICIONAIS

Laços condicionais são aqueles cujo conjunto de comandos em seu interior é executado até que uma determinada condição seja satisfeita. Ao contrário do que acontece nos laços contados, nos laços condicionais não se sabe de antemão quantas vezes o corpo do laço será executado.

As construções que implementam laços condicionais mais comuns nas linguagens de programação modernas são:

77

Enquanto laço condicional com teste no início

Repita laço condicional com teste no final

Nos laços condicionais a variável que é testada, tanto no início quanto no final do laço, deve sempre estar associada a um comando que a atualize no interior do laço. Caso isso não ocorra, o programa ficará repetindo indefinidamente este laço, gerando uma situação conhecida como “laço infinito”.

4.2.1. Laços Condicionais com Teste no Início (Enquanto ... faça )

Caracteriza-se por uma estrutura que efetua um teste lógico no início de um laço, verificando se é permitido ou não executar o conjunto de comandos no interior do laço.

No diagrama de blocos a estrutura Enquanto ... faça é representada por:

Uma das sintaxes possíveis usadas para essa construção é:

enquanto <expressão-lógica> faca


fimenquanto

<expressão-lógica> Esta expressão é avaliada antes de cada repetição do laço. Quando seu resultado for VERDADEIRO, <seqüência-de-comandos> é executada.

fimenquanto Indica o fim da <seqüência-de-comandos> que será repetida. Cada vez que a execução atinge este ponto, volta-se ao início do laço para que <expressão-lógica> seja avaliada novamente. Se o resultado desta avaliação for VERDADEIRO, a <seqüência-de-comandos> será executada mais uma vez; caso contrário, a execução prosseguirá a partir do primeiro comando após fimenquanto.

Uma vez dentro do corpo do laço, a execução somente abandonará o mesmo quando a condição for falsa. O usuário deste tipo de construção deve estar atento à necessidade de que em algum momento a condição deverá ser avaliada como falsa. Caso contrário, o programa permanecerá indefinidamente no interior do laço (laço infinito).

Neste tipo de laço condicional a variável a ser testada deve possuir um valor associado antes da construção do laço.

78

Um exemplo desta construção é o algoritmo abaixo que escreve os números maiores que 0 enquanto a sua soma não ultrapasse 1000.

algoritmo "exemplo_enquanto"

var

soma, num : inteiro

inicio

num <- 1

soma<- num

Enquanto soma < 1000 faca

escreval (num)

num <- num + 1

soma <- soma + num

fimenquanto

fimalgoritmo

4.2.2. Laços Condicionais com Teste no Final (Repita ... até )

Caracteriza-se por uma estrutura que efetua um teste lógico no final de um laço, verificando se é permitido ou não executar novamente o conjunto de comandos no interior do mesmo.

No diagrama de blocos a estrutura Repita ... até é representada por:

Uma das sintaxes possíveis usadas para essa construção é:

repita


ate <expressão-lógica>

repita Indica o início do laço.

ate <expressão-lógica> Indica o fim da <seqüência-de-comandos> a serem repetidos. Cada vez que o programa chega neste ponto, <expressão-lógica> é avaliada: se seu resultado for FALSO, os comandos presentes entre esta linha e a linha repita são executados; caso contrário, a execução prosseguirá a partir do primeiro comando após esta linha.

79

Seu funcionamento é bastante parecido ao da construção Enquanto. O comando é executado uma vez. A seguir, a condição é testada: se ela for falsa, o comando composto é executado novamente e este processo é repetido até que a condição seja verdadeira, quando então a execução prossegue pelo comando imediatamente seguinte ao final da construção.

Esta construção difere da construção Enquanto pelo fato de o comando composto ser executado uma ou mais vezes (pelo menos uma vez), ao passo que na construção Enquanto o comando composto é executado zero ou mais vezes (possivelmente nenhuma). Isto acontece porque na construção Repita o teste é feito no final da construção, ao contrário do que acontece na construção Enquanto, onde o teste da condição é efetuado no início da mesma.

A construção Repita também difere da construção Enquanto no que se refere à inicialização da variável, visto que na construção Repita a variável pode ser inicializada ou lida dentro do laço.

O algoritmo que lê um número não determinado de vezes um valor do teclado e escreve o valor e o seu quadrado, até que seja digitado um valor par, é um exemplo desta estrutura:

algoritmo "exemplo_repita"

var

num : inteiro

inicio

repita

escreva("Entre com número inteiro: ")

leia (num)

escreval ("O quadrado de", num, " é:", num * num)

escreval

ate num mod 2 = 0

fimrepita

fimalgoritmo

5. ESTRUTURAS DE CONTROLE ENCADEADAS OU ANINHADAS

Um aninhamento ou encadeamento é o fato de se ter qualquer um dos tipos de construção apresentados anteriormente dentro do conjunto de comandos (comando composto) de uma outra construção.

Em qualquer tipo de aninhamento é necessário que a construção interna esteja completamente embutida na construção externa.

A figura abaixo ilustra aninhamentos válidos e inválidos.

80

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

Nos algoritmos, a correta formulação de condições, isto é, expressões lógicas, é de fundamental importância, visto que as estruturas de seleção são baseadas nelas. As diversas formulações das condições podem levar a algoritmos distintos. Considerando o problema:

“Dado um par de valores x, y, que representam as coordenadas de um ponto no plano, determinar o quadrante ao qual pertence o ponto, ou se está sobre um dos eixos cartesianos.”

A solução do problema consiste em determinar todas as combinações de x e y para as classes de valores positivos, negativos e nulos.

Os algoritmos podem ser baseados em estruturas concatenadas uma em sequência a outra ou em estruturas aninhadas uma dentro da outra, de acordo com a formulação da condição.

O algoritmo a seguir utiliza estruturas concatenadas.

algoritmo "estruturas_concatenadas"

var x, y : inteiro

inicio

leia(x, y)

se (x=0) e (y=0) entao

escreva("Ponto na origem")

fimse

se (x=0) e (y<>0) entao

escreva("Ponto sobre o eixo y")

fimse

se (x<>0) e (y=0) entao

escreva("Ponto sobre o eixo x")

fimse

se (x>0) e (y>0) entao

escreva("Ponto no quandrante 1")

fimse

se (x<0) e (y>0) entao


fimse

se (x<0) e (y<0) entao


fimse

se (x>0) e (y<0) entao


fimse

fimalgoritmo

81

O algoritmo a seguir utiliza estruturas aninhadas ou encadeadas.

algoritmo "estruturas_aninhadas"

var x, y : inteiro

inicio

leia(x, y)

se x<>0 entao

se y=0 entao

escreva("Ponto sobre o eixo x")

senao

se x>0 entao

se y>0 entao

escreva("Ponto no quadrante 1")

senao


fimse

senao

se y>0 entao


senao


fimse

fimse

fimse

senao

se y=0 entao

escreva("Ponto na origem")

senao

escreva("Ponto sobre o eixo y")

fimse

fimse

fimalgoritmo

As estruturas concatenadas tem a vantagem de tornar o algoritmo mais legível, facilitando a correção do mesmo em caso de erros. As estruturas aninhadas ou encadeadas tem a vantagem de tornar o algoritmo mais rápido pois são efetuados menos testes e menos comparações, o que resulta num menor número de passos para chegar ao final do mesmo.

Normalmente se usa estruturas concatenadas nos algoritmos devido à facilidade de entendimento das mesmas e estruturas aninhadas ou encadeadas somente nos casos em que seu uso é fundamental.


Questão 01:

O que será apresentado na tela após a execução do seguinte algoritmo, se o número digitado for 5?

82


var fat, A, N : inteiro

inicio

fat <- 1

leia ( N )

para A de N ate 2 passo —1 faca

fat <- fat * a

fimpara

escreva (“Fatorial de “, N, 'é: “, fat )

fimalgoritmo

Questão 02:

Quais os valores impressos após a execução do seguinte algoritmo? algoritmo “quest02”

var I, J : inteiro

inicio

para I de 1 ate 2 passo 1 faca

para J de 1 ate 5 passo 2 faca

escreva ( I, J )

fimpara

fimpara

fimalgoritmo

Questão 03:

Faça o teste de mesa do algoritmo abaixo. O que será apresentado na tela? algoritmo “quest03”

var x, y, R, soma : inteiro

inicio

soma <- 10

para y de 50 ate 30 passo -10 faca

para x de 5 ate 7 passo 2 faca

soma <- soma + y

R <- x + y

escreva ( R )

fimpara

fimpara

escreva ( soma )

fimalgoritmo

Questão 04:

Quais os valores que serão impressos após a execução do seguinte algoritmo? algoritmo “quest04”

var A : inteiro

inicio

A <- 0

enquanto A < 20 faca

escreva ( A, A^2)

A <- A – 1

Escreva (“...”)

fimenquanto

escreva (“UFA! CHEGUEI AQUI”)

fimalgoritmo

83

Questão 05:

Dado o algoritmo abaixo, responda as questões seguintes: algoritmo “quest05”

var MAIOR, MENOR, VALOR : inteiro

inicio

leia ( VALOR )

MAIOR <- VALOR

MENOR <- VALOR

enquanto VALOR < > 0 faca

se VALOR > MAIOR entao

MAIOR <- VALOR;

senao

se VALOR < MENOR entao

MENOR <- VALOR

fimse

fimse

leia ( VALOR )

fimenquanto

escreva (“MAIOR = “, MAIOR, “e MENOR = “, MENOR)

fimalgoritmo

a) Dados os valores de entrada 6, 7, 5, 9, 3 e 0, informe os valores de MAIOR e MENOR a cada valor lido.

b) O que faz o algoritmo acima?

Questão 06:

Quais os resultados produzidos pelo algoritmo que se segue? algoritmo “quest06”

var Y : inteiro

X : logico

inicio

Y <- 0

X <- falso

enquanto Y <> 4 faca

X <- nao X

Y <- Y + 1

se X entao

escreva ( Y )

senao

escreva ( -Y )

fimse

fimenquanto

fimalgoritmo

Questão 07:

Analise o algoritmo abaixo: algoritmo “quest07”

var S, X, R : inteiro

FN : logico

Inicio

S <- 0

R <- 0

FN <- falso

leia ( X )

.<„a- '14

k . „ )

84

enquanto X <> 0 faca

S <- S + X

R <- R + S

FN <- nao FN

leia ( X )

fimenquanto

escreva (“S = “, S, “e R = “, R )

fimalgoritmo

Suponha que serão digitados os valores 9, 5, 3 e 0 (nesta ordem) quando solicitado. Responda:

a) Qual o valor de FN ao término do algoritmo?

b) O que será apresentado na tela?

Questão 08:

Analisando o algoritmo abaixo, faça o teste de mesa e diga qual o valor de Z ao final. algoritmo “quest08”

var X, Y, Z : real

inicio

X <- 1

Z <- 0

Y <- 2

enquanto X <= 3 faca

Y <- Y + 4

X <- X + 2

Z <- Z + Y / X

fimenquanto

fimalgoritmo

Questão 09:

Dado o algoritmo abaixo e os valores 2, 15, 6, 10 e 0, escreva o que será apresentado na tela ao final. algoritmo “quest09”

var X : inteiro

inicio

leia ( X )

enquanto X <> 0 faca

escolha X

caso 2

escreva (“Amarelo”)

caso 5,10

escreva (“Azul”)

escreva (“Branco”)

caso 20,21,22,23,24,25,26,27,28,29,30

escreva (“Verde”)

outrocaso

escreva (“Preto”)

fimescolha

leia ( X )

fimenquanto

escreva (“FIM”)

fimalgoritmo

85

Questão 10:

Analise o algoritmo abaixo: algoritmo “quest10”

var A, S, C : inteiro

inicio

S <- 100

C <- 0

leia ( A )

enquanto a <> 0 faca

S <- S – A

leia ( A )

C <- C + A

fimenquanto

fimalgoritmo

Dado os valores de entrada 10, 20, 15 e 0, qual será a configuração das variáveis ao final da execução?

Questão 11:

Analise o algoritmo abaixo e responda as perguntas seguintes. algoritmo “quest11”

var PAR, SOMA : inteiro

inicio

PAR <- 100

repita

SOMA <- SOMA + PAR

PAR <- PAR + 2

ate PAR > 200

escreva (SOMA)

fimalgoritmo

a) Quais são as variáveis utilizadas e seus respectivos tipos? O que o algoritmo faz?

b) Qual seria o resultado obtido em SOMA se a condição do comando repita fosse PAR > 20?

c) Qual seria o resultado obtido em SOMA se a condição do comando repita fosse PAR > 120?

Questão 12:

Executando o seguinte algoritmo, que valores serão escritos? algoritmo “quest12”

var N, QUADRADO : inteiro

inicio

N <- 10

repita

QUADRADO <- N^2

escreva (QUADRADO)

N <- N – 1

ate N = 1

fimalgoritmo

86

Questão 13:

Executando o seguinte algoritmo, que valores serão escritos? algoritmo “quest13”

var A, Q, TERMO : inteiro

inicio

A < - 1

Q < - 3

TERMO <- A

repita

escreva (TERMO)

TERMO <- TERMO * Q

ate TERMO >= 2000

fimalgoritmo

Questão 14:

Dado o algoritmo abaixo e os valores de entrada 10, 20, 15, 0 e 4, qual será o conteúdo das variáveis ao final da execução? algoritmo “quest14”

var X, S, Z : inteiro

inicio

S <- 100

leia (X)

repita

S <- S – X

Z <- Z + X

leia (X)

ate X = 0

leia (X)

Z <- X + X

fimalgoritmo

Questão 15:

Faça a equivalência dos comandos conforme solicitados nos itens abaixo.

a) Faça dois algoritmos utilizando os comandos ENQUANTO e REPITA algoritmo “quest15”

var C : inteiro

inicio

para C de 10 ate 30 passo 3 faca

escreva ( C )

fimpara

fimalgoritmo

b) Faça dois algoritmos utilizando os comandos PARA e REPITA algoritmo “quest15”

var X : inteiro

inicio

X <- 5

enquanto X < 51 faca

escreva ( X )

X <- X + 5

fimenquanto

fimalgoritmo

87

c) Faça dois algoritmos utilizando os comandos PARA e ENQUANTO algoritmo “quest15”

var K : inteiro

inicio

K <- 10

repita

escreva ( K * K )

K <- K – 1

ate K < 0

fimalgoritmo

Questão 16:

Escreva um algoritmo que imprima todos os números inteiros de 0 a 50.

Questão 17:

Criar um algoritmo que imprima todos os números de 1 até 100, inclusive, e a soma de todos eles.

Questão 18:

Escreva um algoritmo que imprima todos os números inteiros de 100 a 1 (em ordem decrescente).

Questão 19:

Escreva um algoritmo que imprima todos os números múltiplos de 5, no intervalo fechado de 1 a 500.

Questão 20:

Escreva um algoritmo que imprima todos os números pares do intervalo fechado de 1 a 100.

Questão 21:

Criar um algoritmo que leia dez números inteiros e imprima o maior e o segundo maior número da lista.

Questão 22:

Um número é, por definição, primo se ele não tem divisores, exceto 1 e ele próprio. Escreva um programa que leia um número e determine se ele é ou não primo.

Questão 23:

Escreva um programa que calcule o fatorial de um número inteiro lido, sabendo-se que:

N! = 1 x 2 x 3 x ... x N-1 x N

0! = 1

88

Questão 24:

A série de Fibonacci é formada pela seqüência: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...

Escreva um algoritmo que gere a série de FIBONACCI até o enésimo termo.

Questão 25:

Elabore um algoritmo que leia o número de termos da série abaixo e imprima o valor de H, sendo:

Questão 26:

Supondo que a população de um país A seja da ordem de 80.000 habitantes com uma taxa anual de crescimento de 3% e que a população de B seja 200.000 habitantes com uma taxa de crescimento de 1.5%. Faça um programa que calcule e escreva o número de anos necessários para que a população do país A ultrapasse ou iguale a população do país B, mantidas as taxas de crescimento.

Questão 27:

Uma pousada estipulou o preço para a sua diária em R$ 30,00 e mais uma taxa de serviços diários de:

R$ 15,00, se o número de diárias for menor que 10

R$ 8,00, se o número de diárias for maior ou igual a 10

Elabore um algoritmo que imprima o nome, a conta e o número da conta de cada cliente e ao final, o total ganho pela pousada. O algoritmo encerra sua execução quando for digitado 0 (zero) para o número da conta.

Questão 28:

Escreva um algoritmo que leia um conjunto de 50 fichas, cada uma contendo, a altura e o código do sexo de uma pessoa (código = 1 se for masculino e 2 se for feminino), e calcule e imprima:

a maior e a menor altura da turma; a média de altura das mulheres; a média de altura da turma.

Questão 29:

Criar um algoritmo que imprima todos os números de 1 até 100, inclusive, e a soma da metade desses números.

89

Questão 30:

Num frigorífico existem vários bois. Cada boi traz preso em seu pescoço um cartão contendo um número de identificação e seu peso. Elabore um algoritmo que imprima o número e o peso do boi mais gordo e do boi mais magro. O algoritmo encerra sua execução quando se digita um número menor ou igual a 0 (zero) para a identificação do boi. Não é necessário armazenar os dados de todos os bois.

91

CAPÍTULO 7

ESTRUTURAS DE DADOS HOMOGÊNEAS

Vimos, no início deste curso, ser possível dar um nome para uma posição de memória, sendo que a esta será associado um valor qualquer. Pois bem, acontece que, muitas vezes, esta forma de definição, ou melhor, de alocação de memória, não é suficiente para resolver certos problemas computacionais. Imagine por exemplo, como faríamos para construir um algoritmo, para ler o nome de N pessoas e que imprimisse um relatório destes mesmos nomes, mas ordenados alfabeticamente? Não seria uma tarefa simples, haja visto não ser possível determinar quantos nomes seriam lidos. Mesmo que soubéssemos o número de pessoas, digamos 1.000 pessoas, teríamos que definir 1.000 variáveis do tipo caractere, como é mostrado abaixo:

algoritmo “loucura”

var

Nome1,Nome2,Nome3,...., Nome999, Nome1000 : caractere

inicio

<sequencia de comandos>

fimalgoritmo

Considere o tamanho do algoritmo, e o trabalho braçal necessário para construi-lo. Isto só

com 1.000 nomes. Imagine agora 1.000.000 de pessoas. A construção deste algoritmo começaria a

ficar inviável na prática. Para resolver problemas como este e outros, foi criado um novo conceito

para alocação de memória sendo, desta forma, também criado uma nova maneira de definir

variáveis, a qual foi denominada de variável indexada.

Uma variável indexada corresponde a uma sequência de posições de memória, a qual

daremos um único nome, sendo que cada uma destas pode ser acessada através do que

conhecemos por índice. O índice corresponde a um valor numérico (exceto REAL), ou a um valor

caractere (exceto STRING). Cada uma das posições de memória de uma variável indexada pode

receber valores no decorrer do algoritmo como se fosse uma variável comum, a única diferença

reside na sintaxe de utilização desta variável.

As estruturas de dados homogêneas permitem agrupar diversas informações dentro de

uma mesma variável. Este agrupamento ocorrerá obedecendo sempre ao mesmo tipo de dado, e

é por esta razão que estas estruturas são chamadas homogêneas.

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. Os nomes mais usados e que utilizaremos para estruturas homogêneas são:

matrizes (genérico) e vetores (matriz de uma linha e várias colunas).

Exemplos:

92

Cada elemento dos arrays pode ser referenciado através de índices. Exemplos:

V[1] = 4 M[1,1] = 3

V[2] = 7 M[2,3] = 4

V[5] = 3 M[3,1] = 2

1. MATRIZES DE UMA DIMENSÃO OU VETORES

Este tipo de estrutura em particular é também denominado por profissionais da área como matrizes unidimensionais. Sua utilização mais comum está vinculada à criação de tabelas. Caracteriza-se por ser definida uma única variável vinculada dimensionada com um determinado tamanho. A dimensão de um vetor é constituída por constantes inteiras e positivas. Os nomes dados às matrizes seguem as mesmas regras de nomes utilizados para indicar as variáveis simples.

A sintaxe do comando de definição de vetores é a seguinte:

var

<nome_da_variável> : vetor [<indice_inicial>..<indice_final>] de <tipo_de_dado>

Exemplo:

var V : vetor [1..10] de inteiro

1.1. OPERAÇÕES BÁSICAS COM VETORES

Do mesmo modo que acontece com variáveis simples, também é possível operar com variáveis indexadas. Contudo não é possível operar diretamente com o conjunto completo, mas com cada um de seus componentes isoladamente.

O acesso individual a cada componente de um vetor é realizado pela especificação de sua posição no mesmo por meio do seu índice. No exemplo anterior foi definida uma variável V capaz de armazenar 10 números inteiros. Para acessar um elemento deste vetor deve-se fornecer o nome do mesmo e o índice do componente desejado do vetor (um número de 1 a 10, neste caso).

Por exemplo, V[1] indica o primeiro elemento do vetor, V[2] indica o segundo elemento do vetor e V[10] indica o último elemento do vetor.

93

Portanto, não é possível operar diretamente sobre vetores como um todo, mas apenas sobre seus componentes, um por vez. Por exemplo, para somar dois vetores é necessário somar cada um de seus componentes dois a dois. Da mesma forma as operações de atribuição, leitura e escrita de vetores devem ser feitas elemento a elemento.

1.1.1. Atribuição de Uma Matriz do Tipo Vetor

No capítulo sobre as instruções primitivas, o comando de atribuição foi definido como:

<nome_da_variável> <- <expressão>

No caso de vetores (variáveis indexadas), além do nome da variável deve-se necessariamente fornecer também o índice do componente do vetor onde será armazenado o resultado da avaliação da expressão.

Exemplo:

V[1] <- 15

V[2] <- 150

V[5] <- 10

V[10] <- 35

1.1.2. Leitura de Dados de Uma Matriz do Tipo Vetor

A leitura de um vetor é feita passo a passo, um de seus componentes por vez, usando a mesma sintaxe da instrução primitiva da entrada de dados, onde além do nome da variável, deve ser explicitada a posição do componente lido:

LEIA <nome_da_variável> [<índice>]

Uma observação importante a ser feita é a utilização de uma estrutura de repetição (Para; Enquanto) a fim de efetuar a operação de leitura repetidas vezes, em cada uma delas lendo um determinado componente do vetor. De fato esta construção é muito comum quando se opera com vetores, devido à necessidade de se realizar uma mesma operação com os diversos componentes dos mesmos. Na verdade, são raras as situações que se deseja operar isoladamente com um único componente do vetor.

O algoritmo a seguir exemplifica a operação de leitura de um vetor:

algoritmo “exemplo_leitura_de_vetor”

var

numeros : vetor [1..10] de inteiro

i : inteiro

inicio

para i de 1 ate 10 faca

leia (numeros[i])

fimpara

fimalgoritmo

94

O algoritmo acima ilustra a operação de leitura de um vetor usando a estrutura de repetição PARA. Podemos realizar a mesma operação usando a estrutura de repetição ENQUANTO.

algoritmo “exemplo_leitura_de_vetor_2”

var


i : inteiro

inicio

i <- 1

enquanto i <= 10 faca

leia (numeros[i])

i <- i + 1

fimenquanto

fimalgoritmo

1.1.3. Escrita de Dados de Uma Matriz do Tipo Vetor

A escrita de um vetor obedece à mesma sintaxe da instrução primitiva de saída de dados e também vale lembrar que, além do nome do vetor, deve-se também especificar por meio do índice o componente a ser escrito.

ESCREVA <nome_da_variável> [ <índice> ]

O algoritmo a seguir exemplifica a operação de leitura e escrita de um vetor, utilizando a construção PARA:

algoritmo “exemplo_escrita_de_vetor”

var


i : inteiro

inicio


leia (numeros[i])

fimpara


escreva (numeros[i])

fimpara

fimalgoritmo

Um exemplo mais interessante é mostrado a seguir, onde um vetor de dez números é lido e guardado no vetor numeros. Paralelamente, a soma destes números é calculada e mantida na variável soma, que posteriormente é escrita.

95

algoritmo “exemplo_escrita_de_vetor_com_soma”

var


i : inteiro

soma : inteiro

inicio

soma <- 0


leia (numeros[i])

soma <- soma + numeros[i]

fimpara


escreva (numeros[i])

fimpara

escreva (“Soma = ”, soma)

fimalgoritmo

1.2. EXEMPLOS DE APLICAÇÃO DE VETORES

O espectro de aplicação de vetores em algoritmos é muito extenso, mas normalmente os vetores são usados em duas tarefas muito importantes no processamento de dados: pesquisa e classificação.

A pesquisa consiste na verificação da existência de um valor dentro de um vetor. Trocando em miúdos, pesquisar um vetor consiste em procurar dentre seus componentes um determinado valor.

A classificação de um vetor consiste em arranjar seus componentes numa determinada ordem, segundo um critério específico. Por exemplo, este critério pode ser a ordem alfabética de um vetor de dados caractere, ou então a ordem crescente ou decrescente para um vetor de dados numéricos. Há vários métodos de classificação, mas o mais conhecido é o método da bolha de classificação (Bubble Sort).

1.2.1. O Método da Bolha de Classificação

Este método não é o mais eficiente, mas é um dos mais populares devido à sua simplicidade.

A filosofia básica deste método consiste em “varrer” o vetor, comparando os elementos vizinhos entre si. Caso estejam fora de ordem, os mesmos trocam de posição entre si. Procede-se assim até o final do vetor. Na primeira “varredura” verifica-se que o último elemento do vetor já está no seu devido lugar (no caso de ordenação crescente, ele é o maior de todos). A segunda “varredura” é análoga a primeira e vai até o penúltimo elemento. Este processo é repetido até que seja feito um número de varreduras igual ao número de elementos a serem ordenados menos um. Ao final do processo o vetor está classificado segundo o critério escolhido.

96

O exemplo a seguir ilustra o algoritmo bubble sort para ordenar 50 números inteiros em ordem crescente:

algoritmo "Bubble Sort"

var

i, j : inteiro

aux : inteiro

numeros : vetor[1..10] de inteiro

inicio


leia(numeros[i])

fimpara



se numeros[j] > numeros[j+1] entao

aux <- numeros[j]

numeros[j] <- numeros[j+1]

numeros[j+1] <- aux

fimse

fimpara

fimpara


escreval(i, " - ", numeros[i])

fimpara

fimalgoritmo

Podemos observar também que para ordenar o vetor em ordem decrescente basta inverter o sinal de comparação no teste da condição lógica:

Se numeros[j] > numeros[j+1] para Se numeros[j] < numeros[j+1]


Questão 01:

Quais são os valores impressos pelo algoritmo abaixo?


var

a : inteiro

x : real

v : vetor [1..5] de real

inicio

v[1] <- 2

v[2] <- 4

v[3] <- 1

97

v[4] <- 5

v[5] <- 3

x <- v[1]+v[5]

escreva (x)

x <- v[2]-v[5]

escreva (x)

x <- v[4]*v[1]-x

escreva (x)

a <- 3

x <- v[a]

escreva (x)

x <- v[a]/v[v[a]]

escreva (x)

fimalgoritmo

Questão 02:

Mostre qual é a configuração do vetor depois de executado o algoritmo abaixo.

I A M O S R O G L A

1 2 3 4 5 6 7 8 9 10


var

x : inteiro

palavra : vetor [1..10] de caractere

aux : caractere

inicio

para x de 1 ate 5 faca

aux <- palavra[5+x]

palavra[5+x] <- palavra[x]

palavra[x] <- aux

fimpara


aux <- palavra[x]

palavra[x] <- palavra[6-x]

palavra[6-x] <- aux

fimpara

palavra[7] <- “T”

fimalgoritmo

Questão 03:

Mostre qual é a configuração do vetor, depois de executado o algoritmo abaixo.

! O V A T S U G

1 2 3 4 5 6 7 8


var

aux : caractere

x : inteiro

v : vetor [1..8] de caractere

inicio


aux <- v[x]

v[x] <- v[8-x+1]

98

v[8-x+1] <- aux

fimpara

aux <- v[1]

v[1] <- v[8]

v[8] <- aux

fimalgoritmo

Questão 04:

Calcule o número de elementos de cada um dos vetores abaixo:

a) vet [-5..5]

b) nome [0..10]

c) oc [1..10]

d) arr [0..n]

e) conta[1..50]

Questão 05:

Dado um vetor VET, inteiro de 100 posições, fazer um algoritmo para cada um dos itens abaixo:

a) preenche-lo com o valor inteiro 30.

b) preenche-lo com os números inteiros 1, 2, 3, 4, … 100

c) preencher VET[i] com 1, se i é ímpar e com 0 se i for par

Questão 06:

Fazer um algoritmo para ler as notas de 40 alunos de uma turma, calcular e mostrar a média das notas e o número de alunos que tiraram nota acima da média.

Questão 07:

Escreva um algoritmo que armazene em um vetor todos os números inteiros de 0 a 50. Após isso, o algoritmo deve imprimir todos os valores armazenados.

Questão 08:

Escreva um algoritmo que receba a altura de 10 atletas. Esse algoritmo deve imprimir a altura daqueles atletas que tem altura maior que a média.

Questão 09:

A série de Fibonacci é formada pela seqüência: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...

Escreva um algoritmo que armazene em um vetor os 50 primeiros termos da série de FIBONACCI. Após isso, o algoritmo deve imprimir todos os valores armazenados.

99

Questão 10:

Escreva um algoritmo que receba quinze números do usuário e armazene em um vetor a raiz quadrada de cada número. Caso o valor digitado seja menor que zero, o número –1 deve ser atribuído ao elemento do vetor. Após isso, o algoritmo deve imprimir todos os valores armazenados.

Questão 11:

Fazer um programa que leia um vetor A contendo 30 números inteiros, calcule e exiba:

a) o maior elemento;

b) a posição (índice) do maior elemento.

Questão 12:

Fazer um algoritmo para ler 50 números. Ordenar os números em ordem crescente. Mostrar os números sequencialmente depois de ordenados.

2. MATRIZES COM MAIS DE UMA DIMENSÃO

Este tipo de estrutura também tem sua principal utilização vinculada à criação de tabelas. Caracteriza-se por ser definida uma única variável vinculada dimensionada com um determinado tamanho. A dimensão de uma matriz é constituída por constantes inteiras e positivas. Os nomes dados às matrizes seguem as mesmas regras de nomes utilizados para indicar as variáveis simples.

A sintaxe do comando de definição de matrizes de duas dimensões é a seguinte:

var

<nome_da_variável> : vetor [<linha_inicial>..<linha_final> ,

<coluna_inicial>..<coluna_final>] de <tipo_de_dado>

Exemplo:

var M : vetor [1..5,1..10] de inteiro

Também é possível definir matrizes com várias dimensões, por exemplo:

var

N : vetor [1..4] de inteiro

O : vetor [1..50,1..4] de inteiro

P : vetor [1..5,1..50,1..4] de inteiro

100

Q : vetor [1..3,1..5,1..50,1..4] de inteiro

R : vetor [1..2,1..3,1..5,1..50,1..4] de inteiro

A utilidade de matrizes desta forma é muito grande. No exemplo acima, cada matriz pode ser utilizada para armazenar uma quantidade maior de informações:

a matriz N pode ser utilizada para armazenar 4 notas de um aluno

a matriz O pode ser utilizada para armazenar 4 notas de 50 alunos

a matriz P pode ser utilizada para armazenar 4 notas de 50 alunos de 5 disciplinas

a matriz Q pode ser utilizada para armazenar 4 notas de 50 alunos de 5 disciplinas, de 3 turmas

a matriz R pode ser utilizada para armazenar 4 notas de 50 alunos de 5 disciplinas, de 3 turmas, de 2 colégios

2.1. OPERAÇÕES BÁSICAS COM MATRIZES DE DUAS DIMENSÕES

Do mesmo modo que acontece com os vetores, não é possível operar diretamente com o conjunto completo, mas com cada um de seus componentes isoladamente.

O acesso individual a cada componente de uma matriz é realizado pela especificação de sua posição na mesma por meio do seu índice. No exemplo anterior foi definida uma variável M capaz de armazenar 10 números inteiros em cada uma das 5 linhas. Para acessar um elemento desta matriz deve-se fornecer o nome da mesma e o índice da linha e da coluna do componente desejado da matriz (um número de 1 a 5 para a linha e um número de 1 a 10 para a coluna, neste caso).

Por exemplo, M[1,1] indica o primeiro elemento da primeira linha da matriz, M[1,2] indica o segundo elemento da primeira linha da matriz, M[1,10] indica o último elemento da primeira linha da matriz e M[5,10] indica o último elemento da última linha da matriz.

Da mesma forma como vetores, não é possível operar diretamente sobre matrizes como um todo, mas apenas sobre seus componentes, um por vez. Por exemplo, para somar duas matrizes é necessário somar cada um de seus componentes dois a dois.

Da mesma forma, as operações de atribuição, leitura e escrita de matrizes devem ser feitas elemento a elemento.

2.1.1. Atribuição de Uma Matriz de Duas Dimensões

Na atribuição de matrizes, da mesma forma que nos vetores, além do nome da variável deve-se necessariamente fornecer também o índice do componente da matriz onde será armazenado o resultado da avaliação da expressão. O índice referente ao elemento é composto por tantas informações quanto o número de dimensões da matriz. No caso de ter duas dimensões, o primeiro número se refere à linha e o segundo número se refere à coluna da matriz em que se encontra a informação.

Exemplo:

101

M[1,1] <- 15

M[1,10] <- 10

M[3,5] <- 20

M[5,10] <- 35

2.1.2. Leitura de Dados de Uma Matriz de Duas Dimensões

A leitura de uma matriz é feita passo a passo, um de seus componentes por vez, usando a mesma sintaxe da instrução primitiva da entrada de dados, onde além do nome da variável, deve ser explicitada a posição do componente lido:

LEIA <nome_da_variável> [<linha>,<coluna>]

Uma observação importante a ser feita é a utilização de estruturas de repetição aninhadas ou encadeadas a fim de efetuar a operação de leitura repetidas vezes, em cada uma delas lendo um determinado componente da matriz. Esta construção é muito comum quando se opera com matrizes, devido à necessidade de se realizar uma mesma operação com os diversos componentes das mesmas.

O algoritmo a seguir exemplifica a operação de leitura de uma matriz:

algoritmo “exemplo_leitura_de_matriz”

var

mat : vetor [1..5,1..10] de inteiro

lin, col : inteiro

inicio

para lin de 1 ate 5 faca

para col de 1 ate 10 faca

leia (mat[lin,col])

fimpara

fimpara

fimalgoritmo

O algoritmo acima ilustra a operação de leitura de uma matriz usando a estrutura de repetição PARA. Podemos realizar a mesma operação usando a estrutura de repetição ENQUANTO.

algoritmo “exemplo_leitura_de_matriz_2”

var


lin, col : inteiro

inicio

lin <- 1

col <- 1

102

enquanto lin <= 5 faca

enquanto col <= 10 faca

leia (mat[lin,col])

col <- col+1

fimenquanto

col <- 1

lin <- lin+1

fimenquanto

fimalgoritmo

2.1.3. Escrita de Dados de Uma Matriz de Duas Dimensões

A escrita de uma matriz obedece à mesma sintaxe da instrução primitiva de saída de dados e também vale lembrar que, da mesma forma que com vetores, além do nome da matriz, deve-se também especificar por meio do índice o componente a ser escrito:

ESCREVA <nome_da_variável> [<linha>,<coluna>]

O algoritmo a seguir exemplifica a operação de leitura e escrita de uma matriz, utilizando as construções PARA aninhadas ou encadeadas:

algoritmo “exemplo_escrita_de_matriz”

var


lin, col : inteiro

inicio



leia (mat[lin,col])

fimpara

fimpara



escreva (mat[lin,col])

fimpara

fimpara

fimalgoritmo

Um exemplo mais interessante é mostrado a seguir, onde uma matriz de 5 linhas por 10 colunas é lida e guardada na matriz numeros. A seguir é efetuada e escrita e a soma dos elementos da 2ª linha e também a soma dos elementos da 3ª coluna.

103

algoritmo “exemplo_escrita_de_matriz_com_soma”

var

mat : matriz[1..5,1..10] de inteiro

lin, col : inteiro

somal2, somac3 : inteiro

inicio



leia (mat[lin,col])

fimpara

fimpara



escreva (mat[lin,col])

fimpara

fimpara

somal2 <- 0

somac3 <- 0


somal2 <- somal2 + mat[2,col]

fimpara


somac3 <- somac3 + mat[lin,3]

fimpara

escreva (“Soma Linha 2 = ”, somal2)

escreva (“Soma Coluna 3 = ”, somac3)

fimalgoritmo


Questão 01:

Dada a matriz MAT abaixo:

ANTES DEPOIS

1 2 3 4 1 2 3 4

1 O Q * I 1

2 E * E S 2

3 R E U S 3

4 A * * S 4

104

Qual será a configuração de MAT depois de executado o algoritmo abaixo?


var

mat : vetor [1..4,1..4] de caractere

lin, col : inteiro

aux : caractere

inicio


para col de lin+1 ate 4 faca

aux <- mat[lin,col]

mat[lin,col] <- mat[col,lin]

mat[col,lin] <- aux

fimpara

fimpara

aux <- mat[1,1]

mat[1,1] <- mat[4,4]

mat[4,4] <- aux

aux <- mat[2,2]

mat[2,2] <- mat[3,3]

mat[3,3] <- aux

fimalgoritmo

Questão 02:

Analise a matriz e o algoritmo abaixo listados:

Matriz Inicial Matriz Final

1 2 3 4 1 2 3 4

1 1 2 3 4 1

2 5 6 7 8 2

3 9 10 11 12 3

4 13 14 15 16 4


var

MAT : vetor [1..4,1..4] de inteiro

X, Y, lin, col : inteiro

inicio

X <- MAT[4,2] + MAT[3,4]


para col de lin ate 4 faca

se lin = col entao

MAT[lin,col] <- 0

senao

MAT[lin,col] <- MAT[lin,col] + MAT[lin+1,col]

fimse

fimpara

fimpara


MAT[4,col] <- MAT[4,col] * 2

fimpara

Y <- MAT[2,2] + MAT[1,3]

fimalgoritmo

105

Responda às seguintes perguntas:

a) Qual é o valor final de X e Y, respectivamente? b) Quais os valores dos elementos da matriz no final da execução do algoritmo? Apresente o

teste de mesa.

Questão 03:

Escreva algoritmos independentes para a criação e inicialização das seguintes matrizes:

a)

1 2 3 4 5

6 7 8 9 10

11 12 13 14 15

15 17 18 19 20

21 22 23 24 25

b)

18 20 22 24

10 12 14 16

2 4 6 8

c)

P S

P S

P S

S P

S P

S P

d)

1100 700 300

1000 600 200

900 500 100

800 400 0

e)

15 30 45

10 25 40

5 20 35

106

f)

L L L L

C C C C

LC LC LC LC

Questão 04:

Elabore um algoritmo para ler as cinco notas de cada um dos 50 alunos de uma sala. O total de linhas corresponde a quantidade de alunos. Calcule e mostre a média de cada aluno. Calcule e no final informe a média geral da turma.

Questão 05:

Fazer um algoritmo que:

a) Leia uma matriz A, de dimensão 5 x 3. Cada linha da matriz é fornecida como entrada.

b) Determine a matriz transposta de A.

c) Mostre a matriz transposta.

Questão 06:

Construa um algoritmo para ler uma matriz 10 x 10 e escreva a localização (linha e a coluna) do maior valor.

Questão 07:



b) Verifique se os valores da diagonal secundária são primos.

Questão 08:

Construa um algoritmo e declare uma matriz 5 x 5. Preencha com 1 a diagonal principal e com 0 os demais elementos. Escreva ao final a matriz obtida.

Questão 09:

Construa um algoritmo para ler duas matrizes 4 x 4 e escreva uma terceira com os maiores elementos entre as primeiras.

Questão 10:

Construa um algoritmo para ler uma matriz 6 x 6, conte e escreva quantos valores maiores que 10 ela possui.

107

Questão 11:

Construa um algoritmo para ler uma matriz 20 x 20. Leia também um valor X. O programa deverá fazer uma busca desse valor na matriz e, ao final escrever a localização (linha e coluna) ou uma mensagem de “não encontrado”.

Questão 12:

Construa um algoritmo para ler uma matriz 4 x 4 e troque os valores da 1ª linha pelos da 4ª coluna, vice-e-versa. Escrever ao final a matriz obtida.

109

CAPÍTULO 8

ALGORITMOS: EXERCÍCIOS

1. ESTRUTURAS SEQUENCIAIS

1.

Certo dia o professor de Johann Friederich Carl Gauss (aos 10 anos de idade) mandou que os alunos somassem os números de 1 a 100. Imediatamente Gauss achou a resposta – 5050 – aparentemente sem cálculos. Supõe-se que já aí, Gauss, houvesse descoberto a fórmula de uma soma de uma progressão aritmética.

Agora você, com o auxílio dos conceitos de algoritmos, construa um programa para realizar a soma de uma P.A. de N termos, com o primeiro a1 e o último an.

2.

O produto de uma série de termos de uma Progressão Geométrica (P.G.) pode ser calculado pela fórmula abaixo:

Agora, escreva um algoritmo para determinar o produto dos n primeiros termos de uma P.G.

3.

Escreva um programa para calcular a área de um triângulo, sendo dados a sua base e a sua altura.

4.

Escreva um programa para calcular e exibir o comprimento de uma circunferência, sendo dado o valor de seu raio.

110

5.

Escreva um algoritmo que leia dois números quaisquer e informe sua soma, diferença, produto e quociente.

6.

Escreva um programa para ler uma temperatura dada na escala Fahrenheit e exibir o equivalente em Celsius.

( )

7.

Escreva um algoritmo que leia os valores dos catetos de um triângulo retângulo e mostre qual é o valor da hipotenusa desse triângulo.

8.

Faça um algoritmo que leia quatro notas de um aluno e calcule a sua média ponderada. Cada nota tem seu peso associado. O programa deve ler a nota e seu respectivo peso e depois calcular a média.

9.

Escreva um programa para ler o nome e o sobrenome de uma pessoa e escrevê-los de duas formas diferentes:

a) Nome e sobrenome

b) Sobrenome seguido por uma vírgula e pelo nome.

Exemplo:

Entrada: "Antonio","Soares"

Saída: Antonio Soares

Soares, Antonio

10.

Escreva um algoritmo que leia um ângulo em graus e imprima o seu seno, cosseno, tangente e cotangente deste ângulo.

11.

Escreva um algoritmo que leia um número e uma base e calcule o logaritmo desse número e imprima-o na tela.

111

12.

Todo restaurante, embora por lei não possa obrigar o cliente a pagar, cobra 10% de taxa de serviço. Faça um algoritmo que leia o valor gasto com despesas realizadas em um restaurante e calcule o valor total da conta incluindo a gorjeta.

13.

Antes do racionamento de energia der decretado, quase ninguém falava em quilowatts. MNas agora, todos incorporaram essa palavra em seu vocabulário. Sabendo-se que 100 quilowatts de energia custa um sétimo do salário mínimo, faça um algoritmo que receba o valor do salário mínimo e a quantidade de quilowatts gasta por uma residência e calcule:

d) O valor em reais de cada quilowatt

e) O valor em reais a ser pago

f) O novo valor a ser pago por essa residência com um desconto de 10%

Imprima todos os resultados na tela.

14.

Escreva um algoritmo que leia a base e a altura de um retângulo e calcule a sua área, o seu perímetro e a sua diagonal, sabendo que:

( )

√

15.

Em épocas de pouco dinheiro, os comerciantes estão procurando aumentar suas vendas oferecendo descontos. Escreva um algoritmo que possa entrar com o valor de um produto em reais e o valor percentual do desconto dado. Calcule e imprima o novo valor na tela.

16.

Escreva um algoritmo que calcule a quantidade de litros de combustível gastos em uma viagem, sabendo-se que o carro faz 12 km com um litro. Deverão ser fornecidos o tempo gasto na viagem e a velocidade média no percurso.

Utilize as seguintes fórmulas:

O algoritmo deverá apresentar os valores da velocidade média, tempo gasto na viagem, distância percorrida e a quantidade de litros utilizados na viagem.

112

17.

Uma pessoa resolveu fazer uma aplicação em uma poupança programada. Para calcular seu rendimento, ela deverá fornecer o valor constante da aplicação mensal, a taxa e o número de meses. Faça um algoritmo que calcule o valor acumulado desta aplicação, sabendo-se que:

( )

onde:

i = taxa

P = aplicação

n = número de meses

18.

Escreva um algoritmo que leia a quantidade de DVDs que uma locadora de vídeos possui e o valor que ela cobra por cada aluguel. O algoritmo deve mostrar as informações pedidas a seguir:

Sabendo que um terço das fitas são alugadas por mês, exiba o faturamento anual da locadora.

Quando o cliente atrasa a entrega, é cobrada uma multa de 10% sobre o valor do aluguel. Sabendo que um décimo dos DVDs alugados no mês são devolvidos com atraso, calcule o valor ganho com multas por mês.

Sabendo ainda que 2% dos DVDs se estragam ao longo do ano, e um décimo do total é comprado para reposição, exiba a quantidade de DVDs que a locadora terá no final do ano.

19.

Escreva um algoritmo que leia o número de uma conta corrente com três dígitos (numérico inteiro) e retorne o seu dígito verificador, o qual é calculado da seguinte maneira:

Somar o número com o seu inverso.

Multiplicar cada dígito pelo seu valor posicional e somar estes resultados.

O último dígito desse resultado é o dígito verificador da conta.

Exemplo:

Número da conta:

Somar o número com o seu inverso:

Multiplicar cada dígito pelo seu valor posicional e somar estes resultados:

( ) ( ) ( )

O último dígito desse resultado é o dígito verificador da conta.

113

20.

Escreva um algoritmo que leia um número inteiro no formato CDU (centena-dezena-unidade) e imprima os algarismos correspondentes a cada casa.

2. ESTRUTURAS DE DECISÃO

21.

Elabore um algoritmo que leia três números quaisquer e mostre-os em ordem crescente.

22.

A prefeitura de Paracatu abriu uma linha de crédito para seus funcionários. O valor máximo

não pode ultrapassar 30% do salário bruto. Escreva um programa que receba o salário do

servidor, o valor do bem a ser comprado, o número de prestações e os juros. Verifique se é

possível liberar o valor para o servidor e se for, informe o valor das parcelas.

23.

Faça um algoritmo para ler os valores dos três lados de um triângulo. Verificar e mostrar se é

um triângulo ou não e qual tipo.

Dica 1: Triângulo é uma forma geométrica composta por três lados, onde cada lado é menor

que a soma dos outros dois lados.

Dica 2: Um triângulo é: isósceles (quando possui dois lados iguais e um lado diferente),

escaleno (quando possui todos os lados diferentes) ou equilátero (quando possui todos os

lados iguais).

24.

Construa um algoritmo que, dada a idade válida de um nadador, classifique-o em uma das

categorias abaixo:

Idade Categoria

0 – 4 anos Não aceito

5 – 7 anos Infantil A

8 – 10 anos Infantil B

11 – 13 anos Juvenil A

14 – 17 anos Juvenil B

maiores de 17 anos Sênior

114

25.

Escreva um algoritmo que leia o ano de nascimento de uma pessoa e o ano atual. O programa

deve imprimir a idade da pessoa. Não se esqueça de verificar se o ano de nascimento é válido

ou não. O ano de nascimento será válido somente se for menor que o ano atual.

26.

Segundo uma tabela médica, o peso ideal de uma pessoa está relacionado com a altura e o

sexo. Faça um algoritmo que receba a altura e o sexo de uma pessoa, calcule e imprima o seu

peso ideal, utilizando as seguintes fórmulas:

Para homens (72.7 * alt) – 58

Para mulheres (62.1 * alt) – 44.7

27.

Faça um algoritmo que leia o percurso de uma viagem em quilômetros e o tipo de carro

utilizado. O programa deve apresentar uma estimativa de consumo de combustível, sabendo-

se que o carro tipo A faz 12 km com um litro, o tipo B faz 9 km e o tipo C faz 8 km por litro. O

programa deve ainda informar o valor estimado da viagem (em reais) sabendo-se que o preço

do litro do combustível é R$ 2,80.

28.

Crie um algoritmo que informe a quantidade de calorias de uma refeição, a partir da escolha do

usuário que deverá informar o prato, a sobremesa e a bebida de acordo com a tabela abaixo:

Prato Sobremesa Bebida

Salada 180cal Abacaxi 75cal Chá 20cal

Peixe 230cal Sorvete 110cal Suco 70cal

Frango 250cal Mousse 170cal Refri 100cal

Carne 350cal Bolo 200cal Cerveja 50cal

115

29.

Faça um programa que, dado as três notas de um aluno, determine e exiba a sua média final e

o seu conceito, sabendo-se que:

a média final é calculada pela média aritmética das 3 notas;

o conceito é determinado de com base na tabela abaixo:

Média Final Conceito

≥ 8,0 A

≥ 5,0 e < 8,0 B

< 5,0 C

30.

A Secretaria de Meio Ambiente que controla o índice de poluição mantém 3 grupos de

indústrias que são altamente poluentes do meio ambiente. O índice de poluição aceitável varia

de 0,05 até 0,25. Se o índice sobe para 0,3 as indústrias do 1º grupo são intimadas a

suspenderem suas atividades, se o índice crescer para 0,4 as indústrias do 1º e 2º grupo são

intimadas a suspenderem suas atividades, se o índice atingir 0,5 todos os grupos devem ser

notificados a paralisarem suas atividades. Faça um diagrama de bloco que leia o índice de

poluição medido e emita a notificação adequada aos diferentes grupos de empresas.

31.

Escreva um programa que determine o grau de obesidade de uma pessoa, sendo fornecido o

peso e a altura da pessoa. O grau de obesidade é determinado pelo índice da massa corpórea

(Massa = Peso / Altura2) através da tabela abaixo:

IMC Grau de Obesidade

< 18,5 Magreza

18,5 – 24,9 Saudável

25,0 – 29,9 Sobrepeso

30,0 – 34,9 Obesidade Grau I

35,0 – 39,9 Obesidade Grau II

≥ 40,0 Obesidade Grau III

32.

Construa um algoritmo que leia um número de 1 a 12 e informa o trimestre do ano

correspondente. Se o número não corresponder a um mês do ano, é mostrada uma mensagem

de erro.

116

33.

Faça um algoritmo que simule uma calculadora simples. O usuário deve escolher uma operação

básica: adição, subtração, multiplicação, divisão e potenciação. Feito isso, o usuário deve

entrar com dois números quaisquer e o programa deve realizar a operação mostrando o

resultado correto.

34.

Faça um algoritmo que verifique se uma letra digitada é vogal ou consoante.

35.

Uma faculdade atribui menções aos alunos conforme a faixa de notas que tenham atingido

conforme a tabela abaixo.:

Nota Menção

90 a 100 SS (superior)

70 a 89 MS (médio superior)

50 a 69 MM (médio)

30 a 49 MI (médio inferior)

01 a 29 II (inferior)

00 SR (sem rendimento)

Escreva um algoritmo que leia a nota final de um aluno e informa a menção. Mostrar também

se a nota é inválida.

36.

Faça um programa para calcular a conta final de um hóspede de um hotel, considerando que:

a) serão lidos o nome do hóspede, o tipo do apartamento utilizado (A, B, C ou D), o

número de diárias utilizadas pelo hóspede e o valor do consumo interno do hóspede;

b) o valor da diária é determinado pela seguinte tabela:

Tipo do Apartamento Valor da Diária (R$)

A 150,00

B 100,00

C 75,00

D 50,00

c) o valor total das diárias é calculado pela multiplicação do número de diárias utilizadas

pelo valor da diária;

d) o subtotal é calculado pela soma do valor total das diárias e o valor do consumo

interno;

e) o valor da taxa de serviço equivale a 10% do subtotal;

f) o total geral resulta da soma do subtotal com a taxa de serviço.

117

g) escreva a conta final contendo: o nome do hóspede, o tipo do apartamento, o número

de diárias utilizadas, o valor unitário da diária, o valor total das diárias, o valor do

consumo interno, o subtotal, o valor da taxa de serviço e o total geral.

37.

Deseja-se calcular o imposto de renda de um contribuinte. Para isto, escreva um programa

que:

a) leia os seguintes dados do contribuinte: CPF, nome, rendimento anual, imposto retido

na fonte, contribuição previdenciária, despesas médicas, número de dependentes;

b) é deduzido o valor de R$ 1.080,00 por cada dependente;

c) cálculo do valor total das deduções: contribuição previdenciária + despesas médicas +

dedução dos dependentes;

d) cálculo da base de cálculo: rendimento anual – total das deduções;

e) com base na tabela abaixo:

Base de Cálculo Alíquota Parcela a Deduzir

Até 10.800,00 Isento -

De 10.800,01 até

21.600,00

15% 1.620,00

Acima de 21.600,01 25% 3.780,00

Cálculo do imposto devido: ( (base de cálculo * alíquota) - parcela a deduzir )

f) haverá imposto a pagar se a diferença entre o imposto devido e o imposto retido na

fonte for positiva; caso contrário, haverá imposto a restituir.

g) exiba todos os dados lidos e calculados.

38.

As Organizações Tabajaras resolveram dar um aumento de salário aos seus colaboradores e

lhe contrataram para desenvolver o programa que calculará os reajustes. Faça um algoritmo

que recebe o salário de um colaborador e o reajuste segundo o seguinte critério, baseado no

salário atual:

salários até R$ 280,00 (incluindo) : aumento de 20%

salários entre R$ 280,00 e R$ 700,00 : aumento de 15%

salários entre R$ 700,00 e R$ 1500,00 : aumento de 10%

salários de R$ 1500,00 em diante : aumento de 5%

Após o aumento ser realizado, informe na tela:

• o salário antes do reajuste;

• o percentual de aumento aplicado;

• o valor do aumento;

• o novo salário, após o aumento.

118

39.

Faça um algoritmo que calcule as raízes de uma equação do segundo grau, na forma ax2 + bx

+ c. O programa deverá pedir os valores de a, b e c e fazer as consistências, informando ao

usuário nas seguintes situações:

• Se o usuário informar o valor de A igual a zero, a equação não é do segundo grau e o

programa não deve fazer pedir os demais valores, sendo encerrado;

• Se o delta calculado for negativo, a equação não possui raízes reais. Informe ao usuário

e encerre o programa;

• Se o delta calculado for igual a zero a equação possui apenas uma raiz real; informe-a

ao usuário;

• Se o delta for positivo, a equação possui duas raiz reais; informe-as ao usuário;

40.

Um posto está vendendo combustíveis com a seguinte tabela de descontos:

Álcool:

• até 20 litros, desconto de 3% por litro

• acima de 20 litros, desconto de 5% por litro

Gasolina:

• até 20 litros, desconto de 4% por litro

• acima de 20 litros, desconto de 6% por litro

Escreva um algoritmo que leia o número de litros vendidos, o tipo de combustível (codificado

da seguinte forma: A-álcool, G-gasolina), calcule e imprima o valor a ser pago pelo cliente

sabendo-se que o preço do litro da gasolina é R$ 2,50 o preço do litro do álcool é R$ 1,90.

41.

Deseja-se calcular a conta de consumo de energia elétrica de um consumidor. Para isto,

escreva um programa que leia o código do consumidor, o preço do Kw e a quantidade de Kw

consumido, e exiba o código do consumidor e o total a pagar.

total a pagar = preço x quantidade / total a pagar mínimo = R$ 11,20

42.

Escreva um algoritmo que leia um número inteiro qualquer e informe se ele é ou não divisível

por 5.

43.

Escreva um algoritmo que leia um número inteiro de três dígitos e imprima se o algarismo da

casa das centenas é par ou ímpar.

119

44.

Escreva um algoritmo que leia a placa de um automóvel (somente os 4 números) e informe

qual o mês de vencimento do seu IPVA, segundo a lista abaixo:

Final 0 Janeiro Final 1 Fevereiro Final 2 Março

Final 3 Abril Final 4 Maio Final 5 Junho

Final 6 Julho Final 7 Agosto Final 8 Setembro

Final 9 Outubro

45.

Um comerciante comprou um produto e quer vendê-lo com um lucro de 45% se o valor da

compra for inferior a R$20,00; caso contrário, o lucro será de 30%. Escreva um algoritmo que

leia o valor de compra de um determinado produto e mostre o valor da venda.

46.

Escreva um algoritmo que leia a idade de uma pessoa e informe a sua classe eleitoral.

Abaixo de 16 anos não eleitor

Entre 18 e 65 anos eleitor obrigatório

Entre 16 e 18 anos e acima de 65 anos eleitor facultativo

47.

Em um campeonato nacional de arco e flecha, tem-se equipes de três atletas para cada

estado. Escreva um algoritmo que informe se uma equipe foi classificada, de acordo com a

seguinte especificação:

Ler os pontos obtidos por cada atleta da equipe

Mostrar esses valores em ordem decrescente

Se a soma dos pontos for maior que 100, imprimir a média aritmética entre eles e a

mensagem “Equipe classificada com XXX pontos.”, onde XXX é a média; senão,

imprimir a mensagem “Equipe desclassificada.”

48.

Escreva um algoritmo que leia uma palavra qualquer e informe se a quantidade de letras

existentes nessa palavra é par ou ímpar.

120

49.

Um comerciante calcula o valor da venda de um produto tendo em vista a tabela abaixo:

VALOR DA COMPRA VALOR DE VENDA

Menos que 10,00 70%

Entre 10,00 e 30,00 50%

Entre 30,00 e 50,00 40%

Maior que 50,00 30%

Escreva um algoritmo que possa ler o nome do produto e o valor da compra e imprima o nome

do produto e o seu valor de venda.

50.

A biblioteca de uma universidade deseja fazer um programa que leia o nome do livro que será

emprestado, o tipo de usuário (professor ou aluno) e a data de empréstimo do livro. O

programa deve imprimir um recibo conforme mostrado abaixo:

Nome do livro: XXXXX

Tipo de usuário: XXXXX

Data do empréstimo: XXXXX

Data da devolução: XXXXX

O programa deve considerar que o professor tem dez dias para devolver o livro e o aluno

somente cinco dias. Escreva esse algoritmo.

3. ESTRUTURAS DE REPETIÇÃO

51.

Elabore um algoritmo que imprima todos os números inteiros ímpares de 1 a 100.

52.

Elabore um algoritmo que imprima o quadrado de todos os números inteiros de 1 a 20.

53.

Elabore um algoritmo que imprima todos os números inteiros de 120 a 300.

121

54.

Elabore um algoritmo que leia 10 números inteiros e imprima a metade de cada número.

55.

Elabore um algoritmo que leia 10 números inteiros e imprima o quadrado de cada número.

56.

Faça um programa que leia um número N, some todos os números inteiros de 1 a N, e mostre o resultado obtido.

57.

O cardápio de uma casa de lanches, especializada em sanduíches, é dado abaixo. Escreva um programa que leia o código e a quantidade de cada item comprado por um freguês, calcule e exiba o total a pagar. Obs: A leitura do código "X" indica o fim dos itens.

Código Produto Preço (R$)

H Hamburguer 1,50

C Cheeseburguer 1,80

Q Queijo Prato 1,00

58.

Desenvolva um gerador de tabuada, capaz de gerar a tabuada de qualquer número inteiro entre 1 a 10. O usuário deve informar de qual numero ele deseja ver a tabuada. A saída deve ser conforme o exemplo abaixo:

Tabuada de 5:

5 X 1 = 5

5 X 2 = 10

...

5 X 10 = 50

59.

Elabore um algoritmo que imprima uma tabela de conversão de polegadas para centímetros. Na tabela, deseja-se que conste valores desde 1 polegada até N polegadas, sendo N um valor dado pelo usuário. Monte uma interface amigável.

Obs.: 1 polegada vale 2,54 centímetros.

122

60.

Elabore um algoritmo que leia um número inteiro que será o limite superior de um intervalo e o incremento. O algoritmo deve imprimir todos os números inteiros compreendidos no intervalo de 0 até esse número. Os dois números lidos devem ser maiores que zero, caso contrário, imprimir uma mensagem de erro.

61.

Elabore um algoritmo que multiplique dois números inteiros. Nesse algoritmo, você não pode usar o operador de multiplicação (*).

62.

A série de Ricci difere da série de Fibonacci porque os dois primeiros termos são fornecidos pelo usuário. Os demais termos são gerados da mesma forma que a série de Fibonacci. Elabore um algoritmo que imprima os N primeiros termos da série de Ricci e a soma dos termos impressos, sabendo-se que para existir esta série serão necessários pelo menos três termos.

63.

A série de Fetuccine é gerada da seguinte forma: os dois primeiros termos são fornecidos pelo usuário; a partir daí, os termos são gerados com a soma ou a subtração dos dois termos anteriores, ou seja:

para i ímpar

para i par

Elabore um algoritmo que imprima os N primeiros termos da série de Fetuccine.

64.

Elabore um algoritmo que leia 20 números reais e imprima a soma dos números cujos quadrados são menores que 225.

65.

Elabore um algoritmo que leia 12 números e imprima a média aritmética desses números.

66.

Elabore um algoritmo que leia um número e imprima todos os seus divisores.

123

67.

Elabore um algoritmo que leia 20 números inteiros e imprima quantos são pares e quantos são ímpares.

68.

Elabore um algoritmo que leia o número de vezes que se deseja imprimir a palavra ALGORITMOS e imprima.

69.

Elabore um algoritmo que leia o número de termos da série abaixo e imprima o valor de H, sendo:

70.

No dia da estréia do filme “Avatar”, uma grande emissora de TV realizou uma pesquisa logo após o encerramento do filme. Cada espectador respondeu a um questionário no qual constava a sua idade e a sua opinião em relação ao filme: excelente, bom ou regular. Elabore um algoritmo que receba a idade e a opinião de 20 espectadores, calcule e imprima:

a média das idades das pessoas que responderam excelente

a quantidade de pessoas que responderam regular

o percentual de pessoas que responderam bom entre todos os espectadores analisados

71.

Num campeonato estadual de futsal, se inscreveram 20 agremiações. Sabendo-se que na lista oficial de cada agremiação consta, além de outros dados, peso e idade de 12 jogadores, elabore um algoritmo que apresente as seguintes informações:

o peso médio e a idade média de cada um dos times

o peso médio e a idade média de todos os participantes

72.

Elabore um algoritmo que imprima todas as tabuadas de multiplicação de 1 até 10.

73.

Elabore um algoritmo que imprima todas as tabuadas de divisão de 1 até 10.

124

74.

Elabore um algoritmo que entre com 10 notas de cada aluno de uma turma de 20 alunos e imprima:

a média de cada aluno

a média da turma

o percentual de alunos que tiveram médias maiores ou iguais a 5

75.

Uma escola tem 5 turmas e cada turma tem N alunos. Elabore um algoritmo que imprima, por turma, o total de alunos com média igual ou superior a 7 e a média geral da escola.

76.

Elabore um algoritmo que leia números enquanto estes forem positivos e imprima quantos números foram digitados.

77.

Elabore um algoritmo que leia números enquanto estes forem positivos e imprima a média dos números digitados.

78.

Elabore um algoritmo que leia vários números e informe quantos números entre 100 e 200 foram digitados. Quando o valor 0 (zero) for lido, o algoritmo deverá cessar sua execução.

79.

Elabore um algoritmo que leia a profissão de várias pessoas e imprima quantas pessoas são professores. Quando for digitado FIM para profissão, o algoritmo deverá cessar sua execução.

80.

Elabore um algoritmo que entre com vários números e imprima o quadrado de cada número lido até entrar um número múltiplo de 6 que deverá também ter seu quadrado impresso e logo após encerrar sua execução.

81.

Chico tem 1,50m e cresce 2 centímetros por ano, enquanto Juca tem 1,10m e cresce 3 centímetros por ano. Elabore um algoritmo que calcule e imprima quantos anos serão necessários para que Juca seja maior que Chico.

125

82.

Elabore um algoritmo que deixe entrar com 10 números positivos e imprima a raiz quadrada de cada número. Para cada entrada de dados deverá haver um trecho de proteção para que um número negativo não seja aceito.

83.

Uma empresa de fornecimento de energia elétrica faz a leitura mensal dos medidores de consumo. Para cada consumidor, são digitados os seguintes dados:

número do consumidor

quantidade de KW consumidos durante o mês

tipo (código) do consumidor

o 1 – residencial preço em reais por KW: 0,3

o 2 – comercial preço em reais por KW: 0,5

o 3 – industrial preço em reais por KW: 0,7

Os dados devem ser lidos até que seja encontrado um consumidor com o número 0 (zero). O algoritmo deve calcular e imprimir:

o custo total para cada consumidor

o total de consumo para os três tipos de consumidor

a média de consumo dos tipos 1 e 2

84.

Elabore um algoritmo que entre com vários números e verifique se eles são ou não quadrados perfeitos. O algoritmo termina sua execução quando se digita um número menor ou igual a 0 (zero).

Obs.: Um número é quadrado perfeito quando tem um número inteiro como raiz quadrada.

85.

Elabore um algoritmo que entre com um número e verifique se ele é um número triangular.

Obs.: Um número é triangular quando é resultado do produto de três números consecutivos. Exemplo: 24 é triangular, pois 24 = 2 x 3 x 4.

86.

Uma empresa decide dar um reajuste a seus funcionários de acordo com os critérios seguintes:

50% para aqueles que ganham menos de 3.000

20% para aqueles que ganham entre 3.000 e 10.000 (inclusive)

15% para os demais

126

Elabore uma algoritmo que leia o valor do salário atual para calcular e mostrar o valor do salário reajustado dos 105 funcionários da empresa. Desconsidere valores menores que zero.

87.

Elabore um algoritmo para calcular e mostrar os N primeiros termos de uma progressão aritmética (PA) de elementos inicial A e razão R.

88.

Elabore um algoritmo que calcule o MMC (mínimo múltiplo comum) entre dois números lidos.

89.

Elabore um algoritmo que calcule o MDC (máximo divisor comum) entre dois números lidos.

90.

Uma rainha requisitou os serviços de um monge e disse-lhe que pagaria qualquer preço. O monge, necessitando de alimentos, indagou à rainha sobre o pagamento, se poderia ser feito com grãos de trigo dispostos em um tabuleiro de xadrez, de tal forma que o primeiro quadro deveria conter apenas um grão e os quadros subseqüentes, o dobro do quadro anterior. A rainha achou o trabalho barato e pediu que o serviço fosse executado, sem se dar conta de que seria impossível efetuar o pagamento. Faça um algoritmo para calcular o número de grãos que o monge esperava receber.

4. VETORES E MATRIZES

91.

Fazer um programa que:

a) leia um vetor VET de 100 números inteiros;

b) leia um valor inteiro NUM;

c) determine e exiba a posição de NUM dentro de VET. Caso NUM não seja encontrado dentro de VET, exiba o valor 0 (zero).

92.

Construir um algoritmo que leia dois vetores (A e B) de 50 elementos cada um e crie um 3º vetor acumulando a soma dos elementos desses dois vetores, sempre utilizando o mesmo índice. Mostre os valores do 3º vetor somente.

Obs.: Leia os valores dos vetores primeiramente para depois imprimir o vetor C resultante.

127

93.

Escrever um algoritmo que construa um vetor A de 10 elementos reais. Após isso, construa e imprima um outro vetor B formado da seguinte maneira:

a) os elementos de índice par têm o valor de A dividido por 2

b) os elementos de índice ímpar têm o valor de A multiplicado por 3

94.

Fazer um algoritmo para ler 20 números e mostrá-los na ordem inversa de leitura, ou seja, o último número lido deve ser o primeiro a ser apresentado.

95.

Fazer um algoritmo para ler 50 números. Ordenar os números em ordem decrescente. Mostrar os números sequencialmente depois de ordenados.

96.

Faça um algoritmo que leia e armazene 15 números inteiros em um vetor e imprima uma listagem numerada contendo o número armazenado e informando se o número é par ou ímpar.

97.

Faça um algoritmo que leia e armazene o nome e as notas das provas 1 e 2 de 15 alunos. Calcule e armazene a média das notas. Armazene também a situação do aluno: APROVADO, se a média for maior ou igual a 6 e REPROVADO se a média for inferior a 6. Imprima uma listagem contendo o nome, as notas, a média e a situação de cada aluno.

98.

Faça um algoritmo que leia o preço de compra e o preço de venda de 100 mercadorias. O algoritmo deverá imprimir quantas mercadorias proporcionam lucro menor que 10%, quantas proporcionam lucro entre 10 e 20% e quantas proporcionam lucro maior que 20%.

99.

Construa um algoritmo para calcular a média de valores PARES e ÍMPARES, de 50 números que serão digitados pelo usuário. Ao final o algoritmo deve mostrar estas duas médias. O algoritmo deve mostrar também o maior número PAR digitado e o menor número ÍMPAR digitado. Esses dados devem ser armazenados em um vetor. Além disso, devem ser impressos os valores PARES maiores que a média PAR, bem como os valores ÍMPARES menor que a média ÍMPAR.

128

100.

Em uma cidade do interior, sabe-se que, de janeiro a abril de 1976 (121 dias), não ocorreu temperatura inferior a 15ºC nem superior a 40ºC. As temperaturas verificadas em cada dia estão disponíveis em uma unidade de entrada de dados. Fazer um algoritmo que calcule e imprima:

- A menor temperatura ocorrida;

- A maior temperatura ocorrida;

- A temperatura média;

- O número de dias nos quais a temperatura foi inferior à temperatura média.

101.


a) Leia uma variável composta A com 30 valores numéricos distintos;

b) Leia outra variável composta B com 30 valores numéricos;

c) Leia o valor de uma variável X;

d) Verifique qual o elemento de A que é igual a X;

e) Imprima o elemento de B de posição correspondente à do elemento de A igual a X.

102.

Uma agência de uma cidade do interior tem, no máximo, 10.000 clientes. Elabore um algoritmo que possa entrar com número da conta, nome e saldo de cada cliente. O algoritmo deve imprimir todas as contas, os respectivos saldos e uma das mensagens: positivo / negativo. A digitação termina quando se digita -999 para número da conta ou quando chegar a 10.000. Ao final, o algoritmo deverá mostrar o total de clientes com saldo negativo, o total de clientes da agência e o saldo da agência.

103.

Uma pesquisa sobre características físicas da população de uma determinada região coletou os seguintes dados referentes a cada habitante, para serem analisados:

sexo (masculino / feminino)

idade (em anos)

cor dos cabelos (louros/ castanhos / pretos)

Elabore um algoritmo que determine e imprima:

a maior idade dos habitantes

a quantidade de indivíduos de sexo feminino com idade entre 15 e 35 anos

a quantidade de indivíduos que tenham cabelos louros

Obs.: O último indivíduo terá idade -1, e não corresponde a ninguém.

129

104.

Elabore um algoritmo que leia a idade de várias pessoas e imprima:

total de pessoas com menos de 21 anos

total de pessoas com mais de 50 anos

O algoritmo encerra quando a idade digitada for menor ou igual a 0 (zero).

105.

Faça um algoritmo que:

a) Leia uma frase de no máximo 100 caracteres, incluindo brancos;

b) Conte quantos brancos existem na frase;

c) Conte quantas vezes a letra A aparece;

d) Imprima o que foi calculado nos itens b e c.

106.

Leia um vetor de 12 posições e em seguida ler também dois valores X e Y quaisquer correspondentes a duas posições no vetor. Ao final seu programa deverá escrever a soma dos valores encontrados nas respectivas posições X e Y.

107.

Leia um vetor de 16 posições e troque os 8 primeiros valores pelos 8 últimos e vice-e-versa. Escreva ao final o vetor obtido.

108.

Faça um algoritmo que leia um vetor de 500 posições de números inteiros e divida todos os seus elementos pelo maior valor do vetor. Mostre o vetor após os cálculos.

109.

Escrever um algoritmo que lê um vetor X de 20 posições e o escreve. Escreva, a seguir, cada um dos valores distintos que aparecem em X dizendo quantas vezes cada valor aparece em X.

110.

Escrever um algoritmo que lê 2 vetores de tamanho 10 e os escreve. Crie, a seguir, um vetor de 20 posições que contenha os elementos dos outros 2 vetores em ordem crescente.

130

111.

Fazer um programa para ler uma matriz 3 x 5 de números inteiros e escrevê-la após ter multiplicado cada elemento por 2.

112.

Dada uma matriz de 4 x 5 elementos inteiros, calcular a soma de cada linha, de cada coluna e de todos os seus elementos.

Obs: Utilize um vetor para armazenar o resultado da soma de cada linha e outro para a soma de cada coluna.

113.

Elabore um algoritmo para ler as cinco notas de cada um dos 50 alunos de uma sala. O total de linhas corresponde a quantidade de alunos. Calcule e mostre a média de cada aluno. Calcule e no final informe a média geral da turma.

114.



b) Some todos os elementos da matriz.

c) Encontre quais elementos da matriz são pares.

d) Multiplique os elementos da coluna 3.

e) Mostre os elementos da diagonal principal.

115.

Preencha uma matriz 5x5 de números inteiros e escreva os números cuja soma da linha e coluna resultem num número ímpar.

116.

Preencha uma matriz 5x5 de números inteiros e escreva os dados contidos em uma coluna fornecida.

117.

Leia uma matriz 8 x 8 e a transforme numa matriz triangular inferior , atribuindo zero a todos os elementos acima da diagonal principal, escrevendo-a ao final.

131

118.

Dado uma matriz de ordem NxN faça um algoritmo que verifique se a matriz é simétrica (aij=aji).

119.

Dado uma matriz NxM de valores reais faça um algoritmo que faça a leitura destes valores e ao final da leitura de todos, imprimir o seguintes relatório:

a) Qual a soma dos valores de cada coluna da matriz;

b) Listar os valores que são menores que a média dos valores;

c) Qual a soma dos elementos da diagonal secundária;

120.

Dado uma matriz NxM de valores inteiros escreva um algoritmo que faça a leitura destes valores e ao final coloque os elementos ordenados primeiro pela linha e depois pela coluna.

133

REFERÊNCIAS BIBLIOGRÁFICAS

Esta apostila foi compilada e montada pelo professor Gustavo Alexandre de Oliveira Silva, baseando-se na documentação disponível online e em livros didáticos.

APOIO INFORMÁTICA. <http://www.apoioinformatica.inf.br/>. Online, julho de 2011.

CARVALHO, Sergio e CAMPOS, Weber. Raciocínio Lógico Simplificado. Rio de Janeiro. Ed. Campus, 2010.

EGYPTO, Cândido. Introdução a Programação. ASPER – Associação Paraibana de Ensino Renovado. Março, 2004.

FARRER, Harry et al. Algoritmos Estruturados. Rio de Janeiro. Ed. Guanabara Koogan S.A, 1989.

GOMES, Gilene B. e GOMES, Alexandre M. Algoritmos – Fundamentos e Prática.

GUIMARÃES, Ângelo de Moura. Algoritmos e estruturas de dados. LTC, 1985.

MANZANO, José Augusto N. G. & OLIVEIRA, Jayr Figueiredo. Algoritmos: Lógica Para Desenvolvimento de Programação. São Paulo. Érica, 1996.

MORAES, Paulo S. Lógica de Programação. Unicamp – Centro de Computação – DSC. Abril, 2000.

SOUZA, João Nunes. Lógica para Ciência da Computação. Ed. Campus, 2008.

Contato:

Prof. Gustavo Alexandre de Oliveira Silva

Email: [email protected]

Web: http://www.baudogustavo.blogspot.com

instituto federal de educaÇÃo, ciÊncia e … · ministÉrio da educaÇÃo secretaria de...

Documents