Vous êtes sur la page 1sur 377

Algoritmos - Notas de Aula

Ricardo Vargas Dorneles

6 de maio de 2015
Ementa

Construção de soluções algorítmicas para problemas numéricos


simples e problemas envolvendo entrada e saída de dados.
Utilização de rotinas de manipulação de variáveis.
Implementação de algoritmos para realização de operações
sobre conjuntos e de pesquisa e ordenação de dados.
Objetivo

Proporcionar condições de ensino-aprendizagem para que o


aluno seja capaz de analisar problemas, formular soluções
algorítmicas estruturadas que possam ser executadas pelo
computador.
Implementar algoritmos simples utilizando uma linguagem de
programação em português estruturado.
Conteúdo Programado

1 Introdução
1 1.1.Linguagens de programação de alto nível
2 1.2.Etapas no processo de elaboração e execução de programas
2 2. Introdução à programação estruturada com a construção de
soluções algorítmicas para:
1 2.1.Cálculo de expressões aritméticas simples
2 2.2.Problemas numéricos simples
3 2.3.Entrada e saída de dados
4 2.4.Classicação usando variáveis simples e operadores
relacionais
5 2.5.Processamento de uma ou mais entradas gerando uma ou
mais saídas
6 2.6.Cálculo de médias e do desvio padrão
7 2.7.Técnicas de vericação de algoritmos (teste de mesa ou
simulação de algoritmos)
Conteúdo Programado

1 3. Manipulação de variáveis
1 3.1.Auxiliares
2 3.2.Temporárias
3 3.3.Contadoras
4 3.4.Acumuladoras
5 3.5.Sinalizadoras
6 3.6.Totalizadoras
Conteúdo Programado

1 4. Algoritmos de operações com conjuntos


1 4.1.Operações básicas
2 5. Algoritmos de Ordenação e Pesquisa
1 5.1.Método bolha (bubble sort)
2 5.2.Método de seleção
3 5.3.Inserção ordenada
4 5.4.Fusão ordenada
5 5.5.Busca linear
6 5.6.Busca binária
Metodologia

A disciplina deve ser desenvolvida através de


exposições/discussões teóricas que serão realizadas em função
das atividades relacionadas aos conteúdos abordados.
Implementação de soluções para problemas especícos
priorizando a busca de soluções algorítmicas para classes de
problemas tradicionais da computação.
As soluções algorítmicas devem ser expressas em uma
linguagem na forma "português estruturado"para que sejam
trabalhados igualmente aspectos sintáticos e semânticos dos
comandos da linguagem.
Metodologia

A disciplina deve ser desenvolvida em sala de aula


convencional, permitindo que os alunos resolvam os problemas
propostos, testando e comparando soluções.
A disciplina deverá dispor de uma home-page com a função de
organizar o trabalho a ser desenvolvido.
Os alunos deverão ainda ter acesso a um ambiente virtual
através do qual lhes serão disponibilizados recursos para
aprendizagem , assim como recursos de comunicação com
professores e alunos, para tratar de temas e problemas de
interesse comum.
Avaliação

Os resultados da avaliação deverão retro-alimentar o processo


de ensino-aprendizagem.
O sistema de avaliação compreende três avaliações parciais
provas sobre o conteúdo programático, das quais é obtida a
média de aproveitamento do aluno quanto aos objetivos
propostos.
Serão atribuídos pesos diferenciados para cada uma das
provas, sendo que para a primeira prova será atribuído peso 1
(um), para a segunda prova será atribuído peso 2 (dois) e para
a terceira prova será atribuído peso 3 (três).
Avaliação

O resultado da avaliação será calculado de acordo com as


regras estabelecidas pela unidade responsável pela oferta do
curso, bem como a forma de recuperação da avaliação.
Será considerado aprovado o aluno que alcançar 60% dos
resultados das avaliações e tiver freqüência igual ou superior a
75% das aulas.
A nota nal do aluno será expressa segundo as normas
regimentais da Instituição.
O cálculo da média nal é feito pela média harmônica ponderada
das três provas, ou seja:
6
M .H . = 1 2 3
P1 + P2 + P3
Alunos que não atingirem média 6 podem recuperar uma das
provas ao nal do semestre.
Bibliograa Básica

FAR 89 FARRER, H. et al. Algoritmos Estruturados. Rio de Janeiro:


Editora Guanabara, 1999.
Cor 04 CORMEN, Thomas H.. Algoritmos: teoria e prática. Rio de
Janeiro: Elsevier, 2004.
Bibliograa Complementar

SCH 84 SCHEID, F. Computadores e Programação. São Paulo:


McGraw-Hill, 1984.
SIL 82 SILVA, H.V.R.C.; BARANAUSKAS, M.C.C.; DIAS, S.V.
Introdução a Programação de Computadores. Rio de Janeiro:
Campus, 1982.
TRE83 TREMBLAY, J.; BUNT, R.B. Ciência dos Computadores -
Uma abordagem algorítmica. São Paulo: McGraw-Hill, 1983.
SAL 98 SALVETTI, D.D.; BARBOSA, M.B. Algoritmos. São Paulo:
Makron Books, 1998.
ORT 02 ORTH, A.I. Algoritmos. Porto Alegre: Ciência dos
Computadores, 2002.
Algoritmo

Um algoritmo é ums lista ordenada de comandos que, quando


executados, resultam em uma sequencia de ações, que visam
resolver um determinado problema.
Ex:????
Você está dirigindo em uma estrada e sente que um pneu
furou.
Você para o carro no acostamento e...
Faça um algoritmo para trocar o pneu de um carro.
Nessa disciplina os algoritmos vistos serão algoritmos
computacionais, a serem executados por um computador.
A um conjunto de comandos que pode ser executado por um
computador chamamos de "Linguagem de Programação".
Exs:????? (uma consulta ao Google "Quantas linguagens de
programação existem"mostrará que existem centenas)
Para a construção de qualquer tipo de algoritmo, é necessário
seguir estes passos:
1 Compreender completamente o problema a ser resolvido,
destacando os pontos mais importantes e os objetos que o
compõem.
2 Denir os dados de entrada, ou seja, quais dados serão
fornecidos e quais objetos fazem parte desse cenário-problema.
3 Denir o processamento, ou seja, quais cálculos serão
efetuados e quais as restrições para esses cálculos. O
processamento é responsável pela transformação dos dados de
entrada em dados de saída. Além disso, deve-se vericar quais
objetos são responsáveis pelas atividades.
4 Denir os dados de saída, ou seja, quais dados serão gerados
depois do processamento.
5 Construir o algoritmo utilizando um formalismo conhecido.
6 Testar o algoritmo realizando simulações.
Ao conjunto de regras que denem os comandos válidos em
uma linguagem (de programação ou não) chamamos de
sintaxe da linguagem.
Sintaxe : é a parte da gramática que estuda a disposição das
palavras na frase e a das frases no discurso, bem como a
relação lógica das frases entre si.
Aplica-se a linguagens naturais, como a língua portuguesa
(lembram da análise sintática?)
Aplica-se a linguagens de programação
Nessa disciplina, todos os nossos algoritmos serão escritos em
uma linguagem chamada Português Estruturado, que é uma
tradução direta de uma linguagem chamada Pascal.
Todos os algoritmos nessa linguagem tem o formato:
Algoritmo
Declarações
Inicio
Comandos
Fimalgoritmo
Programador x Usuário
Estudo de Caso: O algoritmo Soma2

O objetivo do algoritmo soma2 é que o usuário digite 2


números no teclado e o algoritmo deve exibir na tela a soma
dos 2 números.
Um possível diálogo entre o algoritmo e o usuário seria:
(computador) - Digite o primeiro número
(usuário) 7
(computador) - Digite o segundo número
(usuário) 4
(computador) - A soma é 11
Comando de Escrita

A primeira ação do computador deve ser emitir para a tela a


mensagem "Digite o primeiro número". Para isso é utilizado o
comando de escrita.
O comando de escrita é utilizado para o algoritmo enviar
mensagens para a tela.
Essas mensagens podem ser mensagens solicitando dados ao
usuário ou resultados do processamento.
Seu formato é:
Escreva (lista de mensagens)
onde as mensagens da lista são separadas por vírgula, e cada
mensagem é uma sequência de quaisquer caracteres
delimitadas por .
Escreval

Ex:
Escreva("Bom","Dia")
Ao terminar de executar o comando Escreva, o cursor cará
imediatamente após o último caracter escrito.
Alternativamente, o comando Escreval(lista de mensagens )
escreve uma lista de mensagens e posiciona o cursor na
primeira coluna da linha seguinte.
Variáveis

São os elementos de armazenamento de dados em um


programa.
Uma variável corresponde sicamente a uma posição de
memória do computador.
Ela contem sempre um (1) valor.
Ao receber um novo valor, o valor anterior é substituído.
Uma variável é identicada por um nome, chamado
identicador da variável.
Um identicador de variável deve iniciar por letra e só pode
conter letras, dígitos e o caracter "sublinha".
E não pode ser nenhuma palavra reservada da linguagem
(p.ex. Escreva, algoritmo, inicio, malgoritmo...)
Uma variável pode ser vista como uma caixinha identicada
por um nome e que pode armazenar valores de um tipo
denido (por exemplo: inteiro ou real)
Comando de Atribuição

O comando utilizado para alterar o valor de uma variável


chama-se comando de atribuição e tem o formato:
variável <- expressão (leia-se "variável RECEBE expressão")
Ex:
a <- 1
a <- a+1
a <- a+b
Na atribuição, quando uma variável recebe uma expressão, o valor
da expressão é calculado e o resultado é atribuído à variável.
Em um algoritmo que contenha as variáveis a, b, c e d, após a
sequência de atribuições a seguir:
a <- 1
b <- 2
c <- 3
as variáveis terão os seguintes valores (o "?"em d signica que
d ainda não tem um valor denido ou, em outras palavras,
contem "lixo"):
Ex: O que será escrito pelo trecho de código abaixo?
a <- 1
b <- 2
a <- a+b
b <- a+b
a <- a+b
b <- a+b
a <- a+b
b <- a+b
escreva (a,b)
A lista de elementos do comando de escrita pode conter
variáveis e expressões. Nesse caso, é escrito o conteúdo da
variável ou, no caso da expressão, o valor resultante do cálculo
da expressão.
Teste de Mesa

O teste de mesa simula a execução de um algoritmo sem


utilizar o computador,empregando apenas "papel e caneta"(ou
melhor, sem utilizar um computador).
Passos para realizar o teste de mesa:
Identique as variáveis envolvidas em seu algoritmo;
Crie uma tabela com uma coluna para cada uma das variáveis
do algoritmo;
Crie também uma coluna para o que será escrito pelo
algoritmo ao ser executado um comando de escrita
Situação inicial

Inicialmente nenhuma das variáveis possui um valor conhecido.


Isso pode ser representado por um "?"

a <- 1
b <- 2
a <- a+b
b <- a+b
a b escritas
a <- a+b
? ?
b <- a+b
a <- a+b
b <- a+b
escreva (a,b)
Simule a execução do algoritmo, passo a passo, a partir da
primeira instrução.
A cada comando de leitura a variável que recebe o valor lido
deve ser atualizada na tabela
A cada comando de atribuição, a variável que recebe a
expressão é atualizada na tabela
A cada comando de escrita, o valor escrito pelo comando é
colocado na coluna das escritas
O valor corrente da variável é representado pelo último valor
(mais embaixo) da coluna correspondente;
Primeira instrução

a <- 1
b <- 2
a <- a+b
b <- a+b a b escritas
a <- a+b ? ?
b <- a+b 1
a <- a+b
b <- a+b
escreva (a,b)
Segunda instrução

a <- 1
b <- 2
a <- a+b
b <- a+b a b escritas
? ?
a <- a+b
1
b <- a+b 2
a <- a+b
b <- a+b
escreva (a,b)
Terceira instrução

a <- 1
b <- 2
a <- a+b a b escritas
b <- a+b ? ?
a <- a+b 1
b <- a+b 2
a <- a+b 3
b <- a+b
escreva (a,b)
Quarta instrução

a <- 1
b <- 2
a <- a+b a b escritas
b <- a+b ? ?
1
a <- a+b
2
b <- a+b 3
a <- a+b 5
b <- a+b
escreva (a,b)
Quinta instrução

a <- 1
b <- 2
a b escritas
a <- a+b
? ?
b <- a+b 1
a <- a+b 2
b <- a+b 3
a <- a+b 5
8
b <- a+b
escreva (a,b)
Final da simulação

a <- 1 a b escritas
b <- 2 ? ?
1
a <- a+b
2
b <- a+b 3
a <- a+b 5
b <- a+b 8
a <- a+b 13
21
b <- a+b 34
escreva (a,b) 2134
O valor escrito foi 2134 porque não há separação entre o a e b
O comando de escrita deve explicitamente identicar o que
será escrito entre as variáveis
Ex:
Escreva(a," ",b) // escreverá um espaço em branco entre a e
b
Escreva(a,",",b) // escreverá uma vírgula entre a e b
É importante executar TODOS os comandos, atualizando a
tabela a cada comando, sem pular nenhum.
Se um comando não for executado, o resultado obtido
provavelmente estará errado.
A simulação deve reetir o que o algoritmo realmente faz, e
não aquilo que o programador espera que ele faça
Declaração de variáveis

Para que uma variável seja utilizada em um algoritmo é


necessário que ela seja declarada no início do mesmo. O
formato de uma declaração é:
Var <lista de declarações>
onde cada declaração tem o formato
lista de variáveis : tipo
onde tipo pode ser inteiro ou real.
Ex:
Var a,b,c:inteiro
x,y:real
Comando de Leitura

É utilizado para o algoritmo receber dados pelo teclado. Seu


formato é:
Leia (lista de variáveis)
Ex:
Leia (valor1, valor2, valor3)
Ao executar esse comando, o algoritmo espera o usuário digitar
3 valores, e armazena o primeiro em valor1, o segundo em
valor2 e o terceiro em valor3.
Assim: o algoritmo Soma2 pode ser completado:
Algoritmo
var a,b,soma:inteiro
inicio
escreval("Digite um valor")
leia(a)
escreval("Digite outro valor")
leia(b)
soma <- a + b
escreval("A soma é ",soma)
escreval("Tenha um bom dia!!!")
malgoritmo
Abrir um navegador (preferencialmente o Chrome) em
http://vposeidon9.ucs.br
1 Editar, na janela da esquerda (editor de algoritmos) o
algoritmo a seguir:

Algoritmo
var a,b,soma:inteiro
inicio
escreval("Digite um valor")
leia(a)
escreval("Digite outro valor")
leia(b)
soma <- a + b
escreval("A soma é ",soma)
escreval("Tenha um bom dia!!!")
malgoritmo
Algoritmo digitado
1 Executar o algoritmo digitado (botão "Executar"em cima à
esquerda) diversas vezes, testando com as opções linha-a-linha
e leia aleatório selecionados.
1 Executar através do botão Passo-a-Passo.
2 Durante a execução passo a passo examinar o conteúdo das
variáveis na aba "Variáveis/Computação"(abaixo)
1 Executar através do botão Passo-a-Passo.
2 Durante a execução passo a passo examinar o conteúdo das
variáveis na aba "Variáveis/Computação"(abaixo)
Funcionalidades do Ambiente de Algoritmos

Além dos recursos apresentados (edição e execução de


algoritmos) o ambiente apresentado possui os seguintes
recursos:
Uma lista de aproximadamente 300 problemas cobrindo todo o
conteúdo de algoritmos da disciplina;
Um mecanismo de vericação automática da correção das
soluções para os problemas da lista;
Possibilidade de armazenar todas as soluções dos usuários em
um servidor, possibilitando o acesso às mesmas de qualquer
computador dentro ou fora da UCS;
Mecanismo de avaliação do custo de execução de uma solução;
"Ranking"dos usuários que resolveram corretamente a maior
quantidade de problemas em cada categoria.
"Ranking"dos usuários com mais exercícios resolvidos
Cadastro de usuário

Para utilizar as funcionalidades descritas, é necessário efetuar um cadastro no servidor do


ambiente
Sugere-se que utilize-se o mesmo login, email e senha do ucs virtual, mas não é indispensável,
mas o login, senha e email só podem conter letras e dígitos
O cadastro é efetuado através da aba "Gerência de Usuários"mostrada abaixo:
Banco de Problemas

Após efetuar o cadastro, logar-se no ambiente, selecionar a aba


Banco de Algoritmos e selecionar a categoria de problemas.
Inicialmente trabalharemos com os problemas da categoria
"Sequenciais".
Seleção de Problema

Após selecionada a categoria, selecionar o primeiro problema (S0000050) da lista de problemas.


O enunciado do problema irá aparecer na caixinha "Descrição do problema".
Imediatamente após o enunciado aparecerá também um exemplo de dados de entrada e saídas
esperadas para o problema selecionado.
Criação de uma solução para um problema novo

Criar uma solução vazia para o problema (Botão "Criar


Solução"embaixo, à direita).
A solução criada irá aparecer na lista de soluções do usuário,
abaixo.
Selecionar a solução recém criada na lista de soluções e editar
a solução do problema na janela de edição de algoritmos.
Salvamento de uma solução

O salvamento de uma solução no servidor só é habilitado


quando ela está associada a algum problema da lista.
O salvamento pode ser feito a qualquer momento durante a
edição, mesmo que a solução não esteja completa ou que não
funcione.
Salvamento de uma solução

O salvamento de uma solução no servidor só é habilitado


quando ela está associada a algum problema da lista.
O salvamento pode ser feito a qualquer momento durante a
edição, mesmo que a solução não esteja completa ou que não
funcione.
Cálculo do Custo de uma solução

No cálculo do custo são contabilizadas todas as operações


aritméticas, atribuições, escritas, leituras, testes e desvios
efetuados pelo algoritmo.
No exemplo abaixo as 8 operações executadas são:

1) Escrita de uma mensagem 2) Salto de linha na escrita


3) Uma leitura 4) Cálculo de uma multiplicação
5) Uma atribuição 6) Escrita de uma mensagem
7) Escrita de uma variável 8) Salto de linha na escrita
Validação de uma solução

Na validação de uma solução, ela é executada para diversos


conjuntos de dados, que buscam testar se o algoritmo funciona
em diferentes situações.
Se o algoritmo não gerar o resultado esperado para algum dos
conjuntos de dados previstos, será emitida uma mensagem de
erro.
O algoritmo abaixo funciona somente para a=1 e o erro será
identicado quando o algoritmo tentar escrever o resultado
(errado) gerado.
Validação de uma solução

Na validação de uma solução, se o algoritmo testado gerar a


resposta correta para todos os dados de teste, será mostrada a
mensagem "Executou corretamente todas as instâncias"
Nesse caso o custo total das diversas execuções será mostrado
imediatamente abaixo da tela de edição à esquerda.
Acesso externo ao portal de algoritmos

Para acessar de fora da universidade o portal de algoritmos é


necessário utilizar um protocolo seguro no navegador. Para
fazer isso, deve-se colocar "https://"no início do endereço. O
resto do endereço permanece igual, cando
"https://vposeidon9.ucs.br".
O portal não tem um certicado de segurança válido, então o
navegador vai alertar diversas vezes que o site é suspeito. Mas
é só ir concordando com o navegador e conrmar tudo que ele
pedir.
Para que o navegador consiga entrar em um site sem
certicado pode ser necessário congurar, no painel de
controle do Windows, icone "Java", aba "segurança", a
segurança para "média"e reiniciar o navegador para que o
navegador possa rodar o portal sem um certicado.
Pode-se também adicionar à lista de exceções no Java o
endereço do portal.
S00000050 - Faça um algoritmo que leia um valor N, representando
o lado de um quadrado, e calcule e escreva a área do quadrado.
algoritmo "S001_S00000050"
var N,area:inteiro
inicio
Escreval("Digite o valor do lado")
leia (N)
area<-n*n
escreval("A area é ",area)
malgoritmo
S00000100 - Faça um algoritmo que leia dois valores inteiros e
escreva a sua soma.
algoritmo "S001_S00000100"
var a,b,soma:real
inicio
escreva("Digite dois valores:")
leia(a,b)
soma < − a+b
escreva("A soma é ",soma)
malgoritmo
S00000150 - Faça um algoritmo que leia 3 valores reais, notas de
um aluno, e escreva sua média aritmética. A média aritmética de
um conjunto de valores é dada pela soma dos valores dividido pela
quantidade de valores considerados.
algoritmo "S002_S00000150"
var a,b,c,media:real
inicio
leia(a,b,c)
media<-(a+b+c)/3
escreva("a média é ",media)
malgoritmo
S00000200 - Faça um algoritmo que leia 2 valores reais v1 e v2 e
calcule e escreva a área do triângulo que tem base igual a v1 e
altura igual a v2. Dica:A área de um triângulo é dada pela
expressão: (base x altura)/2
S00000220 - O produto escalar A.B de dois vetores A=[a1,a2,a3...]
e B=[b1,b2,b3...] é dado pelo somatório a1*b1+a2*b2+a3*b3+...
Faça um algoritmo que leia as coordenadas ax,ay,az,bx,by,bz de
dois vetores no espaço tridimensional e calcule e escreva seu
produto escalar.
a l g o r i t m o " S001_S00000220 "
v a r ax , ay , az , bx , by , bz : r e a l
inicio
l e i a ( ax , ay , az , bx , by , bz )
e s c r e v a ( ax ∗ bx+ay ∗ by+az ∗ bz )
fimalgoritmo
Expressões:

