FACULDADES INTEGRADAS SIMONSEN

CURSO DE TECNOLOGIA EM ANÁLISE E DESELVOLVIMENTO DE SISTEMAS

Jonathan Casanova

Luciane da Rocha de Lima

ALGORITMOS COMPUTACIONAIS

Rio de Janeiro
2019
Jonathan Casanova - 201910548
Luciane da Rocha de Lima - 201930331

ALGORITMOS COMPUTACIONAIS

Trabalho do curso de Tecnologia em

Análise e Desenvolvimento de Sistemas
apresentado à disciplina Algoritmos.
Profº: Luiz Cruz

Rio de Janeiro
2019
 Lista de Tabelas

Tabela 1. Operadores Aritméticos ............................................................................... 7

Tabela 2. Operadores Relacionais .............................................................................. 8
Tabela 3. Operadores Lógicos .................................................................................... 8
 Sumário

1. INTRODUÇÃO ....................................................................................................................... 5

2. ALGORITMOS ....................................................................................................................... 6

2.1. Dados x Informação .................................................................................................................. 6

2.2. Tipos de Dados .......................................................................................................................... 6

2.3. Variáveis ..................................................................................................................................... 7

3. OPERADORES ....................................................................................................................... 7

3.1. Operadores aritméticos ............................................................................................................ 7

3.2. Operadores Relacionais ........................................................................................................... 8

3.3. Operadores Lógicos.................................................................................................................. 8

3.4. Operador de atribuição ............................................................................................................. 9

4. CONDICIONAIS ..................................................................................................................... 9

4.1. Condicionais Se, Então, Senão e Fim-se ................................................................................ 9

5. ESTRUTURAS DE REPETIÇÃO .............................................................................................. 10

5.1. Estrutura Enquanto (While) .................................................................................................... 10

5.2. Estrutura Para (For)................................................................................................................. 10

5.3. Estrutura Repita Até (Repeat-Until). ...................................................................................... 11

6. EXEMPLOS DE ALGORITMOS (NÃO USADOS EM SALA) ....................................................... 12

6.1. Algoritmo “Peso Ideal” ........................................................................................................... 12

6.2. Algoritmo "Coletando Dados” ............................................................................................... 13

6.3. Algoritmo “Números ímpares” .............................................................................................. 15

6.4. Algoritmo "Bhaskara" ............................................................................................................. 16

7. REFERÊNCIAS...................................................................................................................... 18
 5

1. INTRODUÇÃO

Algoritmos computacionais, ou simplesmente algoritmos estão por toda a parte,

ganhando cada vez mais evidência no noticiário, internet e dia-a-dia. Eles estão nas
bolsas de valores, engenharia automotiva, redes sociais, mas também na compra do
mês, no planejamento de uma viagem e em cozinhar um bolo.
Isso tudo se deve ao fato de um algoritmo é uma sequência lógica de passos
para resolver um problema (situação), que é escrito em linguagem de computador.
A construção de um algoritmo segue basicamente três etapas, onde: a primeira
consiste em identificar o problema a ser resolvido, assim como sua solução. A
segunda etapa trata da descrição a sequência de passos que todos os envolvidos com
a situação-problema entendam. Por último, vem a etapa onde esses passos são
traduzidos para linguagem de programação, que podem ser das mais variadas ordens,
como: operações matemáticas simples ou complexas, sistemas médicos de marcação
de consulta, ou ainda o tempo de mudança das luzes em um semáforo na esquina.
Para tanto, foram organizados princípios de sintaxe, padrões estruturais e
ainda, estruturas condicionais de repetição lógicas na elaboração e execução dos
algoritmos computacionais.
 6

2. ALGORITMOS

De forma simplificada podemos definir algoritmos como um procedimento bem

definido que toma algum valor ou conjunto de valores como entrada e produz algum
valor ou conjunto de valores como saída. Sendo o algoritmo essa sequência de
passos.

2.1. Dados x Informação

Um dado não possui significado suficientemente relevante e não conduz a
nenhuma compreensão em si.
A informação ordena e organiza os dados de maneira que transmita um
significado em um determinado contexto.
Os dados manipulados por um algoritmo podem possuir variadas naturezas e
dependendo dessa natureza, operações feitas com eles podem não ter sentido lógico.
Por exemplo somar duas letras não faz sentido e não produz informação relevante.
Com base nessa diferença existem tipos e dados aplicados às linguagens de

2.2. Tipos de Dados

