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,