algoritmo & lógica de programação -...
TRANSCRIPT
Pet de Engenharia Elétrica UFRN - CIT A presente apostila foi desenvolvida para o curso oferecido aos alunos
iniciantes dos cursos de Engenharia, pelo PET EE. Nela aborda-se de
maneira sucinta os conceitos fundamentais para uma contato inicial com
a referida disciplina, sendo planejada para o acompanhamento de tal
curso, o qual possui duração de 10hrs.
1 ª E d i ç ã o - 2 0 1 2
Algoritmo & Lógica de Programação
Sumário Introdução ..................................................................................................................................... 1
Capítulo 1 - Algoritmos e Lógica de Programação
1.1 - O que é um algoritmo? ..................................................................................................... 2
1.2 - Lógica de programação & fluxogramas. ............................................................................ 3
1.3 – Como programar? ............................................................................................................ 5
PROBLEMAS - CAPÍTULO 1 ........................................................................................................ 8
Capítulo 2 - Introdução à linguagem C++
2.1 – O que é linguagem de programação? .............................................................................. 9
2.2 – O ambiente DEV-C++ ........................................................................................................ 9
2.3 – Estrutura padrão de um programa em C++ ................................................................... 12
2.4 – Entrada e saída de dados: cin e cout .............................................................................. 14
2.5 – Expressões e variáveis .................................................................................................... 14
2.6 – Operadores ..................................................................................................................... 18
2.7 – Conversão de Tipo .......................................................................................................... 24
PROBLEMAS – CAPÍTULO 2 ..................................................................................................... 25
Capítulo 3 - Estruturas de controladores de fluxo
3.1 - Estruturas de desvios condicionais: ................................................................................ 26
3.2 - Estruturas Iterativas: ....................................................................................................... 30
3.3 – Vetores ........................................................................................................................... 32
PROBLEMAS – CAPÍTULO 3 ..................................................................................................... 35
REFERÊNCIAS: .......................................................................................................................... 36
“When I read commentary about suggestions for where C should go, I often think back and give thanks that it wasn't developed under the advice of a worldwide crowd.” (Dennis Ritchie) “Quando eu leio comentários sobre sugestões de como C deveria mudar, eu geralmente me recordo do passado e agradeço que tal linguagem não tenha sido desenvolvida com base nos conselhos de um mundo lotado de pessoas.” (Dennis Ritchie)
1
Introdução
Algoritmo e lógica de programação é uma disciplina fundamental para qualquer
aluno de engenharia. Essa disciplina permite o desenvolvimento do pensamento
lógico, além de fornecer uma pequena ideia de como os computadores
funcionam. Agora, reflita sobre todos os softwares que você utiliza diariamente,
além daqueles que você gostaria de entender como funcionam. Por diversas
vezes em engenharia, o profissional da área utilizará softwares específicos, ou
até mesmo precisará implementar, ou seja, criar um software para um
determinado fim. Dada a importância dessa disciplina, de uma coisa você
precisa saber antes de começar: NÃO TENHA MEDO. Programar pode ser uma
tarefa empolgante e desafiadora à medida que temos os nossos intelectos
desafiados à cada nova atividade, só o que precisamos é desvendar algumas
ferramentas e saber como elas funcionam, e esse é o objetivo principal dessa
apostila, repassar uma noção inicial sobre essas ferramentas e de como utilizá-
las. Bons estudos!
2
Capítulo 1 - Algoritmos & Lógica de Programação
1.1 - O que é um algoritmo?
A resposta para essa pergunta é geralmente respondida da seguinte forma: Algoritmo
é um conjunto de sequências lógicas para resolução de um determinado problema.
Duas coisas:
1 – Sequência Lógica; isso implica em um conjunto de ações organizadas logicamente,
em passos.
2 – Resolução de um problema; ou seja, existe um fim, logo um algoritmo é algo finito.
E por que você precisa saber o que é um algoritmo? Porque é assim que os softwares
funcionam, eles nada mais são que conjuntos e mais conjuntos de algoritmos, os quais
juntos funcionam pra resolver um determinado problema.
Exemplo 2 - Imagine que você tenha que desenvolver um algoritmo para trocar
lâmpadas. Como seria esse algoritmo? Bem, vamos supor que você disponha de
uma escada, de uma certa quantidade de lâmpadas que funcionam e uma
lâmpada queimada, a qual deve ser trocada. Vamos tentar organizar nossas ações
numa sequência lógica abaixo:
1º - Desligue o interruptor. (Afinal, você não quer correr o riscor de sofrer um
acidente).
2º - Coloque a escada embaixo da lâmpada queimada.
3º - Suba na escada.
4º - Retire a lampada queimada.
5º - Desça da escada.
6º - Pegue uma nova lampada.
7º - Suba na escada. (Tenha cuidado).
8º - Coloque a nova lampada.
9º - Desça da escada.
10º - Ligue o interruptor.
11º - Guarde a escada.
Exemplo 1 - Essa definição lembra alguma coisa? Sim, pense numa receita de bolo
por exemplo. Cada etapa da preparação do bolo está organizada de uma maneira
lógica. Você não coloca o fermento após levar o bolo ao forno, certo? Além do
mais, ao terminar de excutar todas as ações da receita, o resultado esperado é o
bolo.
3
Esse é um exemplo muito simples de um algoritmo, ele segue uma sequência lógica,
afinal você não colocaria a escada embaixo da lâmpada depois de trocá-la, supondo
um altura considerável, você nem conseguiria trocá-la, então uma ação completa a
outra em termos de sentido. Você poderia criar outro algiritmo para um outro
problema? Como o de trocar o pneu de um carro, por exemplo.
1.2 - Lógica de programação & fluxogramas.
Lógica de programação é a técnica de encadear pensamentos para atingir
determinado objetivo. E esse encadeamento é o que se tem abordado bastante
anteriormente, a sequência lógica de como as coisas acontecem.
Se você ainda não se sente confortável com a ideia de algoritmo, há ainda um modo
bem fácil de lembrar que você, de alguma forma ou de outra, já deve ter utilizado um
algoritmo. A prova disso está nos fluxogramas, os quais são tipos de diagramas usados
na esquematização de processos, como um projeto. Vamos pensar no caso da lâmpada
novamente. Mas agora, pensemos que você tem uma certa quantidade de lampadas
que supostamente funcionam, ou seja, você não sabe quais das lâmpadas disponíveis
realmente funciona, vamos considerar também que você não saiba por que a lâmpada
que deve ser trocada não está funcionando. Então, vamos criar um novo algoritmo
focando apenas na parte de testes, supondo as outras condições acessíveis ou já
realizadas, como a de colocar a escada embaixo da lâmpada, essa é uma outra
situação, ok? Podemos organizar nossa rotina, ou seja, nossas instruções que formam
uma repetição, em um fluxograma:
4
Sobre fluxograma há muito que poderia ser abordado, por exemplo, cada tipo de
bloco representa algo, os retângulos de bordas arrendodas significam ações ou
constatações, já os losângulos representam testes, é claro que há vários outros
padrões criados, por isso, informações dentro de cada bloco se fazem necessárias. No
entanto, nosso objetivo foi apenas o de mostrar como esse encadeamento de
pensamentos pode ocorrer.Repare como cada caminho se completa numa sequência
de ações lógicas que levam a resolução do nosso problema. Abaixo, temos uma tabela
que mostra um padrão estabelico para o significado de cada bloco e mais dois
exemplos de fluxogramas:
5
ENTRADA PROCESSAMENTO SAÍDA
1.3 – Como programar?
Agora que você já tem uma noção do que é um algiritmo, temos um novo desafio, que
é o de usar essas informações na prática, ou seja, realmente criar um programa. E
como fazer isso? Bem, sabemos que os programas são conjutos de alritmos, temos
uma noção de como criar um, mas ainda nos falta informações, não sabemos de fato
como o computador vai entender nossas instruções, ou como a nossa lógica poderá
ser interpretada e traduzida de fato para o mesmo. Várias coisas que o ser humano
construiu são baseadas em analogias do que ele encontra na natureza, desse modo,
apresentaremos uma analogia que o auxiliará a entender esse processo. Todo
algoritmo segue três passos fundamentais descritos abaixo:
Onde temos:
ENTRADA: São os dados de entrada do algoritmo.
PROCESSAMENTO: São os procedimentos usados para chegar ao resultado final.
SAÍDA: São os dados já processados.
De certa forma, essas fases se assemelham bastante ao que o ser humano faz durante
a resolução de um problema, ou mesmo durante uma conversa:
6
Tipos de variáveis
As variáveis e as constantes podem ser divididas em quatro categorias básicas:
Númericas: Específicas para o uso de números, as quais posteriomente podem
ser utilizadas em cálculos, etc. Nos próximos capítulos, veremos que há
subdivisões nessa categoria, como variáveis numéricas do tipo inteiro, do tipo
real, entre outras.
Caracteres: Específicas para o armazenamento de caracteres ou conjunto de
caracteres que não contenham números. Como exemplo: nomes, meses, etc.
Alfanuméricas: Específicas para dados que contenham caracteres e/ou números.
No entanto, não podem ser usadas para relações matemáticas.
Lógicas: Armazenam apenas dados lógicos que podem ser Verdadeiro ou Falso.
Essas três etapas são essenciais para qualquer algoritmo, e todo esse processo de
criação acontece no computador por meio de um programa chamado compilador
através de uma linguagem de programação. Mas não se preocupe com isso agora,
primeiro, precisamos entender como cada fase dessa funciona, ou o que ocorre em
cada fase, para isso, vamos simular um problema: O cálculo da média de um aluno.
1ª Parte: Entrada
Na entrada, como dito anteriormente, são onde os dados são fornecidos. Mas, o que
são os dados? Como os usamos? Os dados são basicamente conjunto de informações
que nós possuímos, no nosso caso, nossos dados são as notas. Os dados , de uma
maneira geral, são divididos em categorias: Variáveis e Constantes.
Constante: É um determinado valor fixo que não se modifica à medida que o algoritmo
é executado. Por exemplo, para cálcular a média aritmética de quatro notas, a soma
das quatro notas é dividida por quatro, ou seja, esse valor é imutável ao longo do
processamento, ele é uma constante.
Variável: É a representação simbólica dos elementos de um certo conjunto, tal valor
simbólico pode ser alterado durante a execução de um programa. No entanto, apesar
de poder assumir diversos valores ao longo do tempo, ela só pode assumir um valor
por vez. Por exemplo, nossas variáveis são as notas, você usará o programa para
calcular as médias de vários alunos, então as notas não podem ser contantes, ou o
resultado final sempre seria o mesmo.
7
2ª Parte: Processamento.
No processamento é onde as relações entre os dados acontece, é onde boa parte da
lógica é empregada. No nosso caso, o nosso procedimento será o de somar as quatro
notas fornecidas e depois dividar tal soma por quatro. Para realizar tal procedimento,
precisamos de operadores.
Operadores: São meios pelo qual algumas operações lógicas são realizadas, como
incrementar (aumentar algo), decrementar (diminuir algo), comparar, etc.
No nosso caso, o procedimento seria: Média = (nota1 + nota2 + nota3 + nota4)/4.
“Média “ e “nota1”, “nota2”...”nota4” são nossas variáveis, “4” é uma constante, “+” é
um operador aritimético, assim como “/”, já “=” é um operador relacional.
Tipos de Operadores
Operadores Aritméticos: São utilizados para obter resultados numéricos.
Operações do tipo soma, subtração, multiplicação, divisão e
potênciação.
Operadores Relacionas: São utilizados para comparar. Se um número é
maior do que o outro, menor ou igual, se uma palavra é igual ou difente,
entre outros casos.
Operadores Lógicos: São usados para combinar resultados de
expressões , retornando se o resultado final é verdadeiro ou falso. Por
exemplo, saber se um número “a” é maior do que um número “x” e
número “y”, ou se é maior do que apenas um dos dois. Nesses casos, “e”
e “ou” são operadores lógicos.
OBS.: Uma abordagem mais detelhada sobre Operadores e Variáveis
será dada posteriormente. Os simbolos que representam os operadores
podem ser diferentes dependendo da linguagem de programação
utilizada, bem como a forma de trabalhar com váriaveis, desse modo,
quando entrarmos na linguagem de programação abordada por essa
aspostila, falaremos melhor sobre este assunto.
8
3ª Parte: Saída.
A saída representa a parte em que os dados já foram processados e algora um
resultado é apresentado. No nosso caso, a nossa saída, ou seja, a informação que nós
queremos a partir do dados fornecidos e da lógica usada no processamento é a Média.
Mas como fazemos pra mostrar a média na tela do computador? O que precisamos
usar? Bem, como já dito anteriormente, a comunicação com computador é realizada
por meio de um software chamado compilador e a sua lógica é repassa e traduzida
pelo compilador pelo uso de uma linguagem de programação. Há várias linguagens de
programação atualmente, provavelmente você já deve ter ouvido falar de Java, ou de
C, C++, essas são linguagens de programação, códigos padronizados que representam
a lógica do programador. Nessa apostila, o compilador utilizado é o DEV-C++ e a
línguagem de programação é C++.
PROBLEMAS - CAPÍTULO 1
1 – Três índios, conduzindo três brancos, precisam atravessar um rio dispondo para tal de um barco cuja capacidade é de apenas duas pessoas. Por questões de segurança, os índios não querem ficar em minoria, em nenhum momento e em nenhuma das margens. Escreva um algoritmo que oriente os índios para realizarem a travessia nas condições fixadas. (Cabe observar que, usualmente, este exercício é enunciado envolvendo três jesuítas e três canibais. A alteração feita é uma modesta contribuição para o resgate da verdadeira história dos índios). 2 – O jogo conhecido como Torre de Hanói consiste de três torres chamadas origem, destino e auxiliar e um conjunto de n discos de diâmetros diferentes, colocados na torre origem na ordem decrescente dos seusdiâmetros. O objetivo do jogo é, movendo um único disco de cada vez e não podendo colocar um disco sobreoutro de diâmetro menor, transportar todos os discos para torre destino, podendo usar a torre auxiliar comopassagem intermediária dos discos. Escreva algoritmos para este jogo nos casos n= 2 e n = 3. 3 – Escreva um algoritmo para determinar o resto de uma divisão inteira utilizando uma máquina de calcular que efetue apenas as quatro operações: adição, subtração, multiplicação e divisão.
9
Capítulo 2 – Introdução à linguagem C++
2.1 – O que é linguagem de programação?
Lembre-se que em nossa analogia das fases de um algoritmo, o ser humano recebia instruções ou as captava pelos sentidos, tato, audição, visão, processava as informações no cérebro e dava uma resposta adequada. Agora, de quantas maneiras diferentes através da fala você pode passar uma instrução? Há várias maneiras, uma delas é usar palavras diferentes que no fim, resultam no mesmo significado, é o que chamamos de semântica e a outra forma é simplesmente mudar o idioma, e é claro que você precisaria entender o idioma em que as instruções são passadas para que você as possa processar e fornecer uma resposta adequada. Da mesma forma, há várias formas de passar instruções para o computador, existem várias linguagens que possibilitam a comunicação com ele, desde que haja um tradutor adequado, no caso, o compilador, ou programa que você vai usar para programar. Então, o que seria, de fato, linguagem de programação? Nada mais do que uma forma padronizada de passar instruções ao computador. E o que define essa padronização? O que define a padronização é a sintaxe, que nada mais é do que a forma que você escrever as instruções. O c++ é uma das várias linguagens de programação existentes, ela é considerada uma linguagem de nível médio (quanto mais alto nível, mas fácil de manipular), e existe desde 1985. Passada essa parte teórica, vamos ao que realmente interessa.
2.2 – O ambiente DEV-C++
O compilador usado para os exemplos dessa apostila, o DEV-C++ é muito fácil de ser instalado, é gratuito e pode ser facilmente encontrado na internet. Após a instalação, ao executar o programa você encontrará isso:
10
Na parte de cima, uma barra de ferramentas que você desvendará à medida que utilizar o programa, à esquerda um espaço reservado para visualizar os projetos em que você está trabalhando no momento e na caixa de texto, uma dica sobre o compilador . Para iniciar um novo projeto, vá em File->New->Project, ao fazer isso você verá:
Escolha a opção “Console Application” e dê um nome para o seu projeto, há alguns
caracteres que não podem ser incluídos no nome, então, é melhor escolher um nome
simples para o mesmo. Após escolher a opcão descrita e nomear seu projeto, um local
para salvar os arquivos gerados será perguntando, é sugerido aqui, que você crie uma
pasta específica para cada um de seus projetos, assim, você sempre saberá onde
encontrar os arquivos das suas aplicações. A seguir, temos:
11
Exemplo 3 - Olá mundo! #include <cstdlib> #include <iostream> using namespace std; int main(int argc, char *argv[]) { cout << "Ola mundo!" << endl; system("PAUSE"); return EXIT_SUCCESS; }
Pronto, é aqui onde a “mágica” acontece. Nessa imagem, temos a estrutura inicial para
começar qualquer aplicação simples. Repita o seguinte código abaixo:
Depois de digitar o código acima, você pode executar o código, ou em outras palavras,
compilá-lo para ver o que acontece, para isso, basta pressionar a teclar “F9”. Primeiro,
lhe será perguntando onde você deseja salvar o arquivo “main.cpp”, ou seja, o arquivo
principal do seu projeto, sugerimos que salve na mesma pasta criada por você
anteriormente. Após salvar, o resultado esperado será esse:
E esse foi o nosso primeiro programa, o qual simplesmente exibe na tela a mensagem
“Ola mundo!”.
12
Agora, vamos tentar entender o que aconteceu e adentrar um pouco mais na
linguagem c++.
2.3 – Estrutura padrão de um programa em C++
Vamos dar mais uma olhada no código do nosso primeiro programa:
#include <cstdlib> BIBLIOTECAS: São conjuntos de subprogramas, códigos que #include <iostream> permitem fazer algo, ou utilizar algo. using namespace std; NAMESPACE: Delimitador abstrato, fornece um contexto. int main(int argc, char *argv[]) Função principal, aqui é onde tudo acontece. { cout << "Ola mundo!" << endl; Linha de código, comando “cout” system("PAUSE"); Comando de Pausa. return EXIT_SUCCESS; Determinação do fim do algoritmo. } Voltando àquela analogia inicial, na qual comparávamos um algoritmo a uma receita, o que seria o compilador? O compilador seria a cozinha, espaço onde você vai trabalhar a receita, manipular os ingredientes e processar tudo até chegar no resultado final. Mas, para fazer qualquer receita, você precisa fazer com que as coisas ocorram, colocar leite, mexer a massa, etc. Assim, as bibliotecas são conjuntos de programas que você não vê os códigos, as quais permitem que você utilize comandos, o comando utilizado no nosso caso foi o “cout”, mas tarde veremos mais sobre isso. O namespace seria um contextualizador, por exemplo, nas bibliotecas você tem listas de comandos enumerados, ele é quem diz que o comando número 2 significa algo no seu algoritmo com o contexto específico no seu código, por exemplo, o comando “cout” significa copy out, ao escrever cout , digamos que ele faça refêrencia ao comando de número 125 da sua bilbioteca iostream. Não se preocupe com bibliotecas e namespaces agora, essas são explicações puramente didáticas para que você tenha ao menos uma noção do seus respectivos significados.
Todos os algoritmos são executados numa sequência lógica, o copilador vai lendo as linhas de código de cima para baixo e executando-as à media que passar por elas, cada linha diferente é separada por “;”. Além disso, o símbolo “{“ abre um bloco de comando e ele sempre deve ser fechado pelo seu par: “}”. Você pode escrever algo no código a ser ignorado pelo compilador? A resposta é sim, como comentários por exemplo, os quais são simplesmente frases que os programadores colocam para deixá-lo mais claro a outras pessoas. E para fazer um comentário basta colocar “//” ao lado esquerdo do que você deseja tornar um comentário. Por exemplo, se comentarmos a nossa segunda linha: #include <iostream>, ficaremos com: //#include <iostream> e se executarmos o progarama, teremos o seguinte erro:
13
Ao comentarmos #include <iostream>, o compilador vai ignorar essa linha de código, ou seja tal biblioteca não está sendo mais considerada pelo mesmo, o comando cout vem dessa biblioteca, então, quando o compilador lê a linha em que o cout aparece ele não vai mais reconhecê-lo. Na parte de baixo, temos algo bastante interessante, o compilador informa os erros que eventuamente ocorrem, acompanhando as colunas da esquerda pra direita, temos Line (linha), a linha em que se encontra o erro, no nosso caso a linha 8 (linha destecada em vermelho), depois temos File (arquivo), onde se encontra o arquivo em que o erro foi detectado e em seguida, temos Message (mensagem), a mensagem de erro: ‘cout’ undeclared (first use this function), ou seja, cout não declarado! Outro erro comum é escrever o comando de forma errada, o C++
14
Exemplo 4 – Declaração de variáveis #include <cstdlib> #include <iostream> using namespace std; int main(int argc, char *argv[]) { double lucro; int i, j; char a, b, c; system("PAUSE"); return EXIT_SUCCESS; }
é uma linguagem do tipo case sensitive, o que significa que se você digitar COUT ao invés de cout, ele não reconhecerá mais o comando, por isso, é importante conhecer bem a sintaxe da linguagem, ou seja, a forma de como os comandos devem ser escritos.
2.4 – Entrada e saída de dados: cin e cout
Existem algumas formas de passar e receber informações para um programa, a mais simples e utilizada é através dos comandos cin e cout, esses comandos pertecem à biblioteca iostream ( input, output de stream), o que significa entrada e saída de dados. Para usar tais comandos, precisamos incluír tal biblioteca, o que é feito através do comando include, o qual já aparece automaticamente quando um novo projeto é criado. Temos então: Comandos: cin e cout; (Copy in, Copy out). Sintaxe: cin >> informação que se deseja receber; cout << informação que se deseja mostrar. Se for um texmo cout << “sua frase” << endl;. Se for uma variável cout << variável << endl; Antes de mostrar um exemplo com cin e cout, vamos voltar ao tópico das variáveis, assim nossa compreensão será mais prática sobre o assunto.
2.5 – Expressões e variáveis
Em c++, uma expressão é uma combinação de variáveis, constantes e operadores, resultando em um valor, o qual é chamado valor da expressão, por exemplo: X = 6 * a + b; x e y são variáveis, 6 é uma constante e os simbolos “*” e “+” são operadores. Anteriormente vimos uma definição simples para variáveis, numa definição um pouco mais aprofundada elas representam um espaço de memória alocado para armazenar determinado tipo de dado. Todas as variáveis devem ser declaradas, isso significa que você tem que dizer ao compilador as variáveis que você vai usar no seu código. Declaração de variáveis: Na declaração de variáveis duas coisas devem ser obrigatoriamente especificadas: tipo e nome. a) O nome serve de referência ao dado armazenado na memória. b) O tipo da variável determina a natureza do dado armazenado, se é uma variável do tipo numérica, lógica etc.
15
Exemplo 5 – Declaração de variáveis #include <cstdlib> #include <iostream> #include <string> Inclusão da biblioteca string using namespace std; int main(int argc, char *argv[]) { double lucro; int i, j; char a, b, c; string nome, mes; Variávies do tipo string. system("PAUSE"); return EXIT_SUCCESS; }
Tipos de variáveis: • char: Guarda um caracter; • int: Guarda um número inteiro; • float: Guarda um número real com certa precisão; • double: Guarda um número real maior que do tipo float, mais preciso; • void: Tipo vazio. • bool: Guarda valores lógicos do tipo true ou false, verdadeiro ou falso. • unsigned char: caracter sem sinal; • long int: número inteiro,com domínio estendido; • unsigned int: numero inteiro positivo; • unsigned longint: numero inteiro positivo com domínio estendido. • shortint: inteiro com domínio reduzido. • unsignedshortint: inteiro positivo com domínio reduzido. Abaixo, temos uma tabela que demonstra o quanto de cada espaço é reservado da memória para cada tipo de variável;
Tipo Número de bits Representatividade
char 8 de -127 a 128
unsigned char 8 de 0 a 255
int 16 de -32.768 a 32.767
unsigned int 16 de 0 a 65.535
long int 32 de -2.147.483.648 a 2.147.483.647
unsigned long int 32 de 0 a 4.294.967.295
float 32 de 3,4E-38 a 3,4E+38
double 64 de 1,7E-308 a 1,7E+308
Há ainda um tipo de dado muito usado, que é o tipo string, o qual é usado para representar uma sequência de caracteres, como um nome. Para usar tal tipo de dado, faz-se necessária a inclusão da biblioteca <string>.
16
Exemplo 6 – Declaração de variáveis e atribuíção de valores #include <cstdlib> #include <iostream> #include <string> using namespace std; int main(int argc, char *argv[]) { double valor; Declaração de variáveis. int i, j; string nome; i = 500; j = 10; valor = 4.7 Atribuíção de valores. nome = “fulano”; system("PAUSE"); return EXIT_SUCCESS; }
Identificadores: São nomes de variáveis, funções e outros objetos definidos pelo usuário. No caso anterior, os identificadores são: lucro, i, j, a, b, c, nome e mes. Eles representam variáveis distintas, as variáveis do mesmo tipo são separadas por “,”, mas a cada fim de declaração, terminamos a linha com “;”, tal simbolo representa o fim de uma linha de código. Regras: a) Identificadores podem ser compostos por letras, números ou sublinhados, como nome_1; b) Identificadores devem começar com uma letra ou sublinhado c) Identificadores não pode ser palavras reservadas da linguagem c/c++. Exercício – É possível ter identificadores com os nomes abaixo em C++? 1) soma 2) 7peso 3) Soma 4) 5altura 5) peso_b 6) p2p 7) _2pessoa 8) pessoa_2 OBS.: A declaração de uma variável reserva um espaço na memória para armazenar um dado do tipo da variável e associa o nome da variável a este espaço de memória. Uma vez que as variáveis são declaradas, podemos armazenar valores nos respectivos espaços de memória e estes valores devem ter o mesmo tipo da variável, ou seja, não é possível armazenar um número real numa variável do tipo int (inteiro). Atribuíções: Há duas formas de atribuíções, uma em que primeiro se declara a variável e depois lhe atribui um valor e outra em que a atribuíção ocorre no momento da declaração:
17 Exemplo 6 – Declaração de variáveis e atribuíção de valores (2º Método)
#include <cstdlib> #include <iostream> #include <string> using namespace std; int main(int argc, char *argv[]) { double valor = 4.7; Declaração de variáveis e atribuíção de valores. int i = 500; int j = 10; string nome = “fulano”; system("PAUSE"); return EXIT_SUCCESS; }
Exemplo 7 – Soma de dois valores #include <cstdlib> #include <iostream> using namespace std; int main(int argc, char *argv[]) { int a, b, soma; // Declaração de variáveis cout << “Digite o primeiro valor” << endl; cin >> a; // Recebendo o primeiro valor cout <<”Digite o segundo valor”<< endl; cin >> b; //Recebendo o segundo valor soma = a + b; //Expressão para soma cout << soma << endl; //Exibindo na tela o resultado system("PAUSE"); return EXIT_SUCCESS; } COMENTÁRIOS: Para receber os valores do usuário, usamos o comando cin e para mostrá-los na tela usamos o cout, perceba que calcular a soma através da expressão não é o suficiente se quisermos ver o resultado, precisamos mostrá-lo na tela. Outra forma de deixar o resulta mais claro seria alterando o último cout dessa forma: cout << “A soma eh” << soma << endl;. O “endl” é um comando para pular linha, perceba que quando o código é executado o cursor já aparece na segunda linha.
Agora que já sabemos manipular variáveis, vamos fazer um exemplo simples , no qual recebemos dois números fornecidos pelo usuário e mostramos a soma como resposta:
18
Exercício – Faça um algoritmo que receba dois valores “a” e “b” e forneça como resultado seus valores invertidos, ou seja, o valor de “a” tem que passar para “b” e o valor de “b” tem que passar para “a”.
2.6 – Operadores
Até agora, temos utilizado operadores nas nossas expressões, mas ainda não tivemos uma abordagem mais prática sobre o assunto. Embora conheçamos os tipos de operadores, não sabemos muito bem ainda como utilizá-los na linguagem C++, vamos então aprender um pouco de sintaxe. Operadores Aritméticos
Operador Ação
+ Adição.
- Subtração, menos unário.
* Multiplicação
/ Divisão
% Resto da divisão
OBS.: A operações são feitas na precisão dos operandos. Exercício – Escreva algoritmos para testar os resultdados das seguintes expressões: a) valorFinal = a*b + 3*c; b) valorFinal = (a + b)/a*4; c) valorFinal = a + b *4; d) valorFinal = a - 4*b/c; e) valorFinal = a%b; f) valorFinal = a%(b – c*2); Dica: Lembre-se de usar o tipo adequado (inteiro, real, etc) para as variáveis! Incremento e decremento Algo interessante que podemos fazer com operadores aritméticos são os incrementos e decrementos, que consistem simplemente em aumentar e diminuir algo. Por exemplo, para dizer que uma variável tem o valor dela mesma adicionado de 1, poderíamos fazer isso de duas formas: 1ª Forma: x = x + 1; 2ª Forma: ++x; O mesmo serve para decrementação, de modo que temos a seguinte tabela:
Operador Ação
-- Decrementa -> Subtrai 1 ao operando
++ Incrementa -> Soma 1 ao operando
19
Exemplo 8 – Usando Incrementos e decrementos #include <cstdlib> #include <iostream> using namespace std; int main(int argc, char *argv[]) { int a, b; int n = 4; int m = 4; a = ++n; b = m++; cout << “Valor de a:” << a << “ “ << “Valor de b:” << b << endl; system("PAUSE"); return EXIT_SUCCESS; } Resultado: Valor de a: 5 Valor de b: 4
COMENTÁRIOS: Ao fazer ++n, primeiro ocorre o incremento e depois a atribuíção,
ou seja, primeiro n é incrementado, depois seu valor é atribuído à variável “a”. Já
em m++, ocorre primeiro a atribuíção e depois a incrementação, ou seja, primeiro
o valor de m é atribuído à variável “b” e depois a variável “m” sofre incremento.
OBS.: Há uma diferença entre ++x e x++ quando usados em uma expressão. Atenção ao próximo exemplo: Ou seja, como observamos no exemplo passado há uma precedência para os operadores, obeserve a imagem abaixo:
20
Exemplo 9 – Usando Incrementos e decrementos #include <cstdlib> #include <iostream> using namespace std; int main(int argc, char *argv[]) { int valorFinal, b, c, d; b = 3; c = 4; d = 5; valorFinal = b + ++c*d; cout << “Valor final: ” << valorFinal << endl; system("PAUSE"); return EXIT_SUCCESS; } Resultado: Valor final: 28
COMENTÁRIOS: Analisando a expressão, temos b + ++c*d; sabemos que o
operador ++ tem maior precedência, logo a variável será incrementada de 1 e
passará a valer 5, depois, o operador de segunda maior precedência é o “*”, logo
temos 5*5 = 25, então, por último temos a soma, a expressão se reduz à forma:
valorFinal = 3 + 25 = 28;
Regras: a) Operadores de mesmo nível de precedência são analisados da esquerda para direita. b) Pode-se usar parentêses para forçar uma (ou mais) operação a ter precedência maior.
21
Exemplo 10 – Operadores de atribuíção composta #include <cstdlib> #include <iostream> using namespace std; int main(int argc, char *argv[]) { int v1, v2, v3, v4, v5; v1 = 4; v2 = v1; v3 = v2; v4 = v3; v5 = v4; v1 += 3; v2 -= 2; v3 *= 3; v4 /= 3; v5 %= 3; cout << v1 << “ “ << v2 << “ “ << v3 << “ “ << v4 << “ “ << v5 << endl; system("PAUSE"); return EXIT_SUCCESS; } Resultado: 7 2 12 1 1
COMENTÁRIOS: Na divisão de 4/3 o resultado é 1.333 aproximadamente, no entanto a
resposta foi 1. Isso acontece porque declaramos que as variáveis são do tipo inteiro, então
como resposta, apenas a parte inteira aparece.
Operadores de atribuíção O operador de atribuíção é o mais simples, ele tem sido usado até agora sem nenhum problema. No entanto, há algumas peculiaridades que podem ajudar bastante na hora de escrever um código. A linguagem C++ também permite a utilização de operadores compostos. Por exemplo: 1ª Forma: i = i + 2; 2ª Forma: i += 2; Ambas as linhas produzem o mesmo resultado, só que a segunda é obtida por meio do operador +=. Sendo assim, temos:
Operador Ação
+= Soma o operando do valor que estiver à direita.
-= Subtrai o operando do valor que estiver à direita.
*= Multiplica o operando do valor que estiver à direita.
/= Divide o operando do valor que estiver à direita.
%= Obtém o resto da divisão pelo valor que estiver à direita.
22
OBS.: A expressão: x *= y + 1 equivale à x = x*(y + 1) e não à x = x * y + 1. O mesmo pode ser ditpo à respeito dos outros operadores de atribuíção compostos, sempre o que está à direita será levado em conta. Operadores relacionais & lógicos Operadores relacionais: São usados como o próprio nome diz para comparar valores, o resultado dessa comparação é sempre 0 (falso) ou 1 (verdadeiro).
Operador Comparação
< Menor que
> Maior que
<= Menor ou igual que
>= Maior ou igual que
== Igual a
!= Diferente de
Operadores lógicos: São usados para combinar expressões boolenas, ou seja, expressões cujo resultado é verdadeiro ou falso.
Operador Significado
&& Operador binário E (AND)
|| Operador binário OU(OR)
! Operador unário de NEGAÇÃO (NOT)
Regras: a) Expressões conectadas por && ou || são avaliadas da esquerda para direita, e a avaliação pára assim que a veracidade ou falsidade do resultado for conhecida. b) Quanto ao nível de precedência, têm um nível menor do que os operadores aritméticos. Por exemplo: 10 > 1 + 13 é avaliado como 10 > (1 + 13). Observe a figura abaixo:
23
Exemplo 11 – Operadores lógicos e relacionais #include <cstdlib> #include <iostream> using namespace std; int main(int argc, char *argv[]) { int a, b; int c = 10; int d = c + 3; a = (c > 10) || (d > c); b = (c < 10) && (d > c); cout << “Valor de a: “ << a << “ “ << “Valor de b: “ << b << endl; system("PAUSE"); return EXIT_SUCCESS; } Resultado: Valor de a = 1 Valor de b = 0
COMENTÁRIOS: Analisando a expressão a = (c > 10) || (d > c), temos a setença c é maior
que 10 ou o valor da variável “d” (13) é maior do que o valor da variável “c” (10), como
uma das afirmações resulta em verdadeira e estamos o operador lógico ou, temos como
resposta final 1 (verdadeiro). Já no segundo caso, devemos interpretar a expressão da
seguinte maneira o valor de “c” é menor do que 10 e o valor de “d” é maior do que o valor
de “c”? O que resulta em falso, já que o valor de “c” é 10. Lembre-se que o resultado de
expressões lógicas são sempre 0 ou 1, falso ou verdadeiro.
Os operadores lógicos e relacionais são usados geralmente para tomada de decisões, assunto dos próximos capítulos, no entanto, eles também podem ser usados para a atribuíção de valores, como no exemplo abaixo:
Exercício – Se a = 20, b = a + 2. Faça um algoritmo para testar os seguintes valores de c: a) c = (a > 1) && (b < a); b) c = (a == 3) || (b > a); c) c = (a < b) || ( b < 20) d) c = (a > 2) && (a < 30) e) c = (b < 12) || (a > 20) f) c = (a > b) && (b > 20)
24
2.7 – Conversão de Tipo
Até agora temos trabalhado, nos nossos exemplos, sempre com variáveis do mesmo tipo. No entanto, na prática, em um algoritmo se trabalha com variáveis de mais de um tipo que, por vezes, se relacionam em expressões. Trantando-se de expressões aritméticas, por exemplo, existem conversões automáticas de valores na avaliação de uma expressão. Com exemplo, tivemos a expressão 4/3 cujo resultado aproximado é 1.3333, mas a resposta era dada por 1, uma vez que a variável que recebia o valor da divisão era do tipo inteira. Mas, se tivermos uma variável do tipo double recebendo o resultado da expressão 4/2.5, temos uma constante inteira sendo dividida por uma constante do tipo double e o resultado é 1.6. O que acontece com a constante inteira, já que estamos trabalhando com dois tipos diferentes? O que ocorre é uma conversão implícita, ou seja, a constante 4 do tipo int é promovida ao tipo double antes da operação ser realizada e a operação é feita na precisão do tipo mais representativo. Analisando o gráfico a seguir, podemos visualizar o nível de representatividade dos diferentes tipos: Na figura acima temos uma expressão que combina variáveis de diferentes tipos, à medida que as operações acontecem, temos os tipos dos resultados, o quais vão ser recombinados em uma expressão diferente, orginando, por sua vez, um tipo cuja o nível de representatividade é sempre maior. OBS.: Não podemos usas as variáveis sem antes atribuír um valor a elas, esse é um exemplo puramente ilustrativo.
25
PROBLEMAS – CAPÍTULO 2 1 – Escreva um programa que converta uma temperatura dada em graus Fahrenheite para graus Celsius. 2 – Determine o perímetro de um poligno regular inscrito numa cinrcunferência, dados o número de lados do poligno e o raio da circunferência. 3 – Uma loja vende seus produtos no sistema entrada mais duas prestações, sendo a entrada maior do que ou igual às duas prestações; estas devem ser iguais, inteiras e as maiores possíveis. Por exemplo, se o valor da mercadoria for R$ 270,00, a entrada e as duas prestações são iguais a R$ 90,00; se o valor da mercadoria for R$ 302,75, a entrada é de R$ 102,75 e as duas prestações são a iguais a R$ 100,00. Escreva um programa que receba o valor da mercadoria e forneça o valor da entrada e das duas prestações, de acordo com as regras acima. Observe que uma justificativa para a adoção desta regra é que ela facilita a confecção e o consequente pagamento dos boletos das duas prestações. Dica: As parcelas são iguais e são do tipo inteiro, determine primeiro o valor das parcelas, como o pagamento consiste em entrada + 2 parcelas, fica fácil descobrir o valor da entrada, o qual não é do tipo inteiro. 4 – Um intervalo de tempo pode ser dado em dias, horas, minutos, segundos ou sequências "decrescentes" destas unidades (em dias e horas; em horas e minutos; em horas, minutos e segundos), de acordo com o interesse de quem o está manipulando. Escreva um programa que converta um intervalo de tempo dado em segundos para horas, minutos e segundos. Por exemplo, se o tempo dado for 3 850 segundos, o programa deve fornecer 1 h 4 min 10 s. 5 – Escreva um programa que converta um intervalo de tempo dado em minutos para horas, minutos e segundos. Por exemplo, se o tempo dado for 145.87 min, o programa deve fornecer 2 h 25 min 52.2 s (vale lembrar que o ponto é o separador da parte inteira). 6 – Escreva um problema que receba as três notas do aluno e mostra a média ponderada do mesmo, sabendo que os pesos de cada unidade são 4, 5 e 6. Faça o programa de modo que seja possível cálcular a nota de no mínimo três alunos. Como você faria se fossem 100 alunos? Para resolver tal problema precisamos saber um pouco sobre laços de repetição, assunto dos próximos capítulos.
26
Capítulo 3 - Estruturas de controladores de fluxo
3.1 - Estruturas de desvios condicionais:
a) O comando if e o comando else:
Em algumas situações, alguns comandos só devem ser executados se alguma
condição for satisfeita.
É muito fácil encontrar situações em que a execução de uma ou mais instruções
deve estar condicionada ao fato de que uma condição seja satisfeita. Por
exemplo, veremos algoritmos para ordenar uma relação de números que
necessitam colocar em ordem crescente os conteúdos de duas variáveis. É
óbvio que para ordenar em ordem crescente os conteúdos de duas variáveis x e
y só é necessário se fazer alguma coisa se o conteúdo de x for maior que o
conteúdo de y, ou seja, x > y.
Há situações também em que há necessidade de que se faça uma escolha entre
duas ou mais sequências de instruções qual a sequência deve ser executada.
Por exemplo, se pretendemos verificar se um número n é par podemos
determinar o resto da divisão de n por 2. Se estre resto for zero, então o
número é par. Se este resto for 1, o número é par.
Vale lembrar que os algoritmos que o viver exige que executemos
diuturnamente são pontuados de escolhas e decisões: se não chover, iremos à
praia; se chover, iremos ao shopping; se estiver fazendo frio, vista um casaco.
A verificação de que uma condição é satisfeita e, a partir daí, uma determinada
sequência de comandos deve ser executada é chamada de estrutura de
seleção, estrutura de decisão ou comando de seleção.
O comando if é uma estrutura de decisão que decide se uma sequência de
comandos será ou não executada. Sua sintaxe é
If (Expressão)
{
sequência de comandos
}
Se a “Expressão” for verdadeira, a sequência de comandos será executada.
Caso contrário todo o conteúdo entre {} será ignorado. Vejamos um exemplo
em que dois números distintos são impressos em ordem decrescente:
27
Que, com o uso do comando else poderia ser escrito da seguinte maneira:
Como podemos notar a sequência de comandos após o else é executada no
caso de a “Expressão” ser falsa.
28
b) O comando switch:
Muitos programas são desenvolvidos de modo que eles podem realizar várias
tarefas, de forma independente. Por exemplo, um programa que gerencie um
caixa eletrônico de um banco deve oferecer ao usuário algumas opções em
relação à ação que ele pretende realizar na sua conta como a emissão do saldo
atual, a emissão de um extrato, a realização de um saque e a realização de um
depósito. É comum que um programa que permita a realização de várias
tarefas inicie apresentando ao usuário um menu de opções com a indicação das
diversas tarefas que o programa pode executar e a permissão de que o usuário
escola a tarefa pretendida. Como, em geral, são várias as opções disponíveis
(cada uma delas com uma sequência específica de comandos) e só uma das
opções será a escolhida, é necessária uma estrutura que decida entre várias
sequências de comandos qual vai ser executada ou quais vão ser executadas.
O comando switch tem este objetivo e deve ser escrito com a seguinte sintaxe:
switch (Expressão)
{
case constante1:
sequência de instruções1
case constante2:
sequência de instruções2
...
case constante n:
sequência de instruções n
default:
sequência de comando x
}
Nesse código, a “Expressão” argumento do comando deve resultar num valor
do tipo int ou num valor do tipo char e, opcionalmente, a última instrução de
cada uma das sequências de instruções é o comando break. A “Expressão” é
avaliada e as sequências de instruções situadas entre o valor da expressão
apresentado nos cases e um comando break ou o delimitador do comando são
executadas. Se o valor da “Expressão” for diferente de todas as opções dadas
pelas constantes associadas aos cases, a sequência de instruções vinculada ao
default será executada. Observe o exemplo de uma minicalculadora:
29
Observações:
A sequência de instruções vinculada a uma opção case pode ser vazia,
caso em que, evidentemente, nada é executado;
Se apenas uma sequência de comandos deve ser executada, deve-se
encerrá-la com um break;
A opção default é opcional: se ela não aparece no comando e o valor da
“Expressão” for diferente de todos os valores disponíveis, nada é
executado e a instrução logo após o comando switch passa a ser
executada.
30
Exercícios
1. Escreva um programa que realize arredondamentos de números utilizando a
regra geral da matemática: se a parte fracionária for maior do que ou igual a
0,5, o número é arredondado para o inteiro imediatamente superior; caso
contrário, é arredondado para o inteiro imediatamente anterior.
2. Escreva um programa para determinar o maior entre três números dados.
3. Escreva um programa para classificar um triângulo de lados de comprimentos
dados em escaleno, isósceles ou equilátero.
4. Escreva um programa para verificar se um triângulo de lados de comprimentos
dados é retângulo, exibindo, nos casos afirmativos, sua hipotenusa e seus
catetos.
3.2 - Estruturas Iterativas:
a) O comando for ( ; ; ):
O comando for é uma estrutura de repetição que repete a execução de uma
dada sequência de comandos um número de vezes que pode ser determinado
pelo próprio programa, devendo ser escrito com a seguinte sintaxe:
for (inicializações; condições de manutenção da repetição; incrementos)
{
sequência de comandos
}
Como os nomes indicam, em inicializações, são atribuídos valores iniciais a
variáveis; em condições de manutenção da repetição, estabelecem-se, através
de uma expressão, as condições nas quais a execução da sequência de
comandos será repetida; em incrementos, incrementam-se variáveis. Quando
um comando for é executado, a sequência de comandos da área das
inicializações é executada. Em seguida, a expressão que fixa as condições de
manutenção da repetição é avaliada. Se o valor desta expressão não for nulo, a
sequência de comandos é executada, sendo em seguida executada a sequência
de comandos da área dos incrementos. Novamente a expressão das condições
de manutenção da repetição é avaliada e tudo se repete até que o seu valor
seja igual a zero (falsa).
31
b) O comando while
Estrutura de repetição alternativa.
while (Expressão)
{
sequência de comandos
incrementos
}
c) O comando do while:
Estrutura de repetição alternativa.
do
{
sequência de comandos
}
while (Expressão)
32
A diferença entre essas três estruturas de repetição na ordem de execução do
programa. Em uma a “Expressão” é avaliada para que então seja procedida a
sequência de comandos; em outra, o contrário. A conveniência e cada
circunstância fara o programador optar por uma delas.
Exercícios
1. Escreva um programa para calcular a soma dos n primeiros números de:
a) Uma progressão aritmética de razão r dada;
b) Uma progressão geométrica de razão q dada.
2. Escreva um programa para determinar o número de algarismos de um
número inteiro positivo dado.
3. Escreva um programa que determine o n-ésimo termo da sequência de
Fibonacci.
3.3 – Vetores
Um vetor é um conjunto de variáveis de um mesmo tipo de dado as quais são
acessadas e referenciadas através da aposição de índices ao identificador do vetor.
Um vetor é declarado da seguinte forma:
int Vetor [10]; // vetor com 10 elementos do tipo inteiro.
Vetor [2] = 4; // atribuição de valor a um elemento do vetor por meio da indexação.
OBS.: O índice do primeiro elemento de um vetor é sempre 0 (zero).
33
Pense num ventor como uma gaveta contendo várias pastas, cada pasta é um
elemento que pode receber um determinado valor, é claro que cada gaveta só pode
conter pastas contendo arquivos do mesmo tipo, ou seja, se você declarar um vetor do
tipo inteiro, só poderá amazenar valores do mesmo tipo. Abaixo, um exemplo que
preenche um vetor com números inteiros, checa quantos dos números são maiores ou
iguais a três e quantos são menores.
//Declaração de vetores do tipo inteiro de 5 elementos
int vetor[5];
//Variáveis do tipo inteiro
int qtdMaior = 0;
int qtdMenor = 0;
//Passagem de valores – Preenchendo os valores
for (int i = 0; i < 5; i++)
{
cout << "Digite o elemento numero: " << i << endl;
cin >> vetor[i];
}
//Checagem
for (int i = 0; i < 5; i++)
{
if (vetor[i] >= 3) qtdMaior++;
else qtdMenor++;
}
//Resultado
cout << "Existem " << qtdMaior << " numeros maiores ou igual a 3 e " << qtdMenor << " menores!"
<< endl;
COMENTÁRIOS: Cada elemento do vetor está associado a um índice, no nosso caso, temos um
vetor de 5 elementos, o primeiro elemento tem índice “0”. Na checagem usamos um loop para
percorrer todos os elementos do vetor e verificar, elemento a elemento, quais são maiores ou igual
a três e quais são menores, depois mostramos apenas o resultado de quantos são esses números.
Você saberia mostrar quais são esses números também? (Dica: o mesmo procedimento de
preenchimento pode ser usado, mas nesse caso use o cout para mostrar cada elemento).
34
Exercícios
1. Escreva um programa que exiba as componentes de um vetor na ordem inversa
daquela em que foram armazenadas.
2. Escreva um programa que exiba o maior elemento de um vetor.
3. Escreva um programa que forneça as componentes distintas de um vetor dado.
Por exemplo, se o vetor dado for v = {3, 2, 1, 3, 4, 1, 5, 5, 2}, deve-se obter {3, 2,
1, 4, 5}.
4. Escreva um programa que receba um vetor e o decomponha em dois outros
vetores, um contendo as componentes de ordem ímpar e o outro contendo as
componentes de ordem par.
35
PROBLEMAS – CAPÍTULO 3 1 – Escreva um programa que calcule a média de uma quantidade “n” de alunos determinada pelo usuário. 2 – Escreva um programa que receba uma quantidade “n” de números determinada pelo usuários e diga quantos são os pares e os ímpares dos números recebidos. 3 – Escreva um programa para determinar a idade da pessoa, em anos, meses e dias, dadas a data (dia, mês e ano) do seu nascimento e a data (dia, mês e ano) atual. 4 – Um número inteiro é dito perfeito se o dobro dele é igual à soma de todos os seus divisores. Por exemplo, como os divisores de 6 são 1, 2, 3 e 6 e 1 + 2 + 3 + 6 = 12, 6 é perfeito. A matemática ainda não sabe se a quantidade de números perfeitos é ou não finita. Escreva um programa que liste todos os números perfeitos menores que um inteiro n dado. 5 – A sequência de Fibbonaci é a sequência (1, 1, 2, 3, 5, 8, 13, ...) definida por 1, se n = 1 ou n = 2 an = + , se n > 2 Escreva um programa que determine o n-ésimo termo desta sequência, n dado. 6 – Dada uma seqüência de “n” números reais, determinar os números que compõem a seqüência e o número de vezes que cada um deles ocorre na mesma. (Dica: Use vetores) Exemplo: n = 8 Seqüência: -1.7, 3.0, 0.0, 1.5, 0.0, -1.7, 2.3, -1,7 Saída: -1.7 ocorre 3 vezes 3.0 ocorre 1 vez 0.0 ocorre 2 vezes 1.5 ocorre 1 vez 2.3 ocorre 1 vez
36
REFERÊNCIAS: Aprenda a Programar Programando, EVARISTO, Jaime. Curso Básico de Lógica de Programação, MORAES, Paulo Sérgio de. Slides do professor Dr. Daniel Aloise – UFRN/DCA.