Os dados são divididos em grupos de valores ao qual o dado pertence e às operações
a que eles são submetidos.
Para algoritmos simples ou complexos, trabalhados em Portugol do VisuAlg, temos os
seguintes tipos de dados:
 Inteiro: são números inteiros, positivos e negativos, ou seja, que não
apresentam casas decimais, representados em Portugol pela
concatenação dos dígitos de 0 a 9.
 Real: os números reais, além de números inteiros, são caracterizados por
possuir uma parte fracionada. No Portugol, a separação dos dígitos reais
é feita com um ponto (.) e não com vígula (,) como é feito usualmente.
 Caractere: são os tipos que denotam a concatenação de letras, incluindo
o alfabeto romano, todos os dígitos de 0 a 9, e caracteres de pontuação
como a interrogação (?), dentre outros símbolos. Esses caracteres dentro
do código são caracterizados por serem escritos entre aspas (“”).
 7

 Lógico: é o tipo responsável por valores lógicos de falso e verdadeiro,

assim como as operações de negação.

2.3. Variáveis
Variáveis podem ser imaginadas como “caixas” que armazenam valores de
dados. Elas só podem armazenar um valor de cada vez, mas ainda assim, podendo
ser modificado durante a execução do algoritmo. Essa “caixa” corresponde a um lugar
na memória, quando consideramos um ambiente computacional.
As variáveis são compostas basicamente por um nome, um tipo e um conteúdo.
O nome deve obedecer às normas e padrões preestabelecidos em cada linguagem
de programação. O tipo de uma variável define os valores que poderão ser
armazenados por ela e, o conteúdo é o valor que ela armazena e que é armazenado
um de cada vez. Ao ato de criar uma variável dá-se o nome de “declaração de
variável”.

3. OPERADORES

Há variadas operações que podem ser realizadas por algoritmos, dentre elas constam
as operações aritméticas básicas adição, subtração, multiplicação e divisão, assim
também como a exponenciação.
Mas existem outras operações possíveis como comparações para verificar igualdade
ou diferença entre dados, maior e menor.
Essas operações são subdivididas dentro dos seguintes operadores:

3.1. Operadores aritméticos

Basicamente são as responsáveis pelas operações aritméticas com dados numéricos.
São representados pelos símbolos:

Tabela 1. Operadores Aritméticos

Portugol (VisuAlg) Operadores

+ Soma
- Subtração
* Multiplicação
 8

/ Divisão
\ Divisão inteira
^ ou Exp Exponenciação
% Módulo (resto da divisão)

3.2. Operadores Relacionais

Representam as operações de comparação entre dados: menor/igual e maior/igual,

igual, diferente e são representando pelos símbolos:

Tabela 2. Operadores Relacionais

Portugol (VisuAlg) Operadores

> Maior
< Menor
= Igual
<> Diferente
>= Maior ou igual
<= Menor ou igual

3.3. Operadores Lógicos

São aqueles que realizam operações lógicas, isto é, de verdadeiro ou falso e

negação, baseando na premissa de que uma determinada condição será atendida
para que o resultado seja lógico dentro destes parâmetros. Esses parâmetros formam
uma tabela chamada tabela verdade, cuja a ilustração pode se ver na tabela abaixo:

Tabela 3. Operadores Lógicos

Portugol (VisuAlg) Operadores Tabela Verdade

Verdadeiro, se âmbar partes forem
E Multiplicação Lógica
verdadeiras
Verdadeiro, se uma parte é
OU Adição Lógica
verdadeira
 9

Nega uma afirmação, se for

verdadeiro resulta em falso, e
NÃO Negação
quando falso resulta em
verdadeiro

3.4. Operador de atribuição

É o operador responsável pela atribuição de valores correspondentes a uma

determinada variável dentro do algoritmo, que foi declarada com aquele tipo
correspondente. No VisuAlg é representada pelo símbolo <-.
Exemplo: nome <- “Maria” (A variável nome recebe o valor Maria)

4. CONDICIONAIS

Estruturas condicionais são estruturas que executam um comando sob

condições predeterminadas. Essas estruturas retornarão Verdadeiro ou Falso e usam
os comandos Se, Então, Senão e o Fim-Se.

4.1. Condicionais Se, Então, Senão e Fim-se

O condicional Se é um dos mais usados na programação. Através dele é