Podem ser aritméticas, lógicas ou literais. Consistem da


aplicação de operadores sobre operandos resultando em
valores. Os operadores podem ser:
Aritméticos : são aplicados a operandos numéricos e resultam
em valores numéricos. Os operadores aritméticos suportados
pelo AlgoUCS são o seguintes:
Operação Operador Prioridade Associatividade Tipo de valor retornado
Troca de Sinal - 1 <- o mesmo do operando
se algum operando é real,
Potenciação  2 <- resulta real, caso contrário
resulta inteiro
Multiplicação * 3 -> idem à potenciação
Divisão / 3 -> real
Quociente da divisão inteira \ 3 -> inteiro
Resto da divisão inteira % 3 -> inteiro
Soma + 4 -> idem à potenciação
Subtração - 4 -> idem à potenciação

Observações:
O operador de troca de sinal é o único operador de apenas um
operando
Os operadores de quociente e resto de divisão inteira só são
aplicáveis a operandos inteiros
Observações:

1 Operadores da mesma prioridade são avaliados pela sua


associatividade, normalmente da esquerda para a direita, com
exceção da potenciação e troca de sinal, que são avaliadas da
direita para a esquerda.
2 Parênteses podem ser utilizados para alterar a ordem de
avaliação dos operadores.
3 Radiciação pode ser obtida com o operador de potenciação.
A distância entre dois pontos denidos pelas coordenadas
(x1 , y1 ) e (x2 , y2 ) no plano cartesiano é dada por:
q
(x1 − x2 )2 + (y1 − y2 )2

Escreva a expressão correspondente de acordo com as regras e


operadores utilizados em português estruturado:
As raízes da equação ax 2 + bx + c = 0 podem ser calculadas
pela fórmula de Baskhara a seguir:

−b ± b2 − 4ac
2a

Escreva a expressão correspondente de acordo com as regras e


operadores utilizados em português estruturado:
1 Escreva as expressões correspondentes na nossa linguagem à
expressão da fórmula de Baskhara.
2 Entre com o Firefox em http://vposeidon9.ucs.br e logue-se
com seu usuário (quem não veio à aula anterior e ainda não
tem usuário, execute as orientações da aula anterior).
3 Resolva os exercícios 300 e 900.
S00000300 - Faça um algoritmo que leia 3 valores a, b e c,
coecientes de uma equação de segundo grau, e calcule e escreva a
soma das raízes da equação. Dica:As raízes de uma equação podem
ser calculadas pela fórmula de Baskhara.
algoritmo
v a r a , b , c , d e l t a , x1 , x2 : r e a l
inicio
l e i a (a , b , c)
d e l t a <− r a i z q ( b^2−4∗ a ∗ c )
x1<−(−b+d e l t a ) / ( 2 ∗ a )
x2<−(−b− d e l t a ) / ( 2 ∗ a )
e s c r e v a ( x1+x2 )
fimalgoritmo
S00000350 - Faça um algoritmo que leia 3 valores a, b e c,
coecientes de uma equação de segundo grau, e calcule e escreva o
produto (multiplicação) das raízes da equação. Dica:As raízes de
uma equação podem ser calculadas pela fórmula de Baskhara.
algoritmo
v a r a , b , c , d e l t a , x1 , x2 : r e a l
inicio
l e i a (a , b , c)
d e l t a <− r a i z q ( b^2−4∗ a ∗ c )
x1<−(−b+d e l t a ) / ( 2 ∗ a )
x2<−(−b− d e l t a ) / ( 2 ∗ a )
e s c r e v a ( x1 ∗ x2 )
fimalgoritmo
Funções raizq( ) e abs( )

Além dos operadores aritméticos, também podem ser


utilizadas em expressões as funções raizq( ), que calcula a raiz
quadrada de um valor, e a função abs( ) que calcula o valor
absoluto (módulo) de um valor.
Uma chamada de função pode ser colocada em qualquer lugar
da expressão onde iria um operando. Ex:
a <- raizq (b 2-4*a*c)
b <- a + abs(x-y)
Resolver os exercícios 400, 500 e 600 do portal.
S00000210 - O produto vetorial AxB de dois vetores A=[ax,ay] e
B=[bx,by] é um vetor perpendicular ao plano formado pelos vetores
A e B, de módulo igual a |ax*by-ay*bx|. Faça um algoritmo que
leia as componentes ax,ay,bx e by dos vetores A e B, e calcule e
escreva o módulo do vetor resultante do produto vetorial.
algoritmo
v a r ax , ay , bx , by : r e a l
inicio
l e i a ( ax , ay , bx , by )
e s c r e v a ( abs ( ax ∗ by−ay ∗ bx ) )
fimalgoritmo
S00000400 - Faça um algoritmo que leia 2 valores e escreva o
maior deles. Dica:O maior entre dois valores quaisquer v1 e v2 pode
ser calculado pela expressão v1 +v2 +|2 v1 −v2 | . O operador matemático
de módulo ( |x| ) é representado na nossa linguagem pela função
abs(x)
algoritmo
var a,b,valor:real
inicio
escreva ("digite 3 valores")
leia (a,b)
valor < − (a+b+abs(a-b))/2
escreva ("o maior número é",valor)
malgoritmo
S00000500 - Faça um algoritmo que leia 2 valores e escreva o
menor deles. Dica:O menor entre dois valores pode ser obtido a
partir do maior valor e da soma dos dois (por exemplo: Se a soma
de dois valores é 15 e o valor do maior é 10, como pode ser
calculado o valor do menor?).
algoritmo
var a,b,menor:real
inicio
leia(a,b)
maior< −(a+b+abs(a-b))/2
menor< −a+b-maior
escreva(menor)
malgoritmo
S00000600 - Faça um algoritmo que leia 3 valores escreva o
maior deles. Dica:O maior entre três valores pode ser
encontrado pela aplicação repetida da expressão para
encontrar o maior entre dois valores.
algoritmo
var a,b,c,valor:real
inicio
escreva ("digite 3 valores")
leia (a,b,c)
valor < − (a+b+abs(a-b))/2
valor < − (valor+c+abs(valor-c))/2
escreva ("o maior número é",valor)
malgoritmo
S00000900 - Faça um algoritmo que lê 3 valores, lados de um
triângulo, e calcule e escreva a área do triângulo formado.
Dica: A área de um triângulo de lados l1 , l2 e l3 pode ser
calculada pela expressão

Area = S ∗ (S − l1 ) ∗ (S − l2 ) ∗ (S − l3 )
p

onde S é o semi-perímetro, ou seja, a metade da soma dos


lados.
algoritmo "S001_S00000900"
var a,b,c,s,area:real
inicio
leia(a,b,c)
s<-(a+b+c)/2
area<-raizq(s*(s-a)*(s-b)*(s-c))
escreva(area)
malgoritmo
Operadores de divisão inteira

São utilizados para divisões entre valores inteiros, que devem


resultar em um quociente inteiro e um resto inteiro.
Os operadores são o de quociente inteiro, representado pela
contrabarra (\) e o de resto inteiro, representado pelo
percentual (%).
Os operadores são independentes um do outro, pode-se querer
calcular só o resto ou só o quociente.
Se for necessário calcular os dois (o resto e o quociente),
deve-se executar dois comandos, um para o cálculo do resto e
um para o cálculo do quociente. Ex:
b <- 378
a <- b \ 100 nesse comando a variável a recebe 3
c <- b % 100 e c recebe 78
Resolva os exercícios 700, 800 e 1000 do portal.
S00000700 - Faça um algoritmo que lê um valor inteiro em reais e
calcula e escreve qual o menor número possível de notas de
100,50,20,10,5,2 e 1 real em que o valor pode ser decomposto.
Dica:Isso pode ser calculado a partir de operações de divisão inteira.

leia ( valor )
Notas100 <− v a l o r \ 100
v a l o r <− v a l o r % 100
Notas50 <− v a l o r \50
v a l o r <− v a l o r %50
...
S00000800 - Faça um algoritmo que lê uma quantia inteira em
segundos e escreva o número de horas, minutos e segundos
correspondente. Dica:Pode-se converter segundos para minutos
usando-se a divisão inteira por 60. Ou pode-se converter segundos
para horas usando-se a divisão por 3600.
S00001000 - Faça um algoritmo que le um valor entre 0 e 9999 e
calcula a soma dos seus dígitos. Dica: O dígito menos signicativo
de um número inteiro pode ser obtido pelo resto da divisão do
número por 10. Os dígitos restantes podem ser obtidos pela divisão
inteira por 10.
Ex: Separação de dígitos

leia ( valor )
m i l h a r <− v a l o r \ 1000
Ex: Separação de dígitos

leia ( valor )
m i l h a r <− v a l o r \ 1000
v a l o r <− v a l o r % 1000
Ex: Separação de dígitos

leia ( valor )
m i l h a r <− v a l o r \ 1000
v a l o r <− v a l o r % 1000
c e n t e n a <− v a l o r \ 100
Ex: Separação de dígitos

leia ( valor )
m i l h a r <− v a l o r \ 1000
v a l o r <− v a l o r % 1000
c e n t e n a <− v a l o r \ 100
v a l o r <− v a l o r % 100
Ex: Separação de dígitos

leia ( valor )
m i l h a r <− v a l o r \ 1000
v a l o r <− v a l o r % 1000
c e n t e n a <− v a l o r \ 100
v a l o r <− v a l o r % 100
d e z e n a <− v a l o r \ 10
Ex: Separação de dígitos

leia ( valor )
m i l h a r <− v a l o r \ 1000
v a l o r <− v a l o r % 1000
c e n t e n a <− v a l o r \ 100
v a l o r <− v a l o r % 100
d e z e n a <− v a l o r \ 10
u n i d a d e <− v a l o r % 10
Ex: Separação de dígitos (b)

leia ( valor )
u n i d a d e <− v a l o r % 10
v a l o r <− v a l o r \ 10
d e z e n a <− v a l o r % 10
v a l o r <− v a l o r \ 10
c e n t e n a <− v a l o r % 10
m i l h a r <− v a l o r \ 10
S00001200 - Faça um algoritmo que leia 4 valores, Hi, Mi, Hf, Mf,
representando respectivamente a hora e minuto inicial e nal de um
evento, e calcule a duração do mesmo em horas e minutos.
Considere que o evento inicia e termina no mesmo dia. Dica: Para
simplicar o problema, converta cada par de valores em um único
valor em minutos.
algoritmo "S001_S00001200"
var hi,mi,hf,mf,dh,dm,d:inteiro
inicio
leia(hi,mi,hf,mf)
d<-hf*60+mf-hi*60-mi
dh<-d\60
dm<-d\60
escreva(dh,"horas e ",dm,"minutos")
malgoritmo
S00001300 - Faça um algoritmo que leia dois horários (hora,
minuto e segundo) e escreva quantos segundos transcorreram entre
esses dois horários.
algoritmo "S001_S00001300"
var hi,mi,si,hf,mf,sf:inteiro
inicio
leia(hi,mi,si,hf,mf,sf)
escreva(hf*3600+mf*60+sf-(hi*3600+mi*60+si))
malgoritmo
S00001350 - Faça um algoritmo que leia um horário (hora, minuto
e segundo) e escreva o horário correspondente ao segundo seguinte.
Ex: se for lido, 17,21,36 escrever 17,21,37. Considere que os
horários (lido e escrito) estão na faixa de 00:00:00 a 23:59:59.
algoritmo
v a r h ,m, s : i n t e i r o
inicio
l e i a ( h ,m, s )
s <−3600∗ h+60∗m+s+1
h<−(s \3600)%24
m<−s %3600\60
s<−s%60
e s c r e v a ( h ,m, s )
fimalgoritmo
S00001400 - Faça um algoritmo que a partir de um horário (hora,
minuto, segundo) e uma quantidade de segundos transcorridos,
calcule o segundo horário.
a l g o r i t m o " S001_S00001400 "
v a r h ,m, s , s t : i n t e i r o
inicio
l e i a ( h ,m, s , s t )
s<−s+s t
m<−m+s \60
s<−s%60
h<−h+m\60
m<−m%60
e s c r e v a ( h ,m, s )
fimalgoritmo
S00001500 - Faça um algoritmo que leia a quantidade de alunos
em uma sala de aula e a quantidade de alunos por grupo, e calcule
e escreva quantos grupos serão formados e o resto de alunos que
não foram sucientes para formar mais um grupo.
a l g o r i t m o " S001_S00001500 "
v a r N, Ag , g , r : i n t e i r o
inicio
l e i a (N, Ag )
g<−N\Ag
r<−N%Ag
escreva (g , r )
fimalgoritmo
S00001650 - Faça um algoritmo que leia um número de 10 dígitos e
rotacione os dígitos uma posição para a esquerda, de modo que o
primeiro dígito passe a ocupar a última posição. Ex: 1234561234
deve gerar 2345612341 (todos os dígitos foram uma posição para a
esquerda e o 1 da primeira posição passou a ocupar a última
posição).
a l g o r i t m o " S001_S00001650 "
var a : i n t e i r o
inicio
leia (a)
e s c r e v a ( a %1000000000 ∗ 10+ a \1000000000)
fimalgoritmo
S00001700 - Faça um algoritmo que leia 5 números inteiros e
escreva a quantidade deles que são pares. Dica:Um número é par se
o resto da sua divisão por 2 é zero.
a l g o r i t m o " S001_S00001700 "
var a , b , c , d , f : i n t e i r o
inicio
l e i a (a , b , c ,d , f )
e s c r e v a (5 − ( a%2+b%2+c%2+d%2+f %2))
fimalgoritmo
S00001800 - Faça um algoritmo que leia 5 números inteiros e
escreva a soma dos que forem ímpares. Dica:Um número é ímpar se
o resto da sua divisão por 2 é um.
a l g o r i t m o " S001_S00001800 "
v a r n1 , n2 , n3 , n4 , n5 , soma : i n t e i r o
inicio
l e i a ( n1 , n2 , n3 , n4 , n5 )
n1<−n1 % 2 ∗ n1
n2<−n2 % 2 ∗ n2
n3<−n3 % 2 ∗ n3
n4<−n4 % 2 ∗ n4
n5<−n5 % 2 ∗ n5
soma<−n1+n2+n3+n4+n5
e s c r e v a ( soma )
fimalgoritmo
Troca de variáveis

Para trocar os conteúdos de duas variáveis entre si, é


necessário copiar o valor de uma delas para uma terceira
variável.
O trecho a seguir é o trecho padrão para trocar entre si os
valores de a e b:
aux <- a
a <- b
b <- aux
Resolva o exercício 1100.
S00001100 - Faça um algoritmo que leia 3 valores v1, v2 e v3, e
troque os valores entre si de modo que ao nal a variável v2
contenha o valor que foi lido para v1, a variável v3 contenha o valor
que foi lido para v2, e a variável v1 contenha o valor que foi lido
para a variável v3. Dica:Para trocar os valores de duas variáveis
(digamos v1 e v2) entre si, salva-se o valor de uma delas (p.ex., v1)
em uma variável auxiliar qualquer (p.ex., aux) , copia-se o valor da
segunda (v2) para a variável que foi salva (v1), e copia-se o valor
da variável auxiliar (que contem o valor original da primeira), para a
segunda variável.
Comando Se ou Comando Condicional

É utilizado quando o algoritmo deve executar comandos


diferentes em diferentes situações.
Seu formato é:
Se condição
entao lista de comandos
mse
ou
Se condição
entao lista 1
senao lista 2
mse
onde condição é uma expressão de comparação que resulta
verdadeiro ou falso.
Os operadores de comparação são:
=
<> (diferente)
>
<
>=
<=
Exemplo:
Se a>0
entao escreva("Positivo")
senao escreva("Negativo")
mse
Se a>b
entao escreva(A, "é maior")
mse
O comando condicional deve ser utilizado quando há diversas
situações que devem ser tratadas de formas diferentes pelo
algoritmo. Os passos para utilizá-lo são:
1 Identicar com clareza quais as diferentes situações que devem
ser tratadas pelo algoritmo.
2 Denir qual o comportamento (comandos que devem ser
executados) que o algoritmo deve ter em cada uma das
situações.
3 Encontrar expressões que permitam ao algoritmo identicar
cada uma das situações.
Resolva os exercícios 20, 40, 60, 80, 100, 200, 1200, 300, 350
e 360 da lista de condicionais.
C00000020 - Faça um algoritmo que leia um valor e escreva:
0, se o valor é zero;
1, se o valor é maior que zero;
-1 - se o valor é negativo.
escreva("Digite um valor:")
leia(a)
Se a>0
entao escreva(1)
mse
Se a=0
entao escreva(0)
mse
Se a<0
entao escreva(-1)
mse
C00000040 - Faça um algoritmo que leia um valor e escreva:
0, se o valor é par;
1, se o valor é ímpar.
C00000060 - Faça um algoritmo que leia dois valores e,
através de uma comparação, escreva o maior deles. Considere
que os dois valores são diferentes.
C00000080 - Faça um algoritmo que leia dois valores e escreva
os dois em ordem crescente.
Operadores Lógicos

uma condição pode conter diversas expressões de comparação


combinadas com o uso dos operadores e e ou.Ex:
Se a>=b e a>=c
entao escreva(a, "é maior")
mse
uma expressão com e é verdadeira se ambas as subexpressões
são verdadeiras.
Uma expressão com ou é verdadeira se pelo menos uma das
expressões é verdadeira.
O operador e tem prioridade maior que o operador ou.
C00000100 - Faça um algoritmo que leia 3 valores v1, v2 e v3,
e escreva-os em ordem crescente.
C00000200 - Faça um algoritmo que leia 3 valores v1, v2 e v3
e coloque-os em ordem crescente, de forma que v1 contenha o
menor, v2 contenha o elemento do meio (nem o maior, nem o
menor), e v3 contenha o maior. Escreva os valores ordenados.
C00000250 - Escreva um algoritmo que leia os valores das
quatro provas de um aluno e escreva a média aritmética
considerando apenas as três melhores notas. Por exemplo, se o
valores lidos foram 9, 9.5, 7, e 8, a média será (9 + 9.5 +
8)/3 (a prova de nota 7 é descartada). Dica:Não esqueça de
considerar a possibilidade de ocorrerem notas iguais.
C00000300 - Faça um algoritmo que leia 3 valores a, b e c,
coecientes de uma equação de segundo grau, e verique se a
equação tem raízes reais. Se a equação tiver raízes reais,
calcule e escreva as raízes da equação (em ordem crescente).
Se não tiver, escreva "A equação não possui raízes reais".
Dica: As raízes de uma equação podem ser calculadas pela
fórmula de Baskhara. Uma equação não possui raízes se reais
se B*B-4*a*c < 0
Comandos Se aninhados

A sintaxe do comando Se é:
Se c o n d i ç ã o
e n t a o l i s t a de comandos
senao l i s t a 2
fimse

As listas de comandos (do entao e do senao) podem conter


qualquer comando dentre os comandos já vistos, leitura,
escrita, atribuição... inclusive o comando se.
Para utilizar um comando se dentro de outro (no então ou no
senão), ele deve estar completo (Se condição entao lista de
comandos mse).
Um exemplo de uso é:
Se a=0
entao escreva("zero ",0)
senao Se a>0
entao escreva("positivo", 1)
senao escreva("negativo", 2)
mse
mse
C00000350 - Faça um algoritmo que leia 3 valores a, b e c,
lados de um triângulo, e verique o tipo de triângulo formado
escrevendo:
0 - se o triângulo é equilátero (os três lados são iguais);
1 - se o triângulo é isósceles (dois lados iguais e um diferente);
2 - escaleno (3 lados diferentes).
Alternativa 1

