Algoritmos I.E Book

ALGORITMOS I
ENSINO A
DISTÂNCIA
Copyright © 2020 by Editora Faculdade Avantis.
Direitos de publicação reservados à Editora Faculdade
Avantis e ao Centro Universitário Avantis – UNIAVAN.
Av. Marginal Leste, 3600, Bloco 1.
88339-125 – Balneário Camboriú – SC.
editora@avantis.edu.br
Depósito legal na Biblioteca Nacional, conforme Lei nº 10.994, de 14 de dezembro de 2010.
Nenhuma parte pode ser reproduzida, transmitida ou duplicada sem o consentimento

da Editora, por escrito. O Código Penal brasileiro determina, no art. 184, “dos crimes
contra a propriedade intelectual”.
Projeto gráfico e diagramação: Ana Lúcia Dal Pizzol

Editoração: Bruna Jaime Feiden
PLANO DE ESTUDOS
EMENTA
Introdução. Operadores. Comandos Condicionais e Repetitivos. Conceitos preliminares

de Manipulação de Dados. Estruturas de Controle de Fluxo. Vetores e Matrizes.
OBJETIVOS DA DISCIPLINA
• Introduzir os conceitos de projeto e desenvolvimento de algoritmos.

• Desenvolver uma visão crítica e sistemática sobre a resolução de problemas.
• Aprender a solucionar problemas de forma analítica e propor estas soluções de
forma estruturada, e em linguagem algorítmica.
• Modelar e implementar soluções de tecnologia da informação em vários domínios
de aplicação.
• Identificar e projetar soluções de alto nível, realizando estudos de viabilidade com
múltiplos critérios de decisão.
• Debater sobre o que é preciso para empreender, os conhecimentos necessários, os
valores do empreendedor.
• Saber elaborar um plano de negócios e as partes que o compõem.
O PAPEL DA DISCIPLINA NA FORMAÇÃO DO ACADÊMICO
Prezado(a) aluno(a),
Aprender é a grande chave responsável pelo sucesso de qualquer profissional. Neste

caderno de estudos, você terá a oportunidade de escolher os horários de aprendizagem, com
o apoio sempre atento de uma equipe multidisciplinar. Eu terei o prazer e a responsabilidade
de auxiliá-lo nesse processo, através da produção do caderno que servirá como um guia a
vocês. Então, começaremos a entender melhor o que é a programação de computadores!
No desenvolvimento de software, nos variados domínios de aplicação, quanto mais
tarde qualquer erro ou problema for detectado, maior será o custo financeiro para sua
solução e minimização das consequências que ele venha a ocasionar. Desta forma, a
responsabilidade do programador é ainda maior quanto ao projeto e desenvolvimento de
algoritmos, pois sendo bem projetados, não se gastará tempo na sua reescrita, testes, ou
resolvendo problemas futuros.
Considerando que esta disciplina seja o primeiro contato de muitos de vocês com os
ambientes e recursos tecnológicos destinados ao projeto de programas (e, futuramente,
sistemas completos), faz-se necessário que a compreensão e aplicação dos conceitos aqui
apresentados sejam realizadas com comprometimento e diligência.
Existe uma máxima, a qual diz que entender os princípios básicos envolvidos ao
andarmos de bicicleta é fácil! Por outro lado, andar nela, pela primeira vez, é muito mais
complicado. Isto espelha a diferença entre a teoria e a prática, claramente presente,
quando se aprende a programar um computador. Assim, você deve aplicar todos os
conceitos aqui apresentados e vê-los em funcionamento no seu computador.
Falaremos, na primeira unidade, sobre os conceitos de lógica, lógica de programação,
métodos de solução de problemas e algoritmos. Além disso, também apresentaremos os
conceitos fundamentais de variáveis, operadores e operações, sem os quais não é possível
criar programas funcionais. Também apresentaremos as linguagens de programação,
seus princípios fundamentais básicos e sua importância no desenvolvimento de software,
especialmente da Linguagem de Programação C, que será utilizada como ferramenta de
programação para os conceitos deste material.
Na segunda unidade, avançaremos nos recursos de programação e analisaremos como
controlar o fluxo de execução dos nossos algoritmos e programas, através das técnicas
presentes nas linguagens para verificação condicional.
Na terceira unidade, aprofundaremos os recursos de controle de fluxo de execução
em nossos programas, para permitir que partes do nosso código possam ser repetidas,
de acordo com critérios bem definidos, fazendo com que os programas sejam menores e
mais organizados.
Finalmente, na quarta unidade, trataremos de tipos estruturados de dados
homogêneos. Na programação, é muito frequente necessitarmos de tipos de dados (ou
mesmo de objetos) compostos de dados básicos, com variadas naturezas. Esta unidade
mostrará como pode ser realizado na Linguagem C, apresentando a implementação e o
uso de vetores e matrizes dentro da linguagem.
PROFESSOR
APRESENTAÇÃO DO AUTOR
MARCOS CÉSAR CARRARD

Aproveito este espaço para me apresentar, chamo-
me professor Marcos César Carrard. Sou graduado
em Ciências da Computação, pela Universidade de
Passo Fundo/RS (1990) e especialista de Ciências da
Computação, pela Pontifícia Universidade Católica
do RS (1991).
Atualmente, sou professor do Centro
Universitário Avantis (UNIAVAN), nas disciplinas
de programação. Também sou empresário no ramo
de desenvolvimento de software. Tenho experiência
na área de Sistemas de Informação e Ciências da
Computação, principalmente em áreas como: programação, banco de dados, análise e
projeto de sistemas, computação gráfica e processamento de imagens.
Curriculum Lattes:
http://buscatextual.cnpq.br/buscatextual/visualizacv.do?id=K4705963J5
SUMÁRIO
UNIDADE 1 - CONCEITOS INICIAIS DE PROJETO DE ALGORITMOS.. . . . . . . . . . . . . . .11

1 INTRODUÇÃO À UNIDADE......................................................................................................................................12
1.1 ALGORITMOS E PROGRAMAÇÃO.....................................................................................................................13
1.2 LÓGICA.........................................................................................................................................................................14
1.2.1 Lógica de Programação............................................................................................................................................14
1.2.2 Solução de Problemas..............................................................................................................................................16
1.3 ALGORITMOS........................................................................................................................................................... 19
1.3.1 Conceito de Algoritmo................................................................................................................................................19
1.3.2 Representação de Algoritmos............................................................................................................................21
1.4 MANIPULAÇÃO DE DADOS...............................................................................................................................23
1.4.1 Constantes e Variáveis..............................................................................................................................................23
1.4.2 Expressões Aritméticas e seus Operadores...........................................................................................26
1.4.3 Expressões Lógicas e seus Operadores....................................................................................................28
1.5 ALGORITMOS SEQUENCIAIS............................................................................................................................32
1.5.1 Comandos de Entrada e Saída...........................................................................................................................32
1.5.2 Primeiros Algoritmos.................................................................................................................................................34
1.6 LINGUAGEM C........................................................................................................................................................ 38
1.6.1 Conceitos Básicos.........................................................................................................................................................38
1.6.2 Transcrever o Algoritmo para C.........................................................................................................................39
CONSIDERAÇÕES FINAIS........................................................................................................................................ 44
EXERCÍCIO FINAL........................................................................................................................................................ 45
REFERÊNCIAS................................................................................................................................................................ 48
UNIDADE 2 - DESVIO CONDICIONAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .49
INTRODUÇÃO À UNIDADE ..................................................................................................................................... 50
2.1 DESVIO CONDICIONAL........................................................................................................................................51
2.1.1 Seleção Simples...............................................................................................................................................................51
2.1.2 Seleção Dupla.................................................................................................................................................................56
2.1.3 Seleção Aninhada........................................................................................................................................................59
2.1.3 SELEÇÃO MÚLTIPLA......................................................................................................................................................61
EXERCÍCIO FINAL.........................................................................................................................................................67
REFERÊNCIAS..................................................................................................................................................................71
UNIDADE 3 - CONTROLE DE REPETIÇÃO E FLUXO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

INTRODUÇÃO À UNIDADE ......................................................................................................................................74
3.1 CONTROLE DE REPETIÇÃO...............................................................................................................................75
3.2 VARIÁVEIS CONTADORAS.................................................................................................................................76
3.3 REPETIÇÃO COM VARIÁVEL DE CONTROLE...........................................................................................78
3.4 REPETIÇÃO COM TESTE NO INÍCIO........................................................................................................... 84
3.5 REPETIÇÃO COM TESTE NO FINAL............................................................................................................ 89
EXERCÍCIO FINAL........................................................................................................................................................ 95
REFERÊNCIAS................................................................................................................................................................ 99
UNIDADE 4 - VETORES E MATRIZES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .101

4 INTRODUÇÃO À UNIDADE.................................................................................................................................102
4.1 VETORES..................................................................................................................................................................103
4.1.1 Conceitos Básicos.......................................................................................................................................................103
4.1.2 Implementação e Uso.............................................................................................................................................105
4.1.3 Strings........................................................................................................................ 110
4.2 MATRIZES.................................................................................................................................................................111
4.2.1 Conceitos Básicos........................................................................................................................................................111
4.2.2 IMPLEMENTAÇÃO E USO.........................................................................................................................................113
CONSIDERAÇÕES FINAIS........................................................................................................................................118
EXERCÍCIO FINAL........................................................................................................................................................119
REFERÊNCIAS...............................................................................................................................................................122
1
unidade
CONCEITOS INICIAIS
DE PROJETO DE
ALGORITMOS
1 INTRODUÇÃO À UNIDADE
Figura 1 - Programação de Computadores.

Fonte: < https://atn.org.br/como-comecar-a-aprender-programacao-de-computadores/> Acesso em: 10
de setembro de 2019.
Olá! Seja bem-vindo!

Suponha que você tenha recebido de presente um pequeno robô que não sabe fazer
absolutamente nada. Por outro lado, ele tem a capacidade de ser ensinado e, quando
aprende a fazer algo, o faz com muita agilidade e rapidez. Entretanto, ele faz isso sem
ponderar se está certo ou não, pois apenas repete o que você o ensinou a fazer. O que
você ensinaria inicialmente a ele, e como faria isso?
Programar um computador, seja qual for a linguagem escolhida, é exatamente como
transmitir instruções a este robô, chamado computador. Ele é extremamente rápido, mas
apenas repete as instruções que lhe foram dadas por um programador. Se o programador
errar, ele também o fará e produzirá um resultado não desejado.
Nesta unidade, trabalharemos os primeiros temas relacionados à construção de
soluções computacionais para problemas bem conhecidos, ou seja, como devem ser
dadas as instruções ao robô, de forma a produzir a resposta desejada.
Além de ser a maneira correta de transmitirmos instruções a um computador, o
aprendizado de como programar computadores trará outros benefícios ao estudante,
fazendo com que ele mude a sua forma tradicional de abordar problemas e também como
vê as suas soluções. Já que o software (programa) está presente em quase tudo, inclusive
em equipamentos tradicionais, como veículos, eletrodomésticos, telefones e outros, eles
serão usados com maior eficiência, e o estudante estará, ainda, aprendendo a linguagem
12
ALGORITMOS I
de comunicação do futuro.
Para fazermos isso, é necessário entender o que é um algoritmo e suas formas de
representação. O algoritmo dará origem ao programa que todos desejam, mas ele também
tem regras e estrutura própria a serem seguidas no seu projeto.
No encerramento da primeira unidade, veremos como os dados são tratados
nos algoritmos e, por consequência, nos programas. Estes dados são envolvidos em
expressões aritméticas e lógicas, as quais possuem regras de formação, bem como para
sua análise/solução.
Os principais objetivos de aprendizagem desta unidade são:
• compreender os conceitos fundamentais da lógica na solução de problemas;
• conhecer as técnicas de estruturação do pensamento lógico e sua formalização
enquanto algoritmos;
• identificar operadores e operandos envolvidos na construção de algoritmos e sua
aplicação na solução de problemas;
• conhecer e utilizar ferramentas básicas de projeto de software.
1.1 ALGORITMOS E PROGRAMAÇÃO
É bastante comum pensarmos, pelo menos para quem conhece o conceito, que
algoritmo é algo ligado à programação. Na verdade, este conceito é bem mais amplo, e
utilizado de forma inconsciente, do que pensamos. Por exemplo, você já viu uma receita
na cozinha? Ou então, algumas instruções que lhe permitem montar alguma coisa? Pois
é, também são algoritmos. Então, podemos entender, inicialmente, que um algoritmo é
uma sequência de passos que nos levam à solução de um problema.
Por outro lado, o que desejamos é automatizar este processo. Assim, ao descrevermos
as ações que nos levam à solução do problema, devemos sempre pensar de forma
repetitiva, ou seja, que o mesmo possa ser repetido tantas vezes quanto for necessário e,
de forma fundamental, com o mesmo resultado final.
Ainda sobre isso, devemos sempre pensar que estamos transmitindo instruções a
uma máquina, ou seja, um equipamento que não tem capacidade de pensamento e de
raciocínio e, portanto, precisa ser “ensinado” de forma muito objetiva, direta e sem
nenhuma margem para dúvida na execução daquela ação.
13
ALGORITMOS I
1.2 LÓGICA
Nesta seção, será apresentado o conceito de lógica de programação. Mas, antes

de mais nada, o que é “Lógica”? De forma simplista, podemos ver lógica como sendo
a arte de pensar corretamente sobre algo. Assim sendo, a lógica busca colocar o nosso
pensamento em ordem, por exemplo:
1. Sabemos que o objeto que desejamos está dentro do armário;
2. O armário está fechado;
3. Logo, concluímos que precisamos abrir o armário para pegar o objeto!
Observe a premissa 3 logo acima. Nela, fizemos uma inferência (conclusão) sobre duas
outras premissas anteriores que fundamentam (dão base) esta conclusão.
EXERCÍCIO
Considere as seguintes premissas:
1. Rodrigo está inscrito no curso de preparação de motorista de uma
autoescola;
2. Para ser aprovado ele precisa ter 100% de frequência nas aulas teórico-práticas e ter
nota mínima de 80% nos testes;
3. Rodrigo compareceu em todas as aulas e obteve 90% de aproveitamento nos testes.
Então, o que podemos concluir sobre o Rodrigo neste curso?
1.2.1 Lógica de Programação
Já que entendemos a “Lógica” como a arte de organizar o pensamento humano, de

forma racional, sobre algo, qual a ligação deste termo com a programação de computadores
e o desenvolvimento de software? Quando usamos ou aplicamos este pensamento lógico
na solução de um problema e a expressamos de forma organizada, a fim de que a mesma
possa ser repetida sistematicamente, estamos trabalhando com Lógica de Programação.
14
ALGORITMOS I
Assim, entendemos que a lógica de programação é a capacidade que o programador
deve desenvolver para solucionar os problemas que lhe são apresentados. Esta capacidade
implica analisar cuidadosamente cada problema e/ou situação e propor um método
formal que, quando aplicado, conduza à solução correta para o problema.
Eventualmente, caso a dimensão do problema exija, ele ainda pode ser dividido em
partes menores que, ao serem solucionadas individualmente, comporão a solução do
problema integral. Se esse for o caso, a lógica de programação proposta deve, também,
indicar como estas soluções individuais serão combinadas ou agrupadas para formar a
solução total.
Vamos analisar o seguinte problema: dados três valores reais (que pertencem ao
conjunto dos números reais) quaisquer, sua tarefa é determinar se esses valores podem
ser usados para formar um triângulo (serão os possíveis tamanhos dos lados). Como você
poderia fazer para deduzir um caminho que o permitisse determinar se dá ou não para
formar esse triângulo?
Uma solução seria recortar três pedaços de algum material, madeira por exemplo,
com dimensões escolhidas para teste, e experimentar a construção da forma geométrica,
permitindo determinar se aquelas medidas formam ou não um triângulo, mas não
possibilita, pelo menos inicialmente, saber qual seria uma regra geral para resolvermos
o problema.
Por outro lado, ao tomarmos esses pedaços recortados, talvez venhamos a perceber
que, se colocarmos o maior deles sobre a mesa, os outros dois somente formarão um
triângulo caso “fiquem inclinados”, ou seja, que os dois juntos tenham dimensão maior
que o outro lado. Veja:
Figura 2 - Formando triângulos com pedaços de material.

Fonte: Elaborado pelo autor (2020).
Na Figura 2(I), podemos observar que, ao tentarmos formar o triângulo, com lados
medindo 10cm, 8cm e 6cm, os lados azul (8cm) e verde (6cm) precisaram ficar inclinados (foi
aí que o triângulo apareceu!). Já na Figura 2(II), quando colocamos lados com medidas de 5cm
e 4cm, isto não aconteceu, porque os dois juntos não ocupam toda a dimensão do lado 10cm.
15
ALGORITMOS I
Se aplicarmos a lógica, podemos deduzir que sempre que os dois lados menores a
serem testados, somados, forem menores ou iguais ao lado maior, o triângulo não poderá
ser formado. Da mesma forma, caso esta soma seja maior que o outro lado, o triângulo é
possível. Isso é lógica!
Suponha, agora, que você precisa escrever uma “receita” de como essa solução pode ser
obtida por qualquer outra pessoa. Como seria isso? Bem, isso é Lógica de Programação,
e pode ser descrita da seguinte forma (como uma regra):
Você deve tomar as três medidas que deseja testar e separar aquela
que tiver o maior comprimento dentre elas. Depois disso, tome as outras
duas e as some. Caso o valor da soma seja maior do que a medida
separada, é possível formar um triângulo. Se a soma for igual ou menor,
o triângulo não poderá ser formado!
Observe que a solução proposta pode ser repetida quantas vezes desejarmos, e
sempre teremos o resultado correto, desde que a executemos conforme foi proposto. O
que acabamos de propor é o “algoritmo”. O conceito de algoritmo, como veremos depois,
não é exclusivo da área de programação. Ele é apenas uma “receita” para solucionar um
problema, a qual foi formalmente escrita e pode ser repetida, quando desejarmos.
1.2.2 Solução de Problemas

Quando você tem um problema que necessita ser solucionado, qual a abordagem dada
por você na solução do mesmo? Vai tentando, por chute, várias soluções, até encontrar
uma que funcione? E se ela não existir?
Na programação de computadores, precisamos ser mais sistemáticos, quando
buscamos solucionar um problema. Devemos ter em mente que, mais do que a solução,
interessam-nos os caminhos, os quais levaram a ela. É dos caminhos que o algoritmo
nasce, e não da resposta final.
Para resolvermos sistematicamente um problema, é importante termos um método
correto para abordar este problema e construir a solução. É muito comum cada
programador desenvolver gradativamente o seu próprio método, mas, em geral, tais
métodos possuem uma sistemática muito parecida. Eles são divididos em quarto etapas:
1- Compreender o problema: é fundamental que o problema seja compreendido em
sua totalidade. Não podemos propor uma solução correta para algo que não tenhamos
16
ALGORITMOS I
entendido perfeitamente. Para compreender o problema, podemos realizar perguntas
como:
a) Quais são os dados de que dispomos?
b) Existem condições ou restrições para solucionarmos o problema?
c) Quais são as partes importantes do problema e da solução?
d) O que precisamos descobrir ou determinar?
2- Estabelecer um plano: precisamos planejar detalhadamente como vamos solucionar

o problema. Podemos, por exemplo, verificar se há algum problema semelhante que já
tenha sido resolvido. Devemos, também, conferir e garantir que estamos atendendo a
todas as condições e restrições e que todos os dados foram utilizados corretamente.
3- Executar o plano: considere o plano da segunda etapa como um roteiro. Precisamos