estabelecido o caminho por onde o algoritmo caminhará, submetendo uma situação
condicionada à seus desdobramentos dentro do código.
Atrelado ao condicional Se está o condicional Então, que oferece o desenrolar
do comando definido no Se.
O comando Senão é a oposição ao Se/Então, oferecendo a possibilidade
contrária ao que foi proposto pelo condicional Se.
O Fim-Se é o comando que determina o fim da estrutura condicional
encabeçada por Se, como pode ser visto no exemplo abaixo:
Se <alguma condição for atendida> Então
<executa a condição> Senão
<executa a não-condição>
Fim-se
 10

5. ESTRUTURAS DE REPETIÇÃO

Na construção de um algoritmo as estruturas de repetição são estruturas que

permitem executar mais de uma vez o mesmo comando ou conjunto de comandos,
de acordo com uma condição ou com um contador.
São utilizadas, por exemplo, para repetir ações semelhantes que são
executadas para todos os elementos de uma lista de dados, ou simplesmente para
repetir um mesmo processamento até que a condição seja satisfeita.
Para tal repetição são utilizadas basicamente 3 estruturas, são elas o Para,
Enquanto e Repita Até.

5.1. Estrutura Enquanto (While)

Dentre as estruturas de repetição a Enquanto é a mais simples. Ela condiciona

um bloco de códigos para que repita enquanto uma condição permanecer verdadeira.
Quando essa condição se torna falsa, a repetição para.
Ela é usada quando não há necessidade de inicializar ou atualizar variáveis
contadoras.
Após entrar dentro da repetição, o bloco de comandos sempre será executado,
mesmo que dentro do bloco a variável que está controlando a execução seja alterada.

5.2. Estrutura Para (For)

O Para é utilizado para executar um conjunto de comandos executado por um

número finito de vezes. É passada uma situação inicial, uma condição e uma ação a
ser executada a cada repetição.
A variável é inicializada com uma valor inicial, essa variável é utilizada para
controlar a quantidade de vezes em que o conjunto de comandos será executado.
E ao final do conjunto de comandos a variável sempre sofrerá uma alteração,
aumentando ou diminuindo de acordo com a lógica utilizada. O número de repetições
é controlado por uma variável controladora.
 11

5.3. Estrutura Repita Até (Repeat-Until).

Uma outra estrutura de repetição é a Repita Até. A diferença desta estrutura é

que ela é uma repetição pós-testada, isto é, o teste para verificar se o bloco será
executado novamente, acontece no final do bloco. Isso garante que as instruções
dentro deste bloco serão executadas ao menos uma vez.
 12

6. EXEMPLOS DE ALGORITMOS (NÃO USADOS EM SALA)

6.1. Algoritmo “Peso Ideal”

Tendo como dados de entrada a altura e o sexo de uma pessoa, construa um
algoritmo empseudocodigo que calcule peso ideal, utilizando as seguintes
fórumulas:Para homens: (72.7*h) – 58 Para mulheres: (62.1*h) – 44.7 Onde h equivale
a altura da pessoa

var
a, p :real
s : caracter

Inicio
escreval("Digite o seu sexo F ou M: ")
leia(s)
escreval("Digite a sua altura: ")
leia(a)

se(s = "F") entao

p <- (62.1 * a) - 44.7
escreval("Seu peso ideal é: ",p)
senão
fimse
se(s = "M") entao
p <- (72.7 * a) - 58
escreval("Seu peso ideal é: ",p)
senao
escreval("Digite um sexo válido")
fimse
fimalgoritmo
 13

6.2. Algoritmo "Coletando Dados”

A prefeitura de uma cidade fez uma pesquisa entre seus habitantes, coletando
dados sobre o salário e número de filhos. Elabore um algoritmo para
apresentar.

a) média do salário da população;

b) média do número de filhos;
c) maior salário;
d) percentual de pessoas com salário até R$100,00.

var
sinal,filho,qtdCad,TotalFilho,qtd100: inteiro
salario,SomaSal,MediaSal,MediaFilho,perc100,maiorSal: real
Inicio
qtdCad<-0
qtd100<-0
SomaSal<-0
TotalFilho<-0
sinal<-1
maiorsal<-0
Enquanto sinal=1 faca
escreval("Escolha um opcao:")
escreval("1- Para Cadastrar")
escreval("2- Para Sair")
leia(sinal)
limpatela
se sinal=1 entao
escreval("Infore o Salário: ")
leia(salario) // lê o salario
escreval("Informe N.o De Filhos: ")
leia(filho) // lê qtd de filho
 14

SomaSal<-SomaSal+salario //Soma o Salario