Leia(a,b,c)
se a=b e a=c
entao escreva("Equilatero ",0)
mse
se a<>b e a<>c e b<>c
entao escreva("Escaleno ",2)
mse
se a=b e a<>c ou a=c e a<>b ou b=c e a<>b
entao escreva("Isósceles ",1)
mse
Alternativa 2

Leia(a,b,c)
se a=b e a=c
entao escreva("Equilatero ",0)
senao se a<>b e a<>c e b<>c
entao escreva("Escaleno ",2)
senao escreva("Isósceles", 1)
mse
mse
Alternativa 3

Leia(a,b,c)
se a=b e a=c
entao escreva("Equilatero ",0)
senao se a=b ou a=c ou b=c
entao escreva("Isósceles", 1)
senao escreva("Escaleno ",2)
mse
mse
Qual das três alternativas é mais eciente?
Por quê é mais eciente?
Por que a expressão do Isósceles na alternativa 1 é diferente da
alternativa 3?
Em que situações se pode colocar um se dentro do outro (Se's
aninhados)
Pode-se colocar sempre?
Pode-se usar Se's aninhados no código seguinte?
algoritmo "C001 C00000100"
var a,b,c,aux:inteiro
inicio
leia(a,b,c)
se a>b entao
aux<-a
a<-b
b<-aux
mse
se a>c entao
aux<-a
a<-c
c<-aux
mse
se b>c entao
aux<-b
b<-c
c<-aux
mse
escreva(a,b,c)
malgoritmo
C00000360 - Faça um algoritmo que leia 3 valores a, b e c,
lados de um triângulo, e verique o tipo de triângulo formado
escrevendo:
0 - se o triângulo é retângulo (A2 = B 2 + C 2 );
1 - se o triângulo é acutângulo (A2 > B 2 + C 2 ) ;
2 - obtusângulo (A2 < B 2 + C 2 ).
Lembre que, para aplicar as relações mostradas, o algoritmo
deve garantir que o maior dos 3 lados estará em A.
C00000400 - Faça um algoritmo que leia 3 valores l1,l2 e l3 e
verique se formam um triângulo. Se formarem, calcule e
escreva a área do triângulo formado (veja exercício
S00000900). Se não formarem, escreva -1.
Obs: A área do triângulo de lados a, b e c pode ser calculada
pela fórmula de Hierão, dada abaixo:
Area = S (S − a)(S − b)(S − c )
p

onde
a+b+c
S=
2
Obs: Uma triângulo pode ser denido pelo valor de seus três
lados. Entretanto, nem todo conjunto de 3 valores formam um
triângulo. Assim, 3,4,5 formam um triângulo. 10,3,2 não
formam. 10,5,5 formam? Qual a condição para que 3 valores
formem um triângulo?
Condição para 3 valores formarem um triângulo

"Cada um dos três lados deve ser menor que a soma dos
outros dois"
ou seja, "A deve ser menor que B+C, B deve ser menor que
A+C e C deve ser menor que A+B"
ou, como uma condição: A<B+C e B<A+C e C<A+B
Condição para 3 valores NÃO formarem um triângulo

"Um dos lados deve ser maior que a soma dos outros dois"
ou seja, "A deve ser maior ou igual a B+C, B deve ser maior
ou igual a A+C OU C deve ser maior ou igual a que A+B"
ou, como uma condição: A>=B+C ou B>A+C ou
C>A+B
C00000410 - Faça um algoritmo que leia 3 valores l1,l2 e l3 e
verique se formam um triângulo e, se formarem, o tipo de
triângulo formado, escreva:
0 - se não formarem triângulo;
1 - se formarem um triângulo equilatero (os três lados são
iguais);
2 - se formarem um triângulo isósceles (dois lados iguais e um
diferente);
3 - se formarem um triângulo escaleno (3 lados diferentes)
C00000450 - Faça um algoritmo que implemente uma
calculadora de 4 operações. O algoritmo deve ler, nessa
ordem: o primeiro operando, o operador (+,-,*,/) e o segundo
operando, e deve escrever o resultado da operação. Por
exemplo, se o usuário digitar 2,+,3 o algoritmo deve escrever
5. Dica: Para que uma variável possa receber um texto
(mesmo que seja apenas o caracter "+") ela deve ser
declarada como "literal".
Literais

Variáveis literais são variáveis utilizadas para trabalhar com


informação não numérica.
Elas devem ser declaradas como "literal"e podem conter
qualquer sequencia de caracteres.
Para atribuir um texto a uma variável literal usa-se o comando
de atribuição, da mesma forma que uma variável numérica. Ex:
nome <- "Maria"
Comparação de Literais

Pode-se efetuar comparações entre literais usando os


operadores de comparação:
se nome="Juca"
entao ...
Para comparação de maior ou menor, é considerada a ordem
lexicográca (alfabética).
Resolva o exercício 450 da lista de condicional.
C00000460 - Faça um algoritmo que leia um literal contendo
uma expressão com 3 caracteres, onde o primeiro caractere é
um dígito entre 0 e 9, o segundo é um operador (+,-,*,/) e o
terceiro caractere é um dígito entre 0 e 9, e efetue o cálculo da
expressão escrevendo o resultado. Dica:Use a função subliteral
para separar os 3 caracteres e a função val para converter os
operandos em seus valores numéricos.
Função subliteral

Além de atribuição e comparação há outras funções para


trabalhar com literais:
subliteral ( literal, posicao inicial, numero de posicoes) -
retorna o subliteral, a partir de <posicao inicial> por
<numero posicoes>
Ex: nome<-subliteral("Joana",2,3)
retorna o literal "oan"(3 caracteres a partir da segunda
posição)
val(lit,var) - converte o literal em lit para o valor numerico
correspondente que coloca em var.
A função retorna um valor lógico (verdadeiro ou falso) dizendo
se o literal era um valor numérico ou não
se val("123",valor)=verdadeiro entao...
vai colocar o valor 123 na variável "valor". Se o literal não for
um número válido, retorna falso
tamanho(literal) - retorna o tamanho do literal, em caracteres
e o operador + aplicado a literal concatena os literais
ex: Nomecomp <- "Joao"+ "da Silva"
5) Resolva o exercício 460 da lista de condicional.
C00000500 - Faça um algoritmo que leia 3 notas de um aluno
e escreva sua média harmônica. Dica: A média harmônica
entre três valores N1, N2 e N3 é calculada pela expressão
3
1/N1 + 1/N2 + 1/N3
O que acontece se alguma das notas for igual a 0? Que
resultado o algoritmo deve emitir?
C00000600 - Faça um algoritmo que leia 3 notas de um aluno
e escreva sua média harmônica. Se o aluno obteve média
abaixo de 6.0, E SOMENTE NESSE CASO, leia uma quarta
nota (da prova de recuperação) e substitua a menor das três
notas pela nota da recuperação e recalcule a média harmônica.
Escreva a média harmônica nal e o conceito obtido (0, se
média harmônica (MH) < 6.0; 1 se 6.0 <= MH <7.0; 2 se 7.0
<= MH < 8.0; 3 se 8.0 <= MH < 9.0; 4 se MH>=9.0).
C00000650 - Faça um algoritmo que leia 3 notas de um aluno
e escreva sua média harmônica (MH). Caso alguma das notas
seja 0 (zero), MH deve receber 0 (zero). Se o aluno obteve
uma MH abaixo de 6.0 e AINDA PUDER OBTER média igual
ou superior a 6.0, o algoritmo deve ler uma quarta nota (da
prova de recuperação) e substituir a menor das três notas pela
nota da recuperação, recalculando MH. O algoritmo deve
escrever a MH nal e o conceito obtido (0, se MH < 6.0; 1 se
6.0 <= MH <7.0; 2 se 7.0 <= MH < 8.0; 3 se 8.0 <= MH
< 9.0; 4 se MH>=9.0). Dica:No caso do aluno ter obtido
média inferior a 6.0, uma forma de vericar se ele pode
alcançar média 6.0 através da prova de recuperação é
substituindo a menor nota por 10 e vericando se a MH
resultante é igual ou superior a 6.0.
C00000660 - Faça um algoritmo que leia 4 valores, Hi, Mi, Hf,
Mf, representando respectivamente a hora e minuto inicial e
nal de um evento, e calcule a duração do mesmo em horas e
minutos. Considere que o evento pode iniciar em um dia e
terminar no dia seguinte. Algumas (mas não todas) situações
que podem ocorrer são:
Entrada: 10:30 Saída: 10:45
Entrada: 10:30 Saída: 11:15
Entrada: 22:15 Saída: 1:45
Entrada: 22:15 Saída: 10:45
C00001000 - Faça um algoritmo que leia para um trabalhador
o valor que ganha por hora, a hora de entrada e a hora de
saída (valores inteiros, sem minutos) e calcule quanto ele
ganhou pelo turno. Considere que ele entra e sai no mesmo
dia, e que as horas a partir das 20:00 valem 20% a mais
(adicional noturno).
Quantos casos diferentes existem?
Que cálculo deve ser feito em cada caso?
Como o algoritmo pode identicar cada caso?
C00001100 - Faça um algoritmo que leia para um trabalhador
o valor que ganha por hora, a hora de entrada e a hora de
saída (valores inteiros, sem minutos) e calcule quanto ele
ganhou pelo turno. Considere que ele entra e sai no mesmo
dia, e que as horas antes das 6:00 da manhã e a partir das
20:00 valem 20% a mais (adicional noturno).
Quantos casos diferentes existem?
Que cálculo deve ser feito em cada caso?
Como o algoritmo pode identicar cada caso?
C00001200 - Faça um algoritmo que leia para um trabalhador
o valor que ganha por hora, a hora de entrada e a hora de
saída (valores inteiros, sem minutos) e calcule quanto ele
ganhou pelo turno. Considere que ele pode entrar em um dia e
sair no outro, mas que o total de horas trabalhadas não excede
23 horas.
Quantos casos diferentes existem?
Que cálculo deve ser feito em cada caso?
Como o algoritmo pode identicar cada caso?
C00001250 - Faça um algoritmo que leia para um trabalhador
o valor que ganha por hora, a hora de entrada e a hora de
saída (valores inteiros, sem minutos) e calcule quanto ele
ganhou pelo turno. Considere que ele pode entrar em um dia e
sair no dia seguinte, e que se ele permanecer mais do que 8
horas, as duas horas a partir da nona hora valem 20% a mais,
e as horas a partir da décima primeira hora valem 50% a mais
(horas extras).
C00001300 - Faça um algoritmo que leia para um trabalhador
o valor que ganha por hora, a hora de entrada e a hora de
saída (valores inteiros, sem minutos) e calcule quanto ele
ganhou pelo turno. Considere que ele pode entrar em um dia e
sair no outro, mas que o total de horas trabalhadas não excede
23 horas. Considere que as horas a partir das 20:00 valem 20%
a mais (adicional noturno).
C00001400 - Faça um algoritmo que leia para um trabalhador
o valor que ganha por hora, a hora de entrada e a hora de
saída (valores inteiros, sem minutos) e calcule quanto ele
ganhou pelo turno. Considere que ele pode entrar em um dia e
sair no outro, mas que o total de horas trabalhadas não excede
23 horas. Considere também que as horas antes das 6:00 da
manhã e a partir das 20:00 valem 20% a mais (adicional
noturno).
C00001700 - Escreva um algoritmo que leia duas datas, cada
uma composta de Dia, Mês e Ano, e as escreva em ordem
cronológica crescente. Ex:se as datas são 01/04/2000 e
17/05/1988, o algoritmo deve escrever 17/05/1988
01/04/2000.
C00002100 - A distância entre dois pontos denidos pelas
coordenadas (X1,Y1) e (X2,Y2) é dada por
q
(X1 − X2 )2 + (Y1 − Y2 )2
.
Faça um algoritmo que leia 8 valores representando as
coordenadas X e Y de 4 pontos,vértices de um polígono, e
verique se os pontos formam um quadrado, escrevendo:
1 - se formam um quadrado;
0 - se não formam.
Considere que os pontos são lidos no sentido horário, seguindo
o perímetro do quadrado.
C00002150 - Faça um algoritmo que leia oito valores
correspondentes às coordenadas dos quatro vértices de um
quadrilátero convexo no espaço cartesiano (X0 ,Y0 , X1 ,Y1 ,
X2 ,Y2 , X3 ,Y3 ). O algoritmo deve identicar o tipo de polígono
formado escrevendo:
1 se os 4 pontos formam um quadrado;
2 se formam um retângulo;
3 se formam um losango;
4 se formam um paralelograma;
5 se formam um papagaio (2 pares de lados adjacentes iguais.
Ex: lados de tamanhos 3,3,4 e 4);
6 se não formam nenhum dos anteriores.
A distância (tamanho dos lados) entre dois pontos quaisquer
(Xi ,Yi ) e (Xj ,Yj )ppode ser obtida através da fórmula
distXi Yi Xj Yj = (Xi − Xj )2 + (Yi − Yj )2 ).
Por exemplo, se os pontos lidos foram (3,2), (0,5), (3,8) e
(6,5), a gura formada é um quadrado e o algoritmo escreve 1.
Para que a gura seja um quadrado, os comprimentos das
duas diagonais devem ser iguais, bem como os 4 lados.
Se os pontos lidos foram (4,2), (1,4), (4,6) e (7,4), a gura
formada é um losango.
Se os pontos lidos foram (2,3), (0,5), (3,8) e (5,6), a gura
formada é um retângulo.
Se os pontos lidos foram (7,3), (0,3), (2,5) e (5,5), a gura
formada não é nenhuma das anteriores e o algoritmo escreve 6
Os pontos são fornecidos em sentido horário ao longo do
perímetro do quadrilátero.
C00003100 - Faça um algoritmo que leia as dimensões (altura,
largura e profundidade) de duas caixas e verique se a primeira
caixa pode ser colocada dentro da segunda. Considere que as
caixas podem ser rotacionadas em qualquer direção. Se a
primeira caixa couber dentro da segunda escreva 1, caso
contrário escreva 0.
C00003300 - Faça um algoritmo que leia 4 valores
X1,Y1,X2,Y2, correspondendo às coordenadas do canto
inferior esquerdo e canto superior direito de uma região
retangular no plano. Leia a seguir dois valores X,Y
correspondendo a um ponto no plano e escreva:
0 - Se o ponto está fora da região retangular;
1 - Se o ponto está dentro da região retangular;
2 - Se o ponto está exatamente na borda da região retangular.
C00001700 - Escreva um algoritmo que leia duas datas, cada
uma composta de Dia, Mês e Ano, e as escreva em ordem
cronológica crescente.
Ex:se as datas são 01/04/2000 e 17/05/1988, o algoritmo
deve escrever 17/05/1988 01/04/2000.
Sugestões:
1 Converta cada data (dia,mês,ano) em um único valor, da
forma como zemos com hora-minuto-segundo, para poder
efetuar uma única comparação; ou
2 Efetue primeiro a comparação entre os anos, se esses forem
iguais compare os meses e, se anos e meses forem iguais
compare os dias.
C00001750 - Escreva um algoritmo que leia três datas, cada
uma composta de Dia, Mês e Ano, e as escreva em ordem
cronológica crescente.
Ex:se as datas são 01/04/2000, 17/05/1988 e 23/10/1969, o
algoritmo deve escrever 23/10/1969 17/05/1988 01/04/2000.
Sugestão: As mesmas do exercício anterior
C00001790 - Escreva um algoritmo que leia uma data,
composta por dia, mês e ano, e verique se a data corresponde
ao último dia do mês, escrevendo:
1, se for o último dia do mês
0 se não for o último dia do mês.
Considere, para simplicar o problema, que ano bissexto é
aquele divisível por 4, e que fevereiro tem 28 dias (29 em ano
bissexto).
Setembro, abril, junho e novembro têm 30 dias e todos os
outros meses tem 31 dias.
C00001800 - Escreva um algoritmo que leia uma data,
composta por dia, mês e ano, e escreva a data correspondente
ao dia seguinte.
Considere, para simplicar o problema, que ano bissexto é
aquele divisível por 4, e que fevereiro tem 28 dias (29 em ano
bissexto), setembro, abril, junho e novembro têm 30 dias e
todos os outros meses tem 31 dias.
Sugestão: lâmina seguinte
leia(dia,mes,ano)
Se {dia é o último dia do ano}
estao escreva (1, 1, ano+1)
senao se {dia é o último dia do mes}
estao escreva (1, mes+1, ano)
senao escreva(dia+1,mes,ano)
C00001850 - Escreva um algoritmo que leia uma data, composta
por dia, mês e ano, e escreva quantos dias passaram-se desde o
início do ano. Considere, para simplicar o problema, que ano
bissexto é aquele divisível por 4, e que fevereiro tem 28 dias (29 em
ano bissexto), setembro, abril, junho e novembro têm 30 dias e
todos os outros meses tem 31 dias.
C00001900 - Para enviar uma carta são necessários um selo e um
envelope. O selo custa 12 centavos e o envelope custa 5 centavos.
Faça um algoritmo que leia uma quantia inicial de selos, envelopes
e centavos, e escreva o número de cartas que podem ser enviadas
com esses selos, envelopes e centavos (utilizando-os para comprar
mais selos e envelopes). Considere que não é possível converter
selos ou envelopes em dinheiro.
C00001925 - Para enviar uma carta são necessários um selo e um
envelope. O selo custa 12 centavos e o envelope custa 5 centavos.
Faça um algoritmo que leia uma quantia inicial de selos, envelopes
e dinheiro (em reais), e escreva o número de cartas que podem ser
enviadas com esses selos, envelopes e centavos (utilizando-os para
comprar mais selos e envelopes). Escreva também, nessa ordem, a
quantidade de selos, envelopes e dinheiro (em centavos), que
restará após enviadas as cartas. Considere que não é possível
converter selos ou envelopes em dinheiro.
C00001950 - Uma fábrica produz um recipiente de plástico com sua
tampa (também de plástico). Ambos os componentes utilizam o
mesmo equipamento para fabricação (ou seja, não podem ser
fabricados ao mesmo tempo). A fabricação do recipiente consome
duas horas; a fabricação da tampa consome meia hora. Um cliente
deseja o máximo de recipientes (com tampa) para 10 dias. A
fábrica trabalha 24 horas/dia e já dispõe de uma quantidade r de
recipientes e t de tampas em seu estoque (não necessariamente
iguais). Faça um algoritmo que leia os valores de r e t e informe o
máximo de conjuntos recipiente-tampa que ela pode fornecer em 10
dias.
C00003000 - Escreva um algoritmo que leia dois valores D e DS,
correspondentes a um dia do mes, e ao dia da semana que
corresponde a ele (1-domingo 2-segunda 3- terça 4-quarta 5-quinta
6-sexta 7-sábado). Calcule e escreva em que dia da semana caiu o
dia primeiro do mês do dia digitado. Exemplo: dia 10 no mês e 3
(terça) na semana. Resposta 1 (domingo) Exemplo: dia 30 no mês
e 4 (quarta) na semana. Resposta 3 (terça feira)
C00003100 - Faça um algoritmo que leia as dimensões (altura,
largura e profundidade) de duas caixas e verique se a primeira
caixa pode ser colocada dentro da segunda. Considere que as
caixas podem ser rotacionadas em qualquer direção. Se a primeira
caixa couber dentro da segunda escreva 1, caso contrário escreva 0.
C00003200 - Faça um algoritmo que leia dois números de três
dígitos cada um, e verique se possuem os mesmos dígitos.
Considere que pode haver dígitos repetidos em um número, e que a
cada dígito de um número deve corresponder exatamente um dígito
do outro número. Assim, os números 221 e 112 não tem os
mesmos dígitos, porque apesar de ambos terem somente os dígitos
1 e 2, aos dois dígitos 2 do primeiro número corresponde o mesmo
dígito no segundo número. O algoritmo deve escrever 1, caso os
números tenham os mesmos dígitos, e 0 em caso contrário.
C00003250 - Faça um algoritmo que leia um número de três dígitos
e escreva o maior número que possui os mesmos dígitos do número
lido. Se um dígito aparecer repetido no número lido, deve ser
repetido o mesmo número de vezes no número gerado.
C0003650 - A locadora Só Filmassos classica os lmes em
"lançamentos"e "acervo", sendo que a diária do lançamento é
5 reais e a diária do acervo é 3 reais. A locadora está com uma
promoção, ao locar 2 lançamentos o cliente tem direito a um
lme de acervo grátis. Faça um algoritmo que leia a
quantidade de lançamentos e a quantidade de lmes de acervo
a serem locados, e calcule o valor (mínimo) a ser pago.
C00003700 - A locadora Só Filmassos classica os lmes em
"lançamentos"e "acervo", sendo que a diária do lançamento é
5 reais e a diária do acervo é 3 reais. A locadora está com uma
promoção, ao locar 2 lançamentos o cliente tem direito a um
lme grátis, podendo ser de acervo ou lançamento. Faça um
algoritmo que leia a quantidade de lançamentos e a
quantidade de lmes de acervo a serem locados, e calcule o
valor (mínimo) a ser pago.
C00000750 - Faça um algoritmo que leia, para duas barras de
ouro, o seu peso e seu valor. O algoritmo deve ler também o
limite de peso de uma mochila, e vericar e escrever que barra
(s) devem ir na mochila de modo a maximizar o valor dentro
dela, sem exceder seu limite de peso. O algoritmo deve
escrever:
0 - Se nenhuma das barras puder ser colocada na mochila sem
exceder o limite de peso
1 - Se a melhor solução for colocar somente a barra 1 na
mochila
2 - Se a melhor solução for colocar somente a barra 2 na
mochila
3 - Se a melhor solução for colocar a barra 1 e a barra 2 na
mochila
total s c s+c Prova 1
9(c)3(s)49c14s 14 49 63 9,40
1(c)14c26s 26 14 40 10,00
1(s) 0 0 0 10,00
5(c)38c26s 26 38 64 10,00
2(c)2(s)5c3s 3 5 8 9,20
12(c)1(s)4c4s 4 4 8 9,00
6(c)6(s)5c4s 4 5 9 9,00
4(s)2s 2 0 2 8,00
23(c)11(s)12c15s 15 12 27 8,00
nada 0 0 0 7,50
2(c)9(s)2c 0 2 2 6,30
3(c)3(s)2c1s 1 2 3 6,10
nada 0 0 0 6,00
2(c)1(s) 0 0 0 4,50
2(s)1s 1 0 1 4,50
15(s) 0 0 0 4,00
9(c)5(s)6c20s 20 6 26 2,50
19(c)7(s)12c14s 14 12 26 2,50
nada 0 0 0 1,50
4(s)4s 4 0 4 1,50
15(c)2(s)1c3s 3 1 4 1,00
3(s)4s 4 0 4 1,00
nada 0 0 0 0,50
nada 0 0 0 0,50
6(s)3s 3 0 3 0,50
1(c)2(s) 0 0 0 0,00
3(c)8(s) 0 0 0 0,00
1(s) 0 0 0 0,00
6(s)2s 2 0 2 0,00
Comandos de Repetição