garantir que todos os detalhes foram cuidadosamente pensados e que não restem dúvidas
de algum erro ou problema ter sido esquecido. Feito isso, podemos executar com cuidado
o nosso planejamento e buscarmos a solução.
4- Revisar a solução: uma vez obtida a solução, é necessário ter certeza de que se
resolveu o problema de maneira correta. Devemos ter em mente que a obtenção de
uma solução nos aproxima da solução final, mas não a garante. Executando o plano
adequadamente, cabe certificar se o problema foi realmente resolvido e se nenhum erro
ocorreu durante o processo. É preciso questionar:
a) É possível verificarmos o resultado? Ele está correto?
b) Todas as condições e restrições foram obtidas/respeitadas?
c) Existem outras estratégias para solucionar o problema?
Caso tenhamos êxito neste passo, obtivemos um processo que soluciona o nosso
problema. Observe que o modo como vemos o problema pode sofrer alterações durante o
seu processo de solução. No início, temos uma visão incompleta e complicada do mesmo,
mas quando avançamos na análise e planejamento, começamos a compreender melhor o
que necessitamos e quais são as implicações para obtermos a solução.
De forma sintética, podemos propor a seguinte ordem, para tratarmos a solução de
um problema (a sistemática está representada no Quadro 1):
1. Identificar o problema;
2. Analisar as características do problema;
3. Determinar suas causas e efeitos principais;
4. Conceber um plano para eliminar o problema;
17
ALGORITMOS I
5. Executar o plano;
6. Verificar a eficácia da sua ação (executando o plano);Eliminar os problemas e erros;
7. Recapturar as atividades desenvolvidas.
Quadro 1 - Método de Análise e Solução de Problemas
Fonte: < https://blogdaqualidade.com.br/masp-metodo-de-analise-e-solucao-de-problemas-parte-1/.

Acesso em: 12 de setembro de 2019.
PARA PRATICAR
EXERCÍCIO
Você conhece o clássico (e histórico) problema das Torres de Hanói? Neste
problema, baseado em uma lenda, existem três torres iguais e, em uma delas, existem N (pode
ser qualquer número maior ou igual a 3!) torres com tamanhos diferentes. Elas estão colocadas
de tal forma que a maior está embaixo e a menor em cima, conforme o desenho (com cinco
discos):
18
ALGORITMOS I
Sua tarefa é mover todos estes discos da torre 1 para a torre 2, usando a torre 3 como arma-
zenamento temporário. Para realizar a tarefa, você deve respeitar duas regras: deve mover um
disco de cada vez e nunca pode colocar um disco maior sobre um menor.
Analise este problema e descreva uma forma de mover 3 (três) discos da torre 1 para a 2.
1.3 ALGORITMOS
Uma vez que já temos uma ideia básica do que é lógica e, especialmente, lógica de
programação, vamos conhecer o ator principal da tarefa de programação de computadores:
o algoritmo.
1.3.1 Conceito de Algoritmo

Podemos entender que algoritmo é uma sequência de ações, as quais nos levam à
solução de certo problema. No dia a dia, as pessoas usam algoritmos de maneira intuitiva,
sem haver a necessidade de planejar previamente a sequência de passos para a resolução
das tarefas. Por exemplo, considere que você chegou na garagem para pegar o seu carro e:
Surpresa!, ele estava com o pneu furado. O que fazer agora?
Um motorista que deseje trocar o pneu do carro, estabelecerá uma rotina (algoritmo)
muito semelhante a esta:
1. Verificar qual pneu está furado;
2. Pegar as ferramentas (macaco, chaves e outros) no porta-malas;
3. Pegar o pneu estepe;
4. Posicionar o macaco sob o carro, ao lado do pneu que está furado, para levantar o
carro;
19
ALGORITMOS I
5. Soltar os parafusos que prendem o pneu (mas não soltar completamente);
6. Elevar o carro até que o pneu saia do chão e haja espaço para a entrada do pneu
novo;
7. Soltar e remover o restante dos parafusos;
8. Remover o pneu furado e colocar o novo no lugar;
9. Recolocar os parafusos e apertá-los o quanto possível;
10. Descer o carro e retirar o macaco;
11. Apertar novamente os parafusos o máximo possível;
12. Guardar as ferramentas e o pneu furado.

Estas ações constituem um algoritmo que poderia ser repassado para uma pessoa que
nunca trocou um pneu e, com os devidos cuidados, ela conseguiria efetuar a troca.
Formalmente, a definição de um algoritmo é:
Um algoritmo é definido como uma sequência finita de operações

que, quando executadas na ordem estabelecida, atingem um objetivo
determinado em um tempo finito (EDELWEISS,2010).
Com base nesta definição, podemos caracterizar que um algoritmo deve obedecer a
alguns requisitos:
• Todo algoritmo tem um estado inicial em que o problema começa a ser preparado
para a solução;
• Ele consiste em uma sequência lógica e finita de ações que, por definição, devem
ser claras e precisas;
• Ao concluir a tarefa (ou durante ela) ele deve produzir dados de saída e resultados
corretos;
• Ele deve sempre ser finito, ou seja, ter um final previsível.
Por mais que um algoritmo possa estar presente em nossas tarefas diárias, para ser
executado em um computador, faz-se necessário identificar claramente quais serão as
ações que o computador deverá executar.
Devemos compreender que um computador é uma máquina eletrônica, com poucos
recursos no seu nível básico, sendo capaz de realizar operações aritméticas (somar,
subtrair e outras) e operações lógicas (decidir se algo é verdadeiro ou falso). Então, foram
implementadas linguagens de programação, com recursos para colocarmos os algoritmos
em funcionamento, mas que, em nível de máquina, serão traduzidas nestas operações
básicas (SANTOS, 2018).
20
ALGORITMOS I
Como os programas de computadores são um conjunto de instruções, admitidas
naquela linguagem, que devem ser executadas para concluir a tarefa, nossos algoritmos
também serão um conjunto de passos que foram projetados, com o foco de serem
transformados em um futuro programa.
FIQUE ATENTO
Um algoritmo também pode ser definido como uma sequência de passos que
visam atingir um objetivo definido previamente.
PARA PRATICAR
EXERCÍCIO
Suponha que você realizou três avaliações em uma disciplina qualquer. Com
base nestas avaliações, você precisa calcular sua média final (aritmética). Você será aprovado
na disciplina se sua média for igual ou superior a 7,0. Escreva, ou descreva, os passos necessá-
rios para resolver este problema.
1.3.2 Representação de Algoritmos
Um algoritmo pode ser representado de várias formas diferentes, estando todas

corretas. Em especial, vamos encontrar algoritmos descritos nos seguintes formatos:
Descrição narrativa: nela, fazemos uso de uma linguagem natural (português,
por exemplo) para especificar os passos necessários à realização da tarefa. Isso dá,
normalmente, margem a interpretações errôneas e ambíguas. Por exemplo:

“Para calcular a área de um triângulo, você deve possuir as medidas
da sua base e da altura do triângulo. Possuindo essas medidas e elas
sendo maiores do que zero, você deve calcular a área multiplicando a
medida da base pela altura e dividindo o resultado por dois”.
Fluxograma: é uma forma gráfica de representação que utiliza figuras e formas

geométricas para ilustrar os passos a serem seguidos na solução do problema. Por
21
ALGORITMOS I
exemplo:
Figura 3 - Fluxograma.
Pseudocódigo: esta é a forma mais usual de escrevermos os algoritmos, quando

somos iniciantes. Utiliza-se uma linguagem própria e estrutura que se assemelha muito
com uma linguagem de programação, facilitando a descrição futura em um programa.
Por exemplo, para calcularmos a área de um círculo:
Algoritmo AreaCirculo
variável
area, raio: reais
início
ler (raio);
area = raio * raio * 3.14
escrever (“Área = “, area)
fim
Neste material, iniciaremos o projeto dos nossos algoritmos como um pseudocódigo

e, posteriormente, faremos uso da Linguagem de Programa C (PEREIRA, 2018) para a
solução dos problemas.
Em nosso pseudocódigo, um algoritmo será dividido em três partes distintas:

Nome do algoritmo
Declaração das variáveis
Corpo do algoritmo
22
ALGORITMOS I
Na primeira parte, nomearemos nosso algoritmo para identificá-lo, bem como a
tarefa que ele soluciona. Assim, devemos dar um nome significativo para ele: Algoritmo
AreaCirculo é melhor do que chamá-lo, por exemplo, Algoritmo Exercicio1.
Na parte seguinte, vamos declarar as variáveis que estarão envolvidas na solução deste
problema. Fique tranquilo, pois será o assunto da próxima seção deste material.
Finalmente, vem o corpo do algoritmo, começando na palavra “inicio” e terminando
em “fim”. Entre estas duas palavras, devem estar descritas as ações ou comandos que
levam à solução do problema. Perceba que as ações devem ser executadas na ordem que
aparecem, sequencialmente.
Os comandos e recursos possíveis de serem utilizados no corpo do algoritmo serão
objeto deste material, ou seja, iremos gradativamente descobrir que recursos podemos
usar na solução de um problema.
1.4 MANIPULAÇÃO DE DADOS
1.4.1 Constantes e Variáveis

Um programa de computador e, por consequência, um algoritmo fazem uso de dados
que serão (ou poderão ser), via programação, transformados em informação.
Dados são números, medidas ou valores que, sozinhos, transmitem pouco ou nenhum
conhecimento sobre ele. Por exemplo, 182 é um dado. Informação é quando o dado passa
a transmitir uma mensagem, ou seja, ganha significado. Por exemplo, ao dizermos que o
valor 182 representa a altura de uma pessoa, em centímetros.
Uma vez que nossos algoritmos manipulam dados e informações, precisamos definir
como isto acontece. Inicialmente, devemos saber que os dados (vamos chamá-los
somente de dados para simplificar!) serão armazenados na memória do computador.
Esta memória é um espaço interno do computador, onde coisas podem ser armazenadas
e recuperadas posteriormente, quando houver necessidade. Por simplicidade, vamos
entender que a memória é um grande arranjo matricial (organizado em linhas e colunas)
no qual cada posição pode guardar um dado de certo tipo ou natureza. Por exemplo,
podemos ter, na 4a linha e 3a coluna desta memória, o nosso dado da altura.
23
ALGORITMOS I
Figura 4 – Dado da altura
182
SAIBA MAIS
Memória de um computador é um meio físico para armazenar dados, temporá-
ria ou permanentemente. Para saber mais, consulte TANENBAUM, 2013.

Podemos entender, então, que dados são os recursos, os quais entregamos ao
algoritmo, para que ele realize a tarefa. Por exemplo, para executar o cálculo da área do
triângulo, nosso algoritmo precisa conhecer a base e a altura. Com isso, ele produzirá um
novo dado (ou informação) que é o resultado da área.
Os dados, que são armazenados na memória, chamam-se, em programação, de
variáveis. Este nome vem do fato de que, durante a execução do algoritmo, os dados
podem mudar de valor. Assim, variáveis são nomes atribuídos às posições de memória,
de forma que possamos usá-las em nosso algoritmo. Por exemplo, podemos nomear duas
posições de memória como “base” e como “altura” e, nelas, armazenarmos as medidas da
base e da altura do nosso triângulo:
base = 12
altura = 18
Com esses comandos, nosso algoritmo irá guardar nas posições de memória base e
altura os valores 12 e 18. Podemos, também, ter uma posição de memória, nomeada de
“area” e, para ela, atribuirmos:
area = (base * altura) / 2
Assim, na posição “area”, o valor armazenado será igual a 108, que representa a área
do nosso triângulo. Observe a Figura 4, para a visualização deste exemplo.
24
ALGORITMOS I
Figura 5 - Variáveis em memória.
Cada vez que utilizamos uma variável em um algoritmo ou programa, devemos

declará-la antes do seu uso. No pseudocódigo, virá logo após o nome do algoritmo.
Quando realizarmos esta declaração, devemos informar ao computador o espaço de
memória que ocuparemos para guardar esta variável, o que se faz ao definir o tipo de
dado que será usado.
Os tipos de dados, os quais estarão disponíveis para o uso, dependem da linguagem
e ambiente de programação que estivermos usando. Em nosso caso, as possibilidades
iniciais são:
1. Inteiro: dados destinados ao armazenamento de números inteiros, sem casas
decimais, positivos ou negativos.
2. Real: dados destinados aos números reais, com casas decimais, positivos ou
negativos.
3. Caractere: dados destinados ao armazenamento de um único caractere. Os
caracteres são as letras A..Z (minúsculas ou maiúsculas), dígitos 0..9 e símbolos
como, por exemplo, +, &, # e outros.
Toda variável possui um nome definido pelo programador. Para nomear uma variável,
podemos usar letras minúsculas ou maiúsculas e números. O nome de uma variável
não pode ter espaços e nem acentuação. Ele deve sempre iniciar com uma letra, sendo
fortemente recomendado que haja relação com a sua função em nosso algoritmo. Por
exemplo, dadas as variáveis:
salario_base nomeFuncionario altura
Por definição, devemos sempre assumir que, ao declaramos uma variável, não
sabemos qual será o valor presente na memória naquele momento. Assim, as variáveis
devem sempre ser inicializadas (receber um valor inicial) antes do seu uso:
base = 12
25
ALGORITMOS I
Observe o papel do operador = (igual) presente neste tipo de ação. Ele tem a função
de tomar o valor que está à direita (12) e armazená-lo na posição de memória chamada
“base”, ou seja, ele faz uma atribuição.
Além das variáveis, nossos algoritmos contêm constantes, que são valores utilizados
em nossas expressões e que não serão alterados em nenhum momento. Por exemplo:
area = (base * altura) / 2 ou area = raio * raio * 3.14
Nestes dois casos temos constantes. No primeiro cálculo, 2 é um valor constante,

enquanto no segundo é 3.14.
1.4.2 Expressões Aritméticas e seus Operadores

Para construirmos a resolução de um problema, necessitamos, com frequência,
escrever comandos que representarão operações aritméticas, as quais devem ser escritas
de um modo que sejam corretamente compreendidas pelo computador ou por quem
estiver analisando o seu algoritmo/programa. Cada linguagem de programação tem
regras muito claras sobre o que é permitido nestas expressões.
Em nosso pseudocódigo (e na Linguagem C), nossas expressões aritméticas são
definidas como:
<variável/constante> <operador> <variável/constante>
Neste material, definiremos como <operador> os símbolos das operações matemáticas

tradicionais, com pequenas diferenças/novidades:
Quadro 2 – Operador e Operações Matemáticas Tradicionais

Operador Significado
+ Soma
- Subtração
* Multiplicação
/ Divisão
^ Potência
% Resto da divisão (possível apenas para dados do tipo inteiro)
26
ALGORITMOS I
Essas expressões devem ser escritas em uma única linha, e os operadores respeitam
a ordem de resolução tradicional da matemática: em primeiro lugar, serão solucionadas
as potências, depois as multiplicações e divisões e, no final, as somas e subtrações. No
caso de operações com a mesma precedência, a solução será sempre da esquerda para a
direita.
Para alterar a ordem de solução das operações em uma expressão, podemos utilizar
os parênteses. Observe que, em algoritmos e programação, diferente da matemática
tradicional, usamos apenas parênteses, em quantos níveis forem necessários. Os
colchetes e as chaves têm outra função em programação, e não podem ser usados neste
caso.
DICA
Tome cuidado: cada parêntese que for aberto em uma expressão deverá ter
seu correspondente de fechamento, pois a falta da abertura ou fechamento de um
parêntese causará um erro em nosso programa.
Observe, a seguir, algumas expressões válidas em nossos algoritmos:
a+1
b * 2 + 3.14
peso / altura * altura
b*b–4*a*c
(a + 5) / ((b – 2) *(a – b + c)
Expressões mais complexas devem ser apresentadas sempre em uma linha única (ou
divididas em vários cálculos mais básicos). Por exemplo, considere a fórmula da soma
dos termos de uma progressão geométrica:
Ela deveria ser descrita em uma expressão, como:
S = a1 * (q ^ n - 1) / (q - 1)
27
ALGORITMOS I
Com essas expressões, podemos resolver boa parte dos problemas, mas existem
situações em que elas não são suficientes. Por exemplo, se precisarmos calcular
uma raiz ou uma função matemática, como seno ou cosseno, o que faremos? Neste
caso, as linguagens de programação oferecem um conjunto de funções previamente
implementadas que podemos usar em nossos programas.
PARA PRATICAR
EXERCÍCIO
Determine o valor final das seguintes expressões aritméticas:
a) (3 * (5 + 6)) = ________
b) 9 + 9 * 2 – 14 % 5 = ___________
c) 4 + ((10 / 2) * 4) = _______
d) 125 / 3 % 7 + 3 * 5 – 4 = _________
e) 25 / 2 % 3 * 2 + 49 = _________
1.4.3 Expressões Lógicas e seus Operadores

Uma expressão lógica segue princípios parecidos com os das operações matemáticas,
mas é avaliada sempre como verdade (true) ou falsa (false) no seu resultado final.
Uma expressão lógica pode ser unária (ter um único operando) ou binária (ter dois operandos
ou sinal relacional). Vamos considerar a seguinte representação para nossos operados desta
natureza: se for verdade, seu valor será 1 ou V; sendo falso, seu valor será O ou F.

a) Operação Unária
A única operação unária possível é a negação. Com ela, negamos ou invertemos o valor
de um operador. Ela é representada por um ~(til) ou !(exclamação). Considere a seguinte
tabela verdade:
A ~A
F V
V F
28
ALGORITMOS I
Um operador de negação será sempre resolvido em primeiro lugar na expressão, a
menos que existam parênteses, indicando uma ordem diferente.
b) Operação Binária
As operações lógicas binárias são o OR (ou) e o AND (e). Quando estes operadores
estiverem presentes em uma expressão, entre dois operandos lógicos (que são V/F),
devemos aplicar as seguintes tabelas verdade:
A B AeB A B A ou B
F F F F F F
F V F F V V
V F F V F V
V V V V V V
Observe que uma expressão com o operador AND ou E será verdadeira, apenas se
ambos os operandos forem verdadeiros. No OR ou OU, ela será falsa, apenas se ambos os
operandos forem falsos.
Podemos usar parênteses nas expressões lógicas com AND e OR. Caso eles não existam,
o operador AND tem prioridade sobre o OR e será resolvido primeiro.
Na Linguagem C, a qual usaremos em nossos programas, o operador OR é representado
pelo sinal || (duas barras verificais lado a lado) e o AND pelo sinal && (dois “e” comercial,
lado a lado).
c) Sinal Relacional
Um sinal relacional poderá ser utilizado entre dois operandos não lógicos (variáveis,
constantes e expressões) e terá sempre como resultado um valor lógico de verdadeiro ou
falso.
Quadro 3 - Sinais Relacionais

Sinal Significado
== Igualdade
!= Diferente (negação da igualdade)
> Maior
>= Maior ou igual
< Menor
29
ALGORITMOS I
<= Menor ou igual
Fonte: Elaborado pelo autor (2020).Delacionaissinais eno, o que faz0).

Com esses sinais, podemos escrever expressões como:
idade > 18
altura == 182
(b * b – 4 * a * c) >= 0
Nas expressões acima, existem variáveis e constantes, e o resultado final será sempre
TRUE ou FALSE. Por exemplo, na primeira expressão, se a variável idade contiver um valor
como 25, o resultado da expressão será TRUE, pois 25 é maior do que 18. Já se o valor da
idade for 12, o resultado final será FALSE.
Com esses operadores e sinais, vamos escrever expressões combinadas que serão
avaliadas pelo computador e julgadas como verdadeiras ou falsas. Como exemplo, vamos
considerar a existência das variáveis aux e letra contendo, respectivamente, os valores 10
e ‘A’. Qual seria, então, o resultado das expressões:
a) (aux >= 10) or (letra == ‘A’)

