exercícios algoritmos

Prévia do material em texto

Iterativos
I00000100 - Faça um algoritmo que escreva os números de 1 a 20.
algoritmo "I001_I00000100"
var i:inteiro
inicio
i<-1
enquanto i<=20 faca
escreva(i)
i<-i+1
fimpara
fimalgoritmo
I00000200 - Faça um algoritmo que escreva todos os números pares entre 1 e 50.
algoritmo "I001_I00000200"
var i:inteiro
inicio
i<-2
enquanto i<=50 faca
escreva(i)
i<-i+2
fimenquanto
fimalgoritmo
I00000300 - Faça um algoritmo que escreva todos os números entre 1 e 200 que são múltiplos de 11.
algoritmo "I001_I00000300"
var i:inteiro
inicio
i<-1
enquanto i<=200 faca
se i%11=0
entao escreva(i)
fimse
i<-i+1
fimenquanto
fimalgoritmo
I00000400 - Faça um algoritmo que leia 10 números e escreva os que forem pares. Dica: Um número inteiro é par se o
resto da sua divisão inteira por 2 é igual a 0.
algoritmo "I002_I00000400"
var i,a:inteiro
inicio
i<-1
enquanto i<=10 faca
leia(a)
se a%2=0
entao escreva(a)
fimse
i<-i+1
fimenquanto
fimalgoritmo
I00000500 - Faça um algoritmo que leia números até que seja digitado um número negativo, e escreva todos que forem
pares.
algoritmo "I001_I00000500"
var a:inteiro
inicio
leia (a)
enquanto a>=0 faca
se a%2=0
entao escreva(a)
fimse
leia (a)
fimenquanto
fimalgoritmo
I00000600 - Faça um algoritmo que leia 30 valores e conte quantos estão no intervalo [10,20], escrevendo ao final essa
informação.
algoritmo "I001_I00000600"
var i,a,cont:inteiro
inicio
cont<-0
i<-1
enquanto i<=30 faca
leia(a)
se a<=20 e a>=10
entao cont<-cont+1
fimse
i<-i+1
fimenquanto
escreva(cont)
fimalgoritmo
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 final essa informação.
algoritmo "I001_I00000700"
var i,a,c1,c2,c3,c4:inteiro
inicio
c1<-0
c2<-0
c3<-0
c4<-0
i<-1
enquanto i<=30 faca
leia(a)
se a<=25 e a>=0
entao c1<-c1+1
fimse
se a<=50 e a>25
entao c2<-c2+1
fimse
se a<=75 e a>50
entao c3<-c3+1
fimse
se a<=100 e a>75
entao c4<-c4+1
fimse
i<-i+1
fimenquanto
escreva(c1,c2,c3,c4)
fimalgoritmo
I00000750 - Faça um algoritmo que leia um valor N. Escreva a seguir os números de 1 a N.
algoritmo
var n,i:inteiro
inicio
leia(n)
i<-1
enquanto i<=n faca
escreva(i)
i<-i+1
fimenquanto
fimalgoritmo
I00000800 - Faça um algoritmo que leia um valor N. Leia, a seguir, N valores e escreva todos que forem positivos.
algoritmo
var n,a,i:inteiro
inicio
leia(n)
i<-1
enquanto i<=n faca
leia(a)
se a>0
entao escreva(a)
fimse
i<-i+1
fimenquanto
fimalgoritmo
I00000900 - Faça um algoritmo que leia um valor N, e escreva todos os seus divisores.
algoritmo
var n,i:inteiro
inicio
leia(n)
i<-1
enquanto i<=n faca
se n%i=0
entao escreva(i)
fimse
i<-i+1
fimenquanto
fimalgoritmo
I00001000 - Faça um algoritmo que leia um valor N, e conte quantos divisores possui, escrevendo ao final essa
informação.
algoritmo
var n,i,cont:inteiro
inicio
leia(n)
cont<-0
i<-1
enquanto i<=n faca
se n%i=0
entao cont<-cont+1
fimse
i<-i+1
fimenquanto
escreva(cont)
fimalgoritmo
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
i<-1
enquanto i<=n faca
se n%i=0
entao soma<-soma+i
fimse
i<-i+1
fimenquanto
escreva(soma)
fimalgoritmo
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).
algoritmo "I001_I00001150"
var i,n:inteiro
inicio
leia(n)
i<-n-1
enquanto n%i<>0 faca
i<-i-1
fimenquanto
escreva(i)
fimalgoritmo
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.
algoritmo "I001_I00001155"
var i,n:inteiro
inicio
leia(n)
i<-2
enquanto n%i<>0 faca
i<-i+1
fimenquanto
escreva(i)
fimalgoritmo
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 verifique se é primo escrevendo: 1 - se o número é primo; 0 - se o número não é
primo. Dica:Pode-se também verificar se um número é primo encontrando seu primeiro divisor maior que 1. Se o
primeiro divisor for o próprio número, ele é primo.
algoritmo
var n,i,cont:inteiro
inicio
leia(n)
cont<-0
para i de 1 ate n faca
se n%i=0
entao cont<-cont+1
fimse
fimpara
se cont<=2
entao escreva(1)
senao escreva(0)
fimse
fimalgoritmo
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 verifique se são amigos entre si escrevendo: 1 - se são amigos; 0 - se não são amigos.
algoritmo
var n1,n2,soma1,soma2,i:inteiro
inicio
leia(n1,n2)
soma1<-0
para i de 1 ate n1\2 faca
se n1%i=0
entao soma1<-soma1+i
fimse
fimpara
soma2<-0
para i de 1 ate n2\2 faca
se n2%i=0
entao soma2<-soma2+i
fimse
fimpara
se soma1=n2 e soma2=n1
entao escreva(1)
senao escreva(0)
fimse
fimalgoritmo
I00001400 - Faça um algoritmo que leia 10 números positivos e escreva ao final o maior deles.
algoritmo
var a,i,maior:inteiro
inicio
maior<-0
para i de 1 ate 10 faca
leia(a)
se a>maior
entao maior<-a
fimse
fimpara
escreva(maior)
fimalgoritmo
I00001500 - Faça um algoritmo que leia 10 números, positivos ou negativos, e escreva ao final o maior deles.
algoritmo
var a,i,maior:inteiro
inicio
leia(maior)
para i de 1 ate 9 faca
leia(a)
se a>maior
entao maior<-a
fimse
fimpara
escreva(maior)
fimalgoritmo
I00001600 - Faça um algoritmo que leia 10 números e escreva ao final o maior e o menor deles.
algoritmo
var a,i,maior,menor:inteiro
inicio
leia(maior)
menor<-maior
para i de 1 ate 9 faca
leia(a)
se a>maior
entao maior<-a
fimse
se a<menor
entao menor<-a
fimse
fimpara
escreva(maior,menor)
fimalgoritmo
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.
algoritmo "I001_I00001610"
var
n,x,cont1,cont2,porcent,menor:real
inicio
escreval("Digite um numero")
leia(n)
menor<-11
cont1 <- 0
cont2 <- 0
enquanto cont1<n faca
escreval("Digite a nota")
leia(x)
se x>=0 E x<=10 entao
cont1 <- cont1+1
se x<menor entao
menor <- x
cont2 <- 1
senao
se x=menor entao
cont2 <- cont2+1
fimse
fimse
fimse
fimenquanto
porcent <- (cont2/n)*100
escreva(menor,",",porcent)
fimalgoritmo
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.
algoritmo
var a,p,maior,mpeso:real
i:inteiro
inicio
maior<-0
mpeso<-0
para i de 1 ate 10 faca
leia(p,a)
se a>maior
entao maior<-a
mpeso<-p
fimse
fimpara
escreva(mpeso,maior)
fimalgoritmo
I00001750 - O índice de massa corporal (IMC) de uma pessoa é dada pela relação peso/(altura^2). Faça um algoritmo
que leia, para 10 pessoas, seu peso e altura e escreva o IMC, peso e altura da pessoa de maior IMC.
algoritmo
var i:inteiro
p,a,imc,maiorIMC,mp,ma:real
inicio
maiorIMC<-0
para i de 1 ate 10 faca
leia(p,a)
imc<-p/(a^2)
se imc>maiorIMC
entao maiorIMC<-imc
mp<-p
ma<-a
fimse
fimpara
escreva(maiorIMC," ",mp," ",ma)
fimalgoritmo
I00001800 - Faça um algoritmo que leia o código e a votação decada 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).
algoritmo
var cod,vot,CM,VM,CS,VS:inteiro
inicio
VM<-0
VS<-0
CM<-0
leia(cod)
enquanto cod>0 faca
leia(vot)
se vot>VM
entao VS<-VM
CS<-CM
VM<-vot
CM<-cod
senao se vot >VS
entao CS<-cod
VS<-vot
fimse
fimse
leia(cod)
fimenquanto
escreva(CM,VM,CS,VS)
fimalgoritmo
I00001900 - Faça um algoritmo que leia 10 números e escreva os que forem primos.
algoritmo
var
n,i,j:inteiro
rn:real
inicio
para j de 1 ate 10 faca
leia(n)
i<-2
rn<-raizq(n)
enquanto n% i<>0 e i<=rn faca
i<-i+1
fimenquanto
se i>rn entao
escreva(n)
fimse
fimpara
fimalgoritmo
ou, usando funções...
algoritmo
var
n,j:inteiro
funcao primo(n:inteiro):inteiro
var d:inteiro
inicio
d<-2
enquanto n% d<>0 faca
d<-d+1
fimenquanto
se n=d entao
retorne 1
senao
retorne 0
fimse
fimfuncao
inicio
para j de 1 ate 10 faca
leia(n)
se primo(n)=1 entao
escreva(n)
fimse
fimpara
fimalgoritmo
I00001950 - Faça um algoritmo que escreva os 50 primeiros números primos.
algoritmo
var n,cont:inteiro
funcao primo(n:inteiro):inteiro
var d:inteiro
inicio
d<-2
enquanto n%d<>0 faca
d<-d+1
fimenquanto
se n=d
entao retorne 1
senao retorne 0
fimse
fimfuncao
inicio
cont<-0
n<-2
enquanto cont<50 faca
se primo(n)=1
entao escreva(n)
cont<-cont+1
fimse
n<-n+1
fimenquanto
fimalgoritmo
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)..
algoritmo
var n,n1,n2,i,cont,soma:inteiro
inicio
leia (n1,n2)
soma<-0
para n de n1 ate n2 faca
cont<-0
para i de 1 ate n faca
se n%i=0
entao cont<-cont+1
fimse
fimpara
se cont<=2
entao soma<-soma+n
fimse
fimpara
escreva(soma)
fimalgoritmo
algoritmo
var n,n1,n2,soma:inteiro
funcao primo(n:inteiro):inteiro
var d:inteiro
inicio
d<-2
enquanto n%d<>0 faca
d<-d+1
fimenquanto
se n=d
entao retorne 1
senao retorne 0
fimse
fimfuncao
inicio
leia (n1,n2)
soma<-0
para n de n1 ate n2 faca
se primo(n)=1
entao soma<-soma+n
fimse
fimpara
escreva(soma)
fimalgoritmo
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).
algoritmo
var n,n1,n2,i,cont,soma:inteiro
inicio
leia (n1,n2)
soma<-1
para n de n1 ate n2 faca
cont<-0
para i de 1 ate n faca
se n%i=0
entao cont<-cont+1
fimse
fimpara
se cont<=2
entao soma<-soma*n
fimse
fimpara
escreva(soma)
fimalgoritmo
algoritmo
var n,n1,n2,prod:inteiro
funcao primo(n:inteiro):inteiro
var d:inteiro
inicio
d<-2
enquanto n%d<>0 faca
d<-d+1
fimenquanto
se n=d
entao retorne 1
senao retorne 0
fimse
fimfuncao
inicio
leia (n1,n2)
prod<-1
para n de n1 ate n2 faca
se primo(n)=1
entao prod<-prod*n
fimse
fimpara
escreva(prod)
fimalgoritmo
I00002200 - Faça um algoritmo que leia um número N e escreva os N primeiros números primos maiores que 100.
algoritmo
var n,i,cont,quant:inteiro
inicio
leia(quant)
n<-101
enquanto quant>0 faca
cont<-0
para i de 1 ate n faca
se n%i=0
entao cont<-cont+1
fimse
fimpara
se cont<=2
entao escreva(n)
quant<-quant-1
fimse
n<-n+1
fimenquanto
fimalgoritmo
algoritmo
var n,cont,p:inteiro
funcao primo(n:inteiro):inteiro
var d:inteiro
inicio
d<-2
enquanto n%d<>0 faca
d<-d+1
fimenquanto
se n=d
entao retorne 1
senao retorne 0
fimse
fimfuncao
inicio
leia(N)
cont<-0
p<-100
enquanto cont<n faca
se primo(p)=1
entao escreva(p)
cont<-cont+1
fimse
p<-p+1
fimenquanto
fimalgoritmo
I00002250 - Faça um algoritmo que leia um número inteiro N e escreva o maior número primo menor do que N.
algoritmo "I001_I00002250"
var N,d:inteiro
inicio
leia(N)
d<-N-1
enquanto d<>N faca
N<-N-1
d<-2
enquanto n%d<>0 faca
d<-d+1
fimenquanto
fimenquanto
escreva(N)
fimalgoritmo
algoritmo
var n:inteiro
funcao primo(n:inteiro):inteiro
var d:inteiro
inicio
d<-2
enquanto n%d<>0 faca
d<-d+1
fimenquanto
se n=d
entao retorne 1
senao retorne 0
fimse
fimfuncao
inicio
leia(N)
N<-N-1
enquanto primo(N)=0 faca
N<-N-1
fimenquanto
escreva(N)
fimalgoritmo
I00002260 - Faça um algoritmo que leia um número inteiro N e escreva o menor número primo maior do que N.
algoritmo "I001_I00002250"
var N,d:inteiro
inicio
leia(N)
d<-N+1
enquanto d<>N faca
N<-N+1
d<-2
enquanto n%d<>0 faca
d<-d+1
fimenquanto
fimenquanto
escreva(N)
fimalgoritmo
algoritmo
var n:inteiro
funcao primo(n:inteiro):inteiro
var d:inteiro
inicio
d<-2
enquanto n%d<>0 faca
d<-d+1
fimenquanto
se n=d
entao retorne 1
senao retorne 0
fimse
fimfuncao
inicio
leia(N)
N<-N+1
enquanto primo(N)=0 faca
N<-N+1
fimenquanto
escreva(N)
fimalgoritmo
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 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.
algoritmo "I001_I00002270"
var N,A,B,i,fim:inteiro
inicio
leia(N)
i<-2
enquanto N%i<>0 faca
i<-i+1
fimenquanto
se N=i
entao escreva(N)
senao fim<-0
A<-N-1
B<-N+1
enquanto fim=0 faca
se A>1
entao i<-2
enquanto A%i<>0 faca
i<-i+1
fimenquanto
se i=A
entao escreva(A)
fim<-1
fimse
fimse
se B>1
entao i<-2
enquanto B%i<>0 faca
i<-i+1
fimenquanto
se i=B
entao escreva(B)
fim<-1
fimse
fimse
A<-A-1
B<-B+1
fimenquanto
fimse
fimalgoritmo
algoritmo
var n,p1,p2:inteiro
funcao primo(n:inteiro):inteiro
var d:inteiro
inicio
d<-2
enquanto n%d<>0 faca
d<-d+1
fimenquanto
se n=d
entao retorne 1
senao retorne 0
fimse
fimfuncao
inicio
leia(N)
se primo(N)=1
entao escreva(N)
senao p1<-N-1
enquanto primo(p1)=0 faca
p1<-p1-1
fimenquanto
p2<-N+1
enquanto primo(p2)=0 faca
p2<-p2+1
fimenquanto
se n-p1=p2-n
entao escreva(p1,p2)
senao se n-p1<p2-n
entao escreva(p1)
senao escreva(p2)
fimse
fimse
fimse
fimalgoritmo
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.
algoritmo "I001_I00002280"
var d1,d2,achei,i,n:inteiro
inicio
leia(n)
d1<-2
achei<-0
enquanto achei=0 faca
i<-2
enquanto d1%i<>0 faca
i<-i+1
fimenquanto
se d1=i
entao d2<-n-d1
i<-2
enquanto d2%i<>0 faca
i<-i+1
fimenquanto
se d2=i entao
escreva(d1,d2)
achei<-1
fimse
fimse
d1<-d1+1
fimenquanto
fimalgoritmo
algoritmo
var n,p1:inteiro
funcao primo(n:inteiro):inteiro
var d:inteiro
inicio
d<-2
enquanto n%d<>0 faca
d<-d+1
fimenquanto
se n=d
entao retorne 1
senao retorne 0
fimse
fimfuncao
inicio
leia(N)
p1<-2
enquanto primo(p1)=0 ou primo(N-p1)=0 faca
p1<-p1+1
fimenquanto
escreva(p1,N-p1)
fimalgoritmo
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 verifique para cada um se é perfeito ou não, escrevendo: 1 - se o
número é perfeito; 0 - se o número não é perfeito.
algoritmo
var
n,i,j,soma:inteiro
inicio
para i de 1 ate 10 faca
leia(n)
soma<-0
para j de 1 ate n-1 faca
se n% j=0 entao
soma<-soma+j
fimse
fimpara
se soma=n entao
escreva(1)
senao
escreva(0)
fimse
fimpara
fimalgoritmo
I00002350 - Faça um algoritmo que leia, para um funcionários: 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 o funcionário deve ser escrito o
quanto ganhou no mês.
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).
algoritmo
var cod,he,hs,th,vh,i:inteiro
inicio
leia(cod)
enquanto(cod<> -1) faca
leia(vh)
th<-0
para i de 1 ate 30 faca
leia(he,hs)
se he<=hs
entao th<-th+hs-he
senao th<-th+24-he+hs
fimse
fimpara
escreva(vh*th)
leia(cod)
fimenquanto
fimalgoritmo
I00002500 - A série de fibonacci é uma sequência de números 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 20 primeiros termos da série de fibonacci.
algoritmo
var a,b,s,i:inteiro
inicio
a<-0
b<-1
escreval(a," ",b)
para i de 1 ate 18 faca
s<-a+b
escreval(s)
a<-b
b<-s
fimpara
fimalgoritmo
I00002525 - A sequência de Fibonacci é formada pelos números: 0 1 1 2 3 5 8 13 21 34 55 ...; sendo que
fibonacci(0)=0; fibonacci(1)=1; fibonacci(2)=1;
fibonacci(3)=2; fibonacci(4)=3; fibonacci(10)=55; ...
Faça um algoritmo que leia um número (N) e escreva o enésimo número da série de Fibonacci.
algoritmo "fib2"
var n,a,b:inteiro
inicio
leia(n)
a<-0
b<-1
enquanto N>1 faca
a<-a+b
b<-a+b
n<-n-2
fimenquanto
se n=0 entao escreva (a)
senao escreva(b)
fimse
fimalgoritmo
I00002550 - A sequência de fibonacci é uma sequência de números 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 entre os 20 primeiros termos da série de fibonacci apenas os que são primos.
algoritmo "I001_I00002550"
var a,b,t,i,cont,fim:inteiro
inicio
a<-1
b<-1
para cont de 3 ate 20 faca
t<-a+b
a<-b
b<-t
i<-2
fim<-int(raizq(t))
enquanto t%i<>0 e i<=fim faca
i<-i+1
fimenquanto
se i>fim
entao escreval(t)
fimse
fimpara
fimalgoritmo
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.
algoritmo
var a,b,mdc:inteiro
inicio
leia(a,b)
mdc<-a
enquanto a%mdc<>0 ou b%mdc<>0 faca
mdc<-mdc-1
fimenquanto
escreva(mdc)
fimalgoritmo
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.
algoritmo
var n,fat,i:inteiro
inicio
leia(n)
fat<-1
para i de 1 ate n faca
fat<-fat*i
fimpara
escreva(fat)
fimalgoritmo
I00002750 - O número de combinações de N diferentes objetos em grupos de P objetos, é dado por N!/(P!(N-P)!). Faça
um algoritmo que leia uma quantidade N de objetos e o tamanho P dos grupos a serem formados, e calcule a quantidade
de grupos que podem ser formados.
algoritmo
var n,p,fatn,fatnp,fatp,i:inteiro
inicio
leia(n,p)
fatn<-1
para i de 1 ate n faca
fatn<-fatn*i
fimpara
fatnp<-1
para i de 1 ate n-p faca
fatnp<-fatnp*i
fimpara
fatp<-1
para i de 1 ate p faca
fatp<-fatp*i
fimpara
escreva(fatn\(fatp*fatnp))
fimalgoritmo
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.
algoritmo
var i,j,n:inteiro
fat:inteiro
inicio
para i de 1 ate 10 faca
leia(n)
enquanto(n>=13) faca
leia(n)
fimenquanto
fat<-1
para j de 1 ate n faca
fat<-fat*j
fimpara
escreval(fat)
fimpara
fimalgoritmo
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.
algoritmo
var a,b,mdc:inteiro
inicio
leia(a,b)
mdc<-a
enquanto mdc%a<>0 ou mdc%b<>0 faca
mdc<-mdc+1
fimenquanto
escreva(mdc)
fimalgoritmo
I00003000 - Faça um algoritmo que leia um número N e efetue sua fatoração, escrevendo os fatores que o compõem.
Ex: 28 = 2 x 2 x 7 60 = 2 x 2 x 3 x 5
algoritmo
var d,n:inteiro
inicio
leia(n)
d<-2
enquanto n>1 faca
se n%d=0
entao escreva(d)
n<-n\d
senao d<-d+1
fimse
fimenquanto
fimalgoritmo
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.
I00003100 - Faça um algoritmo que leia 10 números e para cada um escreva a soma dos seus dígitos formantes.
algoritmo
var i,soma,n:inteiro
inicio
para i de 1 ate 10 faca
leia(n)
soma<-0
enquanto n>0 faca
soma<-soma+n%10
n<-n\10
fimenquanto
escreva(soma)
fimpara
fimalgoritmo
I00003200 - Faça um algoritmo que leia um número N e o escreva com seus dígitos invertidos.
algoritmo
var soma,n:inteiro
inicio
leia(n)
soma<-0
enquanto n>0 faca
soma<-soma*10+n%10
n<-n\10
fimenquanto
escreva(soma)
fimalgoritmo
I00003300 - Faça um algoritmo que leia um número N até (até 9 dígitos) e retira os dígitos impares.
algoritmo "I001_I00003300"
var n,a,b:inteiro
inicio
leia(n)
a<-0
enquanto n>0 faca
a<-a*10+n%10
n<-n\10
fimenquanto
n<-a
b<-0
enquanto n>0 faca
a<-n%10
n<-n\10
se a%2=0
entao
b<-b*10+a
fimse
fimenquanto
se b>0 entao escreva(b) fimse
fimalgoritmo
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 fim da sequência).
I00003400 - Faça um algoritmo que leia um número N até 100.000.000 e verifique 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.
algoritmo
var soma,n,naux:inteiro
inicio
leia(n)
naux<-n
soma<-0
enquanto n>0 faca
soma<-soma*10+n%10
n<-n\10
fimenquanto
se naux=soma
entao escreva(1)
senao escreva(0)
fimse
fimalgoritmo
I00003500 - Faça um algoritmo que escreva os primeiros 20 números cuja soma dos dígitos formantes é 10.
algoritmo
var cont,n,a,s:inteiro
inicio
cont<-0
n<-1
enquanto cont<20 faca
a<-n
s<-0
enquanto a>0 faca
s<-s+a%10
a<-a\10
fimenquanto
se s=10
entao escreva(n)
cont<-cont+1
fimse
n<-n+1
fimenquanto
fimalgoritmo
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 final do primeiro
mês terá 10.500 reais.
algoritmo "I001_I00003600"
var valor,valinic,m:real
inicio
leia(valor)
valinic<-valor
m<-0
enquanto valor-valinic<1000 faca
m<-m+1
valor<-valor * 1.05
fimenquanto
escreva(m)
fimalgoritmo
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.
algoritmo
var menor,cont,n,i:inteiro
inicio
cont<-1
leia(n)
menor<-n
para i de 1 ate 19 faca
leia(n)
se n=menor
entao cont<-cont+1
senao se n<menor
entao menor<-n
cont<-1
fimse
fimse
fimpara
escreva(cont)
fimalgoritmoI00003800 - Data juliana é o número de dias transcorridos no ano (ex:236/1995). A faixa é de 1 a 365 (366 se o ano for
bissexto). 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 bissexto é aquele divisível por 4.
algoritmo
var a,m,d,cont,i:inteiro
inicio
leia(cont,a)
d<-1
m<-1
para i de 1 ate cont-1 faca
se d=31 ou
(d=30 e (m=4 ou m=6 ou m=9 ou m=11)) ou
(d=29 e m=2) ou (d=28 e m=2 e a%4<>0)
entao d<-1
m<-m+1
senao d<-d+1
fimse
fimpara
escreva(d,m,a)
fimalgoritmo
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 final. Considere que ano bissexto é aquele divisível por 4.
algoritmo
var a,m,d,d2,m2,a2,cont:inteiro
inicio
leia(d,m,a,d2,m2,a2)
cont<-1
enquanto d<>d2 ou m<>m2 ou a<>a2 faca
se d=31 ou
(d=30 e (m=4 ou m=6 ou m=9 ou m=11)) ou
(d=29 e m=2) ou (d=28 e m=2 e a%4<>0)
entao d<-1
m<-m+1
se m=13
entao m<-1
a<-a+1
fimse
senao d<-d+1
fimse
cont<-cont+1
fimenquanto
escreva(cont)
fimalgoritmo
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 final. Considere que ano bissexto é aquele divisível por 4. Considere também
que a data inicial é menor ou igual à data final.
algoritmo "I001_I00003950"
var d,m,a,d1,m1,a1:inteiro
inicio
leia(d,m,a,d1,m1,a1)
escreva(d,",",m,",",a)
enquanto d<>d1 ou m<>m1 ou a<>a1 faca
se d=31 ou (d=30 e (m=4 ou m=6 ou m=9 ou m=11)) ou
(d=29 e m=2) ou (d=28 e m=2 e a%4<>0)
entao d<-1
m<-m+1
se m=13
entao m<-1
a<-a+1
fimse
senao d<-d+1
fimse
escreva(",",d,",",m,",",a)
fimenquanto
fimalgoritmo
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.
algoritmo "I001_I00003960"
var d,m,a,ds,cont:inteiro
inicio
leia(d,m,a,ds)
cont<-0
enquanto cont<3 faca
se d=13 e ds=6
entao cont<-cont+1
escreval(d,"/",m,"/",a)
fimse
se d=31 ou (d=30 e (m=4 ou m=6 ou m=9 ou m=11)) ou
(d=29 e m=2) ou (d=28 e m=2 e a%4<>0)
entao d<-1
m<-m+1
se m=13
entao m<-1
a<-a+1
fimse
senao d<-d+1
fimse
se ds=7
entao ds<-1
senao ds<-ds+1
fimse
fimenquanto
fimalgoritmo
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.
algoritmo
var d,m,a,cont:inteiro
inicio
leia(m,a)
d<-13
cont<-0
enquanto cont<5 faca
d<-d+7
se d>28 e m=2 e a%4<>0
entao d<-d-28 m<-m+1
senao se d>29 e m=2
entao d<-d-29 m<-m+1
senao se d>30 e (m=4 ou m=6 ou m=9 ou m=11)
entao d<-d-30 m<-m+1
senao se d>31 entao d<-d-31
se m=12 entao
m<-1
a<-a+1
senao m<-m+1
fimse
fimse
fimse
fimse
fimse
se d=13 entao escreval(m," ",a) cont<-cont+1 fimse
fimenquanto
fimalgoritmo
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....
algoritmo
var termo,soma,i:inteiro
inicio
soma<-0
termo<-1
para i de 1 ate 100 faca
soma<-soma+termo
termo<-termo+2
fimpara
escreva(soma)
fimalgoritmo
I00004100 (não está no portal porque o resultado é real)
Faça um algoritmo que calcule e escreva a soma dos 100 primeiros termos da sequência a seguir: 1/1 + 1/3 + 1/5 + 1/7
+ 1/9 +.
I00004200 (não está no portal porque o resultado é real)
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/1
+ X/3 + X/5 + X/7 + X/9 +...
I00004300 (não está no portal porque o resultado é real)
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/1
- X/3 + X/5 - X/7 + X/9 -...
I00004400 (não está no portal porque o resultado é real)
Faça um algoritmo que leia um valor N e escreva a soma dos N primeiros termos da série a seguir:
1/2 + 1/3 + 1/5 + 1/7 + 1/11 + 1/13 + 1/17... ou seja, a série onde os denominadores são os números primos
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.
algoritmo "I001_I00004500"
var
min,p2,p3,n,pir,cont,cd,i:inteiro
inicio
leia(min)
p2<-3
p3<-5
n<-7
cont<-0
enquanto cont<10 faca
cd<-0
para i de 1 ate n faca
se n%i=0
entao cd<-cd+1
fimse
fimpara
se cd<=2
entao pir<-p2+p3+n
p2<-p3
p3<-n
se pir >= min
entao escreval(pir)
cont<-cont+1
fimse
fimse
n<-n+1
fimenquanto
fimalgoritmo
I00004600 - Faça um algoritmo que leia 30 números. O algoritmo deve escrever ao final 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.
algoritmo
var qpar,qprim,somapar,i,n,cd,prod,j:inteiro
inicio
qpar<-0
qprim<-0
somapar<-0
prod<-1
para i de 1 ate 20 faca
leia (n)
se n%2=0
entao somapar<-somapar+n
qpar<-qpar+1
fimse
cd<-0
para j de 1 ate n faca
se n%j=0
entao cd<-cd+1
fimse
fimpara
se cd<=2
entao qprim<-qprim+1
fimse
se n%5=0
entao prod<-prod*n
fimse
fimpara
escreva(somapar/qpar," ",qprim," ",prod)
fimalgoritmo
I00004700 - Faça um algoritmo que leia 20 números e verifique qual a maior sequência estritamente crescente (isso é,
cada número é maior que o anterior) dentre os números digitados, escrevendo ao final o primeiro e último valor da
sequência.
algoritmo
var n,tm,im,ia,fm,fa,ta,b,j:inteiro
inicio
leia (n)
tm<-1
ta<-1
im<-n
fm<-n
ia<-n
fa<-n
para j de 1 ate 19 faca
leia(b)
se b>n
entao fa<-b
ta<-ta+1
senao se ta>tm
entao tm<-ta
im<-ia
fm<-fa
fimse
ta<-1
ia<-b
fa<-b
fimse
n<-b
fimpara
se ta>tm
entao tm<-ta
im<-ia
fm<-fa
fimse
escreva(im," ",fm)
fimalgoritmo
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 sequência é não-decrescente (cada número é maior OU IGUAL ao anterior); 2 - se a sequência é estritamente
crescente (cada número é MAIOR que o anterior); 3 - Se a sequência é não-crescente (cada número é menor OU
IGUAL ao anterior); 4 - Se a sequência é estritamente decrescente (cada número é MENOR que o anterior); 5 - A
sequência é desordenada (há partes crescentes e partes decrescentes)
algoritmo
var c,d,i,b,a,j:inteiro
inicio
c<-0
d<-0
i<-0
leia(a)
para j de 1 ate 9 faca
leia(b)
se b=a
entao i<-1
fimse
se a<b
entao c<-1
fimse
se a>b
entao d<-1
fimse
a<-b
fimpara
se c=0 e d=0
entao escreva(0)
fimse
se i=1 e c=1 e d=0
entao escreva(1)
fimse
se i=0 e c=1 e d=0
entao escreva(2)
fimse
se i=1 e c=0 e d=1
entao escreva(3)
fimse
se i=0 e c=0 e d=1
entao escreva(4)
fimse
se c=1 e d=1
entao escreva(5)
fimse
fimalgoritmo
I00004850 - Faça um algoritmo que leia 15 números e identifique a maior sequência de números pares dentre os
números lidos, escrevendo ao final o comprimento da sequência identificada, 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.
algoritmo
var CMS,PMS,UMS,CSA,PSA,USA,i,N:inteiro
inicio
CMS<-0
CSA<-0
PMS<-0
UMS<-0
para i de 1 ate 15 faca
Leia(N)
se N%2=0
entao CSA<-CSA+1
USA<-N
se PSA=0
entao PSA<-N
fimse
se CSA>CMS
entao CMS<-CSA
PMS<-PSA
UMS<-USA
fimse
senao CSA<-0
PSA<-0
USA<-0
fimse
fimpara
escreva(CMS,PMS,UMS)
fimalgoritmo
I00004900 - Faça um algoritmo que leia a média e a quantidade de faltas para cada alunode um grupo de 20 alunos, e
escreva ao final 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.
algoritmo
var i,f:inteiro
cont,m:real
inicio
cont<-0
para i de 1 ate 10 faca
leia(m,f)
se m<6 ou f>20 ou (f>=10 e m<7.5)
entao cont<-cont+1
fimse
fimpara
escreva(100-cont*10)
fimalgoritmo
I00005000 - Faça um algoritmo que leia um número inteiro qualquer e escreva os dígito desse número em ordem
crescente do valor de cada dígito.
algoritmo
var n,dig,d,a:inteiro
inicio
leia(n)
para dig de 0 ate 9 faca
a<-n
enquanto a>0 faca
d<-a%10
se d=dig
entao escreva(d)
fimse
a<-a\10
fimenquanto
fimpara
fimalgoritmo
I00005100 - Faça um algoritmo que leia um número inteiro qualquer e verifique se possui algum dígito repetido
escrevendo ao final: 0 - se ele não contem nenhum dígito repetido; 1 - se ele contem algum dígito repetido.
algoritmo
var rep,n,dig,d,cont,a:inteiro
inicio
rep<-0
leia(n)
para dig de 0 ate 9 faca
a<-n
cont<-0
enquanto a>0 faca
d<-a%10
se d=dig
entao cont<-cont+1
fimse
a<-a\10
fimenquanto
se cont>1
entao rep<-1
fimse
fimpara
escreva(rep)
fimalgoritmo
I00005120 - Faça um algoritmo que leia um número inteiro e escreva quantas vezes ocorre o dígito 2.
algoritmo
var N,C:inteiro
inicio
leia(N)
c<-0
enquanto N>0 faca
se N%10=2
entao c<-c+1
fimse
N<-N\10
fimenquanto
escreva(c)
fimalgoritmo
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
algoritmo
var N,M,dig,C:inteiro
inicio
leia(M)
para dig de 0 ate 9 faca
c<-0
N<-M
enquanto N>0 faca
se N%10=dig
entao c<-c+1
fimse
N<-N\10
fimenquanto
escreva(dig,c)
fimpara
fimalgoritmo
I00005160 - Faça um algoritmo que leia um número inteiro (máximo 5 casas - não maior que 99999). Mostre o número
que mais se repete. Em caso de empate, mostre o menor deles.
algoritmo "I001_I00005160"
var contmax,digmax,dig,naux,n,cont:inteiro
inicio
leia(naux)
contmax<-0
digmax<-0
para dig de 0 ate 9 faca
n<-naux
cont<-0
enquanto n>0 faca
se n%10=dig
entao cont<-cont+1
fimse
n<-n\10
fimenquanto
se cont>contmax
entao contmax<-cont
digmax<-dig
fimse
fimpara
escreva(digmax)
fimalgoritmo
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 verifique
se ele é ou não ascendente escrevendo: 1 - se ele é ascendente; 0 - se ele não é ascendente.
algoritmo "I001_I00005170"
var dec,n,d,ant:inteiro
inicio
dec<-1
leia(n)
ant<-n%10
n<-n\10
enquanto n>0 faca
d<-n%10
se d>=ant
entao dec<-0
fimse
n<-n\10
ant<-d
fimenquanto
escreva(dec)
fimalgoritmo
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.
algoritmo
var d,ds:inteiro
inicio
leia(d,ds)
d<-(d-1)%7+1
ds<-ds-(d-1)
se ds<1
entao ds<-ds+7
fimse
escreva(ds)
fimalgoritmo
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 significativo, peso 2 para o segundo dígito, peso 3 para o terceiro e assim por diante. Escreva a
soma calculada.
I00005400 - Faça um algoritmo que leia 20 números e escreva a maior sequência de valores iguais entre os números
digitados.
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).
algoritmo
var N,soma,num,den,r1,X,ult,pen,atu:inteiro
inicio
leia(N)
X<-1+8*N
ult<-1
atu<-ult
pen<-0
enquanto atu<>pen faca
pen<-ult
ult<- atu
atu <- (ult + X \ ult) \2
fimenquanto
se ult<atu entao atu<-ult fimse
r1<-(-1+atu)\2
soma<-(1+r1)*r1\2
se N>soma
entao num<-N-soma
den<-r1-num+2
senao num<-r1
den<-1
fimse
escreval(num," ",den)
fimalgoritmo
I00005600 - O CPF é formado por onze dígitos (999999999-99), dos quais os dois últimos são verificadores (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 verificador (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 verificador (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 verificadores (dois
últimos).
algoritmo "I001_I00005600"
var d1,d2,cpf,r,soma,soma2,p:inteiro
inicio
leia(cpf)
soma<-0
soma2<-0
para p de 2 ate 10 faca
soma<-soma+cpf%10*p
soma2<-soma2+cpf%10*(p+1)
cpf<-cpf\10
fimpara
r<-soma%11
se r=0 ou r=1
entao d1<-0
senao d1<-11-r
fimse
soma2<-soma2+2*d1
r<-soma2%11
se r=0 ou r=1
entao d2<-0
senao d2<-11-r
fimse
escreva(d1,d2)
fimalgoritmo
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.
algoritmo "I001_I00005700"
var cod,idade,i,c1,c2,c3,ci1,ci2,ci3,s1,s2,s3:inteiro
m1,m2,m3:real
inicio
c1<-0 c2<-0 c3<-0
ci1<-0 ci2<-0 ci3<-0
s1<-0 s2<-0 s3<-0
para i de 1 ate 500 faca
leia(idade,cod)
se cod=1
entao c1<-c1+1
se idade>=20 e idade<=25
entao ci1<-ci1+1
fimse
s1<-s1+idade
senao se cod=2
entao c2<-c2+1
se idade>=20 e idade<=25
entao ci2<-ci2+1
fimse
s2<-s2+idade
senao c3<-c3+1
se idade>=20 e idade<=25
entao ci3<-ci3+1
fimse
s3<-s3+idade
fimse
fimse
fimpara
escreva(c1," ",c2," ",c3," ",ci1," ",ci2," ",ci3," ")
se c1=0
entao m1<-0
senao m1<-s1/c1
fimse
se c2=0
entao m2<-0
senao m2<-s2/c2
fimse
se c3=0
entao m3<-0
senao m3<-s3/c3
fimse
se m1<=m2 e m1<=m3
entao escreva(1)
senao se m2<=m3
entao escreva(2)
senao escreva(3)
fimse
fimse
fimalgoritmo
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
de 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 acima,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.
algoritmo "I001_I00005800"
var n,i,q,k:real
inicio
leia (n,i)
se (n>0 e i>0) ou (n<0 e i<0)
entao k <- 1
senao k <- -1
fimse
n <- raizq(n^2)
i <- raizq(i^2)
q <- 0
enquanto n>=i faca
n <- n-i
q <- q+1
fimenquanto
q <- q*k
escreva (q)
fimalgoritmo
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.
17 - 4 = 13 (2)
13 - 4 = 9 (3)
9 - 4 = 5 (4)
5 - 4 = 1 (5)
Para o exemplo acima, 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.
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 verifique se é um meridiano perfeito, escrevendo 1, se o número é um meridiano
perfeito, e 0, se não for.
algoritmo
var N,soma1,soma2,M:inteiro
inicio
leia(N)
soma1<-0
para M de 1 ate N-1 faca
soma1<-soma1+M
fimpara
soma2<-0
M<-N
enquanto soma2<soma1 faca
M<-M+1
soma2<-soma2+M
fimenquanto
se soma2=soma1
entao escreva(1)
senao escreva(0)
fimse
fimalgoritmo
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.
algoritmo
var qtde,soma1,soma2,n,j:inteiro
inicio
leia(qtde)
n<-6
soma1<-15
soma2<-15
j<-9
enquanto qtde<>0 faca
enquanto soma2<soma1 faca
soma2<-soma2+j
j<-j+1
fimenquanto
se soma2=soma1
entao escreval(n)
qtde<-qtde -1
fimse
n<-n+1
soma1<-soma1+(n-1)
soma2<-soma2-n
fimenquanto
fimalgoritmo
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 definição, 2^0 * 3^0 * 5^0), 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.
algoritmo
var N,N1,Quant,i:inteiro
inicio
leia(Quant)
escreva(1)
i<-1
N<-2
enquanto i<Quant faca
N1<-N
enquanto N1%2=0 faca
N1<-N1\2
fimenquanto
enquanto N1%3=0 faca
N1<-N1\3
fimenquanto
enquanto N1%5=0 faca
N1<-N1\5
fimenquanto
se N1=1
entao escreval(N)
i<-i+1
fimse
N<-N+1
fimenquanto
fimalgoritmo
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.
algoritmo
var tem,vant,nant,seq,n,v,i:inteiro
inicio
tem<-0
leia(vant,nant)
seq<-1
para i de 1 ate 9 faca
leia(v,n)
se n=nant e v=vant+1
entao seq<-seq+1
se seq=7
entao tem<-1
fimse
senao se n<>nant ou v<>vant
entao seq<-1
fimse
fimse
nant<-n
vant<-v
fimpara
escreva(tem)
fimalgoritmo
I00006201 - Faça um algoritmo que leia em sequencia "decrescente": O número de uma carta (de 1 até 13) e seu naipe
(de 1 até 4); Escreva a maior sequência decrescente formada a partir da primeira carta, omitindo cartas repetidas. Caso a
sequencia seja quebrada em dado ponto, coloque um "0", omitindo todos os demais dados que vierem. Dica:Considere
que todas as entradas serão sequenciadas, não havendo necessidade de qualquer reorganização ou armazenamento de
dados.
algoritmo "I001_I00006201"
var v,n,vant,nant,seq,fim,i:inteiro
inicio
leia(vant,nant)
escreval(vant," ",nant)
seq<-1
fim<-0
para i de 1 ate 9 faca
leia(v,n)
se fim=0 entao
se n=nant e v=vant-1
entao escreval(v," ",n)
seq<-seq+1
se seq=7 entao fim<-1 fimse
senao se n<>nant ou v<>vant
entao escreval(0)
fim<-1
fimse
fimse
fimse
nant<-n
vant<-v
fimpara
fimalgoritmo
I00006300 - Faça um algoritmo que leia inicialmente duas "cartas" e em seguida, leia a opção de jogo: (1) dar mais uma
carta, (0) encerrar jogo. O jogo também acaba, caso a soma das cartas na mão do jogador atinja ou ultrapasse "21". Ao
fim do jogo, diga a quantia de cartas que o jogador recebeu (incluindo as duas cartas iniciais) e qual é a soma das cartas
que ele recebeu em mãos caso esta não ultrapasse 21, pois neste caso, deve-se devolver "0" como resposta. Dica: Neste
caso, nada impede o jogador de encerra o jogo com as duas cartas iniciais, ou de perder com elas;
algoritmo "I001_I00006301"
var a,b,soma,opcao,cont:inteiro
inicio
leia(a,b)
a<-(a-1)%13+1
b<-(b-1)%13+1
se a>10 entao a<-10 fimse
se b>10 entao b<-10 fimse
se a=1 e b>=10 ou b=1 e a>=10
entao escreva(21)
senao
soma<-a+b
leia(opcao)
cont<-2
enquanto opcao=1 e soma<21 faca
leia(a)
a<-(a-1)%13+1
se a>10 entao a<-10 fimse
soma<-soma+a
cont<-cont+1
se soma<21
entao leia(opcao)
fimse
fimenquanto
escreva(cont)
se soma<=21 entao escreva(soma)
senao escreva(0)
fimse
fimse
fimalgoritmo
I00006301 - Continuação do exercício <I6300>. Considere que agora, há um total de 52 cartas (Baralho inteiro) e as
cartas valete, rainha e rei, valem uma pontuação igual a 10; E que caso inicialmente o jogador receba um "ás" e outra
carta de valor igual a 10, ele vence o jogo instantaneamente, e neste caso, deve-se devolver o valor "21" como resposta.
Nos demais casos, devolva o número de cartas que ele recebeu, e a soma delas, caso não ultrapasse 21, pois neste caso
deve-se devolver "0" como resposta.
Dica:Resto de uma divisão;
I00006302 - Continuação do exercício <I6301>. O motivo pelo qual o jogador recebe vitoria automática no caso de
receber inicialmente "um As e uma carta de valor 10", se deve ao fato de que o "As" pode assumir dois valores "1" e
"11", de acordo com a situação; Logo um As e outra carta de valor 10, equivalem a soma "11+10=21", entretanto, se o
jogador possuísse em mãos uma soma desfavorável: Um ás, um nove e um dez. O ás assume seu menor valor "1+9+10",
pois "11+9+10" geraria derrota. A partir destes dados, construa um algoritmo que integre o jogo de blackjack,
averiguando esta nova informação.
I00006303 - Continuação do exercício <I6302>. O jogador, nunca joga "sozinho" como talvez você possa ter
imaginado, afinal, ele poderia parar com o menor número de cartas e sempre vencer! Por isto, ele tem neste caso, como
concorrente, a "casa", porem, esta não joga para "vencer" o jogo, e sim, para simplesmente impedir o jogador de vencer.
Funciona da seguinte forma: O jogador faz todas as suas jogadas, até parar, se ele não tiver passado de 21 ou ganho
automaticamente (tirando21 com as duas primeiras cartas), passa para a "casa", que diferente do jogador, só precisa ter
uma quantia "maior" ou "igual" de pontos na mão, pois em caso de "empate" nenhum dos dois ganha. Ao fim, diga, se
o jogador venceu(1), se a "casa" venceu(2) ou se houve empate(3). Considere que serão dados inicialmente, o numero
de pontos que o jogador fez (podendo este ser maior que 21. Neste caso, dá a resposta de vitoria para a "casa"), em
seguida, virão os dados com os quais a mesa joga. Considere também que as cartas não passam do valor 13.
I00006400 - Baseando-se na sequência de fibonacci (0,1,1,2,3...), verifique 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.
algoritmo "I001_I00006400"
var a,b,c,d,f,tn,t1,t2,t3,t4,t5:inteiro
inicio
leia(a,b,c,d,f)
t1<-0
t2<-1
t3<-1
t4<-2
t5<-3
enquanto d>t4 faca
tn<-t4+t5
t1<-t2 t2<-t3 t3<-t4 t4<-t5 t5<-tn
fimenquanto
se a=t1 e b=t2 e c=t3 e d=t4 e f=t5
entao escreva(0)
senao escreva(1)
fimse
fimalgoritmo
I00006500 - Leia um termo n que define 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 (a^2 + b^2 = c^2)
algoritmo "I001_I00006500"
var n,a,b:inteiro
hip:real
inicio
leia(N)
para a de 1 ate N faca
para b de a+1 ate N faca
hip<-raizq(a*a+b*b)
se hip=int(hip) e hip<=N
entao escreval(a," ",b," ",int(hip))
fimse
fimpara
fimpara
fimalgoritmo
I00006600 - Fazer um algoritmo que leia o sexo (1=masculino, 2=feminino), a idade e o salário dos 10 funcionários de
uma empresa, calcule e escreva (nessa ordem): a média dos salários dos funcionários menores que 30 anos, dos que tem
de 30 a 45 anos e dos maiores que 45 anos, escreva também 1, se o menor salário é de um homem ou 2, se for de uma
mulher. Todos os valores devem ser do tipo inteiro, inclusive as médias, portanto utilizar o operador de divisão inteira
para efetuar o cálculo da média. Escrever média zero quando não houver nenhum funcionário no respectivo intervalo de
idade.
algoritmo
var salario30,salario3045,salario45,conta30,conta3045,conta45,idade,salario,sexo,i,maiorsalario,sexomaior:inteiro
inicio
salario30<-0 conta30<-0
salario3045<-0 conta3045<-0
salario45<-0 conta45<-0
para i de 1 ate 10 faca
leia(sexo,idade,salario)
se i=1
entao
maiorsalario<- salario
sexomaior<-sexo
fimse
se idade<30
entao salario30<-salario30+salario
conta30<-conta30+1
senao se idade>=30 e idade<=45
entao salario3045<-salario3045+salario
conta3045<-conta3045+1
senao salario45<-salario45+salario
conta45<-conta45+1
fimse
fimse
se salario<maiorsalario
entao maiorsalario<-salario
sexomaior<-sexo
fimse
fimpara
se conta30>0
entao escreva(salario30\conta30)
senao escreva(0)
fimse
se conta3045>0
entao escreva(salario3045\conta3045)
senao escreva(0)
fimse
se conta45>0
entao escreva(salario45\conta45)
senao escreva(0)
fimse
escreva(sexomaior)
fimalgoritmos
I00006700 - Fazer um algoritmo que leia 100 números inteiros e escreva os últimos 2 números primos informados.
Escreva primeiramente o penúltimo depois o último. Caso não seja informado nenhum número primo, escreva 0; caso
seja informado apenas um primo, escreva apenas esse.
algoritmo "I001_I00006700"
var p1,p2,i,j,n:inteiro
inicio
p1<-0
p2<-0
para i de 1 ate 100 faca
leia(N)
se n>1 entao
j<-2
enquanto n%j<>0 faca
j<-j+1
fimenquanto
se n=j
entao p1<-p2
p2<-n
fimse
fimse
fimpara
se p1<>0
entao escreva(p1)
fimse
escreva(p2)
fimalgoritmo
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.
algoritmo "I001_I00006800
var n,maiordigito,n1,cont,valor:inteiro
inicio
maiordigito<-0
valor<-0
leia(n)
enquanto n<>0 faca
se n>0
entao n1<-n
cont<-0
enquanto n1<>0 faca
n1<-n1\10
cont<-cont+1
fimenquanto
se cont>maiordigito
entao maiordigito<-cont
valor<-n
senao se cont=maiordigito e n<valor
entao valor<-n
fimse
fimse
fimse
leia(n)
fimenquanto
escreva(valor)
fimalgoritmo
Vetores
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.
algoritmo "V001_V00000100"
var
v :vetor[1..10]de inteiro
i ,cont:inteiro
inicio
para i de 1 ate 10 faca
leia(v[i])
fimpara
para i de 1 ate 10 faca
escreva(v[i])
fimpara
cont<-0
para i de 1 ate 10 faca
se v[i]<0 entao
cont<-cont+1
fimse
fimpara
escreva(cont)
fimalgoritmo
V00000200 - Faça um algoritmo que leia 10 valores e os escreva na ordem contrária à que foram digitados.
algoritmo
var
v :vetor [1..10] de inteiro
i :inteiro
inicio
para i de 1 ate 10 faca
leia(v[i])
fimpara
para i de 1 ate 10 faca
escreva(v[11-i])
fimpara
fimalgoritmo
ou
algoritmo
var
v :vetor [1..10] de inteiro
i :inteiro
inicio
para i de 1 ate 10 faca
leia(v[i])
fimpara
para i de 10 ate 1 passo -1 faca
escreva(v[i])
fimpara
fimalgoritmo
ou
algoritmo
var
v :vetor [1..10] de inteiro
i :inteiro
inicio
para i de 1 ate 10 faca
leia(v[i])
fimpara
i<-10
enquanto i>0 faca
escreva(v[i])
i<-i-1
fimenquanto
fimalgoritmo
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.
algoritmo
var
v :vetor [1..10] de inteiro
i :inteiro
inicio
para i de 1 ate 10 faca
leia(v[i])
fimpara
para i de 1 ate 10 faca
se v[i]% 2=0 entao
escreva(v[i])
fimse
fimpara
para i de 1 ate 10 faca
se v[i]% 2=1 entao
escreva(v[i])
fimse
fimpara
fimalgoritmo
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.
algoritmo
var
v :vetor[1..10] de inteiro
i :inteiro
inicio
para i de 1 ate 10 faca
leia(v[i])
fimpara
para i de 1 ate 10 faca
se v[i]<0 entao
escreva(i)
fimse
fimpara
fimalgoritmo
V00000600 - Escreva um algoritmo que lê um vetor A(10) e escreva a posição de cada elemento primo deste vetor.
algoritmo
var
v:vetor[1..10] de inteiro
i,j:inteiro
inicio
para i de 1 ate 10 faca
escreva("Digite:")
leia(v[i])
j<-2
enquanto v[i]% j<>0 faca
j<-j+1
fimenquanto
se j=v[i] entao
escreval("pos=",i)
fimse
fimpara
fimalgoritmo
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.
algoritmo
var
v :vetor[1..10] de inteiro
i :inteiro
inicio
para i de 1 ate 10 faca
leia(v[i])
escreva(v[i])
fimpara
para i de 1 ate 10 faca
se v[i]<0 entao
v[i]<-abs(v[i])
fimse
fimpara
para i de 1 ate 10 faca
escreva(v[i])
fimpara
fimalgoritmo
V00000800 - Escrever um algoritmo que lê um vetor C(50) e o escreve. Encontre, a seguir,o maior elemento de C e o
escreva.
algoritmo "V001_V00000800"
var
v:vetor[1..30] de inteiro
i,maior:inteiro
inicio
para i de 1 ate 30 faca
leia(v[i])
escreva(v[i])
fimpara
maior<-v[1]
para i de 2 ate 30 faca
se v[i]>maior entao
maior<-v[i]
fimse
fimpara
escreva("O maior é ",maior)
fimalgoritmo
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 é... ".
algoritmo
var
v:vetor[1..30] de inteiro
i,menor,pos:inteiro
inicio
para i de 1 ate 30 faca
leia(v[i])
escreva(v[i])
fimpara
pos<-1
menor<-v[1]
para i de 2 ate 30 faca
se v[i]< menor entao
menor<-v[i]
pos<-i
fimse
fimpara
escreva(menor,pos)
fimalgoritmo
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.
algoritmo
var
v:vetor[1..10] de inteiro
soma,media:real
i:inteiro
inicio
soma<-0
para i de 1 ate 10 faca
leia(v[i])
soma<-soma+v[i]
fimpara
media <- soma/10
para i de 1 ate 10 faca
se v[i]>media entao
escreval(v[i])
fimse
fimpara
fimalgoritmo
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.
algoritmo "V001_V00001010"
var v:vetor[1..10]de inteiro
media:real
i,menor:inteiro
inicio
media<-0
para i de 1 ate 10 faca
leia(V[i])
media<-media+v[i]
fimpara
media<-media/10
i<-1
enquanto v[i]<media faca
i<-i+1
fimenquanto
menor<-v[i]
enquanto i<10 faca
i<-i+1
se v[i]<menor e v[i]>=media
entao menor<-v[i]
fimse
fimenquanto
escreva(menor)
fimalgoritmo
V00001050 - Faça um algoritmo que leia um vetor de 10 elementos. Leia, a seguir, um valor N e verifique 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
algoritmo
var
v : vetor [ 1 .. 10 ] de inteiro
i , N , tem : inteiro
inicio
para i de 1 ate 10 faca
leia ( v [ i ] )
fimpara
leia ( N )
tem <- 0
para i de 1 ate 10 faca
se v [ i ] = N entao
tem <- 1
fimse
fimpara
escreva ( tem )
fimalgoritmo
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 modificado.
algoritmo
var
v:vetor[1..10] de inteiro
i,aux:inteiro
inicio
para i de 1 ate 10 faca
leia(v[i])
escreva(v[i])
fimpara
para i de 1 ate 5 faca
aux<-v[i]
v[i]<-v[11-i]
v[11-i]<-aux
fimpara
para i de 1 ate 10 faca
escreva(v[i])
fimpara
fimalgoritmo
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 modificado.
algoritmo
var
v:vetor[1..10] de inteiro
i,aux:inteiro
inicio
para i de 1 ate 10 faca
leia(v[i])
escreva(v[i])
fimpara
para i de 1 ate 9 passo 2 faca
aux<-v[i]
v[i]<-v[i+1]
v[i+1]<-aux
fimpara
para i de 1 ate 10 faca
escreva(v[i])
fimpara
fimalgoritmo
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). Nesse último caso, o valor zero não deve fazer parte do vetor.
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. Escreva o vetor modificado.
algoritmo
var
i,j,k,x:inteiro
v:vetor[1..20] de inteiro
inicio
i<-1
leia(v[i])
enquanto v[i]<>0 e i<20 faca
i<-i+1
leia(v[i])
fimenquanto
se v[i]=0 entao
i<-i-1
fimse
leia(X)
para j de 1 ate i faca
escreva(v[j]," ")
fimpara
j<-1
enquanto j<=i faca
se v[j]=X entao
para k de j ate i-1 faca
v[k]<-v[k+1]
fimpara
i<-i-1
senao
j<-j+1
fimse
fimenquanto
para j de 1 ate i faca
escreva(v[j])
fimpara
fimalgoritmo
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 verifique quantas questões acertou, escrevendo para cada aluno o
número de acertos.
algoritmo "V001_V00001300"
var g:vetor[1..10] de inteiro
i,j,r,acertos:inteiro
inicio
para i de 1 ate 10 faca
leia (g[i])
fimpara
para i de 1 ate 5 faca
acertos<-0
para j de 1 ate 10 faca
leia(r)
se r=g[j]
entao acertos<-acertos+1
fimse
fimpara
escreva(acertos)
fimpara
fimalgoritmo
V00001400 - Faça um algoritmo que leia 10 valores e verifique se algum dos valores aparece repetido. Escreva 1 se
algum valor aparece repetido e 0 se não houver nenhum valor repetido.
algoritmo "V001_V00001300"
var
g:vetor[1..10] de inteiro
i,j,tem:inteiro
inicio
para i de 1 ate 10 faca
leia (g[i])
fimpara
tem<-0
para i de 1 ate 10 faca
para j de 1 ate 10 faca
se g[i]=g[j] e i<>j entao
tem<-1
fimse
fimpara
fimpara
escreva(tem)
fimalgoritmo
ou
algoritmo "V001_V00001300"
var
g:vetor[1..10] de inteiro
i,j,tem:inteiro
inicio
para i de 1 ate 10 faca
leia (g[i])
fimpara
tem<-0
para i de 1 ate 10 faca
para j de i+1 ate 10 faca
se g[i]=g[j] entao
tem<-1
fimse
fimpara
fimpara
escreva(tem)
fimalgoritmo
V00001450 - Faça um algoritmo que leia um vetor de 10 elementos. Leia, a seguir, 10 valores N e, para cada um,
verifique 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
algoritmo
var v:vetor[1..10] de inteiro
i,N,j,tem:inteiro
inicio
para i de 1 ate 10 faca
leia(v[i])
fimpara
para j de 1 ate 10 faca
leia(N)
tem<-0
para i de 1 ate 10 faca
se v[i]=N
entao tem<-1
fimse
fimpara
escreva(tem)
fimpara
fimalgoritmo
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).
algoritmo
var x,y,z:vetor[1..10] de inteiro
i,k,j:inteiro
inicio
para i de 1 ate 10 faca
leia(x[i])
fimpara
para j de 1 ate 10 faca
leia(y[j])
fimpara
k<-0
para j de 1 ate 10 faca
para i de 1 ate 10 faca
se x[j]=y[i]
entao k<-k+1
z[k]<-x[j]
fimse
fimpara
fimpara
para i de 1 ate k faca
escreva(z[i])
fimpara
fimalgoritmo
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).
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.
algoritmo
var v:vetor[1..5] de inteiro
i,n,acertos,j,k:inteiro
inicio
para i de 1 ate 5 faca
leia(v[i])
fimpara
para i de 1 ate 5 faca
acertos<-0
para k de 1 ate 5 faca
leia(N)
para j de 1 ate 5 faca
se N=v[j]
entao acertos<-acertos+1
fimse
fimpara
fimpara
escreval(acertos," acertos")
fimpara
fimalgoritmo
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.
algoritmo "V001_V00001650"
var
v:vetor[1..100] de inteiro
p,i,N,cont:inteiro
inicio
p<-2
cont<-0
leia(N)
enquanto cont<N faca
i<-2
enquanto p% i<>0 facai<-i+1
fimenquanto
se i=p entao
cont<-cont+1
v[cont]<-p
fimse
p<-p+1
fimenquanto
para i de N ate 1 passo -1 faca
escreva(v[i])
fimpara
fimalgoritmo
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).
algoritmo
var X,Y:vetor[1..10] de inteiro
i,achou,j:inteiro
inicio
para i de 1 ate 10 faca
leia(X[i])
fimpara
para i de 1 ate 10 faca
leia(Y[i])
fimpara
para i de 1 ate 10 faca
achou<-0
para j de 1 ate 10 faca
se X[i]=Y[j]
entao achou<-1
fimse
fimpara
se achou=0 entao escreva(X[i]) fimse
fimpara
fimalgoritmo
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 fim 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 fim 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).
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 final, quais dos valores entre 1 e 10 que não foram digitados nenhuma vez.
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?
algoritmo
var X:vetor[1..10] de inteiro
i,aux:inteiro
inicio
para i de 1 ate 10 faca
leia(X[i])
fimpara
para i de 1 ate 9 faca
se x[i]>x[i+1]
entao aux<-x[i]
x[i]<-x[i+1]
x[i+1]<-aux
fimse
fimpara
para i de 1 ate 10 faca
escreva(x[i])
fimpara
fimalgoritmo
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?
algoritmo
var X:vetor[1..10] de inteiro
i,j,aux:inteiro
inicio
para i de 1 ate 10 faca
leia(X[i])
fimpara
para j de 1 ate 9 faca
para i de 1 ate 9 faca
se x[i]>x[i+1]
entao aux<-x[i]
x[i]<-x[i+1]
x[i+1]<-aux
fimse
fimpara
fimpara
para i de 1 ate 10 faca
escreva(x[i])
fimpara
fimalgoritmo
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)
algoritmo
var P:vetor[1..10] de inteiro
A:vetor[1..10] de real
i,j,auxi:inteiro
aux:real
inicio
para i de 1 ate 10 faca
leia(P[i],A[i])
fimpara
para j de 1 ate 9 faca
para i de 1 ate 9 faca
se A[i]>A[i+1]
entao aux<-A[i]
A[i]<-A[i+1]
A[i+1]<-aux
auxi<-P[i]
P[i]<-P[i+1]
P[i+1]<-auxi
fimse
fimpara
fimpara
para i de 1 ate 10 faca
escreva(P[i],A[i])
fimpara
fimalgoritmo
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.
algoritmo
var V,W:vetor[1..10] de inteiro
z:vetor[1..20] de inteiro
i,j,iv,iz,iw,aux:inteiro
inicio
para i de 1 ate 10 faca
leia(V[i])
fimpara
para i de 1 ate 10 faca
leia(W[i])
fimpara
para j de 1 ate 9 faca
para i de 1 ate 9 faca
se V[i]>V[i+1]
entao aux<-V[i]
V[i]<-V[i+1]
V[i+1]<-aux
fimse
fimpara
fimpara
para j de 1 ate 9 faca
para i de 1 ate 9 faca
se W[i]>W[i+1]
entao aux<-W[i]
W[i]<-W[i+1]
W[i+1]<-aux
fimse
fimpara
fimpara
iv<-1
iw<-1
para iz de 1 ate 20 faca
se iv>10
entao z[iz]<-w[iw]
iw<-iw+1
senao
se iw>10
entao z[iz]<-v[iv]
iv<-iv+1
senao
se v[iv]<w[iw]
entao z[iz]<-v[iv]
iv<-iv+1
senao z[iz]<-w[iw]
iw<-iw+1
fimse
fimse
fimse
fimpara
para i de 1 ate 20 faca
escreva(z[i]," ")
fimpara
fimalgoritmo
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 final, o vetor X.
algoritmo
var primos:vetor[1..10] de inteiro
i,n,ip:inteiro
inicio
N<-100
ip<-1
enquanto ip<=10 faca
i<-2
enquanto n%i<>0 faca
i<-i+1
fimenquanto
se n=i entao
primos[ip]<-n
ip<-ip+1
fimse
n<-n+1
fimenquanto
para i de 1 ate 10 faca
escreva(primos[i]," ")
fimpara
fimalgoritmo
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.
algoritmo
var x:vetor[1..20] de inteiro
i,j,aux,cont,n:inteiro
inicio
para i de 1 ate 20 faca leia(x[i]) fimpara
para j de 1 ate 19 faca
para i de 1 ate 19 faca
se x[i]>x[i+1]
entao aux<-x[i]
x[i]<-x[i+1]
x[i+1]<-aux
fimse
fimpara
fimpara
escreval(" ")
cont<-1
N<-x[1]
para i de 2 ate 20 faca
se x[i]>N
entao escreval(N ," ",cont)
N<-x[i]
cont<-1
senao cont<-cont+1
fimse
fimpara
escreva(N," ",cont)
fimalgoritmo
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 fim 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 final os
números primos. Eles são indicados pelas posições do vetor que contem 0.
algoritmo
var x:vetor[1..200] de inteiro
i,j:inteiro
inicio
para i de 1 ate 200 faca
x[i]<-0
fimpara
para i de 2 ate 100 faca
se x[i]=0 entao
j<-i*2
enquanto j<=200 faca
x[j]<-1
j<-j+i
fimenquanto
fimse
fimpara
para i de 2 ate 200 faca
se x[i]=0
entao escreva(i," ")
fimse
fimpara
fimalgoritmo
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.
algoritmo
var cont:vetor[1..10] de inteiro
i,n:inteiro
inicio
para i de 1 ate 10 faca
cont[i]<-0
fimpara
para i de 1 ate 30 faca
leia(n)
cont[n]<-cont[n]+1
fimpara
para i de 1 ate 10 faca
escreva(cont[i]," ")
fimpara
fimalgoritmo
V00002550 - Faça um algoritmo que leia 20 datas de aniversário, cada uma formada por dia e mês, e escreva os
números dos dois meses em que mais ocorrem aniversários. Escreva primeiro o mês de maior número de aniversários.
algoritmo
var c:vetor[1..12] de inteiro
d,m,mm,i:inteiro
inicio
para i de 1 ate 12 faca c[i]<-0 fimpara
para i de 1 ate 20 faca
leia(d,m)
c[m]<-c[m]+1
fimpara
mm<-1
para i de 2 ate 12 faca
se c[i]>c[mm]
entao mm<-i
fimse
fimpara
escreva(mm)
c[mm]<-0
mm<-1
para i de 2 ate 12 faca
se c[i]>c[mm]
entao mm<-i
fimse
fimpara
escreva(mm)
fimalgoritmo
V00002600 - Faça um algoritmo que leia 10 números reais armazenando-os em um vetor. Desloque, a seguir, todosos
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.
algoritmo "V001_V00002600"
var v:vetor [1..10] de real
i,k,pm:inteiro
maior,prim:real
inicio
para i de 1 ate 10 faca leia(v[i]) fimpara
maior<-v[1]
pm<-1
para i de 2 ate 10 faca
se v[i]>maior
entao maior<-v[i]
pm<-i
fimse
fimpara
para k de 1 ate pm-1 faca
prim<-v[1]
para i de 1 ate 9 faca
v[i]<-v[i+1]
fimpara
v[10]<-prim
fimpara
para i de 1 ate 10 faca escreva(v[i]) fimpara
fimalgoritmo
V00002700 - Faça um algoritmo que coloque em um vetor os 20 primeiros números primos da série de Fibonacci
algoritmo "V001_V00002700"
var cont,a,b,p,d,N,i:inteiro
v:vetor [1..10] de inteiro
fim:real
inicio
a<-1
b<-1
cont<-0
leia(N)
enquanto cont<N faca
p<-a+b
a<-b
b<-p
d<-2
fim<-raizq(p)
enquanto p%d<>0 e d<fim faca
d<-d+1
fimenquanto
se d>fim
entao cont<-cont+1
v[cont]<-p
fimse
fimenquanto
para i de N ate 1 passo -1 faca
escreva(v[i]," ")
fimpara
fimalgoritmo
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.
algoritmo "V001_V00002800"
var n,pos,tem,i:inteiro
v:vetor[1..10] de inteiro
inicio
pos<-0
enquanto pos<10 faca
leia(N)
tem<-0
para i de 1 ate pos faca
se n=v[i] entao tem<-1 fimse
fimpara
se tem=0
entao pos<-pos+1 v[pos]<-n
fimse
fimenquanto
para i de 1 ate 10 faca escreva(v[i]," ") fimpara
fimalgoritmo
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 identificar se um número é primo, verifique se é divisível por algum dos primos já
colocados no vetor.
algoritmo "V001_V00002900"
var
p:vetor[1..20] de inteiro
pos,n,tem,i:inteiro
inicio
p[1]<-2
pos<-2
n<-3
enquanto pos<=20 faca
tem<-0
para i de 1 ate pos-1 faca
se n% p[i]=0 entao
tem<-1
fimse
fimpara
se tem=0 entao
p[pos]<-n
pos<-pos+1
fimse
n<-n+1
fimenquanto
para i de 1 ate 20 faca
escreva(p[i]," ")
fimpara
fimalgoritmo
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 significativo 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 final o vetor S. Os dois vetores de
entrada devem ser lidos separadamente, primeiro o vetor V e, após, o vetor W.
algoritmo
var
v,w:vetor[1..15] de inteiro
s:vetor[1..16] de inteiro
i,vaium,sum:inteiro
inicio
para i de 1 ate 15 faca
leia(v[i])
fimpara
para i de 1 ate 15 faca
leia(w[i])
fimpara
vaium<-0
para i de 15 ate 1 passo -1 faca
sum<-v[i]+w[i]+vaium
s[i+1]<-sum% 10
vaium<-sum\10
fimpara
s[1]<-vaium
para i de 1 ate 16 faca
escreva(s[i]," ")
fimpara
fimalgoritmo
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 significativo 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 final o vetor S. Considere que
o número de 15 dígitos no vetor V é maior que o número contido no vetor W.
algoritmo
var
v,w,s:vetor[1..15] de inteiro
i:inteiro
inicio
para i de 1 ate 15 faca
leia(v[i])
fimpara
para i de 1 ate 15 faca
leia(w[i])
fimpara
para i de 15 ate 1 passo -1 faca
se v[i]>=w[i] entao
s[i]<-v[i]-w[i]
senao
v[i-1]<-v[i-1]-1
s[i]<-v[i]+10-w[i]
fimse
fimpara
para i de 1 ate 15 faca
escreva(s[i]," ")
fimpara
fimalgoritmo
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.
algoritmo
var
v:vetor[1..15] de inteiro
s:vetor[1..16] de inteiro
i,n,vaium,sum:inteiro
inicio
para i de 1 ate 15 faca
leia(v[i])
fimpara
leia(N)
vaium<-0
para i de 15 ate 1 passo -1 faca
sum<-n*v[i]+vaium
s[i+1]<-sum% 10
vaium<-sum\10
fimpara
s[1]<-vaium
para i de 1 ate 16 faca
escreva(s[i]," ")
fimpara
fimalgoritmo
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 final o cadastro e número de votos de cada candidato (em
ordem crescente de cadastro). Escreva também, ao final, o número de votos nulos (ou seja, votos que não são iguais ao
cadastro de nenhum candidato).
algoritmo "V001_V00003250"
var cad,votos:vetor[1..5] de inteiro
nulos,aux,i,j,voto:inteiro
inicio
para i de 1 ate 5 faca
leia(cad[i])
votos[i]<-0
fimpara
leia(voto)
nulos<-0
enquanto voto<>0 faca
j<-1
enquanto cad[j]<>voto e j<5 faca
j<-j+1
fimenquanto
se cad[j]=voto
entao votos[j]<-votos[j]+1
senao nulos<-nulos+1
fimse
leia(voto)
fimenquanto
para i de 1 ate 4 faca
para j de 1 ate 4 faca
se cad[j]>cad[j+1]
entao aux<-cad[j]
cad[j]<-cad[j+1]
cad[j+1]<-aux
aux<-votos[j]
votos[j]<-votos[j+1]
votos[j+1]<-aux
fimse
fimpara
fimpara
para i de 1 ate 5 faca
escreva(cad[i],votos[i])
fimpara
escreva(nulos)
fimalgoritmo
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.
algoritmo "V001_V00003300"
var tp:vetor[1..10] de inteiro
pt,cad,votos,i:inteiro
inicio
para i de 1 ate 10 faca tp[i]<-0 fimpara
para i de 1 ate 20 faca
leia(cad,pt,votos)
tp[pt]<-tp[pt]+votos
fimpara
para i de 1 ate 10 faca escreva(tp[i]," ") fimpara
fimalgoritmo
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.
algoritmo "V001_V00003350"
var vp,np:vetor[1..10]de inteiro
i,j,c,p,v,aux:inteiro
inicio
para i de 1 ate 10 faca vp[i]<-0 np[i]<-i fimpara
para i de 1 ate 20 faca
leia(c,p,v)
vp[p]<-vp[p]+v
fimpara
para i de 1 ate 10 faca
para j de 1 ate 9 faca
se vp[j]<vp[j+1]
entao aux<-vp[j]
vp[j]<-vp[j+1]
vp[j+1]<-aux
aux<-np[j]
np[j]<-np[j+1]
np[j+1]<-aux
fimse
fimpara
fimpara
para i de 1 ate 10 faca
escreval(np[i]," ",vp[i])
fimpara
fimalgoritmo
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.
algoritmo "V001_V00003300"
var pt,cad,votos:vetor[1..20] de inteiro
p,cadm,votm,i:inteiro
inicio
para i de 1 ate 20 faca
leia(cad[i],pt[i],votos[i])
fimpara
para p de 1 ate 10 faca
votm<-0
para i de 1 ate 20 faca
se pt[i]=p e votos[i]>votm
entao cadm<-cad[i]
votm<-votos[i]
fimse
fimpara
escreva(cadm," ",p," ",votm," ")
fimpara
fimalgoritmo
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.
algoritmo "V001_V00003250"
var cad,part,votos:vetor[1..20] de inteiro
aux,i,j,voto:inteiro
inicio
para i de 1 ate 20 faca
leia(cad[i],part[i],votos[i])
fimpara
para i de 1 ate 19 faca
para j de 1 ate 19 faca
se (part[j]>part[j+1]) ou
(part[j]=part[j+1] e votos[j]>votos[j+1])
entao aux<-cad[j]
cad[j]<-cad[j+1]
cad[j+1]<-aux
aux<-votos[j]
votos[j]<-votos[j+1]
votos[j+1]<-aux
aux<-part[j]
part[j]<-part[j+1]
part[j+1]<-aux
fimse
fimpara
fimpara
para i de 1 ate 20 faca
escreva(cad[i],part[i],votos[i])
fimpara
fimalgoritmo
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: Classifique o vetor e some os primeiros (ou últimos) elementos até atingir
a metade da soma total.
algoritmo "V001_V00003500"
var v:vetor[1..20] de real
soma,somat,aux:real
i,j:inteiro
inicio
somat<-0
para i de 1 ate 20 faca
leia(v[i])
somat<-somat+v[i]
fimpara
para i de 1 ate 19 faca
para j de 1 ate 19 faca
se v[j]<v[j+1]
entao aux<-v[j]
v[j]<-v[j+1]
v[j+1]<-aux
fimse
fimpara
fimpara
i<-1
soma<-v[i]
enquanto soma<somat/2 faca
i<-i+1
soma<-soma+v[i]
fimenquanto
escreva(i)
fimalgoritmo
V00003550 - Faça um algoritmo que leia 10 datas de aniversário, cada uma composta por dia e mês, e escreva as 10
datas em ordem cronológica crescente.
algoritmo "V001_V00003600"
var d,m:vetor[1..10] de inteiro
i,aux,j:inteiro
inicio
para i de 1 ate 10 faca
leia(d[i],m[i])
fimpara
para j de 1 ate 9 faca
para i de 1 ate 9 faca
se m[i]>m[i+1] ou
(m[i]=m[i+1] e d[i]>d[i+1])
entao aux<-m[i]
m[i]<-m[i+1]
m[i+1]<-aux
aux<-d[i]
d[i]<-d[i+1]
d[i+1]<-aux
fimse
fimpara
fimpara
para i de 1 ate 10 faca
escreval(d[i]," ",m[i])
fimpara
fimalgoritmo
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.
algoritmo "V001_V00003600"
var d,m,a:vetor[1..10] de inteiro
i,aux,j:inteiro
inicio
para i de 1 ate 10 faca
leia(d[i],m[i],a[i])
fimpara
para j de 1 ate 9 faca
para i de 1 ate 9 faca
se a[i]>a[i+1] ou (a[i]=a[i+1] e m[i]>m[i+1]) ou
(a[i]=a[i+1] e m[i]=m[i+1] e d[i]>d[i+1])
entao aux<-a[i]
a[i]<-a[i+1]
a[i+1]<-aux
aux<-m[i]
m[i]<-m[i+1]
m[i+1]<-aux
aux<-d[i]
d[i]<-d[i+1]
d[i+1]<-aux
fimse
fimpara
fimpara
para i de 1 ate 10 faca
escreva(d[i]," ",m[i]," ",a[i]," ")
fimpara
fimalgoritmo
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.
algoritmo "V001_V00003250"
var ca,naipe:vetor[1..10] de inteiro
aux,i,j:inteiro
inicio
para i de 1 ate 10 faca
leia(ca[i],naipe[i])
fimpara
para i de 1 ate 9 faca
para j de 1 ate 9 faca
se (naipe[j]>naipe[j+1]) ou
(naipe[j]=naipe[j+1] e ca[j]>ca[j+1])
entao aux<-ca[j]
ca[j]<-ca[j+1]
ca[j+1]<-aux
aux<-naipe[j]
naipe[j]<-naipe[j+1]
naipe[j+1]<-aux
fimse
fimpara
fimpara
para i de 1 ate 10 faca
escreva(ca[i],naipe[i])
fimpara
fimalgoritmo
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.
algoritmo "V001_V00003250"
var ca,naipe:vetor[1..10] de inteiro
aux,i,j,cont,tem:inteiro
inicio
para i de 1 ate 10 faca
leia(ca[i],naipe[i])
fimpara
para i de 1 ate 9 faca
para j de 1 ate 9 faca
se (naipe[j]>naipe[j+1]) ou
(naipe[j]=naipe[j+1] e ca[j]>ca[j+1])
entao aux<-ca[j]
ca[j]<-ca[j+1]
ca[j+1]<-aux
aux<-naipe[j]
naipe[j]<-naipe[j+1]
naipe[j+1]<-aux
fimse
fimpara
fimpara
cont<-1
tem<-0
para j de 2 ate 10 faca
se naipe[j]=naipe[j-1] e ca[j]=ca[j-1]+1
entao cont<-cont+1
se cont=7
entao tem<-1
fimse
senao se naipe[j]<>naipe[j-1] ou ca[j]>ca[j-1]+1
entao cont<-1
fimse
fimse
fimpara
escreva(tem)
fimalgoritmo
V00003900 - Faça um algoritmo que leia os 5 números obtidos em um arremesso de 5 dados no jogo de General, e
verifique 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.
algoritmo "V001_V00003900"
var n:vetor[1..5] de inteiro
i,j,aux:inteiro
inicio
para i de 1 ate 5 faca leia(n[i]) fimpara
para i de 1 ate 4 faca
para j de 1 ate 4 faca
se n[j]>n[j+1]
entao aux<-n[j]
n[j]<-n[j+1]
n[j+1]<-aux
fimse
fimpara
fimpara
se n[1]=n[2] e n[5]=n[4] e n[1]<>n[5] e
(n[3]=n[2] ou n[3]=n[4])
entao escreva(1)
senao escreva(0)
fimse
fimalgoritmo
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 final, o comprimento da maior subsequência encontrada.
algoritmo "V002_V00004000"
var vet,p:vetor[1..100] de inteiro
i,qtd,maior,aux,n:inteiro
funcao maiorsubseq(var v:vetor[1..100] de inteiro;ini,fim:inteiro):inteiro
var maior,i,aux:inteiro
inicio
se ini=fim entao
retorne 1
senao
se p[ini]=0 entao
maior<-0
para i de ini+1 ate fim faca
aux<-maiorsubseq(vet,i,fim)
se v[ini]>=v[i] entao
se aux>maior entao
maior<-aux
fimse
fimse
fimpara
p[ini]<-maior+1
fimse
retorne p[ini]
fimse
fimfuncao
inicio
qtd<-0
leia(n)
enquanto n>=0 faca
qtd<-qtd+1
vet[qtd]<-n
p[qtd]<-0
leia(n)
fimenquanto
maior<-0
para i de 1 ate qtd faca
aux<-maiorsubseq(vet,i,qtd)
se aux>maior entao
maior <- aux
fimse
fimpara
escreva(maior)
fimalgoritmo
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).
algoritmo "V002_V00004000"
var vet,p:vetor[1..100] de inteiro
i,qtd,maior,aux,n:inteiro
funcao maiorsubseq(var v:vetor[1..100] de inteiro;ini,fim:inteiro):inteiro
var maior,i,aux:inteiro
inicio
se ini=fim entao
p[ini]<-1
retorne 1
senao
se p[ini]=0 entao
maior<-0
para i de ini+1 ate fim faca
aux<-maiorsubseq(vet,i,fim)
se v[ini]>=v[i] entao
se aux>maior entao
maior<-aux
fimse
fimse
fimpara
p[ini]<-maior+1
fimse
retorne p[ini]
fimse
fimfuncao
inicio
qtd<-0
leia(n)
enquanto n>=0 faca
qtd<-qtd+1
vet[qtd]<-n
p[qtd]<-0
leia(n)
fimenquanto
maior<-0
para i de 1 ate qtd faca
aux<-maiorsubseq(vet,i,qtd)
se aux>maior entao
maior <- aux
fimse
fimpara
// para i de 1 ate qtd faca
// escreval(vet[i]," ",p[i])
// fimpara
para i de 1 ate qtd faca
se p[i]=maior
entao escreval(vet[i])
maior<-maior-1
fimse
fimparafimalgoritmo
V00004150 - Faça um algoritmo que leia um vetor V(10) e um vetor W(3), e verifique 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 verifique 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.
algoritmo
var w:vetor[1..30]de inteiro
v:vetor[1..10]de inteiro
i,pos,j,cont:inteiro
inicio
para i de 1 ate 30 faca leia(w[i]) fimpara
para i de 1 ate 10 faca leia(v[i]) fimpara
pos<-0
para i de 1 ate 21 faca
cont<-0
para j de 1 ate 10 faca
se v[j]=w[i+j-1]
entao cont<-cont+1
fimse
fimpara
se cont=10 entao
pos<-i
fimse
fimpara
escreva(pos)
fimalgoritmo
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.
algoritmo "V001_V00006000"
var notas:vetor[0..10]de inteiro
i,nota:inteiro
inicio
para i de 0 ate 10 faca notas[i]<-0 fimpara
leia(nota)
enquanto nota>=0 faca
notas[nota]<-notas[nota]+1
leia(nota)
fimenquanto
para i de 0 ate 10 faca
escreval(i," ",notas[i])
fimpara
fimalgoritmo
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úmero 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úmero de acertos e escreve o número do apostador e seu número de acertos. O
algoritmo para de ler quando o número do apostador for 0.
algoritmo "V001_V00006100"
var
G: vetor [1..13] de inteiro
apostador, aposta, acertos, i: inteiro
inicio
i<-1
//escreva("Entre com resultado do sorteio ")
enquanto i<=13 faca
leia(G[i])
se (G[i]<>1) e (G[i]<>2) e (G[i]<>4) entao
//escreval("Resultado inválido")
senao
i<-i+1
fimse
fimenquanto
// Leitura dos apostadores
leia(apostador)
enquanto apostador>0 faca
escreva("Entre com número do apostador ")
// Leitura e conferência das apostas
acertos<-0
para i de 1 ate 13 faca
//escreva("Entre com aposta ")
leia(aposta)
se aposta = 7 entao // Marcou triplo: acerta sempre
acertos<- acertos+1
senao
se (G[i]=4) e (aposta>=4) entao // Coluna 1: acerta se marcou 4, 5 ou 6
acertos<- acertos+1
senao
se (G[i]=1) e (aposta%2=1) entao // Coluna 2: acerta se marcou 1, 3 ou 5
acertos<- acertos+1
senao
se (G[i]=2) e ((aposta=2) ou (aposta=3) ou (aposta=6) ou (aposta=7)) entao // Coluna do meio
acertos<- acertos+1
fimse
fimse
fimse
fimse
fimpara
escreva(apostador,acertos)
leia(apostador)
fimenquanto
fimalgoritmo
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.
algoritmo "V001_V00006200"
var x:vetor[1..10]de inteiro
i,j,N:inteiro
inicio
para i de 1 ate 10 faca leia(x[i]) fimpara
leia(N)
i<-1
enquanto N>=0 faca
x[i]<-N
i<-i+1
se i>10
entao i<-1
fimse
leia(N)
fimenquanto
para j de i ate 10 faca escreva(x[j]) fimpara
para j de 1 ate i-1 faca escreva(x[j]) fimpara
fimalgoritmo
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 verificar 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.
algoritmo "V001_V00006300"
var MH,n1,n2,n3:real
C,i,n:inteiro
inicio
para i de 1 ate 10 faca
leia(n,n1,n2,n3)
se n1=0 ou n2=0 ou n3=0
entao MH<-0
senao MH<-3/(1/n1+1/n2+1/n3)
fimse
se MH<6 entao C<-0
senao se MH<7 entao C<-1
senao se MH<8 entao C<-2
senao se MH<9 entao C<-3
senao C<-4
fimse
fimse
fimse
fimse
escreval(n," ",C)
fimpara
fimalgoritmo
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 final, para os partidos
de 1 a 10, o número do partido e o número de cadeiras obtidas.
algoritmo "V001_V00006400"
var votos,vagas:vetor[1..10] de inteiro
media:vetor[1..10] de real
total,tvagas,i,ocupadas,pm,sobras:inteiro
maior:real
inicio
total<-0
para i de 1 ate 10 faca
leia(votos[i])
total<-total+votos[i]
fimpara
ocupadas<-0
leia(tvagas)
para i de 1 ate 10 faca
vagas[i]<-int(votos[i]/total*tvagas)
media[i]<-votos[i]/(vagas[i]+1)
ocupadas<-ocupadas+vagas[i]
fimpara
sobras<-tvagas-ocupadas
enquanto sobras>0 faca
maior<-media[1]
pm<-1
para i de 2 ate 10 faca
se media[i]>maior
entao maior<-media[i]
pm<-i
fimse
fimpara
vagas[pm]<-vagas[pm]+1
media[pm]<-votos[pm]/(vagas[pm]+1)
sobras<-sobras-1
fimenquanto
para i de 1 ate 10 faca
escreval(i," ",vagas[i])
fimpara
fimalgoritmo
V00006500 - Faça um algoritmo que leia o código de 5 carros com seus respectivos preços. Ao final, escreva o código
do carro mais caro com seu respectivo preço.
algoritmo "V001_V00006500"
var maior,i,cod,val,cm:inteiro
inicio
maior<-0
para i de 1 ate 5 faca
leia(cod,val)
se val>maior
entao maior<-val
cm<-cod
fimse
fimpara
escreva(cm,maior)
fimalgoritmo
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.
algoritmo "V001_V00006600"
var v:vetor[1..10] de inteiro
i,j,aux,c:inteiro
inicio
para i de 1 ate 10 faca leia(v[i]) fimpara
para i de 1 ate 9 faca
para j de 1 ate 9 faca
se v[j]>v[j+1]
entao aux<-v[j]
v[j]<-v[j+1]
v[j+1]<-aux
fimse
fimpara
fimpara
c<-1
para j de 2 ate 10 faca
se v[j]=v[j-1]
entao c<-c+1
senao escreval(v[j-1]," ",c)
c<-1
fimse
fimpara
escreval(v[10]," ",c)
fimalgoritmo
V00006700 - Faça um algoritmo que leia um vetor V[10] e ao final escreva o elemento que aparece mais vezes neste
vetor.
algoritmo "V001_V00006700"
var v:vetor[1..10] de inteiro
i,cm,j,cont,vm:inteiro
inicio
para i de 1 ate 10 faca leia(v[i]) fimpara
cm<-0
para i de 1 ate 10 faca
cont<-0
para j de 1 ate 10 faca
se v[j]=v[i]
entao cont<-cont+1
fimse
fimpara
se cont>cm
entao vm<-v[i]
cm<-cont
fimse
fimpara
escreva(vm)
fimalgoritmo
V00006800 - Faça um algoritmo que leia um vetor V[15], já ordenado. Leia, a seguir, um valor N e verifique 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 eficiente possível.
algoritmo
var i,n:inteiro
v:vetor[1..15] de inteiro
inicio
para i de 1 ate 15 faca
leia(v[i])
fimpara
leia(n)
i<-1
enquanto n>v[i] e i<15 faca
i<-i+1
fimenquanto
se n=v[i]
entao escreva(i)
senao escreva(-1)
fimse
fimalgoritmoV00006900 - 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 final, o vetor V
(ordenação por inserção).
algoritmo "V001_V00006900"
var i,k,N:inteiro
v:vetor[1..20] de inteiro
inicio
para i de 1 ate 10 faca leia(v[i]) fimpara
para k de 11 ate 20 faca
leia(N)
i<-k-1
enquanto i>1 e v[i]>N faca
v[i+1]<-v[i]
i<-i-1
fimenquanto
se i=1
entao se v[i]>N
entao v[i+1]<-v[i]
v[i]<-N
senao v[i+1]<-N
fimse
senao
v[i+1]<-n
fimse
fimpara
para i de 1 ate 20 faca escreva(v[i]," ") fimpara
fimalgoritmo
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.
algoritmo
var
i,j,p,n:inteiro
x:vetor[1..10]de inteiro
inicio
para i de 1 ate 5 faca leia(x[i]) fimpara
p<-6
para i de 1 ate 5 faca
leia(n)
j<-1
enquanto x[j]<>n e j<5 faca
j<-j+1
fimenquanto
se n<>x[j] entao
x[p]<-n
p<-p+1
fimse
fimpara
para i de 1 ate p-1 faca
escreva(x[i]," ")
fimpara
fimalgoritmo
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 final, 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 verifique 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 eficiente 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)
algoritmo "V001_V00007200"
var v:vetor[1..15] de inteiro
ini,fim,N,i,meio:inteiro
inicio
para i de 1 ate 15 faca leia(v[i]) fimpara
leia(N)
ini<-1
fim<-15
meio<-(ini+fim)\2
enquanto N<>v[meio] e ini<fim faca
se N>v[meio]
entao ini<-meio+1
senao fim<-meio-1
fimse
meio<-(ini+fim)\2
fimenquanto
se ini>fim
entao escreva(-1)
senao se N=v[meio]
entao escreva(meio)
senao escreva(-1)
fimse
fimse
fimalgoritmo
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 final, o vetor alterado.
algoritmo "V001_V00007300"
var i,N,aux:inteiro
v:vetor[1..10] de inteiro
inicio
para i de 1 ate 10 faca leia(v[i]) fimpara
leia(N)
enquanto N>0 faca
aux<-v[1]
para i de 1 ate 9 faca v[i]<-v[i+1] fimpara
v[10]<-aux
N<-N-1
fimenquanto
para i de 1 ate 10 faca escreva(v[i]," ") fimpara
fimalgoritmo
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.
algoritmo
var g:vetor[1..20]de literal
cod,acertos,i:inteiro
x:literal
inicio
para i de 1 ate 20 faca leia(g[i]) fimpara
leia(cod)
enquanto cod>0 faca
acertos<-0
para i de 1 ate 20 faca
leia(x)
se x=g[i]
entao acertos<-acertos+1
fimse
fimpara
escreva(acertos)
leia(cod)
fimenquanto
fimalgoritmo
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.
algoritmo "V001_V00007500"
var a1,r:inteiro
inicio
leia(a1,r)
escreva(a1,a1+r,a1+2*r,a1+3*r,a1+4*r)
fimalgoritmo
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 considerando os restos obtidos nas
divisões, mas em ordem contrária.
algoritmo "V001_V00007600"
var
v:vetor [1..64] de inteiro
n,i,fleg:inteiro
inicio
escreva("Digite um número")
leia(n)
se n=0 entao
escreva(0)
senao
para i de 64 ate 1 passo -1 faca
v[i]<-n% 2
n<-n\2
fimpara
fleg<-0
para i de 1 ate 64 faca
se fleg=1 ou v[i]=1 entao
escreva(v[i])
fleg<-1
fimse
fimpara
fimse
fimalgoritmo
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
final a soma encontrada.
algoritmo "V001_V00007700"
var i,a,soma,sm:inteiro
inicio
soma<-0
sm<-0
para i de 1 ate 10 faca
leia(a)
soma<-soma+a
se soma<0
entao soma<-0
senao se soma>sm
entao sm<-soma
fimse
fimse
fimpara
escreva(sm)
fimalgoritmo
V00007800 - A sequencia "Look & Say" funciona da seguinte forma: O seu primeiro termo é sempre "1", e a definição
do próximo termo a partir do anterior é "O número de vezes que um número de repete até que a sequência seja
quebrada""O número que estava repetindo"...
Veja do seguinte modo:
1. Termo: 1 (Termo inicial em "1")
2. Termo: 11 (Antes tínhamos "1" vez o número "1")
3. Termo: 21 (Antes tínhamos "2" vezes o número "1")
4. Termo: 1211 (Antes tínhamos "1" vez o número "2" e "1" vezes 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
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.
algoritmo "M001_M00000100"
var M:vetor[1..5,1..5] de inteiro
lin,col,soma:inteiro
inicio
para lin de 1 ate 5 faca
para col de 1 ate 5 faca
leia(M[lin,col])
fimpara
fimpara
soma<-0
para lin de 1 ate 5 faca
soma<-soma+M[lin,lin]
fimpara
escreval(soma)
fimalgoritmo
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.
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.
algoritmo "M001_M00000200"
var M:vetor[1..5,1..5] de inteiro
lin,col,soma:inteiro
inicio
soma<-0
para lin de 1 ate 5 faca
para col de 1 ate 5 faca
leia(M[lin,col])
se lin<col
entao soma<-soma+M[lin,col]
fimse
fimpara
fimpara
escreval(soma)
fimalgoritmo
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.
algoritmo "M001_M00000400"
var M:vetor[1..5,1..5] de inteiro
lin,col,maior,lm,cm:inteiro
inicio
para lin de 1 ate 5 faca
para col de 1 ate 5 faca
leia(M[lin,col])
fimpara
fimpara
maior<-M[1,1]
lm<-1
cm<-1
para lin de 1 ate 5 faca
para col de 1 ate 5 faca
se M[lin,col]>maior
entao maior<-M[lin,col]
lm<-lin
cm<-col
fimse
fimpara
fimpara
escreval(maior,lm,cm)
fimalgoritmo
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.
algoritmo "M001_M00000600"
var M:vetor[1..5,1..5] de inteiro
lin,col,aux:inteiro
inicio
para lin de 1 ate 5 faca
para col de 1 ate 5 faca
leia(M[lin,col])
fimpara
fimpara
para col de 1 ate 5 faca
aux<-M[2,col]
M[2,col]<-M[4,col]
M[4,col]<-aux
fimpara
para lin de 1 ate 5 faca
para col de 1 ate 5 faca
escreva(M[lin,col]," ")
fimpara
fimpara
fimalgoritmo
M00000700 - Uma matriz identidade é uma matriz que possui 1 em todos os elementos da diagonal principal, e 0 em
todas as outras posições. Faça um algoritmo que leia uma matriz M[1..5,1..5] e verifique se é uma matriz identidade
escrevendo: 1 – Se é uma matriz identidade; 0 - Se não é uma matriz identidade.
algoritmo "M001_M00000700"
var
tem,lin,col:inteiro
M:vetor[1..5,1..5] de inteiro
inicio
tem<-1
para lin de 1 ate 5 faca
para col de 1 ate 5 faca
leia(M[lin,col])
se (lin=col e M[lin,col]<>1)ou(lin<>col e M[lin,col]<>0)
entao tem<-0
fimse
fimpara
fimpara
escreva(tem)
fimalgoritmo
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.
algoritmo "M001_M00000800"
var
M:vetor[1..5,1..5] de inteiro
lin,col,maior,lm,soma:inteiro
inicio
para lin de 1 ate 5 faca
para col de 1 ate 5 faca
leia(M[lin,col])
fimpara
fimpara
maior<-0
lm<-1
para col de 1 ate 5 faca
maior<-maior+M[1,col]
fimpara
para lin de 2 ate 5 faca
soma<-0
para col de 1 ate 5 faca
soma<-soma+M[lin,col]
fimpara
se soma>maior entao
maior<-soma
lm<-lin
fimse
fimpara
escreva(lm)
fimalgoritmo
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.
algoritmo "M001_M00000800"
var
M :vetor[1..5,1..5] de inteiro
lin ,col,maior,lm,soma:inteiro
inicio
para lin de 1 ate 5 faca
para col de 1 ate 5 faca
leia(M[lin,col])
fimpara
fimpara
maior<-0
lm<-1
para col de 1 ate 5 faca
maior<-maior+M[1,col]
fimpara
para lin de 2 ate 5 faca
soma<-0
para col de 1 ate 5 faca
soma<-soma+M[lin,col]
fimpara
se soma>maior entao
maior<-soma
lm<-lin
fimse
fimpara
escreva(lm)
fimalgoritmo
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 final os
vetores Somalin e Somacol.
algoritmo "M001_M00001000"
var
m:vetor [1..5,1..5] de inteiro
i,j:inteiro
somalin,somacol:vetor[1..5] de inteiro
inicio
para i de 1 ate 5 faca
somalin[i]<-0
somacol[i]<-0
fimpara
para i de 1 ate 5 faca
para j de 1 ate 5 faca
leia(m[i,j])
somalin[i]<-somalin[i]+m[i,j]
somacol[j]<-somacol[j]+m[i,j]
fimpara
fimpara
para i de 1 ate 5 faca
escreval(somalin[i])
fimpara
para i de 1 ate 5 faca
escreva(somacol[i])
fimpara
fimalgoritmo
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)
algoritmo "M001_M00001010"
var
M:vetor[1..3,1..3] de inteiro
i,j:inteiro
inicio
para i de 1 ate 3 faca
para j de 1 ate 3 faca
leia(M[i,j])
fimpara
fimpara
se M[1,1]=M[1,2] e M[1,2]=M[1,3] e M[1,1]<>0 entao
escreva(M[1,1])
senao
se M[2,1]=M[2,2] e M[2,2]=M[2,3] e M[2,1]<>0 entao
escreva(M[2,1])
senao
se M[3,1]=M[3,2] e M[3,2]=M[3,3] e M[3,1]<>0 entao
escreva(M[3,1])
senao
se M[1,1]=M[2,1] e M[2,1]=M[3,1] e M[1,1]<>0 entao
escreva(M[1,1])
senao
se M[1,2]=M[2,2] e M[2,2]=M[3,2] e M[1,2]<>0 entao
escreva(M[1,2])
senao
se M[1,3]=M[2,3] e M[2,3]=M[3,3] e M[1,3]<>0 entao
escreva(M[1,3])
senao
se M[1,1]=M[2,2] e M[2,2]=M[3,3] e M[1,1]<>0 entao
escreva(M[1,1])
senao
se M[1,3]=M[2,2] e M[2,2]=M[3,1] e M[1,3]<>0 entao
escreva(M[1,3])
senao
se M[1,1]*M[1,2]*M[1,3]*M[2,1]*M[2,2]*M[2,3]*M[3,1]*M[3,2]*M[3,3]=0 entao
escreva(4)
senao
escreva(3)
fimse
fimse
fimse
fimse
fimse
fimse
fimse
fimse
fimse
fimalgoritmo
M00001100 - Uma matriz é dita Diagonalmente Dominante se em todas as linhas o elemento da diagonal principal é
maior ou igual à soma dos outros elementos da linha, e 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 verifique se é diagonalmente dominante escrevendo: 1 – Se é diagonalmente dominante; 0 -
Se não é diagonalmente dominante
algoritmo "M001_M00001100"
var
m: vetor [1..4,1..4] de inteiro
i, j,soma :inteiro
dd,maior:logico
inicio
para i de 1 ate 4 faca
para j de 1 ate 4 faca
leia(m[i,j])
fimpara
fimpara
dd<-verdadeiro
maior<-falso
i<-1
enquanto dd e i<=4 faca
soma<-0
para j de 1 ate 4 faca
soma<-soma+m[i,j]
fimpara
soma<-soma-m[i,i]
se m[i,i]<soma entao
dd<-falso
fimse
se m[i,i]>soma entao
maior<-verdadeiro
fimse
i<-i+1
fimenquanto
se dd e maior entao
escreva(1)
senao
escreva(0)
fimse
fimalgoritmo
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 final 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 passamexatamente 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 final 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 modificada.
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, verifique 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".
algoritmo "M001_M00001900"
var
i,j,k,N,tem:inteiro
m:vetor[1..5,1..5] de inteiro
inicio
para i de 1 ate 5 faca
para j de 1 ate 5 faca
leia (m[i,j])
fimpara
fimpara
para k de 1 ate 5 faca
leia(N)
tem<-0
para i de 1 ate 5 faca
para j de 1 ate 5 faca
se N=m[i,j] e tem=0 entao
tem<-1
escreva(i,j)
fimse
fimpara
fimpara
se tem=0 entao
escreva("Não achou")
fimse
fimpara
fimalgoritmo
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
algoritmo
var
z,x,y,lin,col:inteiro
m:vetor[1..5,1..5] de inteiro
inicio
para lin de 1 ate 5 faca
para col de 1 ate 5 faca
leia(m[lin,col])
fimpara
fimpara
x<-0
y<-0
z<-0
para lin de 1 ate 5 faca
para col de 1 ate 5 faca
se lin>col e m[lin,col]<>0 entao
x<-1
fimse
se col>lin e m[lin,col]<>0 entao
y<-1
fimse
se lin=col e m[lin,col]<>0 entao
z<-1
fimse
fimpara
fimpara
se x=0 e y=1 entao
escreva(1)
senao
se x=1 e y=0 entao
escreva(2)
senao
se z=1 e x=0 e y=0 entao
escreva(0)
senao
escreva(3)
fimse
fimse
fimse
fimalgoritmo
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 verifique 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 verifique 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
3 9 6
2 8 4
torna-se
1 2 3
1 3 2
1 4 2
e finalmente
1 2 3
0 1 -1
0 2 -1
Escreva a matriz alterada.
algoritmo "M001_M00002300"
var i,j,aux:inteiro
M:vetor[1..3,1..3] de inteiro
inicio
para i de 1 ate 3 faca
para j de 1 ate 3 faca
leia(M[i,j])
fimpara
fimpara
para i de 1 ate 3 faca
aux<-M[i,1]
para j de 1 ate 3 faca
M[i,j]<-M[i,j]\aux
fimpara
fimpara
para i de 2 ate 3 faca
para j de 1 ate 3 faca
M[i,j]<-M[i,j]-M[1,j]
fimpara
fimpara
para i de 1 ate 3 faca
para j de 1 ate 3 faca
escreva(M[i,j])
fimpara
fimpara
fimalgoritmo
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 verifique se ela é de Hadamard escrevendo: 0 - Se
não é de Hadamard; 1 – Se é de Hadamard
algoritmo
var M:vetor[1..4,1..4] de inteiro
i,j,k,erro1,erro2,pvet:inteiro
inicio
erro1<-0
erro2<-0
para i de 1 ate 4 faca
para j de 1 ate 4 faca
leia(M[i,j])
se M[i,j]<>-1 e M[i,j]<>1
entao erro1<-1
fimse
fimpara
fimpara
para i de 1 ate 3 faca
para j de i+1 ate 4 faca
pvet<-0
para k de 1 ate 4 faca
pvet<-pvet+M[i,k]*M[j,k]
fimpara
se pvet>0
entao erro2<-1
fimse
fimpara
fimpara
se erro1=0 e erro2=0
entao escreva(1)
senao escreva(0)
fimse
fimalgoritmo
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.
algoritmo
var m:vetor[1..3,1..3] de inteiro
i,j,aux:inteiro
inicio
para i de 1 ate 3 faca
para j de 1 ate 3 faca
leia (M[i,j])
fimpara
fimpara
aux<-M[1,2]
M[1,2]<-M[2,1]
M[2,1]<-M[3,2]
M[3,2]<-M[2,3]
M[2,3]<-aux
aux<-M[3,3]
M[3,3]<-M[1,3]
M[1,3]<-M[1,1]
M[1,1]<-M[3,1]
M[3,1]<-aux
para i de 1 ate 3 faca
para j de 1 ate 3 faca
escreva (M[i,j])
fimpara
fimpara
fimalgoritmo
M00004900 - Um quadrado mágico de ordem N (sendo N um número ímpar) é um arranjo de números 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, então 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 final a
matriz P.
algoritmo "M001_M00000100"
var M,N,P:vetor[1..5,1..5] de inteiro
lin,col,soma,aux:inteiro
inicio
para lin de 1 ate 3 faca
para col de 1 ate 3 faca
leia(M[lin,col])
fimpara
fimpara
para lin de 1 ate 3 faca
para col de 1 ate 3 faca
leia(N[lin,col])
fimpara
fimpara
para lin de 1 ate 3 faca
para col de 1 ate 3 faca
soma<-0
para aux de 1 ate 3 faca
soma<-soma+M[lin,aux]*N[aux,col]
fimpara
P[lin,col]<-soma
fimpara
fimpara
para lin de 1 ate 3 faca
para col de 1 ate 3 faca
escreva(P[lin,col]," ")
fimpara
fimpara
fimalgoritmo
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 verifique se a matriz é equivalente a uma pirâmide inca, ou seja, se partindo-se do canto superioresquerdo 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.
algoritmo "M001_M00005100"
var
m,mat:vetor[1..10,1..10]de inteiro
i,j,dir,lin,col,N,tem:inteiro
inicio
leia(N)
para i de 1 ate N faca
para j de 1 ate N faca
leia(mat[i,j])
m[i,j]<-0
fimpara
fimpara
lin<-1
col<-1
dir<-1 //1-esq 2-bai 3-dir 4-cim
para i de 1 ate N*N faca
m[lin,col]<-i
se dir=1 entao
se col=N entao dir<-2
lin<-lin+1
senao se m[lin,col+1]<>0
entao dir<-2
lin<-lin+1
senao col<-col+1
fimse
fimse
senao se dir=2 entao
se lin=N entao dir<-3
col<-col-1
senao se m[lin+1,col]<>0
entao dir<-3
col<-col-1
senao lin<-lin+1
fimse
fimse
senao se dir=3 entao
se col=1 entao dir<-4
lin<-lin-1
senao se m[lin,col-1]<>0
entao dir<-4
lin<-lin-1
senao col<-col-1
fimse
fimse
senao
se lin=1 entao dir<-1
col<-col+1
senao se m[lin-1,col]<>0
entao dir<-1
col<-col+1
senao lin<-lin-1
fimse
fimse
fimse
fimse
fimse
fimpara
tem<-1
para i de 1 ate N faca
para j de 1 ate N faca
se mat[i,j]<>m[i,j]
entao tem<-0
fimse
fimpara
fimpara
escreva(tem)
fimalgoritmo
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 final, escrever a matriz C.
algoritmo "M001_M00000700"
var lin,col:inteiro
A,B,C:vetor[1..3,1..4] de inteiro
inicio
para lin de 1 ate 3 faca
para col de 1 ate 4 faca
leia(A[lin,col])
fimpara
fimpara
para lin de 1 ate 3 faca
para col de 1 ate 4 faca
leia(B[lin,col])
se (B[lin,col]=A[lin,col])
entao C[lin,col]<-1
senao C[lin,col]<-0
fimse
fimpara
fimpara
para lin de 1 ate 3 faca
para col de 1 ate 4 faca
escreva(C[lin,col])
fimpara
fimpara
fimalgoritmo
M00005300 - Na Teoria de Sistemas, define-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 final, escrever o valor do elemento minimax, bem como a linha e coluna onde
ocorreu.
algoritmo "M001_M00005300"
var m:vetor[1..5,1..5] de inteiro
i,j,lm,maior,menor,cm:inteiro
inicio
para i de 1 ate 5 faca
para j de 1 ate 5 faca
leia(m[i,j])
fimpara
fimpara
maior<-m[1,1]
lm<-1
para i de 1 ate 5 faca
para j de 1 ate 5 faca
se m[i,j]>maior
entao maior<-m[i,j]
lm<-i
fimse
fimpara
fimpara
menor<-m[lm,1]
cm<-1
para j de 2 ate 5 faca
se m[lm,j]<menor
entao cm<-j
menor<-m[lm,j]
fimse
fimpara
escreva(m[lm,cm],lm,cm)
fimalgoritmo
M00005400 - (Problema específico da disciplina de Teoria de Grafos) 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). Matrizes de adjacências são uma das formas utilizadas para representação de grafos. 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 o menor
caminho de c1 a c2, mostrando a cidade inicial, as cidades intermediárias e a cidade final.
algoritmo "M001_M00005400"
var dist,s:vetor[1..5]de inteiro
p,i,j,c1,c2,nivel,v:inteiro
mat:vetor[1..5,1..5]de inteiro
inicio
para i de 1 ate 5 faca
dist[i]<- -1
para j de 1 ate 5 faca
leia(mat[i,j])
fimpara
fimpara
leia(c1,c2)
dist[c1]<-0
nivel<-0
enquanto dist[c2]=-1 e nivel<6 faca
para i de 1 ate 5 faca
se dist[i]=nivel entao
para j de 1 ate 5 faca
se mat[i,j]=1 entao
se dist[j]=-1
entao dist[j]<-nivel+1
fimse
fimse
fimpara
fimse
fimpara
nivel<-nivel+1
fimenquanto
v<-c2
p<-1
para i de nivel-1 ate 1 passo -1 faca
j<-1
enquanto dist[j]<>i ou mat[j,v]<>1 faca
j<-j+1
fimenquanto
s[p]<-j
p<-p+1
v<-j
fimpara
escreva(c1," ")
enquanto p>1 faca
p<-p-1
escreva(s[p]," ")
fimenquanto
escreva(c2," ")
fimalgoritmo