São utilizados quando um ou mais comandos deve ser


executado mais de uma vez no algoritmo.
Nossa linguagem possui três comandos de repetição, o
Enquanto, o Para e o Repita.
O formato do comando Enquanto é:

Enquanto condição faca


lista de comandos
menquanto
onde condição é uma expressão lógica, como as condições do
comando se.
Ao entrar no comando
Enquanto a condição é
avaliada.
Se ela é verdadeira, a lista a ←1
de comandos é executada.
enquanto a<4 faca
Isso (avalia condição +
executa comandos) se escreva(a)
a←a+1
repete até que a condição
seja falsa. menquanto
Por exemplo, o trecho ao
lado escreve de quanto a
quanto?
Teste de Mesa

Uma coluna para cada variável e uma coluna para os


comandos de escrita
Executa-se os comandos sequencialmente, um a um
A cada atribuição, a coluna da variável que recebeu o valor
deve ser atualizada
A cada comando de escrita, a coluna das escritas é atualizada
Esse formalismo é usado há 60 anos e funciona muito bem.
Não tente inventar algo diferente.

a ←1
enquanto a<4 faca
a esc
escreva(a)
a←a+1
1
menquanto
Teste de Mesa

a ←1
enquanto a<4 faca
a esc
escreva(a)
a←a+1
1 1
menquanto
Teste de Mesa

a ←1
enquanto a<4 faca a esc
escreva(a) 1 1
a←a+1 2
menquanto
Teste de Mesa

a ←1
enquanto a<4 faca a esc
escreva(a) 1 1
a←a+1 2
menquanto
Teste de Mesa

a ←1
enquanto a<4 faca a esc
escreva(a) 1 1
a←a+1 2
menquanto
Teste de Mesa

a ←1
enquanto a<4 faca a esc
escreva(a) 1 1
a←a+1 2 2
menquanto
E continua até concluir a simulação...
Uma estrutura de repetição, como o enquanto, também é
chamada de laço de repetição (ou loop)
Cada repetição dos comandos dentro do enquanto também é
chamada de iteração.
Por essa razão algoritmos ou métodos que utilizam estruturas
de repetição são ditos iterativos
Ex: os trechos a seguir escrevem o que na tela? (teste de mesa)

a) b)
i <−1 i <−1
Enquanto i <=2 f a c a Enquanto i <=2 f a c a
escreva ( i ) i <− i +1
i <− i +1 escreva ( i )
fimenquanto fimenquanto
Ex: os trechos a seguir escrevem o que na tela? (teste de mesa)

c) d)
i <−1 i <−1
enquanto i <3 f a c a enquanto i <3 f a c a
i <− i +1 escreva ( i )
escreva ( i ) i <− i +1
fimenquanto fimenquanto
Ex: os trechos a seguir escrevem o que na tela? (teste de mesa)

e)
f)
a<−1
b<−2 a<−100
e n q u a n t o a <200 f a c a enquanto a>0 f a c a
a<−a+b e s c r e v a ( a%2)
b<−a+b a<−a \2
e s c r e v a ( a , "" , b , "" ) fimenq uanto
fimenquanto
h)

g)
a<−100
d<−2
a<−1234 e n q u a n t o a>1 f a c a
b<−0 s e a%d=0
e n q u a n t o a>0 f a c a entao
b<−b ∗10+a%10 escreva (d)
a<−a \10 a<−a \d
fimenquanto senao
escreva (b) d<−d+1
fimse
fimenquanto
I00000100 - Faça um algoritmo que escreva os números de 1 a
20.
I00000200 - Faça um algoritmo que escreva todos os números
pares entre 1 e 50.
Esse exercício pode ser resolvido por dois caminhos diferentes:

a) Gerando todos os números entre 1 e 50 e escrevendo somente


os que forem pares;
b) Gerando e escrevendo somente os números pares.
b)
a)

a<−2
a<−1
e n q u a n t o a<=50 f a c a
e n q u a n t o a<=50 f a c a
escreva (a)
s e a %2=0 e n t a o
a<−a+2
escreva (a)
// o incremento da variável
fimse
// que controla o laço pode
a<−a+1
// s e r diferente de 1
fimenquanto
fimenquanto
I00000300 - Faça um algoritmo que escreva todos os números
entre 1 e 200 que são múltiplos de 11.
(Não está no Portal) Faça um algoritmo que escreva 1000
vezes o nome do melhor time do Rio Grande do Sul
A solução para esse problema deve, de alguma forma, repetir
1000 vezes o comando Escreval("Internacional!")
Para isso, utiliza-se uma estrutura de repetição com uma
variável que controle as 1000 repetições.
i <−1
e n q u a n t o i <=1000 f a c a
escreva (" Internacional ! ! ! ")
i <− i +1
fimenquanto

Nesse algoritmo, a variável i tem a importante função de


controlar o número de repetições, para que o comando de
escrita seja executado exatamente 1000 vezes, nem uma a
mais, nem uma a menos.
À variável que controla o número de repetições dá-se o nome
de variável de controle.
Um laço controlado por variável de controle deve conter 3
elementos:
1 A denição do valor inicial (inicialização) da variável de
controle, que deve obrigatoriamente ser feita fora do laço, e
apenas uma vez, no início
2 O incremento (ou decremento) da variável de controle
3 Uma condição de saída que resulte falsa quando o número de
iterações desejadas for completada.
Alguns erros comuns ao implementar laços controlados são:
Falta da inicialização da variável de controle
Inicialização da variável de controle dentro do laço
Falta do incremento (ou decremento) da variável de controle
Condição de saída incompatível com o valor inicial e
incremento da variável de controle, o que fará com que nunca
termine a execução do laço (o famoso "entrar em loop")
I00000400 - Faça um algoritmo que leia 10 números e escreva os
que forem pares.
i<-1
enquanto i<=10 faca
leia(N)
se N %2=0
entao escreva(N)
mse
i ← i +1

menquanto
I00000600 - Faça um algoritmo que leia 30 valores e conte
quantos estão no intervalo [10,20], escrevendo ao nal essa
informação.
A estrutura desse algoritmo é semelhante ao anterior, sendo
necessária uma variável para controlar a contagem de 30 vezes
e uma variável para armazenar o valor lido.
Além delas é necessário uma variável para controlar a
contagem.
Essa variável (contadora) deve iniciar com 0 e, a cada vez em
que for necessário contar, deve ser incrementada de 1.
cont ← 0
i ←1
enquanto i<=30 faca
leia(N)
se N ≥ 10 e N ≤ 20
entao cont ← cont + 1
mse
i ← i +1

menquanto
escreva(cont)
I00000700 - Faça um algoritmo que leia 30 valores e conte
quantos estão em cada um dos intervalos [0,25],(25,50],
(50,75], (75..100], escrevendo ao nal essa informação.
I00000750 - Faça um algoritmo que leia um valor N. Escreva a
seguir os números de 1 a N.
I00000500 - Faça um algoritmo que leia números até que seja
digitado um número negativo, e escreva todos que forem pares.
leia(N) // lê o primeiro valor
enquanto N>0 faca
se N %2=0
entao escreva(N)
mse
leia (N) // lê o próximo valor de N
menquanto
I00000800 - Faça um algoritmo que leia um valor N. Leia, a
seguir, N valores e escreva todos que forem positivos.
I00000900 - Faça um algoritmo que leia um valor N, e escreva
todos os seus divisores.
I00001000 - Faça um algoritmo que leia um valor N, e conte
quantos divisores possui, escrevendo ao nal essa informação.
Comando Para

O comando para é utilizado quando se sabe o número de


vezes que a lista de comandos será repetida.
Ele embute dentro de si a inicialização e o incremento da
variável de controle, e o teste de saída da repetição.
Seu formato é:

Para variável de controle de valor inicial ate valor nal faca


Lista de comandos
mpara
i ←1
Para i de 1 ate 10 faca enquanto i ≤ 10 faca
escreva(i) escreva(i)
i ←i +1
mpara
menquanto
Ao entrar no Para a variável de controle recebe o valor da
expressão valor inicial.
Se for menor que o valor da expressão valor nal, a lista de
comandos é executada e a variável de controle é
automaticamente incrementada de 1.
Isso (a execução dos comandos e o incremento da variável de
controle) se repete até que o valor da variável de controle seja
MAIOR que o valor da expressão de valor nal.

i ←1
Para i de 1 ate 10 faca enquanto i ≤ 10 faca
escreva(i) escreva(i)
i ←i +1
mpara
menquanto
Opcionalmente pode-se especicar o valor que será somado à
variável de controle a cada iteração.
Isso é feito pela palava passo.

Para i de 1 ate 10 passo 2 faca


escreva(i)
mpara
O incremento pode ter um valor negativo. Nesse caso o valor
inicial deve ser maior que o valor nal e o comando para
termina quando a variável de controle é menor que o valor
inicial:

Para i de 10 ate 1 passo -1 faca


escreva(i)
mpara
O valor inicial e o valor nal não precisam necessariamente ser
constantes.
Expressões e variáveis podem também ser utilizadas.
A variável de controle e as expressões de valor inicial e nal
devem obrigatoriamente ser do tipo inteiro.

Para i de j ate k-1 faca


escreva(i)
mpara
I00001100 - Faça um algoritmo que leia um valor N, e calcule e
escreva a soma dos seus divisores.
algoritmo
var n,i,soma:inteiro
inicio
leia(n)
soma←0
para i de 1 ate n faca
se n%i=0
entao soma←soma+i
mse
mpara
escreva(soma)
malgoritmo
I00001300 - Dois números n1 e n2 são ditos amigos entre si se
a soma dos divisores de n1 (excluindo o próprio n1) é igual a
n2, e a soma dos divisores de n2 (excluindo o próprio n2) é
igual a n1. Ex: 220 e 284.
Faça um algoritmo que leia 2 valores e verique se são amigos
entre si escrevendo:
1 - se são amigos;
0 - se não são amigos.
I00001150 - Faça um algoritmo que leia um valor N inteiro e
maior do que 1, e calcule e escreva o seu maior divisor
(excetuando N).
Isso pode ser feito procurando o primeiro divisor a partir de N
para baixo.

leia(N)
N=10 d=9 não é d ←N-1
N=10 d=8 não é
enquanto N%d<>0 faca
N=10 d=7 não é
N=10 d=6 não é d<-d-1
N=10 d=5 Achei!!!! menquanto

escreva(d)
I00001155 - Faça um algoritmo que leia um valor N inteiro e
maior do que 1, e calcule e escreva o seu menor divisor maior
do que 1.
Mesma estrutura do anterior. Procura-se o primeiro divisor a
partir de 2, incrementando d até encontrar um valor que seja
divisor de N.
I00001200 - Um número inteiro maior do que 1 é primo se ele
possui como divisores somente o 1 e ele mesmo. Faça um
algoritmo que leia um número e verique se é primo
escrevendo:
1 - se o número é primo;
0 - se o número não é primo.
Dica:Pode-se vericar se um número é primo encontrando seu
primeiro divisor maior que 1.
Se o primeiro divisor for o próprio número, ele é primo.
Ou pode-se contar quantos divisores o número possui.
Números primos possuem exatamente 2 divisores.
Ou pode-se calcular a soma dos divisores. A soma dos
divisores de um número primo N é igual a N+1.
Buscando o cálculo do primeiro divisor do exercício 1155 ( em
vermelho)

leia(N)
leia(N)
cont ←0
d ←2 para i de 1 ate N faca
enquanto N%d<>0 faca se N%i=0 entao
d ←d +1 cont ← cont + 1
mse
menquanto
mpara
Se N=d
entao escreva(N) Se cont=2
entao escreva(N)
mse
mse
Exercícios envolvendo busca de maior ou menor

I00001400 - Faça um algoritmo que leia 10 números positivos


e escreva ao nal o maior deles.
Todos os exercícios envolvendo busca de maior ou menor tem
a mesma estrutura.
Utiliza-se uma variável para armazenar o maior, e a cada novo
valor compara-se o novo valor com o maior anterior, e se o
novo valor for maior que o maior anterior, o novo valor
substitui o maior.
algo como:
maior ← 0
para i de 1 ate 10 faca
leia(N)
se N>maior entao
maior← N
mse
mpara
escreva(maior)
I00001500 - Faça um algoritmo que leia 10 números, positivos
ou negativos, e escreva ao nal o maior deles.
Cuidado com o valor inicial da variável que armazena o maior.
O que acontecerá se todos os valores lidos forem negativos?
Nesse caso qual pode ser o valor inicial da variável que guarda
o maior?
Uma possibilidade poderia ser iniciar maior com um valor bem
pequeno.
por exemplo: -999999...
mas qual o menor valor possível para uma variável? Depende
da linguagem, do compilador...
e se todos os valores forem menores do que o valor inicial?
Uma alternativa é ler o primeiro valor fora do laço e utilizar o
primeiro valor como valor inicial para o maior.
Nesse caso, como um valor já foi lido fora do laço, dentro do
laço deve ser lido um valor a menos.
Algo como:

leia(N)
maior← N
para i de 1 ate 9 faca
leia(N)
se N>maior entao maior←N mse
mpara
escreva(maior)
I00001600 - Faça um algoritmo que leia 10 números e escreva
ao nal o maior e o menor deles.
nesse caso deve-se ter uma variável para guardar o maior, e
uma para guardar o menor.
ambas as variáveis podem começar com o primeiro valor lido,
que é, ao mesmo tempo, o maior e o menor (já que é o único
até o momento)
I00001610 - Faça um algoritmo que leia um valor n (n>=1)
correspondente ao número de alunos de uma turma. Após, o
algoritmo lê as notas das provas dos n alunos dessa turma.
As notas deverão ser lidas até que sejam informadas n notas
válidas, ou seja, no intervalo [0, 10], descartando as notas fora
desse intervalo.
As notas somente poderão ser lidas uma única vez.
O algoritmo deve informar qual foi a menor nota e o
percentual dos alunos que tiraram a menor nota (que não é,
necessariamente, 0).
Por exemplo, se o valor lido para n foi 20 e as notas foram 6.0
6.5 8.0 9.0 4.5 3.0 9.0 8.5 4.5 3.0 6.0 3.0 8.0 9.0 4.5 10 9.0
8.5 4.5 3.0 o algoritmo escreve 3.0 e 20, já que quatro (20%
de 20) alunos tiraram essa nota.
I00001700 - Faça um algoritmo que leia, para 10 pessoas, seu
peso e altura e escreva o peso e a altura da pessoa mais alta.
I00001750 - O índice de massa corporal (IMC) de uma pessoa
é dada pela relação peso 2 . Faça um algoritmo que leia, para
I00001800 - Faça um algoritmo que leia o código e a votação
de cada um dos candidatos a uma vaga no senado, até que o
código digitado seja 0 (não deverá ser lida a votação neste
caso). O algoritmo deve escrever os códigos e as votações dos
dois senadores eleitos (assuma que não haverão três
candidatos com igual votação e que seja a maior votação).
I00003350 - Faça um algoritmo que leia números até que seja
fornecido um número negativo. O algoritmo deve escrever a
média aritmética dos 3 últimos números fornecidos
(excetuando o negativo indicando m da sequência).
I00003700 - Faça um algoritmo que leia 20 números inteiros e
escreva quantos números são iguais ao menor número lido.
Dica: Use um contador, incrementando-o ao encontrar um
elemento igual ao menor corrente, e reinicializando-o ao
encontrar um elemento menor do que o menor corrente.
Exercícios envolvendo números primos

I00001900 - Faça um algoritmo que leia 10 números e escreva


os que forem primos.
Para i de 1 ate 10 faca
leia(N)
Se "N é primo"// ??????
entao escreva(N)
mse
mpara
Para i de 1 ate 10 faca
leia(N)
Se "N tem só dois divisores"// tem que contar os
entao escreva(N) // divisores antes
mse
mpara
Para i de 1 ate 10 faca
leia(N)
Se "o primeiro divisor de N é o próprio N"// tem
// que encontrar antes o primeiro divisor de N
entao escreva(N)
mse
mpara
Vamos tentar essa solução!!!
Buscando o cálculo do primeiro divisor do exercício 1155 ( em
vermelho)
Para i de 1 ate 10 faca
leia(N)
d ← 2
enquanto N%d<>0 faca
d ←d +1
menquanto
Se N=d
entao escreva(N)
mse
mpara
Mas pode ter "enquanto"dentro de "para"?
Sim, pode ter para dentro de para, para dentro de
enquanto, enquanto dentro de para...
deve-se tomar cuidado com o lugar onde vai a inicialização das
variáveis do laço interno
Ela deve estar dentro do laço externo mas fora do laço interno
Ex: o d ← 2 do exemplo anterior.
I00001950 - Faça um algoritmo que escreva os 50 primeiros
números primos.
cont ← 0
N←2
enquanto cont<50 faca
Se "N é primo"entao
escreva(N)
cont ← cont + 1
mse
N ← N +1