Analisando a expressão por partes, verificamos que a primeira condição (aux >=
10) é verdade, pois aux vale 10. Também a segunda condição (letra == ‘A’) é verdade.
Assim, a avaliação final é um or entre duas verdades. Olhando a tabela verdade anterior,
verificamos que o resultado final é TRUE.
(aux >= 10) or (letra == ‘A’)

true or true
true
b) (aux > 30) or (50 != 100/3) and (aux % 2 > 0)

Aqui, a primeira condição de teste (aux >30) é falsa, visto que o valor de aux é menor
que trinta. O segundo teste, 50 ser diferente de 100/3 (aproximadamente 33,33), é verdade.
Finalmente, o resto da divisão de aux por 2 é igual a zero (ele é par!). Então, esta condição
é falsa. A análise completa é (observe que o operador AND será resolvido primeiro):
(aux > 30) or (50 != 100/3) and (aux % 2 > 0)
true or true and false
true or false
true
30
ALGORITMOS I
c) (letra == “B”) and (27/3 == 9) or (aux <= 300/100)
Aqui, temos uma falsidade (letra igual a B), uma verdade (27/3 é igual a 9) e uma
falsidade, pois o valor de aux é maior que 3 (300/100). Assim, a expressão é:
(letra == “B”) and (27/3 == 9) or (aux >= 300/100)

false and true or false
false or false
false
PARA PRATICAR
EXERCÍCIO
Defina se o resultado final das expressões abaixo é true ou false:
a) 10 % 5 != 40 / 8.0
b) 127 % 40 >= 5
c) 25 / 2 % 3 * 2 + 40 <= 40
d) 9/3 != 3 h) true ||true && true
e) true && true && false ||!false
f) true || true ||false && true
g) true ||true && false
SAIBA MAIS
O Instituto de Matemática e Estatística da USP mantém uma página no ar com
a explicação dos operadores e operações lógicas. Nesta página, é possível fazer
simulações com os operadores lógicos e observar o resultado das expressões. Para mais infor-
mações, acesse: https://panda.ime.usp.br/cc110/static/cc110/02-booleanos.html. Acesso em: 12
de outubro de 2019.
31
ALGORITMOS I
1.5 ALGORITMOS SEQUENCIAIS
1.5.1 Comandos de Entrada e Saída

Todos os algoritmos devem produzir uma saída, contendo o resultado final da tarefa
que eles se propõem a solucionar. Por outro lado, a maioria deles também necessita de
dados de entrada, os quais podem, sempre que necessário, ser solicitados aos usuários
(pessoa que executará o algoritmo ou programa).
a) Comando de entrada de dados

Através do comando de entrada de dados, podemos solicitar ao usuário que digite,
por meio de um dispositivo de entrada (embora a origem não seja relevante ainda), os
valores das variáveis de trabalho do algoritmo. Estes valores serão lidos do dispositivo
(teclado, por exemplo) e armazenados na memória, justamente na posição indicada pela
variável que foi utilizada. Assim, sua sintaxe implica que, além do comando de leitura
(LER), devemos informar quais serão as variáveis a serem lidas.
Em nossa pseudolinguagem, a palavra-chave para a escrita do algoritmo, quando
desejamos ler um valor, é o comando LER, expresso como segue:
ler ( lista de variáveis separadas por vírgula )

Por exemplo, podemos escrever:
ler (altura)
Caso desejemos que o usuário digite, via dispositivo de entrada, um valor que será
armazenado na variável altura e, logo após a leitura, esteja disponível para uso em outras
expressões.
Se escrevermos:
ler( a, b, c )
Estaremos definindo que: serão recebidos 3 valores, via entrada, e serão atribuídos
às variáveis a, b e c, na ordem em que forem digitados. Vamos supor que estes sejam os
coeficientes de uma equação do segundo grau, e o usuário digitou:
32
ALGORITMOS I
C:\> 1, -7, 5
Se for o caso, após a leitura, ‘a’ valerá 1, ‘b’ valerá -7 e ‘c’ terá 5 como valor. Isso é
equivalente a escrevermos no algoritmo a=1, b=-7 e c=5, mas é mais genérico, pois permite
que possamos testar vários valores diferentes a cada execução do nosso algoritmo ou
programa.
b) Comando de saída de dados
O comando de saída de dados é utilizado para transferir dados e informações do

algoritmo ou da memória para um dispositivo de saída, como o monitor de vídeo ou
impressora, por exemplo.
De forma análoga ao comando de entrada de dados, vamos denominar este comando
como ESCREVER, e sua sintaxe será:
escrever( texto entre aspas )

ou
escrever ( lista de variáveis separadas por vírgula )
ou
escrever( texto entre aspas, variável, outro texto, outra variável, ….)
Podemos, então, apresentar os resultados finais do nosso algoritmo através deste comando.
Por exemplo, após o cálculo da área do triângulo que usamos como exemplo anterior:
escrever( “A área do triângulo é: “, area )
Observe que o texto entre aspas se apresenta de forma literal, ou seja, como estiver
escrito. Já fora das aspas, e separado por vírgula, existe uma variável e ali deve ser escrito
o nome dela, exatamente como foi declarado na primeira parte do algoritmo.
Caso seja necessário, podemos mostrar várias variáveis, com texto ou não. Por exemplo,
considere os coeficientes da equação que foram lidos acima. Podemos apresentá-los como:
escrever( a, b, c )
ou
escrever( “A=”, a, “B=”, b, “C=”, c );
Supondo, então, os valores lidos acima ( a=1, b=-7 e c=5), o resultado de cada uma das
linhas seria:
33
ALGORITMOS I
XX> 1 -7 5
XX> A=1 B=-7 C=5
Perceba, na segunda linha, a importância de transmitirmos a maior quantidade de
informação possível (ou necessária) ao usuário que estiver executando o programa. O
segundo resultado é muito mais legível e compreensível do que o primeiro.
1.5.2 Primeiros Algoritmos
Uma vez que já possuímos conhecimento sobre os elementos básicos da escrita de um

algoritmo, podemos começar a escrever os nossos algoritmos.
Problema 1: Calculando a média final.
Como primeiro problema a ser resolvido, vamos escrever um algoritmo que recebe as
três notas de um aluno em uma disciplina e apresenta a sua média final.
Para escrevermos esse algoritmo, precisamos, em primeiro lugar, definir quais serão
as variáveis necessárias ao algoritmo e quais os seus tipos. Neste caso, necessitaremos
de uma variável para armazenar cada uma das notas e outra para a média final. Todas as
variáveis devem ser reais, uma vez que as notas e a média podem conter casas decimais.
Definido isso, podemos finalmente escrever o primeiro algoritmo:
Quadro 4 - Algoritmo 1: Cálculo da Média em uma Disciplina
1 Algoritmo MediaFinal
2 Variável
3 nota1, nota2, nota3: real
4 media: real
5 início
6 escrever( “Digite três notas: “)
7 ler( nota1, nota2, nota3 )
8 media = (nota1 + nota2 + nota3 ) / 3
9 escrever( “Sua média é: “, media )
10 fim
As linhas do nosso algoritmo foram numeradas, apenas para facilitar a análise e

comentários. A linha 1 define o nome do algoritmo, aqui chamado de MediaFinal (assim
mesmo, tudo junto!).
Logo após, a linha 2 define que aparecerão, na sequência, as variáveis a serem utilizadas.
34
ALGORITMOS I
No nosso caso, são quatro variáveis reais, chamadas de “nota1”, “nota2”, “nota3” (linha
3) e “media” (linha 4). As variáveis de um mesmo tipo podem estar em uma mesma linha.
Assim, não haveria a necessidade de colocarmos “media” em uma linha separada.
Entre as linhas 5 (início) e 10 (fim) estarão os comandos do nosso algoritmo que
efetivamente resolvem o problema proposto. Na linha 6, é dada uma mensagem no
monitor, informando ao usuário que estão sendo aguardados três valores. Na linha 7, os
valores serão lidos e atribuídos às respectivas variáveis (o primeiro vai para “nota1”, o
segundo para “nota2” e o terceiro para “nota3”).
Finalmente, após a linha 7, já possuímos valores em nossas variáveis e podemos
proceder ao cálculo da média. Observe que, na linha 8, há uma expressão aritmética do
lado direito da igualdade, a qual será avaliada (ou calculada) primeiro, cujo resultado
será, então, atribuído à variável “media”. Para terminarmos o algoritmo, apresentamos,
na linha 9, na tela do usuário, o resultado do nosso cálculo.
Vamos supor, a título de exemplo, que o usuário digite os valores 7, 8 e 8 para as notas.
O resultado em tela seria próximo deste:
Digite três notas: 7, 8, 8
Sua média é: 7.666666
Problema 2: Comprimento (da circunferência) e área do círculo.
Neste problema, devemos determinar qual é a área de um círculo, e o comprimento da
circunferência que o define. Para isso, se verificarmos as fórmulas, vamos constatar que
precisamos do valor do raio deste círculo. Assim, podemos afirmar que trabalharemos
com as variáveis “raio”, “area” e “comp”.
O cálculo do comprimento da circunferência é C = 2piR e da área A=piR2. Assim,
podemos projetar o seguinte algoritmo:
Quadro 5 - :CC
1 Algoritmo Circulo
2 Variável
3 raio: real
4 area, comp: real
5 início
6 escrever( “Qual o raio do círculo? “)
7 ler( raio )
8 comp = 2 * 3.14 * raio
9 area = 3.14 * raio * raio
10 escrever( “Comprimento = “, comp )
11 escrever( “Área = “, area )
12 fim
35
ALGORITMOS I
Neste algoritmo, o usuário digitará um valor para o raio (linha 7) e, com ele, realizará
o cálculo do comprimento da circunferência (linha 8) e da área do círculo (linha 9), de
acordo com as fórmulas. Os resultados serão apresentados nas linhas 10 e 11.
Supondo um raio de 10 cm, o resultado seria apresentado assim:
Qual o raio do círculo? 10

Comprimento = 62.8
Área = 314
Problema 3: Combustível necessário para uma viagem.

Neste problema, vamos descobrir qual a quantidade de combustível necessária para
realizar certa viagem. Este cálculo depende de dois fatores: a distância a ser percorrida
e o consumo médio do carro da pessoa, os quais, além do cálculo do combustível, serão
as variáveis necessárias. Vamos tratar a distância como um número inteiro, e as demais
variáveis como reais.
O resultado final é dado pela divisão da distância percorrida pelo consumo médio do
veículo. O algoritmo seria:
Quadro 6 - Algoritmo 3: Consumo de Combustível

1
Algoritmo Combustível
2
Variável
3
distancia: inteiro
4
consumo, resultado: real
5
início
6
escrever( “Qual a distância a ser percorrida? “)
7
ler( distancia )
8
escrever( “Qual a média de consumo do carro? “)
9
ler( consumo )
10
resultado = distancia / consumo
11
escrever( “Serão necessários “, resultado, “ litros de combustível” )
fim
12

Neste algoritmo, as variáveis que serão lidas do usuário são “distancia” (linha 7) e
consumo (linha 9). O cálculo da necessidade de combustível é realizado na linha 10 e
armazenado na variável “resultado”, que será apresentada ao usuário na linha 11.
Supondo um veículo que faz, em média, 15 km/litro, cujo motorista deseja
percorrer 450km. O resultado seria:
36
ALGORITMOS I
Qual a distância a ser percorrida? 450
Qual a média de consumo do carro? 15
Serão necessários 30 litros de combustível
Podemos, inclusive, aprimorar nosso algoritmo, dando mais informações ao usuário.

Se solicitarmos também o preço do combustível a ser utilizado (mais uma variável),
podemos calcular o gasto da viagem. Veja:
Quadro 7 - :C
1 Algoritmo Combustivel2
2 Variável
3 distancia: inteiro
4 consumo, preco, resultado, gasto: real
5 início
6 escrever( “Qual a distância a ser percorrida? “)
7 ler( distancia )
8 escrever( “Qual a média de consumo do carro? “)
9 ler( consumo )
10 escrever( “Qual a valor do litro do combustível? “)
11 ler( preco )
12 resultado = distancia / consumo
13 gasto = resultado * preco
14 escrever( “Serão necessários “, resultado, “ litros de combustível” )
15 escrever( “Você irá gastar R$ “, gasto )
16 fim
Repetindo o teste acima:
Qual a distância a ser percorrida? 450

Qual a média de consumo do carro? 15
Qual a valor do litro do combustível? 3.99
Serão necessários 30 litros de combustível
Você irá gastar R$ 119.70
PARA PRATICAR
EXERCÍCIOS
1- Escreva um algoritmo que calcula e apresenta a área de um trapézio.
2- Escreva um algoritmo que solicita ao usuário o salário de uma pessoa e um aumento (por-
centagem) a ser aplicado nele. No final, apresente o salário original, o aumento e o novo salário,
37
ALGORITMOS I
separadamente.
3- Escreva um algoritmo que solicita dois valores inteiros (a e b) ao usuário e apresenta a
soma (a + b), subtração (a – b), produto (a * b), quociente (a / b) e o resto da divisão (a % b)
entre eles.
FÓRUM
Após construir seus algoritmos para os exercícios acima, acesse o sistema da
UNIAVAN e publique suas respostas no fórum de discussão, para que você e seus
colegas possam debater sobre as soluções construídas.
SUGESTÃO DE LIVRO
Este livro, presente nas referências, apresenta os con-
ceitos introdutórios dos algoritmos e traz vários exemplos
de algoritmos, desenvolvidos passo a passo pelos seus autores Nina
Edelweiss e Maria Aparecida Livi. Ele foi publicado pela Editora Bookamn,
em 2014.
1.6 LINGUAGEM C
1.6.1 Conceitos Básicos

Uma das linguagens de programação mais populares no mundo é a Linguagem C, a
qual foi criada por Dennis Ritchie, nos laboratórios da Bell Telephone, em 1972. Ela é
uma linguagem de propósito geral e procedural que necessita ser compilada, para que o
programa a execute. Compilar é o processo feito por um software (chamado de compilador)
que traduz a linguagem escrita pelo programador (usando C) para a linguagem de máquina
(compreensível pelo computador), conforme apresenta a Figura 6 abaixo.
O processo de compilação ocorre, quando um programa, escrito em certa linguagem,
é verificado quanto a erros de programação e, caso tudo esteja correto, ele é reescrito em
uma linguagem de máquina, que pode ser interpretada diretamente pelo computador
(PINHEIRO, 2012).
38
ALGORITMOS I
Seus pontos fortes vêm do fato de ser compilada, bem como ser capaz de fornecer
acesso pleno, caso necessário, aos recursos do computador, inclusive ao hardware.
Figura 6 - Processo de compilação de um programa.

Fonte: Projeto de linguagens de Programação, disponível em: https://slideplayer.com.br/sli-
de/3214993/. Acesso em: Outubro/2019.
Na linguagem C, os programas são organizados em uma estrutura que contém os

seguintes elementos:
Inclusão de bibliotecas e arquivos de suporte
Definição das constantes e variáveis globais do programa
Funções definidas pelo usuário
Programa principal (ponto obrigatório de entrada no programa)
Essas partes do corpo de um programa são descritas de acordo com a necessidade, e

elas não são obrigatórias, exceto a última delas, que define o local de início da execução
do programa.
No anexo I, você pode observar os tipos de dados e os operadores lógicos da Linguagem
C. Eles são levemente diferentes dos tipos que usamos até o momento. No anexo, você
também encontrará detalhes sobre a IDE (ambiente) de programação que usaremos para
compilar os nossos programas.

1.6.2 Transcrever o Algoritmo para C
Para transcrevermos nossos algoritmos para a Linguagem C, devemos apenas observar

a sintaxe da linguagem e escrever os elementos e comandos, conforme ela estabelece.
39
ALGORITMOS I
Em especial, devemos tomar cuidado com os comandos de leitura e escrita de dados que,
em C, chamam-se scanf (ler) e printf (escrever).
Na secção 1.4.2, escrevemos vários algoritmos, a título de exemplo de como fazê-lo.
Vamos, agora, transcrever estes algoritmos para a Linguagem C, e vê-los executar em um
computador.
Quadro 8 - Programa 1: Cálculo da Média em uma Disciplina

1 #include <stdio.h>
2 #include <locale.h>
3
4 int main(){
5 setlocale( LC_ALL, “Portuguese” );
6 float nota1, nota2, nota3;
7 float media;
8
9 printf( “Digite três notas: “ );
10 scanf( “%f, %f, %f”, &nota1, &nota2, &nota3 );
11 media = (nota1 + nota2 + nota3 ) / 3;
12 printf( “Sua média é: %f”, media );
13 return 0;
14 }
Naturalmente, este programa trouxe novos elementos ao nosso algoritmo. Analisando