TotalFilho<-TotalFilho+filho // Soma os filhos
qtdCad<-qtdCad+1 // Conta qtd de Cadastro
fimse
se salario>maiorsal entao
maiorsal<-salario // Armazena o maior Salario
fimse
se salario <=100 entao
qtd100<-qtd100+1 //Conta qtd de pessoas que ganham te
100,00
fimse
fimenquanto
MediaSal<-SomaSal/qtdCad
MediaFilho<-TotalFilho/qtdCad
Perc100<-qtd100/qtdCad*100
escreval("A media de Salario é: ",MediaSal)
escreval("A media de Filhos é: ",MediaFilho)
escreval("O Maior Salario é: ",maiorsal)
escreval(Perc100,"% Recebem até R$100,00")
fimalgoritmo
 15

6.3. Algoritmo “Números ímpares”

Escrever um algoritmo que gera e escreve os números ímpares entre 100 e 200.

var
i: inteiro
Inicio
Para i de 100 ate 200 faca
se(i mod 2)<>0 entao
escreval(i)
fimse
fimpara
fimalgoritmo
 16

6.4. Algoritmo "Bhaskara"

Escrever um algoritmo que leia 3 números, onde esses números serão
aplicados na fórmula de Bhaskara, como método resolutivo para encontrar raizes. O
resultado determinará se há uma ou duas raizes.

var
a, b, c, x1, x2, b2, delta : real

Inicio
Escreval("Formula: Delta = b^2-4.a.c ")
Escreval("---------------------------------------")
Escreval("Digite um valor para A")
Leia(a)
Escreval("Digite um valor para B")
Leia(b)
Escreval("Digite um valor para C")
Leia(c)

b2<-b*b

delta<-b2-4*a*c
Escreval("---------------------------------------")
Escreval("O resultado de Delta é igual a ", delta)
Escreval("---------------------------------------")

Se delta > 0 Entao

Escreval("Existem duas raizes reais.")
x1<-(-b-RaizQ(delta))/2*a
x2<-(-b+RaizQ(delta))/2*a
Escreval("A primeira raiz (X1) é =",x1)
Escreval("A segunda raiz (X2) é =",x2)
Fimse

Se delta = 0 Entao
 17

Escreval("Existe uma única raiz real.")

x1<-(-b-RaizQ(delta))/2*a
x2<-(-b+RaizQ(delta))/2*a
Escreval("A primeira raiz (X1) é = ",x1)
Escreval("A segunda raiz (X2) é = ",x2)
Fimse

Se delta < 0 Entao

Escreval("Não possui nenhuma raiz real.")
Fimse

Fimalgoritmo
 18

7. REFERÊNCIAS

ALVES, Gustavo Furtado de Oliveira. Estrutura de repetição Repita Até. Dicas de

Programação. Disponível em: https://dicasdeprogramacao.com.br/estrutura-de-
repeticao-repita-ate/. Acesso em: 16 de jun. de 2019.

CAVALCANTE, Sergio. Exercícios Resolvidos. Fórum Masters. Disponível em:

https://forum.imasters.com.br/topic/505362-exercicios-resolvidos-vai-quebrar-seu-
galho/. Acesso em: 16 de jun. de 2019.

CORMEN, Thomas H, Algoritimos: teoria e prática /...[et al.]. Tradução da segunda

edição [americana] Vandenberg D. de Souza – Rio de Janeiro: Elsevier 2002 – 6ª
Reimpressão.

MIYABARA, Willians. Exercícios Resolvidos VisuALg. SlideShare. Disponível em:

https://pt.slideshare.net/williansmiyabara/exercicios-resolvidos-visu-
alg?from_action=save. Acesso em: 16 de jun. de 2019.

PIERRO, Bruno de. O mundo medido por algoritmos. Revista Pesquisa FAPESP,
2018. Disponível em: https://revistapesquisa.fapesp.br/2018/04/19/o-mundo-
mediado-por-algoritmos/. Acesso em: 16 de jun. de 2019.

SILVA, Alexandra da Silva; JESUS, Débora de; MOUTA, Matheus. Noções básicas
de algoritmo. DEVMEDIA. Disponível em https://www.devmedia.com.br/nocoes-
basicas-de-algoritmo/26405. Acesso em: 16 de jun. de 2019.

ZENELATO, Jessica. Lógica de Programação: estruturas de repetição.

PodProgramar. Disponível em: https://podprogramar.com.br/logica-de-programacao-
estruturas-de-repeticao/. Acesso em: 16 de jun. de 2019.