menquanto
I00002000 - Faça um algoritmo que leia 2 números N1 e N2 e
escreva a soma dos números primos entre N1 e N2 (incluindo
N1 e N2 se algum deles for primo)..
soma ← 0
leia(N1,N2)
para N de N1 ate N2 faca
Se "N é primo"entao
soma ← soma + N
mse
mpara
escreva(soma)
I00002100 - Faça um algoritmo que leia 2 números N1 e N2 e
escreva o produto dos números primos entre N1 e N2
(incluindo N1 e N2 se algum deles for primo).
I00002200 - Faça um algoritmo que leia um número N e
escreva os N primeiros números primos maiores que 100.
I00002300 - Um número perfeito é o número que é igual à
soma de seus divisores, exceto o próprio número (ex: 6 = 1 +
2 + 3. Faça um algoritmo que leia 10 números e verique para
cada um se é perfeito ou não, escrevendo:
1 - se o número é perfeito;
0 - se o número não é perfeito.
I00004500 - Um número piramidal é um número que é igual à
soma de 3 números primos consecutivos (ex: 15 = 3 + 5 +
7). Faça um algoritmo que leia um valor N e escreva os 10
primeiros números piramidais maiores ou iguais a N.
I00004600 - Faça um algoritmo que leia 30 números. O
algoritmo deve escrever ao nal a média dos números pares
digitados (soma dos pares dividido pela quantidade de pares);
quantos números são primos e o produto (multiplicação) de
todos os números lidos que são múltiplos de 5.
I00002400 Faça um algoritmo que leia, para um número não
determinado de funcionários, seu código (inteiro), o valor que
ganha por hora e 30 pares de valores (hora de entrada e hora
de saída, inteiros, sem minutos) e calcule o quanto ganhou no
mês.
O funcionário não pode trabalhar mais de 23 horas seguidas e
pode iniciar em um dia e terminar no dia seguinte.
Para cada funcionário deve ser escrito seu código e o quanto
ganhou no mês.
O algoritmo termina ao ser digitado um código igual a -1
(após o que, não deve ser lido mais nenhum dado).
I00002500 - A série de bonacci é uma sequência de numeros
que inicia por 0 e 1, e a partir do terceiro valor cada número é
dado pela soma dos dois anteriores. Assim, os 10 primeiros
termos da série são: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34. Faça um
algoritmo que escreva os 100 primeiros termos da série de
bonacci.
I00002600 - O MDC (máximo divisor comum) entre dois
números n1 e n2 é o maior número que é divisor de n1 e de n2.
Faça um algoritmo que leia dois números e escreva seu MDC.
Uma alternativa é procurar a partir de algum dos números,
decrementando o MDC até encontrar um valor que seja divisor
dos dois
a b MDC
9 6 6 divide b, mas não divide a
9 6 5 não divide nenhum dos dois
9 6 4 não divide nenhum dos dois
9 6 3 Achei!!! divide a e b
Outra alternativa é decompor os dois números em seus fatores
primos (exercício 3000 e teste de mesa da primeira aula de
repetição).
O MDC é o produto dos fatores primos comuns aos 2
a b divisores
30 50 2 divide a e b, entra no MDC
15 25 3 divide somente o a. Não entra no MDC
5 25 5 divide a e b, entra no MDC
1 5 5 divide somente o b, não entra no MDC
1 1 m da fatoração. MDC é 2 * 5 = 10
I00002700 - O fatorial de um número N (representado por N!)
é o produto de todos os números de 1 a N. Assim, 4! = 1 x 2
x 3 x 4 = 24. Faça um algoritmo que leia um número N e
escreva seu fatorial.
I00002750 - O número de combinações de N diferentes objetos
em grupos de P objetos é dado por P !(NN−! P )! . Faça um
algoritmo que leia uma quantidade N de objetos e o tamanho
P dos grupos a serem formados, e calcule e escreva a
quantidade de grupos que podem ser formados.
I00002800 - Faça um algoritmo que leia 10 valores inteiros
menores que 20 e, para cada um, calcule e escreva seu fatorial.
O algoritmo deve ignorar todos os valores maiores ou iguais a
20.
I00002900 - O MMC (mínimo múltiplo comum) entre dois
números n1 e n2 é o menor número que é múltiplo de n1 e de
n2. Faça um algoritmo que leia dois números e escreva seu
MMC.
I00003000 - Faça um algoritmo que leia um número N e efetue
sua fatoração, escrevendo os fatores que o compõem (teste de
mesa da primeira aula de repetição).
Ex: 28 = 2 x 2 x 7
60 = 2 x 2 x 3 x 5
Exercícios de separação de dígitos

I00003100 - Faça um algoritmo que leia 10 números e para


cada um escreva a soma dos seus digitos formantes.
Algoritmos de separação de dígitos de modo geral são
baseados no cálculo do resto da divisão inteira por 10.
Essa operação se repete até que não sobrem mais dígitos. Algo
como:
Leia (N)
Soma ← 0
Enquanto N>0 faca
Soma ← Soma + N %10
N ← N \ 10
menquanto
Escreva(Soma)
I00005200 - Faça um algoritmo que leia um número inteiro e
escreva quantas vezes ocorre o dígito 2.
I00005100 - Faça um algoritmo que leia um número N até
100.000.000 e verique se possui dígitos repetidos escrevendo:
1 - se possuir dígitos repetidos;
0 - se não possuir.
I00003400 - Faça um algoritmo que leia um número N até
100.000.000 e verique se é palíndromo, ou seja, se se igual
quando lido da esquerda para a direita e da direita para a
esquerda. Ex: 13731. Escreva 1 se for palíndromo e 0 se não
for.
I00003500 - Faça um algoritmo que escreva os primeiros 100
dígitos cuja soma dos dígitos formantes é 10.
I00003050 - Faça um algoritmo que leia um número e escreva
seus dígitos na ordem contrária em que aparecem no número.
Por exemplo, se o numero lido foi 32417, o algoritmo escreve
7,1,4,2,3.
I00003200 - Faça um algoritmo que leia um número N e o
escreva com seus dígitos invertidos.
I00006800 - Fazer um algoritmo que leia números inteiros até
que seja informado 0, descartando os números negativos.
Escrever o menor número com a maior quantidade de dígitos.
I00005150 - Faça um algoritmo que leia um número inteiro
(máximo 5 casas - não maior que 99999) e mostre quantos
dígitos contem de cada número de 0 a 9
I00005160 - Faça um algoritmo que leia um número inteiro
(máximo 5 casas - não maior que 99999). Mostre o dígito que
mais se repete. Em caso de empate, mostre o menor deles.
I00005170 - Um número inteiro é dito ascendente se cada um
dos seus algaristmos é maior do que o algarismo
imediatamente à sua esquerda. Por exemplo, o número 3589.
Faça um algoritmo que leia um número inteiro e verique se
ele é ou não ascendente escrevendo: 1 - se ele é ascendente; 0
- se ele não é ascendente.
I00003300 - Faça um algoritmo que leia um número N até (até
9 dígitos), retira os dígitos impares, e escreve o número
resultante. Caso o número só possua dígitos ímpares, o
algoritmo não deve escrever nada.
I00005300 - Faça um algoritmo que leia um número de 8
dígitos e calcule a soma ponderada dos seus dígitos, com peso
1 para o dígito menos signicativo, peso 2 para o segundo
dígito, peso 3 para o terceiro e assim por diante. Escreva a
soma calculada.
I00005000 - Faça um algoritmo que leia um número inteiro
qualquer e escreva os dígitos desse número em ordem
crescente do valor de cada dígito.
I0005120 - Faça um algoritmo que leia um número inteiro e
escreva quantas vezes ocorre o dígito 2.
I00005600 - O CPF é formado por onze dígitos (999999999-99),
dos quais os dois últimos são vericadores (controle), ou seja, a
partir dos nove primeiros dígitos pode-se determinar os últimos
dois. Considerando o CPF no formato abcdefghi-jk, onde cada letra
representa um dígito, pode-se:
- calcular o primeiro dígito vericador (j), da seguinte forma:
- somar: 10a + 9b + 8c + 7d + 6e + 5f + 4g + 3h + 2i
- encontrar o resto da divisão dessa soma por 11.
- se o resto for igual a zero ou um, o dígito é zero, senão o
dígito é onze menos esse resto.
- calcular o segundo dígito vericador (k):
- somar: 11a + 10b + 9c + 8d + 7e + 6f + 5g + 4h + 3i + 2j
- encontrar o resto da divisão dessa soma por 11.
- se o resto for igual a zero ou um, o dígito é zero, senão o
dígito é onze menos esse resto.
Fazer um algoritmo que leia o CPF (somente primeiros nove
dígitos) e escreva separadamente os vericadores (dois últimos).
Exercícios envolvendo datas

I00003960 - Faça um algoritmo que leia 4 valores d,m,a,ds,


onde d,m,a representam uma data (dia,mês,ano) e ds
representa um dia da semana (1-domingo, 2-segunda, 3-terça,
4-quarta, 5-quinta, 6-sexta, 7-sábado), e escreva as datas das
próximas 3 sextas-feiras 13, a partir da data digitada, incluindo
a própria data, se for o caso. Considere que ano bissexto é o
ano divisível por 4.
I00003970 - Faça um algoritmo que leia o mês e o ano de uma
sexta-feira 13 e escreva o mês e ano das próximas 5
ocorrências de sexta-feira 13. Considere que ano bissexto é o
ano divisível por 4.
I00005200 - Faça um algoritmo que leia o dia e mês de uma
data, e o dia da semana (1 - domingo, 2 - segunda... 7 -
sábado) e escreva o dia da semana correspondente ao dia
primeiro do mês digitado.
I00003900 - Faça um algoritmo que leia duas datas, cada uma
formada por dia, mês e ano, e escreva o número de dias entre
as duas, incluindo a data inicial e a data nal. Considere que
ano bisexto é aquele divisível por 4.
I00003950 - Faça um algoritmo que leia duas datas, cada uma
formada por dia, mês e ano, e escreva todas as datas entre as
duas, incluindo a data inicial e a data nal. Considere que ano
bisexto é aquele divisível por 4. Considere também que a data
inicial é menor ou igual à data nal.
I00003800 - Data juliana é o número de dias tanscorridos no
ano (ex:236/1995). A faixa é de 1 a 365 (366 se o ano for
bisexto). Escreva um algoritmo que leia uma data juliana (dia
e ano) e a converta para o formato DD/MM/AAAA
escrevendo a data. Considere que ano bisexto é aquele divisível
por 4.
Exercícios de identicação de sequências

I00004700 - Faça um algoritmo que leia 20 números e verique


qual a maior sequência estritamente crescente (isso é, cada
número é maior que o anterior) dentre os números digitados,
escrevendo ao nal o primeiro e último valor da sequência.
I00004850 - Faça um algoritmo que leia 15 números e
identique a maior sequência de números pares dentre os
números lidos, escrevendo ao nal o comprimento da
sequência identicada, bem como o primeiro e o último valor
da sequência. No caso de mais de uma sequência do mesmo
comprimento, o algoritmo deve considerar a primeira delas.
I00005400 - Faça um algoritmo que leia 20 números e escreva
a maior sequência de valores iguais entre os números digitados.
I00006200 - Faça um algoritmo que para 10 cartas de baralho
leia o seu valor (entre 1 e 13) e naipe (1 - ouros, 2 - copas, 3 -
paus, 4 - espadas) em sequência, e escreva:
1 - se as cartas contem uma canastra;
0 - se não contem.
Considere como canastra apenas uma sequência crescente de 7
cartas do mesmo naipe de numeração contínua (cuja diferença
entre duas cartas seja igual a 1). Dica:Considere que podem
ocorrer cartas de mesmo número e naipe (uso de mais de um
baralho). Nesse caso a carta de mesmo número e naipe não é
contada, mas não quebra a sequência.
I00006201 - Faça um algoritmo que leia, para 10 cartas, seu naipe
(1 a 4) e número (1 a 13), em ordem decrescente de naipe e
número e escreva a maior sequência decrescente (mesmo naipe,
numeração decrescente contínua) formada a partir da primeira
carta. Caso a sequencia possua mais de 7 cartas, escreva apenas as
primeiras sete cartas da sequencia. Se a sequencia tiver menos de 7
cartas, escreva a sequencia encontrada e um 0 ao nal da
sequencia.
I00006400 - Baseando-se na sequência de bonacci (0,1,1,2,3...),
verique se uma sequência de cinco números, faz parte da
sequência, devolvendo como resposta "0"se faz parte, ou "1"se não
faz parte. Dica:Considere que números "repetidos"fazem parte da
sequência proposta, ou seja, devem ser analisados individualmente
como os demais números fornecidos.
I00004800 - Faça um algoritmo que leia uma sequência de 20
números e escreva:
0 - Se todos os números são iguais;
1 - Se a sequencia é não-decrescente (cada número é maior
OU IGUAL ao anterior);
2 - se a sequencia é estritamente crescente (cada número é
MAIOR que o anterior);
3 - Se a sequencia é não-crescente (cada número é menor OU
IGUAL ao anterior);
4 - Se a sequencia é estritamente decrescente (cada número é
MENOR que o anterior);
5 - A sequencia é desordenada (há partes crescentes e partes
decrescentes)
I00005450 - Faça um algoritmo que leia um número inteiro positivo
N não maior que 1000000000000000000 (1E18), calcule e escreva o
maior inteiro menor ou igual a sua raiz quadrada, ou seja, calcule e
escreva a parte inteira da raiz quadrada no número informado.
I00005500 - Georg Cantor demonstrou que os números racionais
são enumeráveis pela sequência:
1 1 2 1 2 3 1 2 3 4 1 2
, , , , , , , , , , , ...
1 2 1 3 2 1 4 3 2 1 5 4
Fazer um algoritmo que leia N (no intervalo de 1 até 1000000) e
escreva o enésimo número dessa sequência (escreva o numerador e
o denominador).
I00005501 - Georg Cantor demonstrou que os números racionais
são enumeráveis pela sequência:
1 1 2 1 2 3 1 2 3 4 1 2
, , , , , , , , , , , ...
1 2 1 3 2 1 4 3 2 1 5 4
Fazer um algoritmo que leia N (no intervalo de 1 até
1000000000000000000 = 1E18) e escreva o enésimo número dessa
sequência (escreva o numerador e o denominador).
I00005700 - Foram entrevistados 500 alunos de uma
universidade. Para cada aluno entrevistado foi registrado o
código do curso que ele frequenta (1: engenharia; 2:
computação; 3: administração) e sua idade. Faça um
algoritmo que processe tais dados fornecendo:
(a) número de alunos por curso;
(b) número de alunos com idade entre [20 25] anos por curso; e
(c) código do curso com a menor média de idade.
Dica:São necessários vários contadores.
I00005800 - O quociente da operação de divisão pode ser obtido
subtraindo-se o divisor do dividendo. Da diferença, subtraímos
novamente o divisor e assim sucessivamente até que a diferença
seja menor do que o divisor. A quantidade se subtrações é o
quociente. Assim, por exemplo:
-21 /4 =
21 - 4 = 17 (1)
17 - 4 = 13 (2)
13 - 4 = 9 (3)
9 - 4 = 5 (4)
5 - 4 = 1 (5)
Para o exemplo anterior, o número de subtrações é 5. Logo, o
quociente é -5 (divisor e dividendo têm sinais diferentes). Faça um
algoritmo que leia o dividendo (0, positivo ou negativo) e o divisor
(positivo ou negativo) e escreva o quociente usando o algoritmo
acima. NÃO deve ser usado o operador de divisão. Dica: Registre,
de alguma forma, os sinais dos operandos e transforme-os para
positivo.
I00005810 - A operação de multiplicação, quando o multiplicador é
um número inteiro, nada mais é do que uma sucessão de somas.
Assim, por exemplo,
4X5= 5+5+5+5= 20.
Escreva um algoritmo que leia o multiplicando e o multiplicador e,
através de uma sucessão de somas, calcule e escreva o produto. O
multiplicador é, necessariamente, um número inteiro. Porém,
multiplicador e multiplicando podem ser 0 ou negativos.
I00003600 - Uma pessoa aplicou um determinado valor em um
banco. Sabe-se que o banco pagará 5% ao mês de juros. Fazer
um algoritmo que leia o valor aplicado e calcule e escreva a
quantidade mínima de meses necessários para que a pessoa
obtenha R$1000,00 ou mais de rendimento. Por exemplo, se a
pessoa aplicou 10.000 reais, ao nal do primeiro mês terá
10.500, e ao nal do segundo mês terá 11.025 e foram
necessários 2 meses para alcançar um rendimento de mais de
1000 reais.
I00005900 - Um número N é dito um Meridiano Perfeito se existe
um número M para o qual a soma dos números de 1 a N-1 é igual à
soma dos números de N+1 a M. Assim, 6 é um Meridiano Perfeito
porque 1+2+3+4+5=7+8. Faça um algoritmo que leia um
número e verique se é um meridiano perfeito, escrevendo 1, se o
número é um meridiano perfeito, e 0, se não for.
I00006000 - Um número N é dito um Meridiano Perfeito se existe
um número M para o qual a soma dos números de 1 a N-1 é igual à
soma dos números de N+1 a M. Assim, 6 é um Meridiano Perfeito
porque 1+2+3+4+5=7+8. Faça um algoritmo que leia um valor
N, e escreva os N primeiros Meridianos Perfeitos maiores que 1.
I00006100 - Um número é dito regular, ou número de hamming (ou
"5-smooth number"ou "ugly number") se tem como fatores primos
apenas 2, 3 e 5, ou seja, é divisível somente por múltiplos de 2, 3
ou 5. Assim, os primeiros números regulares são 1 (é regular por
denição, 20 * 30 * 50 ), 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 16, 18, 20,
24, 25, 27,30,32.... Faça um algoritmo que leia um número N,
menor ou igual a 100, e escreva os N primeiros números regulares.
I00006500 - Leia um termo n que dene o tamanho máximo dos
lados de um triangulo retângulo podem assumir, sendo que os lados
começam com tamanho 3, 4 e 5 (a,b,c). Em sequencia escreva
todos os triângulos retângulos em que o valor máximo do lado é n e
os três lados são inteiros. Cada triangulo deve ser escrito uma
única vez em ordem crescente dos lados. Dica: O triângulo
retângulo é dado como válido pela formula (a2 + b2 = c 2 )
Exercícios envolvendo séries numéricas

I00004000 - Faça um algoritmo que calcule e escreva a soma


dos 100 primeiros termos da sequência a seguir:
1+3+5+7+9....
I00004100 - Faça um algoritmo que calcule e escreva a soma
dos 100 primeiros termos da sequência a seguir:
1 1 1 1 1
+ + + + + ...
1 3 5 7 9
I00004200- Faça um algoritmo que leia um valor X e calcule e
escreva a soma dos 100 primeiros termos da sequência a seguir:
X X X X X
+ + + + + ...
1 3 5 7 9
I00004300 - Faça um algoritmo que leia um valor X e calcule e
escreva a soma dos 100 primeiros termos da sequência a seguir:
X X X X X
− + − + − ...
1 3 5 7 9
I00004400 - Faça um algoritmo que leia um valor N e escreva
a soma dos N primeiros termos da série a seguir:
1 1 1 1 1 1 1
+ + + + + + + ...
2 3 5 7 11 13 17

ou seja, a série onde os denominadores são os números primos


I00004900 - Faça um algoritmo que leia a média e a
quantidade de faltas para cada aluno de um grupo de 20
alunos, e escreva ao nal o percentual de alunos aprovados. Os
alunos serão considerados reprovados se não atingirem média
6.0. Também serão reprovados os alunos que tiverem mais de
20 faltas. Os alunos com uma quantidade de faltas entre 10 e
20 serão aprovados se obtiverem uma média mínima de 7.5.
Funções

Funções são trechos de código que podem ser chamados a


partir de diversos pontos diferentes do algoritmo.
Ao invés de escrever um trecho de código diversas vezes,
escreve-se o código apenas uma vez e ele é chamado diversas
vezes.
Toda linguagem possui algumas funções pré-denidas.
Exemplos de funções em português estruturado são abs e raizq.
Além das funções pré-denidas na linguagem, o programador
pode especicar suas próprias funções.
Algumas vantagens do uso de funções são:
Reduzem o tamanho do programa, eliminando a repetição de
código;
Melhoram a legibilidade do programa, "quebrando"um
programa grande em partes menores, individualmente mais
compreensíveis.
algoritmo
var a : i n t e i r o
funcao f a t (n : i n t e i r o ) : i n t e i r o
var i , f : i n t e i r o
inicio
f <−1
p a r a i de 1 a t e n f a c a
f<− f ∗ i
fimpara
retorne f
fimfuncao
inicio
p a r a a de 1 a t e 10 f a c a
escreval (a , " " , fat (a ))
fimpara
fimalgoritmo
No Matlab, uma função para decompor a velocidade nas
componentes x e y seria:

f u n c t i o n [ vx vy ] = decompoe ( v , t h e t a )
vx=v ∗ c o s ( t h e t a ) ;
vy=v ∗ s i n ( t h e t a ) ;
end

E uma para converter de graus para radianos:

f u n c t i o n [ angrad ] = rad ( graus )


a n g r a d=g r a u s /360 ∗ 2 ∗ p i ;
end
Declarações de funções vão sempre no início do código, junto
às declarações (após o var), antes do inicio do programa
principal.
Ao especicar uma função, o programador deve especicar que
valores que ela irá receber, o tipo de valores que irá receber, e
o tipo de valor que será retornado por ela.
Os valores passados para uma função, que ela utilizará para
efetuar os cálculos necessários, se chamam "parâmetros"ou
"argumentos"da função.
O formato geral de especicação de uma função é assim:
funcao <nome> (lista de parâmetros):tipo do valor retornado
Var <Declarações de variáveis locais>
inicio
< comandos>
mfuncao
Por exemplo, uma função que receba um valor inteiro e retorne
o fatorial desse número pode ser escrita assim:

funcao f a t (n : i n t e i r o ) : i n t e i r o
var i , f : i n t e i r o
inicio
f <−1
p a r a i de 1 a t e n f a c a
f<− f ∗ i
fimpara
retorne f
fimfuncao
E na chamada da função deve ser passado o parâmetro (ou
parâmetros) esperado.
Os parâmetros passados devem ser na mesma quantidade e
tipo dos parâmetros declarados.
O nome do parâmetro na declaração da função só é utilizado
para identicar o parâmetro dentro da função, não havendo
relação nenhuma com o nome do parâmetro passado na
chamada.
No caso da função fat, deve ser passado o valor de quem será
calculado o fatorial.
Uma chamada de função deve ser feita sempre dentro de um
comando onde o valor de retorno será imediatamente utilizado.
Exemplos da chamada da função dentro do programa seriam
algo como:
a←fat(4);
a←fat(b);
escreval(b,"!=",fat(b))
Variáveis Globais e Variáveis Locais

Uma função pode utilizar variáveis declaradas dentro dela,


chamadas variáveis locais, mas pode também utilizar variáveis
declaradas fora de qualquer função.
Essas variáveis são chamadas de variáveis globais e podem ser
utilizadas para passar informações entre funções.
Variáveis locais só podem ser referenciadas dentro da função
onde são declaradas.
Podem haver variáveis locais e variáveis globais com o mesmo
nome.
Nesse caso, se o nome for usado dentro da função, será usada
a variável local
O comando retorne é utilizado para retornar a execução para
o ponto onde a função foi chamada.
Ele pode ser executado em qualquer ponto da função e causa
o encerramento imediato da execução da função.
Se a função deve retornar algum valor, o valor a ser retornado
deve ser especicado no comando retorne.
Exercícios de funções

1) A aceleração de um corpo é dada pela relação entre a