por linhas, vamos detalhar o seu funcionamento. Nas linhas 1 e 2 foram incluídas duas
bibliotecas que nos permitem usar recursos necessários da linguagem. A biblioteca
<stdio.h> nos permite usar os comandos (funções) de leitura e escrita, ou seja, o scanf e
printf presentes no código. A não inclusão da biblioteca causará um erro de compilação,
e o programa não funcionará.
A biblioteca <locale.h> é opcional, mas é com ela que podemos definir que estamos
trabalhando com a língua portuguesa (linha 5), o que permite usarmos acentuação nos
nossos textos. Se não incluirmos esta biblioteca e não definirmos o setlocale da linha 5,
os acentos e caracteres especiais aparecerão como símbolos estranhos na tela.
Nosso programa principal está presente na linha 4, e vai da { (abre chave) presente nesta
linha até o final, na linha 14, (fecha chaves). Observe que em C, nossos marcadores início e
fim do algoritmo são substituídos por chaves. Toda a chave aberta deve necessariamente
ter o seu fechamento, sob pena do programa não compilar.
Outro detalhe importante e relevante é o fato de que toda linha de programação (entre as
linhas 5 e 13, inclusive), onde estão os comandos, devem, necessariamente, ser finalizadas
com um ; (ponto e vírgula). Esquecer esta pontuação também causa erros de compilação.
40
ALGORITMOS I
Na linguagem C, as variáveis são declaradas dentro do código do programa. Isso está
presente nas linhas 6 e 7. O tipo de dado float é equivalente ao nosso real dos algoritmos,
conforme você encontra detalhado no Anexo I.
Os comandos de escrita e leitura chamam-se scanf e printf em C. Sua sintaxe é
muito parecida com aquela do algoritmo, exceto pelo fato de precisarmos indicar o
tipo de variável que será lida ou escrita. Isso é feito através do marcado %f, indicando
que estamos trabalhando com uma variável do tipo float. Se fossem variáveis inteiras,
deveríamos usar um %d e para caracteres %c (veja Anexo I). Atenção: no scanf, cada
variável que será lida deverá ter o símbolo & em frente ao seu nome.
No final dos nossos programas, como está na linha 13, vamos colocar um comando
return 0; indicando que o programa finalizou corretamente. Na unidade que tratarmos
de modularização, o assunto voltará à discussão, para ter o motivo deste comando
esclarecido.
Finalmente, observe que o nome do algoritmo não aparece em nenhum lugar do nosso
programa. Ele deve ser usado como nome do arquivo que vamos salvar em disco com o
programa. Por exemplo, no caso, o arquivo se chamará mediafinal.c.

Problema 2: Comprimento (da circunferência) e área do círculo.
O algoritmo que calcula a área do círculo e comprimento da circunferência, escrito em
C, será representado como:
Quadro 9 - Programa 2: Área e Comprimento do Círculo

3
4 int main(){
6 float raio, area, comp;
7
8 printf( “Qual o raio do círculo? “ );
9 scanf( “%f”, &raio );
10 comp = 2 * 3.14 * raio;
11 area = 3.14 * raio * raio;
12 printf( “Comprimento = %f”, comp );
13 printf( “ Área = %f”, area );
14 return 0;
15 }
41
ALGORITMOS I
Problema 3: Combustível necessário para uma viagem.
Os algoritmos 3 e 4 representaram duas versões de solução deste problema. Ambos
algoritmos, escritos em Linguagem C, são expressos, como segue:
Quadro 10 - Programa 3: Consumo de Combustível

1
#include <stdio.h>
2
#include <locale.h>
3
4
int main(){
5
setlocale( LC_ALL, “Portuguese” );
6
int distancia;
7
float consumo, resultado;
8

9
printf( “Qual a distância a ser percorrida? “ );
10
scanf( “%d”, &distancia );
11
printf( “Qual a média de consumo do carro? “ );
12
scanf( “%f”, &consumo );
13
resultado = distancia / consumo;
14
printf( “Serão necessários %f litros de combustível”, resultado );
15
return 0;
}
16
Neste programa, algumas linhas merecem observação. Na linha 6, estamos usando

uma palavra-chave nova int. Esta é a declaração de um dado do tipo inteiro. Em função
disso, outra mudança necessária ocorreu na linha 10, onde o %f foi trocado para um %d,
indicando que estamos lendo uma variável inteira.
Outro ponto relevante está na linha 14, quando apresentamos os resultados dos
cálculos. No comando printf, todo o texto a ser escrito deve vir no início, dentro de
um único par de aspas. Dentro dele, devemos indicar quais serão as variáveis a serem
mostradas. Cada uma delas deve ter um %x (onde x será trocado por f, d ou c) e, ali, a
linguagem C enxertará o valor da variável, como se fosse um único texto. Para cada %x
presente no texto, devemos ter uma variável listada ao final das aspas, sempre separada
por vírgula. A substituição dos %x pelas variáveis será na ordem em que aparecerem no
comando. Se você não colocar o %x, o valor não será demonstrado na tela do usuário.
Vamos ao algoritmo 4:

42
ALGORITMOS I
Quadro 11 - Programa 4: Consumo de Combustível (versão 2)
1
#include <stdio.h>
2
#include <locale.h>
3
4
int main(){
5
6
int distancia;
7
float consumo, resultado, preco, gasto;
8

9
printf( “Qual a distância a ser percorrida? “ );
10
scanf( “%d”, &distancia );
11
printf( “Qual a média de consumo do carro? “ );
12
scanf( “%f”, &consumo );
13
printf( “Qual a valor do litro do combustível? “ );
14
scanf( “%f”, &preco );
15
16
gasto = resultado * preco;
17
printf( “Serão necessários %f litros de combustível”, resultado );
printf( “Você irá gastar R$ %f”, gasto );
18
return 0;
19
}
20
SUGESTÃO DE LIVRO
O livro de Francisco de Assis Pinheiro apresenta, em de-
talhes, como funciona o desenvolvimento de um programa
em C e suas características. Ele foi publicado pela Bookman, em 2012.
PARA PRATICAR
EXERCÍCIOReescreva os três algoritmos, que formaram a lista de atividades
da seção anterior, sobre os primeiros algoritmos, em Linguagem C, e os execute
corretamente, avaliando os diferentes resultados.
43
ALGORITMOS I
CONSIDERAÇÕES FINAIS

Nesta primeira unidade do caderno, foram apresentados os importantes conceitos de
algoritmos e linguagem de programação. É fundamental que a solução de um problema
seja agora transcrita em uma sequência de passos lógicos e organizados, que nos levem
à solução do problema.
Essa solução algorítmica pode, então, ser repetida de forma sistemática e, espera-se,
sempre com o mesmo resultado final para uma mesma entrada.
No decorrer da Unidade 1, foi possível perceber que o principal problema a ser
enfrentado por quem está aprendendo a programar é a dificuldade em transcrever
uma solução qualquer, nesta sequência de passos. Portanto, torna-se fundamental a
prática desta atividade até que se alcancem os objetivos. Para a prática, a linguagem de
programação desempenha um papel fundamental, pois permite que vejamos o algoritmo
em execução e possamos avaliar se o seu resultado está correto.
Por outro lado, pode acontecer de alguns dos nossos programas apresentarem erros
inesperados quando executados, mesmo que não os tenham na sua escrita. Existem erros
lógicos de programação que precisam ser tratados pelo programador, como, por exemplo,
não permitir que um valor 0 (zero) seja usado em uma divisão. Este será o foco da próxima
unidade: o controle da execução do nosso programa/algoritmo.
44
ALGORITMOS I
EXERCÍCIO FINAL
01- Analise cada uma das expressões lógicas a seguir e defina se o resultado final é
verdade (true) ou falso (false).
I) true && !false
II) !false || !true
III) (!true && true) || (!false && true)
IV) !true && !(false && true)
V) !(false && true)
VI) !(false && false)
VII) false || !true || !(!true && true)
VIII) true && !false && !(!(true || !false))
IX) !(!(false || !(false && !true)) && !true) || !true
X) !false && !(!(false && !true))
Quais são as duas mentiras?

a) IX e VII.
b) III e X.
c) IV e VIII.
d) IV e X.
e) VII e II.
02 - Observe o Algoritmo Exemplo:

Variáveis
nome: ___________;
aux: ____________;
salario: __________;
nível_superior: _________;
Início
Escrever “Digite o nome:”
Ler nome;
Escrever “Digite o salário:”;
Ler salario;
Escrever “Tem curso superior?”;
Ler nivel_superior;
Se nível_superior então
45
ALGORITMOS I
salario = salario * 1.15;
Fim se
aux = 0;
se aux <= 10 faça
escrever aux;
fim enquanto
Fim
No algoritmo do enunciado, nota-se que os tipos de dados não foram declarados.

Neste caso, para ajustar o algoritmo, os tipos de dados para nome, aux, salario e nivel_
superior seriam, respectivamente:
a) real, lógico, inteiro e real.

b) caractere, real, inteiro e lógico.
c) real, lógico, inteiro e inteiro.
d) caractere, inteiro, real e lógico.
e) caractere, lógico, real e real.
03 - Considere o seguinte algoritmo exemplo:
Var
a, b, c : inteiros;
início
ler a, b, c;
c = (a + b) * 4;
escrever c;
fim
Com base no algoritmo acima, e supondo que o valor fornecido para “A”, na linha “leia
A”, seja 3; o valor fornecido para “B”, na linha “leia B”, seja 4, pode-se afirmar que o valor
da variável “C”, na linha “escreva C”, é:
a) 24
b) 28
c) 32
d) 34
e) 43
46
ALGORITMOS I
04- Considere o algoritmo abaixo:var a, b, x: inteiro
Início
Leia (a, b)
x=a
a=b
b = x
imprima(b * x + a) / 2;
Fim
Haja vista que a e b receberam, respectivamente, os valores 4 e 2, conclui-se que

será impresso o valor:
a)19
b) 7
c) 15
d) 10
e) 9
05- Considere o programa em linguagem C:

int main(){
int valor1, valor2;
valor1 = 10;
valor2 = 20;
valor2 = valor1 + valor2 / 2;
printf( “%d”, valor2 );
}
Assinale a alternativa correta, em relação à saída do código acima:a) 10

b) 15
c) 20
d) 25
e) 30
47
ALGORITMOS I
REFERÊNCIAS
DASGUPTA, S; PAPADIMITRIOU, C.; VAZIRANI, U. Algoritmos. Tradutor Guuilherme A.

Pinto. Porto Alegre: AMGH, 2010.
EDELWEISS, N.; LIVI, M. Algoritmos e Programação com Exemplos em Pascal e C.

Série Livros Didáticos Informática UFRGS. Porto Alegre: Bookman, 2014.
OLIVEIRA, J.; MANZANO, J. Lógica para Desenvolvimento de Programação de

Computadores. 28 ed. São Paulo: Erica, 2018.
PEREIRA, S. Algoritmos e Lógica de Programação em C – Uma Abordagem Didática.

São Paulo: Erica, 2018.
PINHEIRO, F. Elementos de Programação em C. Porto Alegre: Bookman, 2012.
SANTOS, M. Algoritmos e Programação. Porto Alegre: SAGAH, 2018.
TANEMBAUM, A. Organização Estrutura de Computadores, 3ed. São Paulo: Pearson,

2013.
48
ALGORITMOS I
2
unidade
DESVIO CONDICIONAL
49
ALGORITMOS I
INTRODUÇÃO À UNIDADE
Figura 7 - Controle de Fluxo de Execução de Programas.

Fonte: < http://www.ambiente.pascal.nom.br/Capitulo6/Cap6Tutorial1.html> Acesso em: Setembro de
2020.
Bem-vindo à Unidade 2 de nosso estudo!Na unidade anterior, você aprendeu a

desenvolver algoritmos simples e, consequentemente, a resolver problemas simples.
Por outro lado, mesmo estes simples algoritmos e programas podem apresentar alguns
problemas. Vamos tomar como exemplo o algoritmo 3, que calcula o consumo de
combustível de uma viagem. Suponha que o usuário, o qual está testando o programa,
tenha digitado, por engano ou de forma proposital, que o consumo do carro é zero.
Ao executar seu programa sob estas condições, ele procederá de forma errada,
abortando a sua execução e apresentando mensagens estranhas ou, até mesmo, travando
seu computador. Isso tudo, porque não é possível fazer uma divisão por zero. É tarefa
do programador (sua!) considerar todas as possíveis situações e problemas que possam
ocorrer no seu programa e tratar cada uma delas individualmente.
Os algoritmos que construímos são considerados algoritmos sequenciais, ou seja,
eles executam suas ações sequencialmente, do início ao final. Entretanto, como vimos,
existem casos em que não é o suficiente para solucionarmos determinados problemas.
Para isto, as linguagens de programa, como o C, apresentam recursos, os quais permitem
o controle do fluxo de execução dos nossos programas, determinando partes que devem
ou não ser executadas sob certas condições ou, até mesmo, repetidas por certa quantidade
de vezes (Unidade 3).
Na primeira seção desta unidade, estudaremos as estruturas de desvio de condicional
e de seleção, as quais permitirão escolher ações ou grupos de ações que podem ou não ser
executadas sob certas condições.
Na última seção da unidade, será apresentada uma varição de desvio condicional,
50
ALGORITMOS I
que permite realizar testes de forma agrupada com ações realizadas de acordo com a
classificação obtida para o item testado.
Os principais objetivos de aprendizagem desta unidade são:
• conhecer as estruturas de controle de fluxo de decisão;
• identificar situações, nas quais o controle fluxo de execução pode ser aplicado na
solução de problemas;
• saber aplicar os conceitos de controle de fluxo e analisar as suas necessidades e
aplicações;
2.1 DESVIO CONDICIONAL
Quando projetamos um programa de computador, quase sempre imaginamos um

fluxo sequencial de execução dos comandos que, muitas vezes, não é real. Quando há
somente este fluxo, chamamos o algoritmo de sequencial. Em todas as execuções do
algoritmo, as ações realizadas serão sempre as mesmas.
Por outro lado, existem situações em que é necessário o programa ter mais de um fluxo
de ações, as quais dependerão de condições variáveis. Vamos imaginar, por exemplo,
a situação do cálculo do IMC (Índice de Massa Corporal). Se analisarmos o problema,
veremos que o cálculo realizado tem diversas interpretações, algumas válidas para homens
e outras para mulheres. Então, como saberemos o que fazer? Obviamente, isto depende
do gênero, masculino ou feminino, e do fornecedor dos dados. Quando soubermos isso,
como controlar a parte do código que iremos executar?
Estruturas condicionais e de seleção são a solução para este problema. Vejamos como
elas funcionam!
2.1.1 Seleção Simples
Um comando de seleção simples é aquele que permite que um trecho do nosso

programa seja executado, se uma condição for considerada verdadeira. Este comando
condiciona a execução de parte do programa à avaliação de uma expressão lógica
(apresentada na Unidade 1).
A sintaxe deste comando é definida por:
51
ALGORITMOS I
Quadro 12 - Comando de Seleção Simples
Pseudocódigo Linguagem C
Se ( expressão lógica ) então

If( expressão lógica ){
... comandos a serem executados
.. comandos a serem executados
fimse
}
Neste comando, sempre que a expressão lógica for considerada como verdade (true), as
linhas de código que ficarem entre o comando e seu final (fimse nos algoritmos ou chaves
na linguagem C), serão executados. Caso a expressão seja falsa, este trecho de código não
será executado, e o fluxo seguirá para a primeira linha de código após ele. O fluxo de
execução pode ser observado na Figura 8.
Figura 8 - Fluxo de execução da seleção simples.

Voltemos ao algoritmo 1 da unidade, que calcula a média das notas de uma disciplina.
Caso a média do aluno seja superior a 6, escreveremos uma mensagem, informando que
ele foi aprovado. Este pedaço do algoritmo será definido da seguinte forma:
Se (media >= 6.0 ) if (media >= 6.0 ){

Escrever( “Você foi aprovado!”); printf( “\nVocê foi aprovado!” );
fimse }
Aqui, temos mais uma novidade no comando printf do C. Observe que, antes da
mensagem, foi inserido um comando \n. Este comando, quando presente no printf, faz
com que seja dada uma nova linha na tela, antes de escrever a mensagem.
O algoritmo e sua versão em C, completos, são:
52
ALGORITMOS I
Quadro 13 - :MDC
Algoritmo MediaFinal
Variável
nota1, nota2, nota3: real
media: real
início
escrever( “Digite três notas: “)
ler( nota1, nota2, nota3 )
media = (nota1 + nota2 + nota3 ) / 3
escrever( “Sua média é: “, media )
se (media >= 6.0 )
escrever( “Você foi aprovado!” );
fimse
fim
Quadro 14 - :MDC
#include <stdio.h>
#include <locale.h>
int main(){
float nota1, nota2, nota3;
float media;
printf( “Digite três notas: “ );

scanf( “%f, %f, %f”, &nota1, &nota2, &nota3 );
media = (nota1 + nota2 + nota3 ) / 3;
printf( “Sua média é: %f”, media );
if( media >= 6.0 ){
printf( “Você foi aprovado!” );
}
return 0;
}
Em qualquer um destes casos, a linha de código que mostrará a mensagem de que

a pessoa foi aprovada, somente será exibida, caso a expressão lógica media >= 6.0 seja
avaliada como verdade (true). Se ela for falsa, a execução será desviada para a linha do
return 0 (no caso da versão em C).
Uma situação muito parecida poderia ser utilizada para resolver o problema do
consumo do veículo ter valor zero no Algoritmo 3. Para isso, bastaria colocar um teste no
53
ALGORITMOS I
final do algoritmo, garantindo que o consumo é um número superior a zero. Por exemplo,
na versão em C:
if( consumo > 0 ){

printf( “Serão necessários %f litros de combustível”,
resultado);
}
Vamos a mais um exemplo de aplicação do desvio condicional. Suponhamos que

você precise fazer um programa, o qual funcionará em um caixa eletrônico, devendo
determinar a quantidade de notas de R$ 50,00, R$ 10,00 e R$ 5,00, as únicas disponíveis,
que deverá ser disponibilizada ao usuário, quando ele solicitar o saque de um certo valor.
Devemos mostrar apenas as notas que devem ser utilizadas para pagar o valor.
Por questões de simplicidade, pelo menos por enquanto, vamos supor que o usuário
do caixa sempre pedirá um valor que é múltiplo de 5. Desta forma, sempre será possível
atendê-lo. Se não fizéssemos assim, haveria valores impossíveis de serem pagos com
estas notas, por exemplo, R$ 43,00.
Mas, como resolveremos o problema? Em primeiro lugar, precisamos saber a quantia
desejada pelo usuário. Após, basta irmos dividindo o valor solicitado pela nota da vez e,
fazendo uma divisão de números inteiros (sem casas decimais), saberemos exatamente
quantas notas cabem no valor disponível. Vamos supor que o usuário tenha solcitado R$
85,00. Desta forma, dividimos este valor por 50. Teremos como resposta 1 (uma unidade)
de nota de R$ 50,00. Tomamos, então, o resto da divisão, que será R$ 35,00, e repetimos o
proceso, dividindo por 10. Saberemos que precisamos de 3 notas de R$ 10,00. O restante,
será dado em uma única nota de R$ 5,00.
Vamos ao nosso próximo programa exemplo:
54
ALGORITMOS I
Quadro 15 - :NCE
#include <stdio.h>
#include <locale.h>
int main(){
int valor, nota50, nota10, nota5;
printf( “Digite o valor desejado: “ );

scanf( “%d”, &valor );
// Notas de 50 reais
nota50 = valor / 50; // essa é uma divisão inteira, sem casas decimais
valor = valor % 50; // resto da divisão nos dá o que ainda falta pagar
nota10 = valor / 10;
valor = valor % 10;
nota5 = valor / 5;
printf( “\n\nPara pagar o valor desejado precisamos: “ );
if( nota50 > 0 ){
printf( “\n\t %d notas de R$ 50,00”, nota50 );
}
if( nota10 > 0 ){
}
if( nota5 > 0 ){
}
return 0;
}
PARA PRATICAR
EXERCÍCIOS
1- Escreva um programa em C, que recebe dois valores reais e, caso seja possí-
vel, divide o primeiro pelo segundo e mostra o resultado.
2- Escreva um programa que recebe duas notas de um aluno e calcula a média aritmética
dele, apenas se as duas notas forem superiores a 7 e se a primeira for superior à segunda. Caso
contrário, não deve fazer nada.
55
ALGORITMOS I
2.1.2 Seleção Dupla
Na sintaxe do comando de seleção simples, é possível perceber que apenas um trecho

de programação pode ser executado a cada condição avaliada. Podemos, também, quando
houver necessidade, estabelecer um segundo grupo ou trecho de comandos que será
executado, sendo a condição avaliada falsa. Neste caso, estaremos fazendo um comando
de seleção dupla. Sua sintaxe é:
Quadro 16 – Seleção Dupla

If( expressão lógica ){

.. comandos (caso verdade)
Se ( expressão lógica ) então
}
... comandos (caso verdade) Senão
else{
... comandos (caso falso) fimse
.. comandos (caso falso)
}
Observe, na Figura 9 abaixo, como é o fluxo de execução de uma seleção dupla. Na figura,
são apresentados os dois caminhos possíveis: para o caso verdadeiro e para o caso falso.
Figura 9 - Fluxo de execução da seleção dupla.

Por exemplo, no caso da média do aluno, podemos colocar no algoritmo e no programa

o código de seleção:
se (media >= 6.0 )

escrever( “Você foi aprovado!” );
56
ALGORITMOS I
senão
escrever( “Infelizmente você não foi aprovado!” );
fimse
ou
if( media >= 6.0 ){

printf( “Você foi aprovado!” );
}
else{
printf( “Infelizmente você não foi aprovado!” );
}
Vamos considerar um problema completo. Faremos um programa em C, que recebe um

número inteiro digitado pelo usuário e informa se ele é par ou ímpar. Podemos descobrir
se um número é par, dividindo-o por 2. Se o resto desta divisão for zero, ele é par; caso
contrário, é ímpar.
O programa finalizado será:
Quadro 17 - Programa 7: Programa Número Par ou Ímpar

#include <stdio.h>
#include <locale.h>
int main(){
int num;
printf( “Digite um número inteiro: “ );

scanf( “%d”, &num );
if( num % 2 == 0 ){
printf( “Você digitou um número par!” );
}
else{
printf( “Você digitou um número ímpar!” );
}
return 0;
}
Agora, com o uso desta variação do desvio condicional, podemos aprimorar o Programa
6, que determina a quantidade de notas a serem usadas para pagar certo valor,a fim de
57
ALGORITMOS I
podermos determinar se o valor digitado pelo usuário do caixa eletrônico pode ou não
ser pago com as notas disponíveis. Vamos a ele:
Quadro 18 - :NCE
#include <stdio.h>
#include <locale.h>
int main(){
int valor, nota50, nota10, nota5;
printf( “Digite o valor desejado: “ );

if( valor > 0 && valor % 5 == 0 ){

// Notas de 50 reais
nota50 = valor / 50; // essa é uma divisão inteira, sem casas decimais
valor = valor % 50; // resto da divisão nos dá o que ainda falta pagar
nota10 = valor / 10;
valor = valor % 10;
nota5 = valor / 5;
printf( “\n\nPara pagar o valor desejado precisamos: “ );
if( nota50 > 0 ){
}
if( nota10 > 0 ){
}
if( nota5 > 0 ){
}
}
else{
printf( “\n\nErro: o valor informado não pode ser pago!” );
}
return 0;
}
58
ALGORITMOS I
PARA PRATICAR
EXERCÍCIOS
1- O cálculo do peso (massa) ideal de uma pessoa é realizado, de acordo com o seguinte
critério:
- Para sexo masculino: peso ideal = (72.7 * altura) - 58
- Para sexo feminino: peso ideal = (62.1 * altura) - 44.7
Escreva um programa em C que solicita a altura de uma pessoa e seu sexo (M ou F) e, com
base nisso, executa e apresenta o peso ideal desta pessoa.
2- As maçãs custam R$ 1,80 cada, se forem compradas menos de uma dúzia, e R$ 1,50, se
forem compradas pelo menos 12. Escreva um programa que leia o número de maçãs compradas,
calcule e escreva o custo total da compra.
2.1.3 Seleção Aninhada
Estendendo as necessidades de controle de fluxo, podemos nos deparar com casos em

que precisamos agrupar vários comandos de seleção, um dentro do outro, para darmos
conta das necessidades do problema. Quando isso acontece, dizemos que os seletores
estão aninhados.
Suponha que, ao calcular a média de um aluno, precisamos dar um conceito para ele,
segundo os critérios:
Quadro 19 – Seleção Aninhada

Média Conceito Final
Média >= 9 A
9 < Média <= 7 B
7 < Média <= 5 C
Média < 5 D
Para fazermos isso, é possível colocarmos vários SE/IF separados, cada um avaliando
um caso separado da tabela. Entretanto, podemos fazer isso, aninhando os comandos.
59
ALGORITMOS I
Veja como seria o programa que resolve o problema desta forma:
Quadro 20 - :CD
3
4 int main(){
6 float nota1, nota2, nota3;
7 float media;
8
9 printf( “Digite três notas: “ );
10 scanf( “%f, %f, %f”, &nota1, &nota2, &nota3 );
11 media = (nota1 + nota2 + nota3 ) / 3;
12 printf( “Sua média é: %f”, media );
13 if( media >= 9.0 ){
14 printf( “\nConceito final: A” );
15 }
16 else{
17 if( media >= 7.0 ){
18 printf( “\nConceito final: B” );
19 }
20 else{
21 if( media >= 5.0 ){
22 printf( “\nConceito final: C” );
23 }
24 else{
25 printf( “\nConceito final: D” );
26 }
27 }
28 }
29 return 0;
30 }
Observe que, caso a expressão lógica da linha 13 seja considerada falsa, a execução
do programa será direcionada para o bloco entre as linhas 17 até 27. Desta forma, não é
necessário fazer um teste para o limite superior do conceito B, pois, caso o programa entre
neste pedaço, a média é, necessariamente, inferior a 9.0 (se fosse superior, teria entrado
na linha 14). A mesma linha de raciocínio justifica os testes feitos para os conceitos C e D.
60
ALGORITMOS I
PARA PRATICAR
EXERCÍCIOS
1- Escreva um programa em C, que recebe um número e apresenta uma mensa-
gem, mostrando se ele é igual, menor ou maior do que zero.
2- Escreva um programa que recebe três valores inteiros e mostra a soma dos dois maiores
entre eles.
2.1.3 SELEÇÃO MÚLTIPLA
Suponha que você precisa escrever um programa que recebe o número do mês de
nascimento de uma pessoa e deve escrever na tela o nome deste mês. Uma possível
solução do problema seria a escrita de 12 testes SE/IF, uma para cada mês, com o printf
correspondente dentro dele. Algo semelhante a:
if( mes == 1 ){
printf( “Você nasceu em janeiro!” );
}
if( mes == 2 ){
printf( “Você nasceu em fevereiro!” );
}
.........
Esse tipo de situação pode ser resolvida com outro comando de seleção, muito útil
para casos de multiplicidade de uma condição única, chamado SWITCH/ESCOLHA. Sua
sintaxe é:
61
ALGORITMOS I
Quadro 21 - Seleção Múltipla
switch( <variável> ){
Escolha ( <variável> ) case valor_01:
Caso (valor_01) : <grupo de comandos 01>
<comandos> break;
Caso (valor_02) : case valor_02:
<comandos> <grupo de comandos 02>
Caso (valor_03) : break;
<comandos> case valor_03:
............... <grupo de comandos 03>
Senão: break;
<comandos> ..........
fim default :
<grupo de comandos do caso default>
}
Neste tipo de seleção, a variável a ser analisada é única, e com teste de igualdade
simples. Caso o seu valor seja igual àquele presente no valor_01, serão executados os
comandos listados a seguir. Quando um caso é aceito, a execução será sequencial e
linear, a partir daquele ponto. Assim sendo, é necessário que seja colocado um comando
chamado break, o qual faz com que a execução dos comandos seja finalizada de forma
compulsória, e a execução seja desviada para a primeira linha após o switch.
O comando switch também tem um caso, chamado default/senão, que será executado,
se nenhum dos outros casos for aceito, ou seja, todos os outros casos sendofalsos.
Voltando ao nosso programa do mês de nascimento, ele poderia ser descrito conforme
segue:
62
ALGORITMOS I
Quadro 22 - :MN
#include <stdio.h>
#include <locale.h>
int main(){
int mes;
printf( “Qual o mês do seu nascimento? “ );

scanf( “%d”, &mes );
switch( mes ){
case 1 : printf( “Você nasceu em janeiro!” );
break;
case 2 : printf( “Você nasceu em fevereiro!” );
break;
case 3 : printf( “Você nasceu em março!” );
break;
case 4 : printf( “Você nasceu em abril!” );
break;
case 5 : printf( “Você nasceu em maio!” );
break;
case 6 : printf( “Você nasceu em junho!” );
break;
case 7 : printf( “Você nasceu em julho!” );
break;
case 8 : printf( “Você nasceu em agosto!” );
break;
case 9 : printf( “Você nasceu em setembro!” );
break;
case 10 : printf( “Você nasceu em outubro !” );
break;
case 11 : printf( “Você nasceu em novembro!” );
break;
case 12 : printf( “Você nasceu em dezembro!” );
break;
default : printf( “Você digitou um número errado para o mês!” );
}
return 0;
}
Neste nosso programa, colocamos todos os testes dentro de um mesmo comando de

seleção, chamado switch. Cada caso de teste possui dois comandos dentro dele: o printf,
que mostra o nome do mês e, logo depois, um comando break, que desvia sua execução
para fora do comando switch, na linha do return 0. O caso default (padrão) será acessado,
63
ALGORITMOS I
somente se nenhum dos casos anteriores foi aceito como verdade.
Existem outras possibilidades de uso para o comando switch. Com ele, podemos
aplicar vários cases para um mesmo bloco lógico de programação. É como se fizessemos
um if contendo vários operadores or entre cada uma das seleções. Ou seja, caso uma
delas seja satisfeita, os comandos serão executados.
Por exemplo, vamos escrever um pequeno programa que deverá ler um caracter do
teclado e informar se ele é uma vogal, consoante ou não é uma letra. Para isso, podemos
usar comandos case agrupadamente. Vejamos o programa:
Quadro 23 - :C
#include <stdio.h>
#include <locale.h>
#include <ctype.h>
int main(){
char ch;
printf( “Digite um caractere? “ );

scanf( “%c”, &ch );
ch = toupper(ch);
switch( ch ){
case ‘A’ :
case ‘E’ :
case ‘I’ :
case ‘O’ :
case ‘U’ : printf( “Você digitou uma vogal!” );
break;
case ‘B’: case ‘C’: case ‘D’: case ‘F’: case ‘G’ : case ‘H’ :
case ‘J’: case ‘K’: case ‘L’: case ‘M’: case ‘N’: case ‘P’ :
case ‘Q’: case ‘R’: case ‘S’: case ‘T’: case ‘V’: case ‘W’ :
case ‘X’: case ‘Y’ : case ‘Z’ :
printf( “Você digitou uma consoante!” );
break;
default : printf( “Você não digitou uma letra!” );
}
return 0;
}
Observe que fizemos a escrita de dois blocos de teste: uma para vogais e outra para as
consoantes, porém eles foram escritos de forma diferente. No primeiro caso, das vogais,
cada uma das letras teve um case colocado em uma linha diferente. Veja que os : (dois
64
ALGORITMOS I
pontos) após cada um dos cases ainda é obrigatório. Já no segundo caso, das consoantes,
para evitar que o programa ficasse excessivamente longo, os cases foram colocados em
quatro linhas apenas. Isso funcionará exatamente como no caso acima, pois a Linguagem
C não diferencia esta nova linha (ou não) entre cada um dos cases.
PARA PRATICAR
EXERCÍCIOS
1- O preço a pagar por certo produto depende do código deste produto. O preço
de cada kg de produto, de acordo com o código, é definido por:
Código Preço Kg
10 2,80
15 3,50
20 4,20
25 1,60
30 3,85
Escreva um programa que leia o código do produto e a quantidade comprada (em kg), e
apresenta o valor total a ser pago.
SAIBA MAIS
Saiba mais sobre lógica de programação e algoritmos, assistindo, novamen-
te, aos vídeos de Gustavo Guanabara. O primeiro vídeo sobre este tema pode
ser acessado em: https://www.youtube.com/watch?v=U5PnCt58Q68&list=PLHz_AreHm4d-
mSj0MHol_ao NYCSGFqvfXV&index=10.
65
ALGORITMOS I
Nesta terceira unidade, aprendemos como fazer com que partes do nosso código sejam
ignoradas durante a execução do programa e, com isso, podemos qualificar o controle da
execução do mesmo. Necessitamos, então, dos controladores de fluxo que, na prática,
implementam “desvios” dentro do código, os quais serão usados sob determinadas
condições.
Neste contexto, o principal representante é o teste if e seu complemento else. No teste
if, teremos uma condição lógica, que deverá ser avaliada como verdadeira ou falsa pela
Linguagem C e, dependendo do resultado, haverá um bloco lógico a ser executado para a
condição verdadeira e outro (opcional) para a condição falsa.
Por outro lado, existem situações, nas quais vários testes if são necessários. Quando
isso acontece, podemos tanto aninhar vários deles, colocando um dentro do outro e,
portanto, refazendo condições que devem acontecer conjuntamente, ou, caso todos os
testes sejam realizados sob uma mesma variável, podemos usar o comando switch.
Com o comando switch, podemos realizar um conjunto agrupado de testes, mas
sempre sob uma mesma variável e com avaliação simples de equivalência. Neste caso,
incluiremos um “case” (caso) para cada valor aceito, e o que deve ser realizado, se ele for
verdade.
Na próxima unidade, iremos ampliar as formas de controle, introduzindo a possibilidade
de repetirmos uma parcela do código, mas sempre sob condições controladas. Estas
repetições controladas, em conjunto com os controles de fluxo representam os elementos
fundamentais de controle de código dentro de qualquer programa de computador,
independente da linguagem usada.
66
ALGORITMOS I
EXERCÍCIO FINAL
01- Assuma que, no fluxograma apresentado, as entradas a, b e c lidas sejam,

respectivamente, 12, 5 e 9 (nele, a representa uma atribuição à variável em questão).
e
Considerando ainda o fluxograma apresentado, assinale a alternativa que apresenta

quantas vezes o teste (se/if) marcado com (*) na figura é executado:
a) 2
b) 3
c) 4
d) 5
e) 6
02- Analise o algoritmo em código:

int n1, n2;
float media;
printf( “\nPrimeira nota: ” );
scanf( “%d”, &n1 );
printf( “\nSegunda nota: ” );
scanf( “%d”, &n2 );
if( ______________________){
media = (n1+n2)/2;
printf( “\nA média é: ”, media );
}
67
ALGORITMOS I
else{
printf( “\nAlguma das notas digitas está errada” );
}
Considerando que uma nota válida deve possuir valores entre 0 e 10 (inclusive), a
lacuna que corresponde à condição do comando IF é corretamente preenchida por:Parte
superior do formulário
Parte inferior do formulário

a) n1 >= 0 || n1 <=10 || n2 >= 0 || n2 <=10
b) (n1 >= 0 && n1 <=10) || (n2 >= 0 && n2 <=10)
c) (n1 >= 0 || n1 <=10) && (n2 >= 0 || n2 <=10)
d) n1 >= 0 && n1 <=10&& n2 >= 0 && n2 <=10
e) n1 > 0 && n1 <10 && n2 > 0 && n2 <10
03- Considere o algoritmo a seguir:
algoritmo
variável
numero: inteiro
inicio
numero = 12;
se ( numero % 2 = 0) então
escrever “A”
senão
escrever “B”
fim-se
se ( numero > 12 ) então
escrever “C”
fim-se
fim
Assinale a opção que apresenta o resultado final, após a execução do algoritmo

precedente:
a) B
b) A
68
ALGORITMOS I
c) AC
d) C
e) BC
04- Fornecidos os dados das candidatas ao time de basquete: altura, peso e idade, e
as restrições abaixo:
altura: mínima de 1,70m
peso: de 48 a 60 kg
idade: máxima de 20
O trecho de algoritmo, em pseudocódigo, que verifica corretamente se os dados se

enquadram nas restrições fornecidas, respeitando as regras de programação, e, quando
verdade, irá mostrar a mensagem “Aprovado”. Caso seja falso, deve mostrar a mensagem
“Reprovado”, é:
a) Se ((altura<=1.70) e (peso>=48 ou peso <= 60) e (idade <=20))

b) Se (170 < altura) e (48kg < peso< 60kg) e (idade < 20anos)
c) Se ( 170 ≤ altura) e (48 ≤ peso ≤ 60) e (idade ≤ 20)
d) Se (altura >= 1.70 e peso >= 48 e peso <= 60 e idade <= 20 )
e) Se ((altura >= 1.70 ) ou (peso >= 48 e peso <= 60) ou (idade >= 20))
05- Considere o algoritmo a seguir:

int main(){
int a, b;
scanf(“%d”, &a );
if( a > 0 && a < 3 ){
b = a * 5;
}
else{
b = 2 * a;
}
printf(“B = %d”, b );
return 0;
}
Caso este algoritmo tenha o valor 3 digitado para a variável a, o resultado apresentado
69
ALGORITMOS I
para a variável b será:
a) 6
b) 12
c) 15
d) 20
e) 25
70
ALGORITMOS I
REFERÊNCIAS



PINHEIRO, F. Elementos de Programação em C. Porto Alegre: Bookman, 2012. SANTOS,

M. Algoritmos e Programação. Porto Alegre: SAGAH, 2018.
71
ALGORITMOS I
72
ALGORITMOS I
3
unidade
CONTROLE DE
REPETIÇÃO E FLUXO
73
ALGORITMOS I
INTRODUÇÃO À UNIDADE
Figura 10 - Controle de Fluxo de Execução de Programas.

Fonte: < https://pt.itpedia.nl/2018/09/14/workflow-biedt-voordelen-aan- projectmanagers/ >. Acesso
em: Setembro de 2020.
Nesta unidade, prosseguiremos no processo de melhorar o controle dentro dos nossos

algoritmos e programas, sendo o passo seguinte dado pelos controladores de repetição.
Frequentemente, podemos ter a necessidade de que certo algoritmo repita as suas ações,
parcial ou totalmente. Por exemplo, usando o mesmo caso, vamos supor que necessitamos
entrar com dados de distância e consumo de vários veículos e deslocamentos diferentes.
Como fazer com que o programa fique repetindo isso, enquanto for necessário?
Os algoritmos que construímos são considerados algoritmos sequencias, ou seja, eles
executam suas ações sequencialmente, do início ao final. Entretanto, como vimos, existem
casos em que não é o suficiente para solucionarmos determinados problemas. Para tanto,
as linguagens de programa, como a C, apresentam recursos, os quais permitem o controle
do fluxo de execução dos nossos programas, determinando partes que devem ou não ser
executadas sob certas condições ou, até mesmo, repetidas por certa quantidade de vezes.
Na primeira secção desta unidade, serão apresentadas as estruturas de controle de
repetição, as quais permitirão definir partes do nosso algoritmo que devem ser repetidas,
um número fixo de vezes, ou mesmo, enquanto o usuário desejar.
Os principais objetivos de aprendizagem da Unidade 3 são: c
• conhecer as estruturas de controle de repetição;
• identificar situações nas quais o controle repetição pode ser aplicado na solução
de problemas;
• saber aplicar os conceitos de controle de repetição e analisar as suas necessidades
e aplicações;
74
ALGORITMOS I
3.1 CONTROLE DE REPETIÇÃO
Em situações reais de desenvolvimento de programas, implementações baseadas

em algoritmos sequenciais e estruturas de seleção não são suficientes para resolver
problemas reais. Com frequência, precisamos fazer com que uma parte do nosso programa
seja repetida sistematicamente, dentro de condições controladas pelo programa ou pelo
usuário.
Nesses casos, aplicamos as estruturas de repetição, as quais são constituídas de
comandos que fazem com que um pedaço do seu algoritmo, escolhido pelo programador,
entre no chamado laço, sendo ele executado novamente, sempre que preciso.
Figura 11 - Controle de repetição com teste no início.

Existem dois grandes grupos de controladores de laço ou repetição. No primeiro deles

(Figura 11), a verificação da necessidade de repetição vai acontecer antes dos comandos
a serem repetidos, havendo a possibilidade de que os comandos não sejam executados
nenhuma vez, pois a condição pode indicar que não deve ocorrer a repetição. Neste
grupo, encontramos os controladores FOR/PARA e WHILE /ENQUANTO.
75
ALGORITMOS I
Figura 12 - Controle de repetição com teste no início (for / while) .
No segundo grupo (Figura 12), a verificação da necessidade de repetição ocorrerá após