variação da velocidade e a variação de tempo. Escreva uma
função que receba a velocidade inicial de um corpo, sua
velocidade nal e a variação de tempo, e retorne sua
aceleração. Use essa função em um programa que leia as
velocidades inicial e nal e a variação de tempo e escreva a
aceleração.
Obs: Ao especicar que uma função "recebe"um valor, ca
implícito que o valor é passado como parâmetro para a função.
2) Escreva uma função que receba três valores inteiros,
respectivamente a hora, minuto e segundo de um horário, e
verique se é um horário válido, retornando 1 se o horário é
válido, e 0 em caso contrário.
3) Faça uma função que receba o dia, mês e ano de
nascimento de uma pessoa, e o dia, mês e ano atual, e retorne
sua idade.
4) Faça uma função que receba um valor N e retorne o
primeiro divisor maior que 1 do valor N.
5) Faça uma função que receba um valor N e retorne a
quantidade de divisores do valor N.
Função para contar divisores

funcao contdiv (n:inteiro) : inteiro


var i,cont:inteiro
inicio
cont <- 0
para i de 1 ate n faca
se n %i=0
entao cont <- cont + 1
mse
mpara
retorne cont
mfuncao
6) Usando uma das duas funções anteriores, faça uma função
que recebe um valor N e verique se ele é primo, retornando:
1, se ele é primo
0 se não for primo
Use essa função para refazer os exercícios I1950 a 2280.
funcao contdiv (n:inteiro) : inteiro
var i,cont:inteiro
inicio
cont <- 0
para i de 1 ate n faca
se n %i=0
entao cont <- cont + 1
mse
mpara
retorne cont
mfuncao
funcao primo (n:inteiro) : inteiro
var i,cont:inteiro
inicio
se contdiv(n)=2 // chamada da funcao contdiv
entao retorne 1
senao retorne 0
mse
mfuncao
I00001950 - Faça um algoritmo que escreva os 50 primeiros números primos.
I00002000 - Faça um algoritmo que leia 2 números N1 e N2 e escreva a soma dos números
primos entre N1 e N2 (incluindo N1 e N2 se algum deles for primo)..
I00002100 - Faça um algoritmo que leia 2 números N1 e N2 e escreva o produto dos números
primos entre N1 e N2 (incluindo N1 e N2 se algum deles for primo).
I00002200 - Faça um algoritmo que leia um número N e escreva os N primeiros números primos
maiores que 100.
I00002250 - Faça um algoritmo que leia um número inteiro N e escreva o maior número primo
menor do que N.
I00002260 - Faça um algoritmo que leia um número inteiro N e escreva o menor número primo
maior do que N.
I00002270 - Um número primo é um número natural maior que 1, que é divisível somente por 1 e
por ele mesmo. Faça um algoritmo que leia um número inteiro N e escreva o número primo mais
próximo a ele. Se N for primo, considere que o mais próximo é o próprio N. Se houver dois
números à mesma distância, escreva os dois em ordem crescente.
I00002280 - A conjectura de Goldbach diz que todo número par maior que 2 pode ser
representado como a soma de dois números primos. Assim, 4=2+2, 6=3+3, 8=3+5... Faça um
algoritmo que leia um número N, par, e escreva, em ordem crescente, os dois números primos
que o compõem. No caso de haver mais de um par de números (p.ex:20=3+17 e 20=7+13)
escreva o par que tiver o menor número primo.
7) Usando a função anterior, faça uma função proxprimo(int
N) que receba um valor N e retorne primeiro valor primo maior
que N. Use essa função para escrever os primeiros 100
números primos.
8) Faça uma funçao que receba o valor de dois resistores e um
terceiro parâmetro denindo o tipo de associação dos
resistores (0 para em série, 1 para em paralelo) e retorne o
valor da associação dos dois resistores.
Funções sem tipo (procedimentos)

São funções que não retornam nenhum valor como resultado


do seu processamento.
Da mesma forma como funções, são chamadas e executam
uma tarefa, mas o resultado do seu processamento não é um
valor numérico retornado.
Pode ser utilizada, por exemplo, para escrever uma série de
valores.
Ex: Uma função para receber três valores, dia, mês e ano, e
escrevê-los no formato "16 de outubro de 2014"
Ou uma função para receber um valor N e escrever os valores
de 1 a N
Essas funções são chamados, em português estruturado,
procedimentos, e tem o seguinte formato:
Procedimento nome ( lista_de_parametros )
Inicio
comandos
mprocedimento
Como eles não retornam um valor, não é utilizado o comando
retorne dentro dele.
E ao contrário da chamada de função, que deve ocorrer em
uma expressão que use seu valor de retorno, a chamada do
procedimento ocorre fora de expressões, como se fosse um
comando.
Ex: esc_1_a_N(n)
algoritmo
var x : i n t e i r o
p r o c e d i m e n t o esc_1_a_n ( n : i n t e i r o )
var i : i n t e i r o
inicio
p a r a i de 1 a t e n f a c a
escreval ( i )
fimpara
fimprocedimento
inicio
leia (x)
esc_1_a_n ( x )
fimalgoritmo
Faça um algoritmo para ler 10 valores inteiros até 999.999.999
e, para cada um deles escrever o valor por extenso.
Utilize procedimentos para escrita da centena, dezena, unidade
e um procedimento para os valores entre 10 e 19.
Tipos de passagem de parâmetros

É utilizada quando se deseja que que a variável passada como


parâmetro tenha seu valor alterado dentro da função
(chamados parâmetros de saída)
O que acontece com a e b no código a seguir?
procedimento troca ( x : i n t e i r o ; y : i n t e i r o )
v a r aux : i n t e i r o
inicio
aux<−x
x<−y
y<−z
fimprocedimento
inicio
a<−3
b<−5
troca (a , b)
escreva (a , b)
Passagem por valor

No código anterior, apesar de x e y terem sido trocados entre


si dentro da função, os valores de a e b ao retornar do
procedimento permaneceram inalterados.
Isso ocorre porque quando é feita uma chamada de função, na
verdade é passada uma cópia do valor do parâmetro, então as
operações feitas sobre o parâmetro dentro da função são feitas
na verdade sobre essa cópia, e não tem efeito nenhum na
variável passada.
Essa forma de passagem de parâmetro se chama passagem
por cópia ou passagem por valor, e é utilizada para a
passagem de parâmetros de entrada, ou seja, parâmetros
pelos quais não retornam resultados.
Passagem por referência (ou por valor)

Quando se deseja que as variáveis passadas como parâmetros


tenham seus valores alterados dentro da função ou
procedimento, utiliza-se a passagem por referência (ou
passagem por endereço).
Nesse tipo de passagem, ao invés de ser passada uma cópia do
valor do parâmetro, é passado o endereço de memória da
variável, de modo que alterações no parâmetro dentro da
função ocorrem, realmente, na variável enviada como
parâmetro.
A passagem por referência é indicada, na lista de parâmetros,
pela palavra Var antes do parâmetro, na lista de parâmetros,
na declaração.
Ex: procedimento troca(var x:inteiro; var y:inteiro)
algoritmo
var a , b : i n t e i r o
procedimento troca ( var x : i n t e i r o ; var y : i n t e i r o )
v a r aux : i n t e i r o
inicio
aux<−x
x<−y
y<−z
fimprocedimento
inicio
a<−3
b<−5
troca (a , b)
escreva (a , b)
fimalgoritmo
A passagem por referência é utilizada para a passagem de
parâmetros de saída, ou seja, parâmetros enviados para
receber resultados de processamento.
Normalmente são utilizados quando se precisa retornar mais de
um valor, o que impede o uso de função, que só pode retornar
um valor.
A passagem por referência obriga que os parâmetros passados
sejam variáveis, ao contrário da passagem por valor, em que os
valores passados na chamada podem ser constantes ou
expressões aritméticas
Escreva um procedimento inc_data que receba uma data,
formada por dia, mês e ano, e retorne, nos mesmos
parâmetros, a data correspondente ao dia seguinte.
Utilizando esse procedimento resolva os exercícios I00003800,
I00003900, I00003950
Escreva um procedimento inc_semana que receba uma data,
formada por dia, mês e ano, e retorne,nos mesmos parâmetros,
a data correspondente a uma semana depois.
Utilizando esse procedimento resolva os exercícios I00003960 e
I00003970
I00003800 - Data juliana é o número de dias tanscorridos no
ano (ex:236/1995). A faixa é de 1 a 365 (366 se o ano for
bisexto). Escreva um algoritmo que leia uma data juliana (dia
e ano) e a converta para o formato DD/MM/AAAA
escrevendo a data. Considere que ano bisexto é aquele divisível
por 4.
I00003900 - Faça um algoritmo que leia duas datas, cada uma
formada por dia, mês e ano, e escreva o número de dias entre
as duas, incluindo a data inicial e a data nal. Considere que
ano bisexto é aquele divisível por 4.
I00003950 - Faça um algoritmo que leia duas datas, cada uma
formada por dia, mês e ano, e escreva todas as datas entre as
duas, incluindo a data inicial e a data nal. Considere que ano
bisexto é aquele divisível por 4. Considere também que a data
inicial é menor ou igual à data nal.
I00003960 - Faça um algoritmo que leia 4 valores d,m,a,ds,
onde d,m,a representam uma data (dia,mês,ano) e ds
representa um dia da semana (1-domingo, 2-segunda, 3-terça,
4-quarta, 5-quinta, 6-sexta, 7-sábado), e escreva as datas das
próximas 3 sextas-feiras 13, a partir da data digitada, incluindo
a própria data, se for o caso. Considere que ano bissexto é o
ano divisível por 4.
I00003970 - Faça um algoritmo que leia o mês e o ano de uma
sexta-feira 13 e escreva o mês e ano das próximas 5
ocorrências de sexta-feira 13. Considere que ano bissexto é o
ano divisível por 4.
Geração de Valores Aleatórios

Em aplicações de engenharia é comum o uso de dados


simulados para testar sistemas, antes de submetê-los a dados
reais.
Esses dados simulados, frequentemente contém valores
aleatórios, para simular a presença de ruídos ou outras
situações.
Um gerador de números aleatórios é uma função que retorna
um número distinto e aparentemente aleatório cada vez que é
chamada.
Como esses valores não são realmente aleatórios, mas gerados
por uma função matemática bem denida, também são
chamados de pseudo-aleatórios
Uma função matemática que gera um valor pseudo-aleatório é
a seguinte:
ni +1 = (8121 ∗ n + 28411)%134456
i

Essa função, como a maioria das funções de geração de valores


aleatórios, utiliza o último número que foi gerado para gerar o
próximo valor.
Escreva um algoritmo que gere os primeiros 10 números
aleatórios gerados por essa função, considerando 0 como valor
inicial.
Essa função gera valores na faixa de 0 a 134455.
Como fazer para gerar valores em outras faixas (p.ex. -10 a
+10)?
A divisão do número gerado por 134455 resulta em valores na
faixa [0..1]
A multiplicação por K desse número entre 0 e 1 gera valores
entre 0 e K.
A soma ou subtração desse valor por X desloca a faixa de
valores de 0 a K, para -X a K-X.
Como converter os valors gerados pela função para valores
entre -10 e 10?
Faça um algoritmo que gere 1000 números entre 0 e 4 e
escreva o percentual de vezes em que ocorrem valores nos
intervalos [0;1), [1;2), [2;3), [3;4]
Vetores

Vetores são conjuntos de variáveis independentes que


compartilham um nome em comum.
Índices são associados a cada elemento permitindo
referenciá-los individualmente.
As declarações tem o formato
vetor [ indice_inicial .. indice_nal ] de tipo
onde o tipo pode ser inteiro, real, numérico, lógico ou literal
Ex: vet : vetor [0..7] de inteiro
Declara um vetor de 8 posições chamado vet, a primeira é
referenciada como a posição 0 e a última é a posição 7.
Cada posição do vetor contem um valor inteiro, independente
dos outros valores.

Para referenciar um elemento de um vetor utiliza-se a notação


nome[posição]
Exemplos de uso:
para i de 0 ate 3 faca
a[i]<-0
mpara

leia(a[3]) - lê um valor e armazena na posição 3 do vetor a


escreva(a[i])
a[i]<-a[i]+1 - soma 1 à posição i do vetor
V00000100 - Escrever um algoritmo que lê um vetor V(10) e o
escreve. Conte, a seguir, quantos valores de V são negativos e
escreva esta informação.
V00000200 - Faça um algoritmo que leia 10 valores e os
escreva na ordem contrária à que foram digitados.
V00000250 - Faça um algoritmo que leia os conceitos (1, 2, 3,
4 ou 5) dos alunos de uma turma de 20 alunos. Após, o
algoritmo desenha um histograma com os conceitos na forma
111
2222
3333333333
44
5
se houveram três alunos com conceito 1, quatro com conceito
2, dez com conceito 3, dois com conceito 4 e um com conceito
5.
V00000300 - Faça um algoritmo que leia 10 valores e escreva
primeiramente todos os números pares digitados e em seguida
os números ímpares.
V00000320 - Faça um algoritmo que leia uma quantidade
indeterminada de números até que sejam informados 10
números positivos (maiores que zero) e em seguida escreva
esses números positivos em ordem contrária à ordem de leitura.
V00000400 - Escrever um algoritmo que lê um vetor V(10) e o
escreve. Conte, a seguir, quantos valores de V são primos e
escreva esta informação.
V00000500 - Faça um algoritmo que leia dez números inteiros
armazenando-os em um vetor. Após, escreva a posição de
cada número menor que zero desse vetor.
V00000600 - Escreva um algoritmo que lê um vetor A(10) e
escreva a posição de cada elemento primo deste vetor.
V00000700 - Escrever um algoritmo que lê um vetor X(10) e o
escreve. Substitua, a seguir, todos os valores negativos de X
pelos seu módulo e escreva novamente o vetor X.
V00000800 - Escrever um algoritmo que lê um vetor C(50) e o
escreve. Encontre, a seguir, o maior elemento de C e o escreva.
V00000900 - Escrever um algoritmo que lê um vetor N(80) e o
escreve. Encontre, a seguir, o menor elemento e a sua posição
no vetor N e escreva: "O menor elemento de N é = ... e a sua
posição é ... ".
V00001000 - Faça um algoritmo que leia 10 valores, calcule
sua média e escreva os valores que estão acima da média
calculada.
V00001010 - Faça um algoritmo que leia 10 valores, calcule
sua média e escreva o valor do menor elemento maior ou igual
à média calculada.
Busca de um valor em um vetor

Uma operação comum em exercícios com vetores é a busca de


um valor em um vetor. Para fazer isso pode-se comparar o
valor a ser pesquisado com todos os valores do vetor e contar
quantas vezes ele ocorre, ou usar um ag. Por exemplo, para
procurar N em um vetor V[1..100].

tem<−0
p a r a i de 1 a t e 100 f a c a
s e N=v [ i ]
e n t a o tem<−1
fimse
fimpara
Flags

Um ag ou variável sinalizadora é uma variável utilizada para


identicar, em um ponto do algoritmo, se alguma situação
ocorreu antes no algoritmo.
É como se fosse um contador, mas limitado ao valor 1.
Da mesma forma que um contador, ele é inicializado com 0 e,
quando ocorre a situação que se busca identicar, ele recebe 1
e mantem esse valor.
Posteriormente testando-se o seu valor (0 ou 1) pode-se saber
se a situação buscada ocorreu.
No exemplo anterior, o ag tem é utilizado para testar mais
adiante se N foi encontrado no vetor ou não.
Um problema da versão anterior é que o algoritmo continua
procurando o valor mesmo após ter encontrado.
Uma alternativa é substituir o para por um enquanto, fazendo
com que a procura termine assim que o valor for encontrado
ou quando chegar no nal.
Algo como:

i <−1
tem<−0
enquanto tem=0 e i <=10 f a c a
s e N=v [ i ]
e n t a o tem<−1
fimse
i <− i +1
fimenquanto
Outra alternativa é colocar a comparação de N e cada
elemento do vetor direto na condição do enquanto
Deve-se tomar cuidado para que o valor de i não exceda 10 no
teste. Se isso ocorrer a condição testará a posição v[11], que
não existe
Ao sair do enquanto, pode-se testar se o valor foi encontrado
comparando N com v[i]