os comandos terem sido executados. Nesta situação, os comandos serão executados,
no mínimo, uma vez. Neste grupo, encontra-se o controlador DO..WHILE/FAÇA...
ENQUANTO. Verificaremos cada um dos controladores.
É importante salientar que, na maioria dos problemas, qualquer um dos controladores
de laço pode ser usado para resolver o problema, mas há sempre um deles que faz a tarefa
de forma mais adequada ou fácil que os demais.
3.2 VARIÁVEIS CONTADORAS
Nos controles de laço, é comum estar presente uma variável que é conhecida como
“contador”. Contadora é aquela variável, a qual recebe certo valor inicial (chamado de
inicializador) e, após certas ações, é incrementada (somada a um valor – tipicamente 1
(um)), fazendo com que ele vá indicando o número de vezes que certa coisa foi realizada.
Por exemplo:
i=1
.......
i=i+1
76
ALGORITMOS I
Existe, também, a possibilidade de usarmos a variável contadora como decremento,
cujo valor inicial é indicado e, depois dele, há um decremento (diminuído um valor –
tipicamente 1 (um)). Veja:
i = 15
.......
i=i-1
A. Incremento
O incremento da variável contadora (não só para ela – pode usar sempre que
necessário), pode ser realizado de várias formas diferentes. Por exemplo, para somarmos
uma unidade a uma variável, podemos usar:
i = i + 1; ou i++
O segundo comando (i++) é igual ao primeiro, ou seja, soma uma unidade ao valor de
i e atribui o resultado ao próprio i. Caso o valor a ser incrementado seja superior a 1 (um),
podemos usar (tendo 2 como incremento):
i = i + 2 ou i+=2
Observe que, no segundo caso, há a indicação do valor a ser acrescentado, após o sinal
de igual. Se desejarmos somar 5 ao contador, por exemplo, devemos usar +=5 e assim por
diante.
B. Decremento
Da mesma forma que o incremento, podemos reduzir o valor de uma variável de várias
formas diferentes. Por exemplo:
i = i -1 e Diminui uma unidade de i e atribui o resultado a ele

i-- e Realiza a mesma coisa que i = i – 1
i-=3 e Retira três unidades de i e atribui o resultado a ele
77
ALGORITMOS I
SAIBA MAIS
Busque na bibliografia maiores informações sobre as formas de atribuir valo-
res às variáveis. É possível usar, por exemplo, *= ou /= além do incremento e do
decremento mostrados acima. O livro de Francisco Pinheiro, Elementos de Programação em C,
publicado pela Bookman, em 2012, é uma boa indicação para isso.
3.3 REPETIÇÃO COM VARIÁVEL DE CONTROLE
O controlador de laço mais comum em programação é conhecido como laço FOR

(Linguagem C) ou PARA (Pseudocódigo). Este controlador utiliza uma variável contadora
para o controle das repetições1. Sua sintaxe é:
Quadro 24 – Variável de Controle

Pseudocódigo
Para <variável>=<inicio> até <fim> [in/decremento <valor>] faça

.....
<comandos a repetir>
.....
Fim
Linguagem C
for( <inicialização> ; <condição> ; <incremento/decremento> ){

.....
.....
}
Em um laço desta natureza, há uma variável de controle que recebe um valor inicial,
indicado com <inicio> (PARA) e <inicialização> (FOR). Essa variável é, então, testada na
parte <condição>, para receber autorização ou não de repetição. Quando a repetição
1 Na Linguagem C, o laço for pode ser utilizado com outro tipo de controle que não de variáveis contado-
ras. Tal forma não será abordada neste material.
78
ALGORITMOS I
chega ao fim, o próprio programa aplica um incremento/decremento nesta variável.
O programador, entretanto, é quem deve tomar o cuidado, para que o valor indicado a
esta mudança da variável, leve-a, necessariamente, a alcançar a condição de parada. Se
isso não acontecer, o laço não terá fim, e o seu programa, quando executado, travará.
Por exemplo, vamos criar uma variável de controle de laço <i> que devereceber o valor
0 (zero) como inicialização e deve repetir o laço até que i seja igual a 9, aumentada uma
unidade por vez (isso fará com que a repetição aconteça por 10 vezes). O laço seria escrito
assim:
para i = 0 até 9 faça for( i=0; i<=9; i++ ){

..... comandos .... .... comandos ......
fim }
Observe que, no caso do pseudocódigo, o incremento ou decremento, quando for

igual a 1 (um) é opcional. Isso não acontece, ao usarmos o for, embora possamos deixar
este espaço em branco e colocar o incremento dentro dos comandos.
É importante entender como o laço se comporta. Vamos fazer (e executar) no
computador o seguinte trecho de código (somente até 5):
for( i=0; i<=5; i++ ){

printf( “\nValor de i = %d (dentro do laço)”, i );
}
printf( “\nValor de i = %d (fora do laço)”, i );
O resultado a ser apresentado ao usuário deste trecho é o seguinte:
Valor de i = 0 (dentro do laço)

Valor de i = 6 (fora do laço) ATENÇÃO
e
Observe que i tem o valor 0 na primeira entrada do laço. Ao final, depois do printf, ele
é aumentado (incrementado) em uma unidade, passando a valer 1. Quando isso acontece,
a condição é testada, e a repetição liberada ou não. Neste caso, será liberada, pois i é
menor ou igual a 5 (verdade).
Após a segunda repetição, o i será aumentado para 2, e a condição verificada
79
ALGORITMOS I
novamente, o que acontecerá até o momento, no qual a repetição ocorrer com i=5. Assim
que este valor for mostrado, o i aumentará para 6; ao fazer o teste da condição, ele será
falso, e o laço terminará. A execução será, então, desviada para a linha imediatamente
seguinte ao final do laço. Nesta linha, haverá um printf, mostrando novamente o valor do
i e, agora, ele valerá 6, isto é, o valor que fez com que a condição fosse falsa.
Vamos fazer um exemplo completo agora. Tomando nosso algoritmo de média,
suponha que a turma tem 20 alunos e é preciso calcular a média, dando o resultado para
todos eles. Um laço for vai resolver o problema. Veja:
Quadro 25 - :MDCA
#include <stdio.h>
#include <locale.h>
int main(){
float media;
int i;
for( i=1; i<=20; i++ ){

printf( “Digite três notas (aluno %d): “, i );
printf( “Média do aluno %d é: %f”, i, media );
if( media >= 6.0 ){
printf( “Aluno %d foi aprovado!”, i );
}
} // Fim do laço for Esse é um comentário e pode ser usado à vontade
e
return 0;
}
Nesse programa, vamos auxiliar o usuário, mostrando, em cada mensagem, o número

do aluno, o qual estamos solicitando, ou a sua média, o que torna mais legível nosso
código. Observe, também, que estamos usando um comentário (duas barras //). Quando
colocamos este comando //, todo o texto que o segue será ignorado, e ele serve apenas
para auxiliar a entender melhor nosso programa. Isto é um comentário!
80
ALGORITMOS I
VAMOS NOS DIVERTIR?!
Um professor pediu a um aluno (programador, óbvio!) que escrevesse no qua-
dro 100 vezes a frase “Não farei mais isso!”. Ele foi lá e....
Analisemos um segundo exemplo: fazer um programa que solicita ao usuário um número in-
teiro e mostra, na tela, a tabuada (até 10) deste número que ele entrou. No caso, após conhecer o
número, vamos usar um laço for, garantindo que a variável de controle assuma todos os valores
necessários ao produto da tabuada. Veja:
Quadro 26 - :TN
#include <stdio.h>
#include <locale.h>
int main(){
int num, i, valor;
printf( “Qual é o número para a tabuada? “ );

printf( “\n\nTabuada do %d:”, num );
for( i=1; i<=10; i++ ){
valor = num * i;
printf( “\n\t%d x %d = %d”, num, i, valor );
}
return 0;
}
Algumas novidades deste programa: observe que no printf dentro do laço for foi
usando um novo formatado \t (além do \n que muda a linha). Este comando acrescenta
uma tabulação (tecla TAB) no texto a ser mostrado, deslocando-o para a direita. No
laço, também estamos mostrando 3 variáveis: o número, o qual o usuário digitou, o
81
ALGORITMOS I
multiplicador (i) e o resultado (valor). Uma possível execução dele, considerando que o
usuário digite o valor 5 para num, seria:
Qual o número para a tabuada? 5

Tabuada do 5:
5x1=5
5 x 2 = 10
5 x 3 = 15
5 x 4 = 20
5 x 5 = 25
5 x 6 = 30
5 x 7 = 35
5 x 8 = 40
5 x 9 = 45
5 x 10 = 50
Vamos a mais um exemplo de uso de laços de repetição. Nesta situação, vamos supor
que estamos fazendo um programa, cujo objetivo é controlar as vendas de uma loja. A
cada venda, o programa deve receber o valor vendido e a forma de pagamento. As formas
possíveis são P para prazo, V para à vista ou C para cartão de crédito. Ao final, o programa
deve informar a quantidade de vendas em cada caso de pagamento, sua porcentagem em
relação ao total de vendas e o valor total vendido. Antes de solicitar os dados ao usuário,
devemos pedir a quantidade de vendas feitas.
Esse programa pode ser expresso, usando o laço for, o qual iniciará em 1 (um), mas terá
seu final informado pelo usuário antes da solicitação dos dados. Observe:
Quadro 27 - :VLFonte: Elaborado pelo autor (2020).
#include <stdio.h>
#include <locale.h>
int main(){
int i, numVendas, numPrazo=0, numVista=0, numCartao=0;
float valor, porcentagem;
float totalVendas=0, totalPrazo=0, totasVista=0, totalCartao=0;
char pgto;
printf( “Qual é o quantidade total de vendas? “ );

scanf( “%d”, & numVendas);
for( i=1; i<=numVendas; i++ ){
82
ALGORITMOS I
printf( “Venda número %d: “, i );
printf( “\n\tTotal vendido: “ );
scanf( “%f ”, &valor );
printf( “\n\tForma de pagamento ([P]razo, à [V]ista ou [C]artão): “ );
scanf( “ %c”, &pgto );
totalVendas += valor;
if( pgto == ‘P’ || pgto == ‘p’ ){
numPrazo++;
totalPrazo += valor;
}
if( pgto == ‘V’ || pgto == ‘v’ ){
numVista++;
totalVista += valor;
}
if( pgto == ‘C’ || pgto == ‘c’ ){
numCartao++;
totalCartao += valor;
}
}
printf( “\n\nO total vendido foi de R$ %.2f em %d vendas!”, totalVendas, numVendas );

porcentagem = (float)numPrazo / (float)totalVendas * 100;
printf( “\nO total vendido à prazo foi de R$ %.2f em %d vendas (%.2f %%)”, totalPrazo, numPrazo, porcenta-
gem );
porcentagem = (float)numVista / (float)totalVendas * 100;

printf( “\nO total vendido à vista foi de R$ %.2f em %d vendas (%.2f %%)”, totalVista, numVista, porcentagem
);
porcentagem = (float)numCartao / (float)totalVendas * 100;

printf( “\nO total vendido com cartão foi de R$ %.2f em %d vendas (%.2f %%)”, totalCartao, numCartao,
porcentagem );
return 0;
}
Neste pequeno programa, alguns itens chamam a atenção. Em especial, a realização

da divisão para o cálculo da porcentagem de cada umas das vendas e a sua apresentação.
Para fazer o cálculo, foi utilizado, pela primeira fez, o recurso de conversão de tipo da
Linguagem C ou cast, colocando-se, na frente dos operandos, a palavra chave (float).
Isto permite que a linguagem faça uma divisão de números reais (com casas decimais).
Caso a divisão dos números não fosse convertida para float, o C os dividiria como valores
83
ALGORITMOS I
inteiros, e o resultado não teria casas decimais.
Ainda sobre a porcentagem, na sua apresentação, em cada uma das vendas, foi usado
o símbolo de % duas vezes (%%), sendo necessário, porque o C trata este símbolo como
um formatador de saída e, caso apenas um símbolo tivesse presente, o C esperaria o
formatador em seguida (%d, %f, %c e outros). Ao colocarmos dois símbolos, a linguagem
entende que o segundo deve ser apresentado na tela.
PARA PRATICAR
EXERCÍCIOS
1- Escreva um algoritmo ou programa que mostre uma tabuada genérica ao
usuário. Este programa deve, então, solicitar o número da tabuada e, também, até qual valor ela
deve ser feita. Por exemplo, podemos entrar com a tabuada do 7 até o valor 15. Assim, o progra-
ma deve mostrar: 7x1, 7x2 até 7x15.
2- Escreva um programa que mostra na tela todos os números naturais pares até um valor
limite informado pelo usuário.
3- Escreva um programa que solicita dois valores ao usuário (a e b) e mostra todos os valo-
res, em ordem decrescente, entre os dois valores. Lembre-se de verificar (testar) qual é o maior e
o menor dos valores. Por exemplo, se o usuário digitar a=40 e b=25, o programa deve apresen-
tar na tela os valores 40, 39, 38, 37 ... 25.
3.4 REPETIÇÃO COM TESTE NO INÍCIO
O segundo tipo de controlador de laço que vamos analisar também faz o teste da
condição no início do processo e, por conta disso, pode fazer com que os comandos
do interior não sejam executados nenhuma vez. Este é o controlador ENQUANTO
(pseudocódigo) ou WHILE (Linguagem C). Sua sintaxe é:
84
ALGORITMOS I
Quadro 28 - Repetição com Teste no Início
Enquanto ( <expressão lógica> )

while( <expressão lógica> ){
.....
.....
.....
.....
fim
}
Esse controlador repetirá o que está dentro dele, enquanto (daí vem o nome dele!) a
expressão lógica for verdadeira. No momento em que ela for considerada falsa, o fluxo de
execução será desviado para a instrução seguinte ao seu final.
Observe que, nesse laço, o valor de inicialização do controle (se houver necessidade) e
a garantia de que a condição seja, em algum momento falsa, é de responsabilidade única
do programador.
Vamos construir o mesmo exemplo do laço anterior, das médias, mas com o controlador
while. Ele será descrito da seguinte forma:
Quadro 29 - :MDCA
#include <stdio.h>
#include <locale.h>
int main(){
float media;
int i = 1;
while( i<=20 ){
if( media >= 6.0 ){
}
i = i + 1; // Aqui a variável de controle foi incrementada
} // Fim do laço while
return 0;
}
85
ALGORITMOS I
Basicamente, é o mesmo modo de operar. Entretanto, observe que foi responsabilidade
nossa fazer o i receber o valor inicial de 1, fora do laço, o que aconteceu no próprio
momento da criação da variável (mais uma novidade!). Além disso, sabendo que o laço
será repetido, enquanto i for menor ou igual a 20 (veja a condição do while), foi necessário
fazê-la aumentar para 2, depois 3 e assim por diante, dentro do próprio laço. Isto está no
final dele.
O controlador while nos dá maior liberdade para o controle da repetição. Com
ele, podemos fazer com que a repetição aconteça, enquanto o usuário desejar, sem
estabelecer um limite (como 20, no exemplo acima). Para tanto, podemos, por exemplo,
fazer o seguinte:
char continuar=’S’;
......
while( continuar == ‘S’ || continuar == ‘s’ ){
.......
<comandos>
.......
printf( “\nDeseja repetir (S/s)?” );
scanf( “%c”, &continuar ); // ou continuar = getch();
}
Esse laço será repetido, enquanto o usuário digitar uma letra s (maiúscula ou
minúscula). Caso o valor digitado seja outro, a repetição irá parar. Observe a necessidade
de testarmos os dois casos na condição do laço while, pois não sabemos se o usuário
digitará um S ou um s, quando solicitado. Esses dois valores foram unidos por um OR
(||) no teste. Assim, caso um deles seja verdadeiro, a execução continuará. A leitura do
caractere pode ser feita com o scanf ou com a função getch().
DICA
A Linguagem C pode apresentar problemas, caso, antes da leitura de um caractere,
seja realizada a leitura de um inteiro ou de um float. Quando isso acontece, o [ENTER],
utilizado para indicar a digitação do número, pode ficar armazenado na memória do teclado (buffer) e
ser atribuído automaticamente para o caractere lido na sequência, o que não ocorrerá com o uso do
getch(), mas sim com o uso de um scanf. Para evitar o problema, usando o scanf, basta acrescentar um
espaço em branco entre a primeira aspa e o %c do scanf, ficando assim: scanf( “[espaço]%c”, &ch).
86
ALGORITMOS I
Podemos, então, fazer com que o exemplo da média seja agora repetido, enquanto o
usuário desejar. Observe:
Quadro 30 - : MRCU
#include <stdio.h>
#include <locale.h>
int main(){
float media;
int i = 1;
char continuar = ‘S’;
while( continuar == ‘S’ || continuar == ‘s’ ){

if( media >= 6.0 ){
}
i = i + 1; // Aqui a variável foi incrementada para mostrar o valor
printf( “\n\nDeseja calcular novamente (S/s)?” );
continuar = getch();
} // Fim do laço while
return 0;
}
Na sequência, converteremos nosso exemplo anterior, das estatísticas de vendas, para

o laço while:
Quandro 31 - : VLL
#include <stdio.h>
#include <locale.h>
int main(){
int i, numVendas, numPrazo=0, numVista=0, numCartao=0;
char pgto;
87
ALGORITMOS I
printf( “Qual é o quantidade total de vendas? “ );
scanf( “%d”, & numVendas);
i = 1;
while( i<=numVendas ){
printf( “Venda número %d: “, i );
if( pgto == ‘P’ || pgto == ‘p’ ){
numPrazo++;
}
if( pgto == ‘V’ || pgto == ‘v’ ){
numVista++;
}
if( pgto == ‘C’ || pgto == ‘c’ ){
numCartao++;
}
i++;
}

printf( “\nO total vendido a prazo foi de R$ %.2f em %d vendas (%.2f %%)”, totalPrazo, numPrazo, porcenta-
gem );

);

porcentagem );
return 0;
}
88
ALGORITMOS I
PARA PRATICAR
EXERCÍCIO
Reescreva todos os exercícios solicitados para o laço FOR, na seção 2.4, agora
utilizando o controlador de laço WHILE ou o ENQUANTO.
3.5 REPETIÇÃO COM TESTE NO FINAL
A outra, e última possibilidade, para um controlador de laço é o uso do comando DO...

WHILE (Linguagem C) ou FAÇA... ENQUANTO (Pseudocódigo). Sua sintaxe é:
Quadro 32 - Repetição com Teste no Final

Faça
do{
.....
.....
.....
.....
Enquanto ( <expressão lógica> )
} while( <expressão lógica> );
Neste controlador, a verificação da condição acontecerá no final do laço. No caso, os

comandos da repetição serão executados, pelo menos, uma vez. A repetição irá acontecer,
enquanto a condição for verdade, e será abortada ou finalizada, quando a condição for
falsa.
Vamos escrever um programa para calcular a tabuada, agora com o laço DO...WHILE:
89
ALGORITMOS I
Quadro 33 - Programa 18: Mostrando a Tabuada com o Laço DO...WHILE
#include <stdio.h>
#include <locale.h>
int main(){
int num, i, valor;
printf( “Qual é o número para a tabuada? “ );

printf( “\n\nTabuada do %d:”, num );
i = 1;
do{
valor = num * i;
printf( “\n\t%d x %d = %d”, num, i, valor );
i = i + 1; // Aumento do i para o valor seguinte
}while( i<=10);
return 0;
}
O controlador do...while também pode ser utilizado para controlar a repetição, de

acordo com o desejo do usuário. Ele é, inclusive, mais indicado para isso, pois faz com que
os comandos da repetição sejam mostrados uma vez, no mínimo. A escrita seria:
char continuar;
......
do{
.......
<comandos>
.......
printf( “\nDeseja repetir (S/s)?” );
scanf( “%c”, &continuar ); // ou continuar = getch();
} while( continuar == ‘S’ || continuar == ‘s’ );
.......
Façamos um exemplo desta situação. Vamos escrever um programa que irá verificar se
um número é primo2, enquanto o usuário desejar que isso aconteça.
2 Um número primo é aquele que tem exatamente dois divisores: o um (1) e ele próprio!
90
ALGORITMOS I
Quadro 34 - :NP
3
4 int main(){
6 char continuar;
7 int num, i, divisores;
8
9 do{
10 printf( “\n\nDigite um número: “);
11 scanf( “%d”, &num );
12
13 if( num > 1 ){
14 // Vamos contar quantos divisores ele tem
15 divisores = 0;
16 for( i=1; i<=num; i++ ){
17 if( num % i == 0 ) divisores++;
18 }
19 if( divisores == 2 )
20 printf( “\n\tO número %d é primo!”, num );
21 else
22 printf( “\n\tO número %d não é primo!”, num );
23 }
24 else{
25 if( num == 1 )
26 printf( “\n\tO número 1 não é primo!”);
27 else
28 printf( “\n\tO digitado [%d] não é positivo!”, num);
29 }
30
31 printf( “\n\nDeseja continuar (S/s)?”);
32 continuar = getch();
33 }while( continuar == ‘S’ || continuar == ‘s’ );
34 printf( “\nObrigado!”);
35 return 0;
36 }
Em nosso programa, existem algumas linhas que precisam ser explicadas ou

comentadas. Em primeiro lugar, está o teste da linha 13, e o seu else nas linhas 25 a 28.
Um número primo precisa ser necessariamente positivo (maior que zero) e, por isso,
verificamos se ele é superior a 1 (um). Caso não seja, ele pode ser o próprio 1 (um), que não
é primo, ou ser inferior a ele e, portanto, não válido. Por isso, os testes e as mensagens.
91
ALGORITMOS I
Outro detalhe importante (e novo!) está em algumas linhas do programa como, por
exemplo, as linhas 17, 20, 22, 26 e 28. Nelas, o comando anterior é um if, e não há chaves
abrindo ou fechando os comandos que estão dentro dele. Quando existe um único
comando dentro de um if, for, while, ou qualquer outro que tenha chaves para definir o
bloco de comandos dentro dele, não há a necessidade das chaves. Elas só precisam estar
presentes, quando existir mais do que um comando.
Nosso último exemplo será o mesmo das seções anteriores, mas implementado de uma
outra forma. Desta vez, utilizaremos o laço do..while para permitir que a repetição aconteça,
enquanto o usuário desejar. Ou seja, ao final de cada interação, solicitaremos ao usuário se ele
deseja continuar ou não. Isso vai deixar nosso programa mais genérico e fácil de usar. Veja:
Quadro 35 - :VLL
#include <stdio.h>
#include <locale.h>
int main(){
int numVendas=0, numPrazo=0, numVista=0, numCartao=0;
char pgto, aux;
do{
numVendas++;
printf( “Venda número %d: “, numVendas );
if( pgto == ‘P’ || pgto == ‘p’ ){
numPrazo++;
}
if( pgto == ‘V’ || pgto == ‘v’ ){
numVista++;
}
if( pgto == ‘C’ || pgto == ‘c’ ){
numCartao++;
}
printf( “\n\nDeseja continuar (S/N)? “ );
92
ALGORITMOS I
scanf( “%c”, &aux );
}while( aux == ‘S’ || aux == ‘s’ );

printf( “\nO total vendido a prazo foi de R$ %.2f em %d vendas (%.2f %%)”, totalPrazo, numPrazo, porcenta-
gem );

);

porcentagem );
return 0;
}
PARA PRATICAR
EXERCÍCIOS
1- Reescreva os exercícios da secção 2.4 do comando for, agora usando do...while.
2- Escreva um programa que leia um número n e, caso ele seja maior que zero, o programa
deverá mostrar todos os números inteiros entre 1 e o valor informado. Caso ele seja inferior a
1(um), o programa deverá dar uma mensagem, informando o erro ao usuário.
3- Escreva um programa que solicita ao usuário a quantidade de alunos existentes em uma
turma, e calcule a média ponderada (pesquise como se faz isso!) de duas notas, cujos pesos são 3
e 2. O programa deve repetir o cálculo para toda a quantidade de alunos informados.
SAIBA MAIS
Saiba mais sobre lógica de programação e algoritmos, assistindo, novamen-
te, aos vídeos de Gustavo Guanabara. O primeiro vídeo sobre este tema pode
ser acessado em: https://www.youtube.com/watch?v=U5PnCt58Q68&list=PLHz_AreHm4d-
mSj0MHol_ao NYCSGFqvfXV&index=10.
93
ALGORITMOS I
Nesta unidade, aprendemos como fazer com que um pedaço do nosso código seja
repetido sob nosso controle. Assim, podemos otimizar os programas, evitando a reescrita
de elementos que podem, inclusive, levar ao aparecimento de erros de programação. Uma
vez que as instruções dentro da repetição estejam corretas, e foram exaustivamente
verificadas, não há mais possibilidade de as mesmas produzirem erros, independente de
quantas vezes sejam repetidas.
Este é um dos recursos de programação mais comuns em nossos códigos, sendo
fundamental que os programadores os conheçam a fundo. Por isso, você deve testar
cada um dos programas, verificar e acompanhar sua execução em detalhes e, sempre
que possível, fazer variações, analisando o novo resultado. Por exemplo, se o laço é
incrementado em uma unidade, tentar fazê-lo de dois em dois ou mais e, até mesmo,
invertê-lo, para iniciar no valor máximo e ir diminuindo até o início.
Em termos de comandos de programação, chegamos muito perto do final, uma vez que
não são muitos comandos disponíveis nas linguagens. O que encontramos são recursos
de programação, os quais agregam estes comandos, fornecendo novas funcionalidades,
o que será apresentado nas próximas unidades.
94
ALGORITMOS I
EXERCÍCIO FINAL
01- No programa a seguir, entraram os valores: 6, 8,12, 10, 4, 14, 10, 2, 2 e 6.
int main(){
int i=1, valor, total=0;
while( i<=10 ){
printf( “Digite um número: “ );
total += valor / 2;
i = i + 1;
}
printf( “\nTotal = %d”, total );
return 0;
}
Sabendo isso, podemos afirmar que o resultado a ser apresentado é:

a) 37
b) 32
c) 74
d) 40
e) 56
02- Assuma que entradas a, b e c, lidas no algoritmo abaixo, sejam, respectivamente,

12, 5 e 9.
int main(){
int a, b, c;
scanf( “%d”, &a );
scanf( “%d”, &b );
scanf( “%d”, &c );
do{
do{
a = a / 2;
95
ALGORITMOS I
}while(a > b );
b = b + 2;
}while( b > c );
printf( “%d, %d, %d ”, a, b, c );
}
Assinale a alternativa que possui, para o algoritmo apresentado no programa, a soma

dos valores de a, b e c resultantes ao final da execução do algoritmo.
a) 17
b) 19
c) 21
d) 23
e) 26
03- Observe o algoritmo abaixo:
int main(){
int x1, x2, x3, i;

scanf( “%d,%d,%d”, &x1, &x2, &x3 );
for( i = 1; i <= x1; i++ ){
x2 = x1 + x3;
x3 = x1 – x2;
}
printf( “%d”, x2+x3 );
}
Considere que os valores lidos para x1, x2 e x3 foram, respectivamente, 5, 4 e 3.

Analisando o algoritmo fornecido, caso a linha de programa:
for( i = 1; i <= x1; i++ )
seja substituída por:
for( i = 1; i <= x1; i += 2 )
O número de vezes que as instruções serão executadas dentro do loop for é igual a:
96
ALGORITMOS I
a) 0
b) 1
c) 2
d) 3
e) 5
04- Considerando trecho de um programa em C:
int a = 11;
while ( a>= 0 ){
a--;
printf( “\nA”);
}
int b = 11;
do{
b--;
printf( “\nB”);
}while( b > 0 );
Com base no que foi escrito do código, podemos afirmar que o número de vezes que a
letra A e a letra B serão mostradas na tela, respetivamente, é:
a) 12 e 11
b) 10 e 10
c) 11 e 11
d) 12 e 12
e) 11 e 10
05- No algoritmo abaixo, todas as variáveis definidas são do tipo numérico inteiro.
x = 20;
y = 3;
z = 0;
do{
x = x – 5;
y = y + 2;
97
ALGORITMOS I
z = z + x + y;
}while( x > 5 || z > 100 );
Simulando o seu funcionamento, o resultado final das variáveis “ X “, “ Y “ e “ Z “ será:
a) X = 5, Y = 9 e Z = 51
b) X = 0, Y = 9 e Z = 51
c) X = 0, Y = 11 e Z = 62
d) X = 5, Y = 11 e Z = 62
e) X = 5, Y = 9 e Z = 62
98
ALGORITMOS I
REFERÊNCIAS




99
ALGORITMOS I
100
ALGORITMOS I
4
unidade
VETORES E MATRIZES
101
ALGORITMOS I
4 INTRODUÇÃO À UNIDADE
Figura 13 - Organizar dados é o segredo para o sucesso de um software. Fonte: < https://abracd.org/
tutorial-numpy-os-primeiros-passos-em-computacao-numerica-e-tratamento-de-dados//>. Acesso em:
Setembro de 2020.
Seja bem-vindo à Unidade 4 de nosso caderno!

No processo de desenvolvimento de aplicações simples e didáticas, as necessidades de
variáveis são muito limitadas. Por outro lado, no processo de construção de software de
forma plena, precisamos organizar os dados, a fim de facilitar o acesso a eles e à produção
de novas informações. Ainda, dentro das possibilidades, buscamos que isso ocorra de
modo simples e claro nos códigos. É neste contexto que os tipos de dados compostos se
inserem.
Com eles, podemos trabalhar com grandes (grandes, mesmo!) quantidades de dados,
de maneira muito simples e intuitiva, além de podermos definir novos tipos de dados,
que existirão apenas dentro do nosso código, mas que poderemos usar como variáveis
normais.
Até o momento, trabalhamos apenas com os tipos de dados básicos oferecidos
pela Linguagem C. E, se precisarmos, por exemplo, trabalhar com os salários de 500
funcionários, juntamente com os seus nomes? Iríamos declarar 500 variáveis tipo float e
os nomes? Mesmo para as variáveis dos salários, controlar e organizar isso em um código
de programação é extremamente complexo e confuso.
Em primeiro lugar, analisaremos como podemos manter grandes conjuntos
homogêneos de dados, ou seja, como faremos para trabalhar com vários elementos de
um mesmo tipo básico de dados. Esta forma de implementarmos variáveis usa uma
quantidade de memória muito próxima (ou idêntica) àquela realizada com variáveis
isoladas, mas o controle das variáveis fica infinitamente mais fácil e organizado. Estes
serão os vetores.
102
ALGORITMOS I
Os vetores são estruturas unidimensionais. Na seção seguinte, vamos ampliar a
dimensionalidade e possibilitar que se trabalhe com armazenamento de dados em duas
ou mais dimensões, todavia ainda com dados homogêneos, ou seja, de um mesmo tipo.
Os principais objetivos de aprendizagem da Unidade 4 são:
• compreender a aplicação das estruturas bidimensionais no
desenvolvimento de software;
• conhecer as diferentes estruturas de dados básicas e suas aplicações na solução
de problemas;
• entender os mecanismos de controle e acesso a estruturas de dados; e
• assimilar a solução de problemas computacionais com processos recursivos.
4.1 VETORES
Vamos supor que, no nosso exemplo de cálculo da média de vários alunos

(Programas 11 e 12), precisamos armazenar os dados de cada aluno, isto é, devemos
guardar as notas que cada um deles obteve e a média calculada. A primeira ideia relativa a
isso é declararmos variáveis para armazenar estes dados, porém surge uma questão
importante: quantos alunos serão? É necessário este dado para definirmos as variáveis.
Além disso, após criarmos as variáveis, precisaríamos ler cada uma, de forma
individual, pois teríamos várias delas com nomes diferentes. Algo parecido com isso:
103
ALGORITMOS I
Quadro 36 - Variáveis
float aluno1_n1, aluno1_n2, aluno1_n3, aluno1_md;

......
printf( “Digite as notas do Aluno 1: “ );

scanf( “%f, %f, %f”, &aluno1_n1, &aluno1_n2,&aluno1_n3 );
.........
Agora, vamos supor que precisemos colocar todas as médias dos alunos em ordem
crescente. A ordenação de 20 médias, usando apenas desvios condicionais e laços, é
extremamente complexa.
Justamente para isso, é que vetores se apresentam como uma organização homogênea
de dados, formando conjuntos de elementos de mesma natureza. Um vetor é uma
estrutura de dados que ocupa N posições contíguas (vizinhas) de memória, todas de um
mesmo tipo. Ao declararmos um vetor de N posições, sua estrutura é a seguinte:
.....
0 1 2 3 4 5 6 7 n-2 n-1
Observe que, ao criarmos um vetor em memória, as posições vizinhas passam a ser

indexadas por um valor de índice. Este índice indica cada uma das posições do vetor. A
primeira delas tem o índice 0 (zero), a segunda tem índice 1 (um) e assim por diante. A
última posição tem por índice o tamanho do vetor subtraído de uma unidade, ou seja, n-1.
Por exemplo, se criarmos um vetor de 10 posições inteiras e guardarmos nele os 10
primeiros números primos, seu armazenamento será:
2 3 5 7 11 13 17 19 23 29
0 1 2 3 4 5 6 7 8 9
104
ALGORITMOS I
Quando declaramos o vetor, damos um nome a ele, como se estivéssemos nomeando
uma variável (inclusive, as regras são as mesmas). Por exemplo, se chamarmos o vetor
acima de V, sua declaração em C seria:
int V[10];
Nesta declaração, estamos fornecendo o tipo dos dados no vetor (int), seu nome (V) e
o seu tamanho (10). Podemos declarar vetores de qualquer tamanho maior ou igual a 2.
O limite é a disponibilidade de memória do computador e a capacidade da linguagem de
usá-la.
Como chamamos nosso vetor de V, podemos indexar (acessar) qualquer uma das
posições dele, informando o nome e a posição desejada. Por exemplo, V[3] indica a
posição atualmente ocupada pelo número 7. Podemos usar este tipo de indexação para
realizarmos qualquer operação que faríamos com uma variável comum. Por exemplo:
V[5] = V[6] – 2;
Faz com que a quinta posição (sexta na sequência – porque começa em zero!) receba
o valor da posição 6, subtraído de duas unidades. Esta posição teria, após a execução do
comando, o valor 15 armazenado nela.
A sintaxe da declaração de um vetor é:
<tipo_de_dado> nome_vetor[ tamanho ];
Como tipo de dado, podemos usar qualquer um dos tipos que estudamos até o
momento, por exemplo, char, int, float e outros tipos que a linguagem oferece. Para o
nome, valem as mesmas regras que usamos nas variáveis (afinal, estamos declarando
uma variável do tipo vetor). Já o tamanho, deve ser um número maior ou igual 2 e indicará
o número total de posições disponíveis.
4.1.2 Implementação e Uso
A criação do vetor nos permite definir um grupo de variáveis que coexistem, mas e
quanto ao seu uso? Se usarmos o vetor como variáveis comuns, nomeando as posições
individualmente, nossos programas serão desorganizados. Para resolver este problema,
105
ALGORITMOS I
os vetores, normalmente, são utilizados em conjunto com controladores de laço,
especialmente o laço FOR.
Para lermos todas as posições de um vetor de 20 posições do tipo inteiro, não
declaramos um scanf para cada posição. Usaremos um for para isso. Observe:
Quadro 37 – Laço FOR

int main(){
int V[20];
int i;
printf( “\nElementos do vetor:\n” );

for(i=0; i<20; i++ ){
printf( “\tPosição %d = “, i );
scanf( “%d”, &v[i] );
}
.........
return 0;
}
Neste exemplo, criamos um laço for com uma variável de controle i que receberá os
valores de 0 (zero) até 19. Para cada um dos valores, o scanf fará a leitura do elemento v[i].
O seu uso é exatamente como uma variável comum, inclusive com o & à frente do nome.
Se, após a leitura ou operações, desejarmos mostrar todos os elementos do vetor na
tela, basta usar um outro for:
for(i=0; i<20; i++ ){

printf( “\nPosição %d = %d“, i, v[i] );
}
Vamos fazer um exemplo completo: o usuário digitará 10 elementos inteiros diferentes

que serão armazenados em um vetor. Depois, vamos percorrer todas as posições do vetor
para determinarmos qual a soma de todos os números digitados. Ao final, mostraremos
o vetor e a soma dos seus elementos.
106
ALGORITMOS I
Quadro 38 - :NIS
int main(){
int V[10];
int i, soma=0;
// Leitura dos elementos

printf( “\nElementos do vetor:\n” );
for(i=0; i<10; i++ ){
printf( “\tPosição %d = “, i );
scanf( “%d”, &v[i] );
}
// Soma dos elementos
for(i=0; i<10; i++ ){
soma = soma + V[i];
}
// Escrever o vetor e a soma na tela
printf( “\nResultado:\n” );
for(i=0; i<10; i++ ){
printf( “ %d “, V[i] );
if( i != 9 ) printf( “ + “ );
}
printf( “ = %d\n”, soma );
return 0;
}
Desta vez, nosso programa teve algumas características estéticas interessantes. A

primeira foi o uso do formatador \t no printf, o qual inseriu uma tabulação, deslocando
o texto 4 ou 8 casas para a direita. O outro detalhe foi o uso dos recursos do printf, para
apresentar a soma na tela. Vamos supor que tenhamos digitado os 10 primeiros números
pares para o vetor. Assim, V={2,4,6,8,10,12,14,16,18,20}. O resultado será apresentado da
seguinte forma:
2 + 4 + 6 + 8 + 10 + 12 + 14 + 16 + 18 + 20 = 110
O símbolo + (mais) será mostrado ao lado do número que está no vetor para todas
as posições, exceto a última, pois o if( i != 9 ) somente será verdade para as posições
anteriores. Como não foi usado o formatador \n, não haverá nenhuma nova linha até que
o valor da soma seja apresentado.
É possível percorrermos os vetores da forma que nos for mais conveniente. Por
exemplo, caso a necessidade indique que ele deve ser percorrido do último elemento ao
107
ALGORITMOS I
primeiro, basta trocarmos o laço de controle para:
for(i-19; i<=0; i-- ){

printf( “\nPosição %d = %d“, i, v[i] );
}
Vamos construir mais um exemplo: faremos um programa que gera aleatoriamente

valores entre 0 e 100 para um vetor de 50 elementos inteiros e, depois, determina qual o
menor e o maior valor gerado para o vetor.
Em primeiro lugar, precisamos saber que a Linguagem C tem uma função para a
geração de números aleatórios, a qual se chama rand(), presente na biblioteca stdlib.h.
A função gerará valores entre 0 (zero) e a constante RAND_MAX definida na biblioteca
stdlib.h. Esta função é, na verdade, pseudoaleatória e tende a gerar valores repetidos.
Para minimizar o problema, costuma-se inicializar novamente o gerador de valores com
um número sobre o qual temos pouco controle, que é o horário do computador. Isso é
realizado através da função srand().
108
ALGORITMOS I
Quadro 39 - Programa 22: Gerar 50 Números e Encontrar o Maior e o Menor Valor
2 #include <stdlib.h>
3 #include <time.h>
4
5 int main(){
6 int V[50];
7 int i, menor, maior;
8
9 // Inicializar o gerador de números
10 srand( time( NULL) );
11
12 // Gerar os elementos
13 for(i=0; i<50; i++ ){
14 v[i] = rand() % 100;
15 }
16
17 // Procura dos valores
18 menor = v[0];
19 maior = v[0];
20 for(i=1; i<50; i++ ){
21 if( v[i] < menor ) menor = v[i];
22 if( v[i] > maior ) maior = v[i];
23 }
24 // Escrever o vetor e os valores encontrados
25 printf( “\nVetor gerado:\n” );
26 for(i=0; i<50; i++ ){
27 printf( “ %d “, V[i] );
28 }
29 printf( “O menor valor foi = %d\n”, menor );
30 printf( “O maior valor foi = %d\n”, maior );
31 return 0;
32 }
Podem-se notar alguns detalhes importantes sobre nosso programa. Em primeiro