i <−1
enquanto N<>v [ i ] e i <10 f a c a
i <− i +1
fimenquanto
Se N=v [ i ]
entao es c re v a ( " Achei ! ! ! " )
fimse
V00001050 - Faça um algoritmo que leia um vetor de 10
elementos. Leia, a seguir, um valor N e verique se o valor
aparece no vetor escrevendo:
0 - se o valor N não aparece no vetor;
1 - se o valor N aparece no vetor
V00001450 - Faça um algoritmo que leia um vetor de 10
elementos. Leia, a seguir, 10 valores N e, para cada um,
verique se o valor aparece no vetor escrevendo:
0 - se o valor N não aparece no vetor;
1 - se o valor N aparece no vetor
V00001500 - Escrever um algoritmo que lê um vetor X(10) e,
após, leia um vetor Y(10). Crie, a seguir, um terceiro vetor Z
com os elementos que aparecem nos dois vetores (intersecção).
Os elementos devem aparecer no vetor Z na mesma ordem em
que aparecem no vetor X. Considere que não há repetição de
valores dentro do mesmo vetor. Escreva o vetor Z (apenas as
posições que foram preenchidas).
V00001501 - Escrever um algoritmo que lê um vetor X(10) e,
após, leia um vetor Y(10). Crie, a seguir, um terceiro vetor Z
com os elementos que aparecem em um X ou em Y (união);
elementos que aparecem em X e Y simultaneamente devem
aparecer apenas uma vez em Z. Os elementos devem aparecer
no vetor Z na mesma ordem em que aparecem no vetor X e Y.
Considere que não há repetição de valores dentro do mesmo
vetor. Escreva o vetor Z (apenas as posições que foram
preenchidas).
V00001700 - Escrever um algoritmo que lê 2 vetores X(10) e
Y(10), e escreva os elementos que aparecem no vetor X e não
aparecem no vetor Y (diferença de conjuntos). Escreva os
valores na ordem em que eles aparecem no vetor X. Os dois
vetores devem ser lidos separadamente (em primeiro lugar,
todo o vetor X, após, o vetor Y).
V00001710 - Escrever um algoritmo que lê 3 vetores A[1..10],
B[1.10] e C[1..10] e escreve os elementos que estão em A e B
(interseção) mas não estão em C. Escreva os valores na ordem
em que eles aparecem no vetor A. Os três vetores devem ser
lidos separadamente (em primeiro lugar, todo o vetor A, após,
o vetor B e por m o vetor C).
V00001720 - Escrever um algoritmo que lê 3 vetores A[1..10],
B[1.10] e C[1..10] e escreve os elementos que são comuns aos
três vetores (intersecção). Escreva os valores na ordem em que
eles aparecem no vetor A. Os três vetores devem ser lidos
separadamente (em primeiro lugar, todo o vetor A, após, o
vetor B e por m o vetor C).
V00001730 - Escrever um algoritmo que lê 2 vetores A[1..10] e
B[1.10] e escreve os elementos que estão somente em A ou
somente em B. Escreva os valores na ordem em que eles
aparecem no vetor A, e em seguida os que aparecem no vetor
B. Os dois vetores devem ser lidos separadamente (em
primeiro lugar, todo o vetor A e, após, o vetor B).
V00001100 - Escrever um algoritmo que lê um vetor N(10) e o
escreve. Troque, a seguir, o 1◦ elemento com o último, o 2◦
com o penúltimo, etc até o 5◦ com o 6◦ e escreva o vetor N
assim modicado.
V00001200 - Escrever um algoritmo que lê um vetor N(10) e o
escreve. Troque, a seguir, cada elemento que estiver em
posição ímpar (o primeiro, o terceiro...) pelo elemento da
posição imediatamente a seguir. Escreva o vetor modicado.
V00001250 - Escreva um algoritmo que lê em um vetor de 20
posições números positivos, até que o vetor esteja completo ou
que tenha sido fornecido o valor 0 (zero). Após, escreva o
vetor. A seguir, o algoritmo deve ler um número positivo
qualquer e, caso ele se encontre no vetor, deve remover todas
suas ocorrências, através de um deslocamento para a esquerda
dos elementos que encontram-se à direita daquele a ser
removido. Escreve o vetor modicado.
V00001300 - Escrever um algoritmo que lê um vetor G(10)
contendo o gabarito de uma prova. Leia a seguir, para cada
aluno de um conjunto de 5 alunos suas 10 respostas e verique
quantas questões acertou, escrevendo para cada aluno o
número de acertos.
V00001400 - Faça um algoritmo que leia 10 valores e verique
se algum dos valores aparece repetido. Escreva 1 se algum
valor aparece repetido e 0 se não houver nenhum valor
repetido.
V00001600 - Faça um algoritmo que leia um vetor V(5), com
os valores sorteados em um sorteio de Loto. Leia, a seguir,
para um conjunto de 5 apostadores, seus 5 palpites e escreva,
para cada um, o número de acertos que teve.
V00001650 - Faça um algoritmo que leia um número N e
escreva os N primeiros números primos em ordem decrescente.
Considere que N é no máximo igual a 100. Ex: Se N=5,
escreva 11,7,5,3,2.
V00001790 - Faça um algoritmo que leia valores inteiros entre
1 e 10 até que seja digitado um valor igual a 0, e escreva, ao
nal, quais dos valores entre 1 e 10 que não foram digitados
nenhuma vez.
Ordenação de Vetores

V00001800 - Faça um algoritmo que leia um vetor X(10).


Compare a seguir cada elemento com o elemento da posição
seguinte, trocando-os entre si se o elemento de maior valor
estiver antes do elemento de menor valor. O que se pode dizer
sobre a ordem dos elementos dentro do vetor após essa
operação?

p a r a i de 1 a t e 9 f a c a
s e v [ i ]>v [ i +1]
e n t a o aux<−v [ i ]
v [ i ]<− v [ i +1]
v [ i +1]<− aux
fimse
fimpara
Ordenação de Vetores

V00001900 - Faça um algoritmo que leia um vetor X(10) e


ordene seus elementos em ordem crescente. Escreva o vetor
ordenado. Dica: o que acontece se o procedimento descrito no
exercício V00001800 for executado repetidamente sobre o
vetor?

p a r a j de 1 a t e 9 f a c a
p a r a i de 1 a t e 9 f a c a
s e v [ i ]>v [ i +1]
e n t a o aux<−v [ i ]
v [ i ]<− v [ i +1]
v [ i +1]<− aux
fimse
fimpara
fimpara
Método da Bolha (Bubblesort)

O algoritmo mostrado acima chama-se Método da Bolha, e


normalmente é o primeiro ensinado em cursos de programação.
Não é muito eciente ou intuitivo, mas pela simplicidade é o
mais usado para ordenar poucos valores.
Pode-se obter uma melhora no seu desempenho substituindo o
para externo por um enquanto, para que ele termine assim
que o vetor já estiver ordenado, o que pode ser identicado
por um ag para sinalizar se foi feita alguma troca na
passagem pelo vetor.
Algo como:

t r o c o u <−1
enquanto t r o c o u =1 f a c a
t r o c o u <−0
p a r a i de 1 a t e 9 f a c a
s e v [ i ]>v [ i +1]
e n t a o aux<−v [ i ]
v [ i ]<− v [ i +1]
v [ i +1]<− aux
t r o c o u <−1
fimse
fimpara
fimenquanto
V00002000 - Faça um algoritmo que leia, para cada pessoa de
um conjunto de 10 pessoas, o seu peso (inteiro) e altura
(real), e escreva a lista de pesos e alturas em ordem crescente
de altura. Os dois dados referentes a cada pessoa devem ser
lidos juntos (ou seja, o algoritmo não deve ler todos os pesos e
em seguida todas as alturas)
Nesse exercício, pode-se manter um vetor para o peso e um
para a altura, sendo que o que relaciona a altura e o peso à
mesma pessoa é o fato de ocuparem a mesma posição nos dois
vetores.
Para manter essa relação, a cada vez que duas alturas forem
trocadas entre si, deve ser feita a mesma troca entre os pesos
correspondentes
Ordenação por mais de uma chave

Em algumas situações, os valores a serem ordenados são


compostos por mais de um elemento, e mais de um elemento
deve ser considerado para identicar a ordem relativa entre os
valores.
Identicando-se claramente a relação de ordem entre os
valores, pode-se utilizar o Método da Bolha ou qualquer
algoritmo de ordenação
Ordenação por mais de uma chave

V00003550 - Faça um algoritmo que leia 10 datas de


aniversário, cada uma composta por dia e mes, e escreva as 10
datas em ordem cronológica crescente.
Na comparação entre duas datas de aniversário, uma data é
maior que a outra (ocorre após a outra) se o mês é maior ou,
quando os meses são iguais, se o dia é maior.
Algo como: Se m1>m2 ou m1=m2 e d1>d2
E caso as datas não estiverem na ordem desejada, deve-se
trocar todos os elementos que compõem a data (no caso, o dia
e o mês)
Algo como:
t r o c o u <−1
enquanto t r o c o u =1 f a c a
t r o c o u <−0
p a r a i de 1 a t e 9 f a c a
s e m[ i ]>m[ i +1] ou m[ i ]=m[ i +1] e d [ i ]>d [ i +1]
e n t a o aux<−m[ i ]
m[ i ]<−m[ i +1]
m[ i +1]<− aux
aux<−d [ i ]
d [ i ]<− d [ i +1]
d [ i +1]<− aux
t r o c o u <−1
fimse
fimpara
fimenquanto
Ordenação por mais de uma chave

V00003600 - Faça um algoritmo que leia 10 datas, cada uma


composta por dia, mês e ano, e escreva as 10 datas em ordem
cronológica crescente.
V00003700 - Faça um algoritmo que para 10 cartas de baralho
leia o seu valor (entre 1 e 13) e naipe (1 - ouros, 2 - copas, 3 -
paus, 4 - espadas), e ordene-as em ordem crescente de naipe e,
para cada naipe, em ordem crescente de valor. Escreva a lista
de cartas ordenada.
Vetores de contadores

V00002500 - Faça um algoritmo que leia 30 valores inteiros


entre 1 e 10 e escreva o número de vezes que ocorre cada
valor.
Esse exercício pode ser resolvido contando inicialmente os 1s,
depois os 2s e assim por diante, até os 10s.

p a r a n de 1 a t e 10 f a c a
cont <−0
p a r a i de 1 a t e 30 f a c a
s e v [ i ]=n
e n t a o cont<−c o n t+1
fimse
fimpara
e s c r e v a l ( "O número " , n , " o c o r r e " , cont , " v e z e s " )
fimpara
Um problema da solução anterior é que, como é utilizado
apenas um contador, é necessário repassar 10 vezes por todos
os dados
Uma alternativa seria a utilização de 10 contadores, um para
cada número a ser contado.
Dessa forma todas as contagens poderiam ser feitas
simultaneamente

l e i a (N)
s e N=1 e n t a o cont1<−c o n t 1+1
s e n a o s e N=2 e n t a o cont2<−c o n t 2+1
...
Pode-se agrupar esses contadores em um vetor de contadores:

l e i a (N)
s e N=1 e n t a o c o n t [1]< − c o n t [1 ]+ 1
s e n a o s e N=2 e n t a o c o n t [2]< − c o n t [2 ]+ 1
...
Como N "diz"qual a posição que deve ser incrementada,
pode-se usar N diretamente como índice do vetor de
contadores:

p a r a i de 1 a t e 10 f a c a
c o n t [ i ]<−0
fimpara
p a r a i de 1 a t e 30 f a c a
l e i a (N)
c o n t [N]<− c o n t [N]+1
fimpara
p a r a i de 1 a t e 10 f a c a
e s c r e v a l (N, " o c o r r e " , c o n t [ i ] , " v e z e s )
fimpara
V00003250 - Faça um algoritmo que leia, para 5 candidatos a
deputado, o seu cadastro. Leia, a seguir, um número não
determinado de votos (termina ao ser digitado 0) e escreva ao
nal o cadastro e número de votos de cada candidato (em
ordem crescente de cadastro). Escreva também, ao nal, o
número de votos nulos (ou seja, votos que não são iguais ao
cadastro de nenhum candidato).
V00003300 - Faça um algoritmo que leia, para 20 candidatos a
deputado, seu cadastro, partido (inteiro entre 1 e 10) e
número de votos, e escreva o total de votos de cada partido.
Os 3 dados correspondentes a cada candidato devem ser lidos
juntos, antes de passar para o próximo candidato.
V00003350 - Faça um algoritmo que leia, para 20 candidatos a
deputado, seu cadastro, partido (inteiro entre 1 e 10) e
número de votos, e escreva, para os 10 partidos, o número do
partido e o total de votos, em ordem decrescente de votação.
Os 3 dados correspondentes a cada candidato devem ser lidos
juntos, antes de passar para o próximo candidato.
V00003400 - Faça um algoritmo que leia, para 20 candidatos a
deputado, seu cadastro, partido (inteiro entre 1 e 10) e
número de votos, e escreva o cadastro, partido e número de
votos do candidato mais votado de cada partido, em ordem
crescente de partido.
V00003410 - Faça um algoritmo que leia, para 20 candidatos a
deputado, seu cadastro, partido (inteiro entre 1 e 10) e
número de votos, e escreva o cadastro, partido e número de
votos do candidato mais votado de cada partido, em ordem
decrescente de votação.
V00003450 - Faça um algoritmo que leia, para 20 candidatos a
deputado, seu cadastro, partido (inteiro entre 1 e 10) e número
de votos, e escreva o cadastro, partido e número de votos de
todos os candidatos, em ordem crescente de partido e, para o
mesmo partido, em ordem crescente de número de votos.
V00003500 - Faça um algoritmo que leia 20 números reais.
Escreva a quantidade mínima de elementos cuja soma seja
maior ou igual à metade da soma total. Dica: Classique o
vetor e some os primeiros (ou últimos) elementos até atingir a
metade da soma total.
V00002100 - Faça um algoritmo que leia dois vetores V(10) e
W(10), ordenando cada um em ordem crescente. Gere, a
seguir, um vetor Z(20) com os elementos de V e W, também
em ordem crescente. Escreva o vetor Z.
V00002200 - Escrever um algoritmo que gera os 10 primeiros
números primos acima de 100 e os armazena em um vetor
X(10) escrevendo, no nal, o vetor X.
V00002250 - Escrever um algoritmo que leia 20 números
inteiros em um vetor e escreva o elemento que aparece
MENOS vezes no vetor com o número de ocorrências.
Suponha que não haverão dois ou mais números com o mesmo
número mínimo de ocorrências.
V00002300 - Escrever um algoritmo que lê um vetor X(20)
possivelmente contento repetições e o escreve. Escreva, a
seguir, cada um dos valores que aparecem em X dizendo
quantas vezes cada valor aparece em X.
V00002400 - Faça um algoritmo para gerar um vetor com os
números primos de 1 a 1000 através do crivo de eratóstenes.
Neste método o vetor (inicializado com zeros) é percorrido da
segunda posição até o m e para cada posição n que contem
0, n é um número primo e todas as posições múltiplas de n
devem receber 1. Escreva ao nal os números primos. Eles são
indicados pelas posições do vetor que contem 0.
V00002600 - Faça um algoritmo que leia 10 números reais
armazenando-os em um vetor. Desloque, a seguir, todos os
elementos do vetor uma posição para a esquerda (colocando
na última posição o elemento que estava na primeira posição).
Repita isso até o que o maior elemento esteja ocupando a
primeira posição.
V00002700 - Faça um algoritmo que coloque em um vetor os
20 primeiros números primos da série de Fibonacci
V00002800 - Faça um algoritmo que leia uma quantidade
indeterminada de números até que sejam digitados 10 números
distintos e escreva esses 10 números.
V00002900 - Faça um algoritmo que preencha um vetor com
os 20 primeiros números primos e após escreva os elementos
desse vetor. Para identicar se um número é primo, verique
se é divisível por algum dos primos já colocados no vetor.
V00003000 - Faça um algoritmo que leia dois vetores V(15) e
W(15), contendo, cada um, um número de 15 dígitos, cada
dígito ocupando uma posição do vetor, o dígito menos
signicativo do número ocupando a posição 15, e calcule a
soma dos dois números, colocando o resultado em um vetor
S(16). Escreva ao nal o vetor S. Os dois vetores de entrada
devem ser lidos separadamente, primeiro o vetor V e, após, o
vetor W.
V00003050 - Faça um algoritmo que leia dois vetores V(15) e
W(15), contendo, cada um, um número de 15 dígitos, cada
dígito ocupando uma posição do vetor, e efetue a comparação
entre os dois números de quinze dígitos em V e W, escrevendo:
-1 se o número em V é menor. 0 (zero) se os números em V e
W são iguais. 1, se o número em V é maior. Leia inicialmente
os 15 dígitos de V e, após, os 15 dígitos de W.
V00003100 - Faça um algoritmo que leia dois vetores V(15) e
W(15), contendo, cada um, um número de 15 dígitos, cada
dígito ocupando uma posição do vetor, o dígito menos
signicativo do número ocupando a posição 15, e calcule a
diferença dos dois números (V-W), colocando o resultado em
um vetor S(16). Escreva ao nal o vetor S. Considere que o
número de 15 dígitos no vetor V é maior que o número contido
no vetor W.
V00003200 - Faça um algoritmo que leia um vetor V(15)
contendo um número de 15 dígitos, e um valor N entre 0 e 9,
e calcule o produto (multiplicação) do número em V pelo valor
N, colocando o resultado em um vetor P(16). Escreva o vetor
P.
V00003750 - Faça um algoritmo que para 9 cartas de baralho
leia o seu valor (entre 1 e 13). O algoritmo deve escrever
quantas trincas a "mão"contém. Uma trinca é composta de
três cartas com o mesmo valor. O naipe das cartas não
importa. Cada carta pode aparecer no máximo em uma trinca.
V00003800 - Faça um algoritmo que para 10 cartas de baralho
leia o seu valor (entre 1 e 13) e naipe (1 - ouros, 2 - copas, 3 -
paus, 4 - espadas), e escreva:
1 - se as cartas contem uma canastra;
0 - se não contem.
Considere como canastra apenas uma sequencia crescente de 7
cartas do mesmo naipe de numeração contínua (cuja diferença
entre duas cartas seja igual a 1). Considere que podem ocorrer
cartas de mesmo número. Nesse caso a carta de mesmo
número não é contada, mas não quebra a sequência.
V00003900 - Faça um algoritmo que leia os 5 números obtidos
em um arremesso de 5 dados no jogo de General, e verique se
os números contém um full-hand (3 números iguais, e os
outros dois números iguais entre si, mas diferentes dos 3
primeiros. Ex. 3,3,3,2,2), e escreva: 1 - se os números contem
um full-hand; 0 - se não contem.
V00004000 - Faça um algoritmo que encontre a maior
subsequência de elementos, não necessariamente contíguos, de
um vetor de no máximo 100 elementos de tal forma que cada
elemento desta subsequência seja menor ou igual ao anterior.
Os dados do vetor devem ser lidos até que seja digitado um
valor negativo (que deve ser descartado). O algoritmo deve
escrever, ao nal, o comprimento da maior subsequência
encontrada.
V00004100 - Faça um algoritmo que encontre e escreva a
maior subsequência de elementos, não necessariamente
contíguos, de um vetor de no máximo 100 elementos de tal
forma que cada elemento desta subsequência seja menor ou
igual ao anterior. Os dados do vetor devem ser lidos até que
seja digitado um valor negativo (que deve ser descartado).
V00004150 - Faça um algoritmo que leia um vetor V(10) e um
vetor W(3), e verique e escreva a primeira posição do vetor V
a partir da qual são encontrados, de forma contígua, os três
elementos do vetor W. Caso o vetor W não ocorra em V, o
algoritmo deve escrever -1.
V00004200 - Faça um algoritmo que leia um vetor de inteiros
W[30]. Leia a seguir um vetor V[10] e verique se a sequência
de 10 números no vetor V ocorre no vetor W, escrevendo a
posição do vetor W onde inicia a sequencia, caso ela exista, ou
0, caso a sequencia em V não exista em W.
V00006000 - Faça um algoritmo que lê os conceitos de uma
turma de N alunos, notas inteiras, de 0 a 10, até que seja
digitado um valor < 0 (que deve ser descartado) e escreva,
para os valores de 0 a 10, o valor e o número de ocorrências
do mesmo.
V00006100 - Crie um algoritmo que lê um vetor G(13)
representando o resultado de um teste de loteria esportiva,
contendo os valores 1 (coluna 2), 2 (coluna do meio) e 4
(coluna 1). A seguir, para cada apostador, o algoritmo lê o n◦
de seu cartão e suas apostas para cada um dos 13 jogos, sendo
válidos os seguintes valores: 1 (coluna 2), 2 (coluna do meio),
3 (coluna 2 e do meio), 4 (coluna 1), 5 (coluna 1 e 2), 6
(coluna 1 e do meio) e 7 (triplo). O algoritmo calcula, para
cada apostador, o n◦ de acertos e escreve o n◦ do apostador e
seu número de acertos. O algoritmo para de ler quando o
número do apostador for 0.
V00006200 - Faça um algoritmo que leia valores até que seja
digitado um valor negativo e escreva os 10 últimos valores
positivos digitados. Considere que serão digitados pelo menos
10 valores positivos. O algoritmo deve escrever os valores na
mesma ordem em que foram digitados pelo usuário.
V00006300 - Crie um algoritmo que lê o número de matrícula
de cada aluno e suas respectivas notas em três provas, em
uma turma de 10 alunos. Após, calcular a média harmônica
(MH) de cada aluno e vericar o conceito obtido (se MH<6.0,
conceito é 0. Se MH<7.0, conceito é 1. Se MH<8.0 o
conceito é 2. Se MH<9.0 o conceito é 3. Se MH>=9.0,
conceito é 4). Escrever seu número de matrícula e seu
conceito. Dica:Lembre que se uma das três notas é 0, a média
harmônica é 0.
V00006400 - Na apuração de um processo de eleição as vagas
disponíveis são distribuídos entre os partidos
proporcionalmente aos votos obtidos pelo partido. As sobras
são distribuídas da seguinte forma: enquanto houver sobras,
calcula-se para cada partido a razão entre o número de votos e
o número de cadeiras já obtidas + 1. Uma das sobras é
atribuída ao partido de maior razão. Isso se repete até que não
haja mais sobras. Faça um algoritmo que leia, para 10
partidos, de 1 a 10, o seu número de votos. Leia, a seguir, o
total de vagas e escreva, ao nal, para os partidos de 1 a 10, o
número do partido e o número de cadeiras obtidas.
V00006500 - Faça um algoritmo que leia o código de 5 carros
com seus respectivos preços. Ao nal, escreva o código do
carro mais caro com seu respectivo preço.
V00006600 - Escreva um algoritmo que lê um vetor V[10] e
escreva, para cada valor diferente que aparece no vetor, o valor
e o número de vezes que o mesmo ocorre no vetor. Escreva os
valores em ordem crescente de valor.
V00006700 - Faça um algoritmo que leia um vetor V[10] e ao
nal escreva o elemento que aparece mais vezes neste vetor.
V00006800 - Faça um algoritmo que leia um vetor V[15], já
ordenado. Leia, a seguir, um valor N e verique se ele se
encontra no vetor escrevendo a posição em que se encontra.
Caso o valor não esteja no vetor, escreva -1. Tente escrever
um algoritmo da forma mais eciente possível.
V00006900 - Faça um algoritmo que leia os 10 primeiros
valores de um vetor V[20], valores estes já ordenados em
ordem crescente. Leia, a seguir, 10 valores e insira cada um
deles na posição correta do vetor V, de modo a mantê-lo
ordenado, deslocando em uma posição para a direita todos os
valores que vêm após ele. Escreva, ao nal, o vetor V
(ordenação por inserção).
V00007000 - Na ordenação por contagem, conta-se, para cada
elemento do vetor, o número de elementos menores ou iguais a
ele. O valor da contagem é a posição que o elemento ocupará
no vetor ordenado. Faça um algoritmo que leia um vetor V[20]
e ordene-o em ordem crescente, escrevendo o vetor ordenado.
Considere que não há repetição de valores no vetor.
V00007100 - Escreva um algoritmo que leia caracteres em dois
vetores A[5] e B[5]. Após os dois vetores terem sido lidos, o
algoritmo deverá colocar em um terceiro vetor C o resultado
da união dos dois primeiros, ou seja, os caracteres que estão
contidos em um ou outro vetor. Assuma que em um mesmo
vetor não haverá caracteres repetidos, mas um caractere
contido em A poderá também estar contido em B. Nesse caso,
apenas uma ocorrência é colocada em C.
V00007150 - Uma loja decidiu fazer um sorteio de prêmios
para seus clientes. Serão sorteados 10 números, porém, a loja
não quer que um mesmo número receba mais do que um
prêmio. Faça um algoritmo que leia cada número sorteado até
que tenham sido sorteados 10 números diferentes. O algoritmo
escreve os 10 números (distintos) sorteados.
V00007160 - Faça um algoritmo que leia números até que
tenham sido lidos 5 números distintos ou 20 números.
Escreva, ao nal, os 5 números distintos em ordem crescente.
V00007200 - Faça um algoritmo que leia um vetor V[15], já
ordenado. Leia, a seguir, um valor N e verique se ele se
encontra no vetor escrevendo a posição em que se encontra.
Caso o valor não esteja no vetor, escreva -1. Tente escrever
um algoritmo da forma mais eciente possível. Dica: Compare
N com o valor na posição do meio do vetor. Essa comparação
dirá se N está na primeira ou na segunda metade do vetor.
(pesquisa binária)
V00007300 - Crie um algoritmo que leia um vetor v[10]. Leia a
seguir um valor N e faça, no vetor V, uma rotação circular
para a esquerda (rotate left) de N posições. Na rotação
circular para a esquerda, cada elemento é copiado para a
posição à esquerda, e o primeiro elemento é copiado para a
última posição. Escreva, ao nal, o vetor alterado.
V00007400 - Escreva um algoritmo que lê em um vetor o
gabarito das 20 questões objetivas de um prova de vestibular
com 4 opções: A, B, C e D. O algoritmo deve, a seguir, ler,
para cada candidato, seu codigo e as respostas fornecidas para
as 20 questões e escrever o número de acertos. O algoritmo
pára de ler quando o código do candidato for igual a 0.
V00007500 - Crie um algoritmo que faça uma progressão
aritmética de cinco posições, onde deve ser fornecido o
primeiro termo da progressão e a razão desta PA.
V00007600 - Faça um algoritmo que leia um número inteiro e
escreva os dígitos binários correspondentes a esse número
(máximo 64 dígitos binários). Dica:Para converter um número
decimal em binário pode-se proceder sucessivas divisões por
dois até que o quociente seja igual a zero. O número binário é
obtido considerandos restos obtidos nas divisões, mas em
ordem contrária.
V00007700 - Leia um vetor de 10 posições que contem
números positivos e negativos. Em seguida, descubra qual a
sequencia de valores dentro dele (intervalo de valores
contíguos no vetor) que resulta na maior soma, escrevendo ao
nal a soma encontrada.
V00007800 - A sequencia "Look & Say"funciona da seguinte
forma: O seu primeiro termo é sempre "1", e a denição do
próximo termo a partir do anterior é "O n◦ de vezes que um
número se repete até que a sequencia seja quebrada seguido
do número que estava repetindo".
Veja do seguinte modo:
1◦ Termo: 1 (Termo inicial em "1")
2◦ Termo: 11 (Antes tínhamos "uma"(1) vez o número "1")
3◦ Termo: 21 (Antes tínhamos "duas"(2) vezes o número "1")
4◦ Termo: 1211 (Antes tínhamos "uma"(1) vez o número
"2"e "uma"(1) vez o número "1")
5◦ Termo: 111221
6◦ Termo: 312211
...
Elabore um algoritmo que calcule o enésimo termo dessa
sequência. Considere que o número é muito grande e você
precisará de 1000 casas no vetor que irá aglomerá-lo.
Matrizes

Matrizes são conjuntos de variáveis organizados em uma


estrutura de duas dimensões (i.e. linhas e colunas)
Da mesma forma que vetores, para referenciar um elemento de
uma matriz deve-se especicar o número da linha e da coluna
que se quer referenciar
Ao declarar uma matriz deve-se especicar a linha e coluna
iniciais e nais:
Ex: Mat:vetor [1..5,1..5] de inteiro

1 2 3 4 5
1 1 0 0 0 0
2 0 1 0 0 0
3 0 0 1 0 0
4 0 0 0 1 0
5 0 0 0 0 1
Operações sobre matrizes

Assim como vetores, operações sobre matrizes são feitas


elemento a elemento
Normalmente constituem de dois para encadeados, para gerar
todas as combinações de linhas e colunas. Ex:

i j
1 1 M[1,1]←0
Para i de 1 ate 3 faca 1 2 M[1,1]←0
Para j de 1 ate 3 faca 1 3 M[1,1]←0
M[i,j]← 0 2 1 M[1,1]←0
mpara 2 2 M[1,1]←0
2 3 M[1,1]←0
mpara 3 1 M[1,1]←0
3 2 M[1,1]←0
3 3 M[1,1]→0
A gura abaixo ilustra os índices (linha e coluna) dos
elementos de uma matriz 5x5.
M00000100 - Faça um algoritmo que leia uma matriz
M[1..5,1..5] e calcule e escreva a soma dos elementos da
diagonal principal (em negrito na gura abaixo).

1 2 3 4 5
1 1,1 1,2 1,3 1,4 1,5
2 2,1 2,2 2,3 2,4 2,5
3 3,1 3,2 3,3 3,4 3,5
4 4,1 4,2 4,3 4,4 4,5
5 5,1 5,2 5,3 5,4 5,5
A gura abaixo ilustra os índices (linha e coluna) dos
elementos de uma matriz 5x5.
M00000150 - Faça um algoritmo que leia uma matriz
M[1..5,1..5] e calcule e escreva a soma dos elementos da
diagonal secundária (em negrito na gura abaixo).

1 2 3 4 5
1 1,1 1,2 1,3 1,4 1,5
2 2,1 2,2 2,3 2,4 2,5
3 3,1 3,2 3,3 3,4 3,5
4 4,1 4,2 4,3 4,4 4,5
5 5,1 5,2 5,3 5,4 5,5
Pode-se identicar a posição de um elemento em relação à
diagonal principal (acima, abaixo ou exatamente na diagonal
principal) pela relação entre seus índices (linha e coluna)
Elementos exatamente na diagonal principal: linha = coluna
Elementos acima da diagonal principal: linha < coluna
Elementos abaixo da diagonal principal: linha > coluna

1 2 3 4 5
1 1,1 1,2 1,3 1,4 1,5
2 2,1 2,2 2,3 2,4 2,5
3 3,1 3,2 3,3 3,4 3,5
4 4,1 4,2 4,3 4,4 4,5
5 5,1 5,2 5,3 5,4 5,5
De forma semelhante pode-se identicar a posição de um
elemento em relação à diagonal secundária (acima, abaixo ou
exatamente na diagonal principal) pela soma de seus índices
(linha e coluna). Em uma matriz NxN:
Elementos exatamente na D.S.: linha + coluna = N + 1
Elementos acima da D.S.: linha + coluna < N + 1
Elementos abaixo da D.S: linha + coluna > N + 1

1 2 3 4 5
1 1,1 1,2 1,3 1,4 1,5
2 2,1 2,2 2,3 2,4 2,5
3 3,1 3,2 3,3 3,4 3,5
4 4,1 4,2 4,3 4,4 4,5
5 5,1 5,2 5,3 5,4 5,5
M00000200 - Faça um algoritmo que leia uma matriz
M[1..5,1..5] e calcule e escreva a soma dos elementos em toda
a região acima da diagonal principal.
M00000300 - Faça um algoritmo que leia uma matriz
M[1..5,1..5] e calcule e escreva a soma dos elementos em toda
a região acima da diagonal secundária.
M00000350 - Faça um algoritmo que leia uma matriz
M[1..5,1..5] e calcule e escreva a soma dos elementos que
estão ao mesmo tempo acima da diagonal principal e da
secundária.
M00000400 - Faça um algoritmo que leia uma matriz
M[1..5,1..5] e escreva o maior valor existente na matriz, bem
como a linha e coluna onde o valor ocorre.
M00000600 - Faça um algoritmo que leia uma matriz
M[1..5,1..5] e troque cada elemento da linha 4 com elemento
correspondente da linha 2. Escreva a matriz resultante.
M00000700 - Uma matriz identidade é uma matriz que possui
1 em todos os elementos da diagonal principal, e 0 em todas
as outras posições.
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1
Faça um algoritmo que leia uma matriz M[1..5,1..5] e verique
se é uma matriz identidade escrevendo:
1 - Se é uma matriz identidade;
0 - Se não é uma matriz identidade.
M00000800 - Faça um algoritmo que leia uma matriz
M[1..5,1..5] e escreva o número da linha que contenha a maior
soma de seus elementos. Considere que a matriz só contem
valores positivos.
M00000900 - Faça um algoritmo que leia uma matriz
M[1..5,1..5] e escreva o número da linha que contenha a maior
soma de seus elementos. Considere que a matriz pode conter
valores positivos e negativos.
M00001000 - Faça um algoritmo que leia uma matriz
M[1..5,1..5] e gere dois vetores SomaLin[1..5] e SomaCol[1..5],
com a soma dos elementos de cada linha e a soma dos
elementos de cada coluna da matriz M. Escreva ao nal os
vetores Somalin e Somacol.
M00001010 - Escrever um algoritmo que lê uma matriz
M[1..3,1..3], contendo uma posição de jogo da velha, com
valores 0 (casa livre), 1 (marcada com cruzinha) ou 2
(marcada com bolinha) e escreva:
1 - se o jogador 1 venceu o jogo (alguma linha, coluna ou
diagonal com o mesmo valor);
2 - se o jogador 2 venceu o jogo;
3 - se o jogo terminou empatado (não há mais lances e
ninguém ganhou);
4 - se o jogo ainda não terminou (há lances por jogar e
ninguém ainda venceu)
M00001100 - Uma matriz é dita Diagonalmente Dominante se
atende às duas condições abaixo::
a) em todas as linhas o elemento da diagonal principal é maior
ou igual à soma dos outros elementos da linha e,
b)há pelo menos uma linha em que o elemento da diagonal
principal é MAIOR que a soma dos outros elementos da linha
(não basta que seja igual).
Faça um algoritmo que leia uma matriz M[1..4,1..4] e verique
se é diagonalmente dominante escrevendo:
1 - Se é diagonalmente dominante;
0 - Se não é diagonalmente dominante
M00001200 - Faça um algoritmo que leia uma matriz
M[1..5,1..5], onde cada posição contem um número entre 0 e
9 e cada linha da matriz representa um número de 5 dígitos. O
algoritmo deve calcular a soma dos 5 números contidos na
matriz colocando o resultado em um vetor Soma[1..6]. Escreva
ao nal o vetor Soma.
M00001300 - Faça um algoritmo que leia uma matriz
M[1..5,1..5], onde cada posição contem um número entre 0 e
9 e cada linha da matriz representa um número de 5 dígitos. O
algoritmo deve encontrar a linha que contem o maior dos 5
números e escrever o número.
M00001400 - Faça um algoritmo que leia uma matriz
M[1..5,1..5], onde cada posição contem um número entre 0 e
9 e cada linha da matriz representa um número de 5 dígitos. O
algoritmo deve ordenar os 5 números em ordem crescente, e
escrever a matriz com os números ordenados.
M00001500 - Faça um algoritmo que leia dois valores D e DS,
correspondendo a um dia do mês e um dia da semana
(1-domingo, 2-segunda,... 7-sábado) e preencha uma matriz
Folhinha[1..6,1..7] com o calendário correspondente ao mês do
dia digitado. A primeira coluna da matriz contem os
domingos, a segunda coluna contem as segundas e assim por
diante. O algoritmo deve escrever a matriz gerada. As
posições não utilizadas da matriz devem conter 0's.
M00001600 - Uma matriz de adjacências, para um mapa
rodoviário, é composta de elementos 0's e 1's, sendo que
M[i,j]= 1 se existe uma ligação rodoviária da cidade i para a
cidade j e M[i,j]= 0 em caso contrário. Essa matriz será
simétrica se para todo caminho i,j existir o caminho j,i
(estradas de mão dupla). Uma característica dessa matriz é
que na matriz M 2 , obtida pelo produto matricial de M por M,
cada posição M[i,j] contém o número de caminhos entre as
cidades i e j que passam exatamente por 1 outra cidade. E M 3
contem a quantidade de caminhos que passam por 2 outras
cidades. E assim por diante.
Escreva um algoritmo que leia uma matriz de adjacências M
para um conjunto de 5 cidades e, após, leia os valores c1 e c2
(ambos menores ou iguais a 5) representando duas cidades
quaisquer do conjunto. O algoritmo deve descrever a
quantidade de caminhos entre c1 e c2 que passam exatamente
por 1 outra cidade.
M00001700 - Faça um algoritmo que leia uma matriz
M[1..5,1..5] e um valor N e multiplica cada valor da matriz M
por N e coloca o resultado em um vetor V[1..25]. Escreva ao
nal o vetor V.
M00001800 - Faça um algoritmo que leia uma matriz
M[1..5,1..6] e divide todos os 6 elementos de cada linha pelo
valor do menor elemento EM MÓDULO da linha. Escrever a
matriz modicada.
M00001900 - Faça um algoritmo que leia uma matriz
M[1..5,1..5], possivelmente com elementos repetidos. Leia, a
seguir, 5 valores e, para cada um, verique se o valor ocorre ou
não na matriz, escrevendo a posição (linha e coluna) em que
foi encontrada a primeira ocorrência do mesmo e, caso ele não
exista na matriz, a mensagem "Não tem".
M00002000 - Uma matriz é dita triangular superior se todos os
elementos abaixo da diagonal principal são iguais a zero, e há
pelo menos um elemento nulo acima da diagonal principal.
Da mesma forma, uma matriz é dita triangular inferior se
todos os elementos acima da diagonal principal são iguais a
zero, e há pelo menos um elemento não nulo abaixo da
diagonal principal.
E uma matriz é dita diagonal se os elementos não nulos
ocorrem somente na diagonal principal.
Faça um algoritmo que leia uma matriz M[1..5,1..5] e escreva:
0 - Se a matriz é uma matriz diagonal;
1 - Se é triangular superior;
2- Se é triangular inferior;
3 - Se não é nenhuma das anteriores
M00002100 - Uma matriz é dita Matriz de Toeplitz se, em
cada diagonal paralela à diagonal principal, todos os elementos
são iguais. Assim, um exemplo de Matriz de Toeplitz é:
1 3 5 4 6
2 1 3 5 4
8 2 1 3 5
+7 8 2 1 3
9 7 8 2 1
Faça um algoritmo que leia uma matriz M[1..5,1..5] e verique
se é uma Matriz de Toeplitz, escrevendo:
1 - Se é uma matriz de Toeplitz;
0 - Se não é uma matriz de Toeplitz
M00002200 - Uma matriz é dita Circulante cada elemento é
igual ao elemento imediatamente acima à esquerda, e se o
primeiro elemento de cada coluna é igual ao último elemento
da coluna anterior. Assim, um exemplo de Matriz Circulante é:
1 9 7 8 2
2 1 9 7 8
8 2 1 9 7
7 8 2 1 9
9 7 8 2 1
Faça um algoritmo que leia uma matriz M[1..5,1..5] e verique
se é uma Matriz Circulante, escrevendo:
1 - Se é uma matriz Circulante;
0 - Se não é uma matriz Circulante
M00002300 - Faça um algoritmo que leia uma matriz
M[1..3,1..3] e para cada linha divida toda a linha pelo seu
elemento da primeira coluna. Após isso, a partir da segunda
linha, de cada linha subtraia toda a a primeira linha elemento
a elemento. ex. a matriz:
2 4 6 1 2 3 1 2 3
3 9 6 1 3 2 0 1 -1
2 8 4 1 4 2 0 2 -1
Escreva a matriz alterada.
M00002400 - Uma matriz é dita de Hadamard se todos os
seus elementos são 1 ou -1, e o produto escalar (somatório dos
produtos de cada elemento de uma linha pelo elemento
correspondente da outra linha) entre quaisquer duas linhas é
igual a zero. Faça um algoritmo que leia uma matriz
M[1..4,1..4] e verique se ela é de Hadamard escrevendo:
0 - Se não é de Hadamard;
1 - Se é de Hadamard
M00002500 - Faça um algoritmo que leia uma matriz
M[1..3,1..3] e rotacione a matriz 90 graus no sentido horário,
escrevendo a matriz resultante.
M00004900 - Um quadrado mágico de ordem N (sendo N um
número ímpar) é um arranjo de número de 1 a NxN em uma
matriz quadrada de tal modo que a soma de cada linha, coluna
e diagonal é a mesma. A matriz abaixo representa um
quadrado mágico de ordem 5.
15 8 1 24 17
16 14 7 5 23
22 20 13 6 4
3 21 19 12 10
9 2 25 18 11
A regra para gerá-lo é relativamente fácil de observar:
Comece com 1 no meio da primeira linha.
Siga para cima e para a esquerda diagonalmente (quando sair
do quadrado suponha que os lados superior e inferior estão
unidos ou que os lados da direita e da esquerda estão unidos,
conforme for o caso).
Em cada quadrado que passar coloque o valor do quadrado
anterior mais 1 (um).
Quando a próxima casa estiver já preenchida, desça um
quadrado e continue seguindo a diagonal até ter preenchido
todos os quadrados.
Escrever um algoritmo que lê um número N ímpar, menor ou
igual a 99, e gere e escreva, para o número lido, o seu
quadrado mágico.
M00005000 - Faça um algoritmo que leia duas matrizes
M[1..3,1..3] e N[1..3,1..3] (primeiro a matriz M, e após a
matriz N) e calcule o produto matricial MxN colocando o
resultado em uma matriz P[1..3,1..3]. Escreve ao nal a
matriz P.
M00005100 - As pirâmides têm a base quadrada, sendo que a
única forma de se atingir o topo é seguir em espiral pela
borda. Escreva um algoritmo que leia um valor N e, a seguir,
uma matriz quadrada A[n,n] de ordem no máximo igual a 10, e
verique se a matriz é equivalente a uma pirâmide inca, ou
seja, se partindo-se do canto superior esquerdo da matriz, no
sentido horário, em espiral, a posição seguinte na ordem é o
inteiro consecutivo da posição anterior. O algoritmo deve
escrever: 1 - Se a matriz forma uma pirâmide inca; 0 - Em
caso contrário.
M00005200 - Escreva um algoritmo que leia duas matrizes
numéricas A[3 X 4] e B[3 X 4] e gere e escreva uma matriz
inteira C[3 X 4], tal que um elemento C[i,j]= 1 se os elementos
nas mesmas posições das matrizes A e B forem iguais, e 0 em
caso contrário. O algoritmo deve, ao nal, escrever a matriz C.
M00005300 - Na Teoria de Sistemas, dene-se como elemento
minimax de uma matriz o menor elemento da linha em que se
encontra o maior elemento da matriz. Escreva um algoritmo
que leia uma matriz A[5 X 5] e determine o seu elemento
minimax. O algoritmo deve, ao nal, escrever o valor do
elemento minimax, bem como a linha e coluna onde ocorreu.