lugar, observe a inclusão das bibliotecas nas três primeiras linhas. A necessidade delas
está guiada pelas funções que usamos. Precisamos de stdio.h para o scanf e o printf;
stdlib.h para o rand e srand; e, time.h para inicializar o gerador na linha 10, chamado a
função time(NULL).
Depois de preenchido o vetor, perceba que não temos controle sobre o que foi
colocado lá. Assim, definimos que o primeiro valor do vetor, presente em v[0] é tanto o
menor quanto o maior até aquele momento, nas linhas 18 e 19. Depois, percorremos todo
109
ALGORITMOS I
o restante do vetor e, encontrando um valor menor do que aquele que estiver na variável
menor, trocamos. O mesmo é feito para a variável maior.
PARA PRATICAR
EXERCÍCIOS
1- Leia 20 valores reais e os armazene em um vetor. Percorra este vetor e calcu-
le a média aritmética dos valores.
2- Faça um programa que carregue um vetor com dez números reais, calcule e mostre a quan-
tidade de números negativos e a soma dos números positivos deste vetor.
3- Faça um algoritmo que leia um vetor de 30 posições e informe quantos elementos são
múltiplos de 2, e quantos são múltiplos de 3.
4.1.3 Strings
Até o momento, trabalhamos com tipos de variáveis como int, float e char, mas, e se
precisarmos armazenar uma sequência de caracteres para formar, por exemplo, um nome
ou outro texto qualquer? Neste caso, usaremos um vetor feito de caracteres para tal tarefa:
char nome[50];
Para este tipo de vetor, possuímos, ainda, alguns recursos especiais que nos permitem
manipular os elementos de forma conjunta. Por exemplo, para ler ou escrever todo o
conjunto de elementos (e não um a um), usamos o controle %s no scanf e no printf.
Em relação ao scanf, temos um pequeno problema: ele lerá o texto digitado até o
primeiro espaço em branco encontrado. Desta forma, ele poderá não ler todo o conteúdo
digitado. Por exemplo, se você digitar o nome “João da Silva”, ele lerá somente o João.
Para resolver, temos duas soluções diferentes. Primeiro, podemos indicar ao scanf que
ele somente deve parar a leitura, quando encontrar um \n (enterou nova linha). A leitura
seria assim:
scanf(“%[^\n]s”,nome);
110
ALGORITMOS I
Ou podemos usar a função gets que faz a leitura de uma string em C, como o scanf:
gets( nome );
Desta forma, podemos escrever um pequeno programa para ler e apresentar o nome
completo de uma pessoa, fazendo:
Quadro 40 - :NP
int main(){
char nome[50];
printf( “\nDigite seu nome: “ );

gets(nome);
printf( “\nO nome digitado foi: %s\n”, nome );
return 0;
}
Atenção: vetores somente são comparáveis elemento a elemento. Assim, caso você
precise verificar se dois strings são iguais, deve escrever uma função que percorra cada
um deles e teste elemento a elemento. Também é possível usar um conjunto de funções
prontas do C, que estão disponíveis na biblioteca string.h e executam as tarefas básicas
com strings, como comparação, remover pedaços e outras. Para maiores informações,
procure nos livros [ZIVIANI,2004] ou [GOODRICH e TAMASIA, 2013].
4.2 MATRIZES

Com frequência, necessitamos armazenar dados de forma tabular, como os elementos
de uma planilha, por exemplo. Para isso, a Linguagem C dispõe de uma estrutura matricial
que nada mais é do que um vetor de duas dimensões. Na verdade, podemos trabalhar com
quantas dimensões necessitarmos, embora os dados sejam sempre da mesma natureza.
No case de uma estrutura bidimensional, trabalhamos com n linhas e m colunas, e a
estrutura forma terá a seguinte “aparência”:
111
ALGORITMOS I
Quadro 41 - Estrutura Bidimensional
0 1 2 3 .... m COLUNAS
0
1
2
...
n
LINHAS
Assim, cada elemento terá um índice que o define de forma única. Para tal, utilizamos
a linha e a coluna onde ele se encontra. Por exemplo, podemos utilizar o elemento
pertencente à linha 2 e coluna 3 e que está marcado com outra cor.
A sintaxe da declaração de uma matriz é:
<tipo_de_dado> nome_matriz[dimensão_1][dimensão_2]...[dimensão_n];
Por exemplo, para declaramos uma matriz com 5 linhas e 6 colunas, de dados inteiros,
devemos fazer:
int matriz[5][6];
Na Figura 13, é possível observar uma matriz que tem 5 linhas, 4 colunas e 3 de
profundidade sendo, portanto, tridimensional. Não há limite para a dimensionalidade
na Linguagem C, embora, dificilmente, será necessária uma matriz com mais do que 3
dimensões.
Figura 14 - Matriz com três dimensões.

112
ALGORITMOS I
A declaração desta matriz da Figura 14, considerando que os dados sejam do tipo float,
seria:
float cubo[5][4][3];
4.2.2 IMPLEMENTAÇÃO E USO
De forma muito semelhante ao vetor, precisaremos de controladores de laço para

manipular uma matriz. Neste caso, será necessário um controlador para cada dimensão
que a matriz possua, e estes controladores estarão aninhados (um dentro do outro).
Por exemplo, caso necessitemos ler os elementos da matriz 5x6 do exemplo anterior,
devemos escrever:
for(i=0; i<5; i++ ){

for( j=0; j<6; j++ ){
printf( “\nM[%d][%d] = “, i, j );
scanf( “%d”, &matriz[i][j] );
}
}
Já no caso do cubo da Figura 14, serão necessários três controladores de laço. Para
mostrá-los na tela, deveríamos fazer:
for(i=0; i<5; i++ ){

for( j=0; j<4; j++ ){
for( k=0; k<3; k++ ){
printf( “%f”, cubo[i][j][k] );
}
}
}
Observe a importância do correto posicionamento e controle dos indexadores.

Convencionamos, por exemplo, que, na matriz de duas dimensões, o primeiro valor
113
ALGORITMOS I
indica a linha e o segundo, a coluna. Não é preciso ser sempre assim, mas é altamente
recomendável que você siga sempre um padrão, para não criar problemas no seu programa.
Vamos construir um exemplo, baseado em matrizes ensinadas na Matemática do
Ensino Médio. Em nosso exemplo, vamos ler uma matriz quadrada 4x4 e um número real
e produzir uma segunda matriz, na qual os elementos devem estar multiplicados pelo
número dado. Esta operação chama-se produto escalar na álgebra de matrizes.
Quadro 42 - :EM
#include <stdio.h>
int main(){
float mat[4][4], res[4][4];
float num;
int i,j;
printf( “\nEntre com os elementos da matriz:” );

for( i=0; i<4; i++ ){
for( j=0; j<4; j++ ){
printf( “\nM[%d][%d] = ”, i, j );
scanf( “%f”, &mat[i][j] );
}
}
printf( “\nEntre com o multiplicador: “ );
scanf( “%f”, &num );
// Realizar a multiplicação
for( i=0; i<4; i++ ){
for( j=0; j<4; j++ ){
res[i][j] = num * mat[i][j];
}
}
// Mostrar o resultado
printf( “\nMatriz resultado:\n” );
for( i=0; i<4; i++ ){
for( j=0; j<4; j++ ){
printf( “\t%.2f”, res[i][j] );
}
printf( “\n” );
}
return 0;
}
114
ALGORITMOS I
Observe que, na impressão da matriz resultado, no final do programa, há uma linha,
contendo um printf(“\n”) entre a finalização dos dois laços for. Isso foi colocado, para
que a matriz apareça na tela com os elementos de cada linha dispostos lado a lado e, na
próxima linha, haja uma quebra de linha imposta pelo programa.
Ainda dentro do universo das matrizes, podemos fazer um novo programa, que recebe
duas matrizes 3x3 de inteiros e produz uma terceira matriz, o produto das duas primeiras.
Neste programa, precisamos lembrar que o produto de duas matrizes é realizado entre
as linhas da primeira, multiplicadas pelas colunas da segunda. Desta forma, vamos
necessitar de mais um controlador de laço para fazer o somatório destes produtos.
115
ALGORITMOS I
Quadro 43 - :M
#include <stdio.h>
int main(){
int A[3][3], B[3][3], res[3][3];
int i, j, k;
printf( “\nEntre com os elementos da matriz A:” );

for( i=0; i<3; i++ ){
for( j=0; j<3; j++ ){
printf( “\nA[%d][%d] = ”, i, j );
scanf( “%d”, &A[i][j] );
}
}
printf( “\nEntre com os elementos da matriz B:” );
for( i=0; i<3; i++ ){
for( j=0; j<3; j++ ){
printf( “\nB[%d][%d] = ”, i, j );
scanf( “%d”, &B[i][j] );
}
}
// Realizar a multiplicação
for( i=0; i<4; i++ ){
for( j=0; j<4; j++ ){
res[i][j] = 0;
for( k=0; k<3; k++ ){
res[i][j] = res[i][j] + (A[i][k] * B[k][j]);
}
}
}
printf( “\nMatriz resultado:\n” );
for( i=0; i<3; i++ ){
for( j=0; j<3; j++ ){
printf( “\t%d”, res[i][j] );
}
printf( “\n” );
}
Para finalizar esta secção, teremos um novo exemplo. Vamos gerar uma matriz 8x8, a
partir da sua regra de formação:
116
ALGORITMOS I
Este tipo de definição é muito comum na matemática de matrizes e, para ser
implementada, obrigará o programador a testar cada um dos casos para aplicar a regra
correta àquela situação.
Quadro 44 - :MRF
#include <stdio.h>
int main(){
int A[8][8];
int i, j;
for( i=0; i<8; i++ ){

for( j=0; j<8; j++ ){
if( i < j ) A[i][j] = 2 * i – 3 * j;
if( i == j ) A[i][j] = 3 * i * i – 1j;
if( i > j ) A[i][j] = 3 * i + 7 * j – 2;
}
}
printf( “\nMatriz:\n” );
for( i=0; i<8; i++ ){
for( j=0; j<8; j++ ){
printf( “\t%d”, A[i][j] );
}
printf( “\n” );
}
return 0;
}
SAIBA MAIS
Saiba mais sobre a implementação de matrizes e vetores na linguagem C, as-
sistindo aos vídeos de Gustavo Guanabara e de Eduardo Casavelha. Os links são:
https://www.youtube.com/watch?v=j9473xQ39vY&list=PLHz_AreHm4dmSj0MHol_ao NYCS-
GFqvfXV&index=15
https://www.youtube.com/watch?v=8qbqFsPov3g&t=266s.
117
ALGORITMOS I
Na última unidade deste material, descobrimos que é possível manipular dados, de

forma conjunta, nas linguagens de programação, usando dados homogêneos (de um
mesmo tipo) com os vetores e matrizes, e dados heterogêneos (tipos diferentes), através
dos registros e structs que farão parte do Carderno 2 desta mesma disciplina.
O uso dos recursos é fundamental para a construção de programas que vão dos mais
simples problemas até os mais complexos, pois todos, sem exceção, manipulam dados
das mais variadas formas. Assim sendo, para que um programa produza as informações
certas na sua saída, o armazenamento correto dos dados é condição fundamental para
sua operação.
Desta forma, é imprescindível que você, aluno deste curso, implemente cada um dos
exemplos, teste-os e analise o seu funcionamento passo a passo, a fim de compreendê-
lo melhor. Resolva também os exercícios propostos, como forma de aprimorar o seu
conhecimento.
118
ALGORITMOS I
EXERCÍCIO FINAL
01- Um programador escreveu o trecho de código a seguir:
int main(){
int i, v[10];
for( i =0; i<10; i++ ){
scanf( “%d”, &v[i] );
}
for( i=9; i>0; i-- ){
v[i] = v[i-1];
}
}
Se a sequência de números digitados pelo teclado for: 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, o
conteúdo do vetor v será:
a) 20, 18, 16, 14, 12, 10, 8, 6, 4, 2

b) 2, 6, 10, 14, 18, 22, 26, 30, 34, 38
c) 32, 30, 28, 26, 24, 22, 20, 18, 16, 14
d) 2, 2, 4, 6, 8, 10, 12, 14, 16, 18
e) 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
02- Considere o trecho de algoritmo a seguir, que usa uma matriz M[3][3] na sua
execução:
for( i=0; i<3 i++ ){

for( j=0; j<3; j++ ){
M[i][j] = 2*i + j;
}
}
Após a execução, a saída será:

a)
b)
c)
119
ALGORITMOS I
d)
e)
03- O seguinte programa define um vetor, atribui seus elementos e realiza

algumas operações com o conteúdo do vetor:
int main (){

int vet[10] = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20};
int x=0, i;
for (i = 0; i < 10; i +=2)

x += vet [i];
printf (“valor = %d”, x);
return 0;
}
Considereando este programa, o valor impresso para x é:
a) 110
b) 0
c) 22
d) 55
e) 50
04- Um programador recebeu a tarefa de implementar uma sub-rotina que,

a partir de uma matriz de entrada “A”, gerasse uma outra matriz de saída “B”. Um
pedaço desta função está apresentado abaixo:
for( i=0; i<2; i++ )

for( j=0; j<2; j++ )
b[j][i] = a[i][j];
Considere a matriz A = (aij) de dimensão 2 x 2, a seguir, onde aij são os elementos da

matriz A.
120
ALGORITMOS I
Nesta matriz, por exemplo, o elemento a0,0 possui o valor 3. A matriz “B”, resultante da
execução do algoritmo acima, tendo a matriz “A” como entrada, é:
a.
b.
c.
d.
e.
05- Considere o seguinte algoritmo:

int i, j,
float m[5][5], temp;
for( i=0; i<5; i++ ){
for( j=0; j<5; j++ ){
temp = m[i][j];
m[i][j] = m[j][i];
m[j][i] = temp;
}
}
Este algoritmo:
a) transforma a matriz M em sua matriz transposta.
b) transforma a matriz M em sua matriz inversa.
c) transforma a matriz M em uma matriz com os mesmos elementos da diagonal
principal e os demais elementos iguais a zero.
d) calcula o determinante da matriz M.
e) mantém a matriz M como ela iniciou o código.
121
ALGORITMOS I
REFERÊNCIAS

GOODRICH, M.; TAMASIA, R. Estruturas de Dados e Algoritmos em Java, 5ed. Porto

Alegre: Bookman, 2013.



ZIVIANI, N. Projeto de Algoritmos com Implementações em Pascal e C, 2ed. São Paulo:

Thompson: 2004.
122
ALGORITMOS I
uniavan.edu.br
124
XXXX

Algoritmos I.E Book

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Algoritmos I.E Book

Enviado por

Direitos autorais:

Formatos disponíveis

ALGORITMOS I

Depósito legal na Biblioteca Nacional, conforme Lei nº 10.994, de 14 de dezembro de 2010.

Nenhuma parte pode ser reproduzida, transmitida ou duplicada sem o consentimento

Projeto gráfico e diagramação: Ana Lúcia Dal Pizzol

Introdução. Operadores. Comandos Condicionais e Repetitivos. Conceitos preliminares

• Introduzir os conceitos de projeto e desenvolvimento de algoritmos.

O PAPEL DA DISCIPLINA NA FORMAÇÃO DO ACADÊMICO

Aprender é a grande chave responsável pelo sucesso de qualquer profissional. Neste

MARCOS CÉSAR CARRARD

UNIDADE 1 - CONCEITOS INICIAIS DE PROJETO DE ALGORITMOS.. . . . . . . . . . . . . . .11

UNIDADE 3 - CONTROLE DE REPETIÇÃO E FLUXO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

UNIDADE 4 - VETORES E MATRIZES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .101

Figura 1 - Programação de Computadores.

Olá! Seja bem-vindo!

1.1 ALGORITMOS E PROGRAMAÇÃO

Nesta seção, será apresentado o conceito de lógica de programação. Mas, antes

1.2.1 Lógica de Programação

Já que entendemos a “Lógica” como a arte de organizar o pensamento humano, de

Figura 2 - Formando triângulos com pedaços de material.

1.2.2 Solução de Problemas

2- Estabelecer um plano: precisamos planejar detalhadamente como vamos solucionar

3- Executar o plano: considere o plano da segunda etapa como um roteiro. Precisamos

Quadro 1 - Método de Análise e Solução de Problemas

Fonte: < https://blogdaqualidade.com.br/masp-metodo-de-analise-e-solucao-de-problemas-parte-1/.

1.3.1 Conceito de Algoritmo

Um algoritmo é definido como uma sequência finita de operações

1.3.2 Representação de Algoritmos

Um algoritmo pode ser representado de várias formas diferentes, estando todas

Fluxograma: é uma forma gráfica de representação que utiliza figuras e formas

Pseudocódigo: esta é a forma mais usual de escrevermos os algoritmos, quando

Neste material, iniciaremos o projeto dos nossos algoritmos como um pseudocódigo

Em nosso pseudocódigo, um algoritmo será dividido em três partes distintas:

1.4 MANIPULAÇÃO DE DADOS

1.4.1 Constantes e Variáveis

Fonte: Elaborado pelo autor (2020).

Cada vez que utilizamos uma variável em um algoritmo ou programa, devemos

salario_base nomeFuncionario altura

area = (base * altura) / 2 ou area = raio * raio * 3.14

Nestes dois casos temos constantes. No primeiro cálculo, 2 é um valor constante,

1.4.2 Expressões Aritméticas e seus Operadores

Neste material, definiremos como <operador> os símbolos das operações matemáticas

Quadro 2 – Operador e Operações Matemáticas Tradicionais

Observe, a seguir, algumas expressões válidas em nossos algoritmos:

Ela deveria ser descrita em uma expressão, como:

1.4.3 Expressões Lógicas e seus Operadores

Quadro 3 - Sinais Relacionais

a) (aux >= 10) or (letra == ‘A’)

(aux >= 10) or (letra == ‘A’)

b) (aux > 30) or (50 != 100/3) and (aux % 2 > 0)

(letra == “B”) and (27/3 == 9) or (aux >= 300/100)

1.5.1 Comandos de Entrada e Saída

a) Comando de entrada de dados

ler ( lista de variáveis separadas por vírgula )

b) Comando de saída de dados

O comando de saída de dados é utilizado para transferir dados e informações do

escrever( texto entre aspas )

escrever( “A área do triângulo é: “, area )

1.5.2 Primeiros Algoritmos

Uma vez que já possuímos conhecimento sobre os elementos básicos da escrita de um

Quadro 4 - Algoritmo 1: Cálculo da Média em uma Disciplina

As linhas do nosso algoritmo foram numeradas, apenas para facilitar a análise e

Qual o raio do círculo? 10

Problema 3: Combustível necessário para uma viagem.