Lista de Problemas Com Soluções PDF

Sequenciais
S00000050 - Faa um algoritmo que leia um valor N, representando o lado de um

quadrado, e calcule e escreva a rea do quadrado.
algoritmo "S001_S00000050"
var N,area:inteiro
inicio
Escreval("Digite o valor do lado")
leia (N)
area<-n*n
escreval("A area ",area)
fimalgoritmo
S00000100 - Faa um algoritmo que leia dois valores inteiros e escreva a sua
soma.
var a,b:real
inicio
leia(a,b)
escreva(a+b)
fimalgoritmo
S00000150 - Faa um algoritmo que leia 3 valores reais, notas de um aluno, e
escreva sua mdia aritmtica. A mdia aritmtica de um conjunto de valores
dada pela soma dos valores dividido pela quantidade de valores considerados.
var a,b,c,media:real
inicio
leia(a,b,c)
media<-(a+b+c)/3
escreva("a mdia ",media)
fimalgoritmo
S00000200 - Faa um algoritmo que leia 2 valores reais v1 e v2 e calcule e
escreva a rea do tringulo que tem base igual a v1 e altura igual a v2. Dica:A
rea de um tringulo dada pela expresso: (base x altura)/2
S00000210 - O produto vetorial AxB de dois vetores A=[ax,ay] e B=[bx,by] um
vetor perpendicular ao plano formado pelos vetores A e B, de mdulo igual a |
ax*by-ay*bx|. Faa um algoritmo que leia as componentes ax,ay,bx e by dos
vetores A e B, e calcule e escreva o mdulo do vetor resultante do produto
vetorial.
algoritmo
var ax,ay,bx,by:real
inicio
leia(ax,ay,bx,by)
escreva(abs(ax*by-ay*bx))
fimalgoritmo
S00000220 - O produto escalar A.B de dois vetores A=[a1,a2,a3...] e
B=[b1,b2,b3...] dado pelo somatrio a1*b1+a2*b2+a3*b3+... Faa um algoritmo
que leia as coordenadas ax,ay,az,bx,by,bz de dois vetores no espao
tridimensional e calcule e escreva seu produto escalar.
var ax,ay,az,bx,by,bz:real
inicio
leia(ax,ay,az,bx,by,bz)
escreva(ax*bx+ay*by+az*bz)
fimalgoritmo
S00000300 - Faa um algoritmo que leia 3 valores a, b e c, coeficientes de uma
equao de segundo grau, e calcule e escreva a soma das razes da equao.
Dica:As razes de uma equao podem ser calculadas pela frmula de Baskhara.
algoritmo
var a,b,c,delta,x1,x2:real
inicio
leia(a,b,c)
delta<-raizq(b^2-4*a*c)
x1<-(-b+delta)/(2*a)
x2<-(-b-delta)/(2*a)
escreva(x1+x2)
fimalgoritmo
S00000350 - Faa um algoritmo que leia 3 valores a, b e c, coeficientes de uma
equao de segundo grau, e calcule e escreva o produto (multiplicao) das
razes da equao. Dica:As razes de uma equao podem ser calculadas pela
frmula de Baskhara.
algoritmo
inicio
leia(a,b,c)
delta<-raizq(b^2-4*a*c)
x1<-(-b+delta)/(2*a)
x2<-(-b-delta)/(2*a)
escreva(x1*x2)
fimalgoritmo
S00000400 - Faa um algoritmo que leia 2 valores e escreva o maior deles. Dica:O
maior entre dois valores quaisquer v1 e v2 pode ser calculado pela expresso
(v1+v2+|v1-v2|)/2. O operador matemtico de mdulo ( |x| ) representado na
nossa linguagem pela funo abs(x)
algoritmo
var a,b,c,valor:real
inicio
escreva ("digite 3 valores")
leia (a,b,c)
valor <- (a+b+abs(a-b))/2
valor <- (valor+c+abs(valor-c))/2
escreva ("o maior nmero ",valor)
fimalgoritmo
S00000500 - Faa um algoritmo que leia 2 valores e escreva o menor deles.
Dica:O menor entre dois valores pode ser obtido a partir do maior valor e da
soma dos dois (por exemplo: Se a soma de dois valores 15 e o valor do maior
10, como pode ser calculado o valor do menor?).
algoritmo
var a,b,maior,menor:real
inicio
leia (a,b)
maior <- (a+b+abs(a-b))/2
menor <- a + b - maior
escreva ("o menor nmero ",menor)
fimalgoritmo
algoritmo
var a,b,menor:real
inicio
leia(a,b)
menor<-(a+b-abs(a-b))/2
escreva(menor)
fimalgoritmo
S00000600 - Faa um algoritmo que leia 3 valores escreva o maior deles. Dica:O
maior entre trs valores pode ser encontrado pela aplicao repetida da
expresso para encontrar o maior entre dois valores.
algoritmo
var a,b,c,valor:real
inicio
leia (a,b,c)
valor <- (a+b+abs(a-b))/2
valor <- (valor+c+abs(valor-c))/2
escreva ("o maior nmero ",valor)
fimalgoritmo
S00000700 - Faa um algoritmo que l um valor inteiro em reais e calcula e
escreve qual o menor nmero possvel de notas de 100,50,20,10,5,2 e 1 real em
que o valor pode ser decomposto. Dica:Isso pode ser calculado a partir de
operaes de diviso inteira.
var n:inteiro
inicio
escreval("Digite um valor")
leia(n)
escreval(n\100," notas de 100")
n<-n%100
n<-n%50
n<-n%10
n<-n%5
escreval(n," notas de 1")
fimalgoritmo
S00000800 - Faa um algoritmo que l uma quantia inteira em segundos e escreva o
nmero de horas, minutos e segundos correspondente. Dica:Para converter segundos
para minutos usa-se a diviso inteira por 60.
S00000900 - Faa um algoritmo que l 3 valores, lados de um tringulo, e calcule
e escreva a rea do tringulo formado. Dica: A rea de um tringulo de lados l1,
l2 e l3 pode ser calculada pela expresso rea=raiz(S*(S-l1)*(S-l2)*(S-l3)),
onde S o semi-permetro, ou seja, a metade da soma dos lados
algoritmo "C001_C00000100"
var a,b,c,s,area:real
inicio
leia(a,b,c)
s<-(a+b+c)/2
area<-raizq(s*(s-a)*(s-b)*(s-c))
escreva(area)
fimalgoritmo
S00001000 - Faa um algoritmo que le um valor entre 0 e 9999 e calcula a soma
dos seus dgitos. Dica: O dgito menos significativo de um nmero inteiro pode
ser obtido pelo resto da diviso do nmero por 10. Os dgitos restantes podem
ser obtidos pela diviso inteira por 10.
S00001100 - Faa um algoritmo que leia 3 valores v1, v2 e v3, e troque os
valores entre si de modo que ao final a varivel v2 contenha o valor que foi
lido para v1, a varivel v3 contenha o valor que foi lido para v2, e a varivel
v1 contenha o valor que foi lido para a varivel v3. Dica:Para trocar os valores
de duas variveis (digamos v1 e v2) entre si, salva-se o valor de uma delas
(p.ex., v1) em uma varivel auxiliar qualquer (p.ex., aux) , copia-se o valor da
segunda (v2) para a varivel que foi salva (v1), e copia-se o valor da varivel
auxiliar (que contem o valor original da primeira), para a segunda varivel.
S00001200 - Faa um algoritmo que leia 4 valores, Hi, Mi, Hf, Mf, representando
respectivamente a hora e minuto inicial e final de um evento, e calcule a
durao do mesmo em horas e minutos. Considere que o evento inicia e termina no
mesmo dia. Dica: Para simplificar o problema, converta cada par de valores em um
nico valor em minutos.
var hi,mi,hf,mf,dh,dm,d:inteiro
inicio
leia(hi,mi,hf,mf)
d<-hf*60+mf-hi*60-mi
dh<-d\60
dm<-d%60
escreva(dh," horas e ",dm," minutos")
fimalgoritmo
S00001300 - Faa um algoritmo que leia dois horrios (hora, minuto e segundo) e
escreva quantos segundos transcorreram entre esses dois horrios.
var hi,mi,si,hf,mf,sf:inteiro
inicio
leia(hi,mi,si,hf,mf,sf)
escreva(hf*3600+mf*60+sf-(hi*3600+mi*60+si))
fimalgoritmo
S00001350 - Faa um algoritmo que leia um horrio (hora, minuto e segundo) e
escreva o horrio correspondente ao segundo seguinte. Ex: se for lido, 17,21,36
escrever 17,21,37. Considere que os horrios (lido e escrito) esto na faixa de
00:00:00 a 23:59:59.
algoritmo
var h,m,s:inteiro
inicio
leia(h,m,s)
s<-3600*h+60*m+s+1
h<-(s\3600)%24
m<-s%3600\60
s<-s%60
escreva(h,m,s)
fimalgoritmo
S00001400 - Faa um algoritmo que a partir de um horrio (hora, minuto, segundo)
e uma quantidade de segundos transcorridos, calcule o segundo horrio.
var h,m,s,st:inteiro
inicio
leia(h,m,s,st)
s<-s+st
m<-m+s\60
s<-s%60
h<-h+m\60
m<-m%60
escreva(h,m,s)
fimalgoritmo
S00001500 - Faa um algoritmo que leia a quantidade de alunos em uma sala de
aula e a quantidade de alunos por grupo, e calcule e escreva quantos grupos
sero formados e o resto de alunos que no foram suficientes para formar mais um
grupo.
var N,Ag,g,r:inteiro
inicio
leia(N,Ag)
g<-N\Ag
r<-N%Ag
escreva(g,r)
fimalgoritmo
S00001600 - Faa um algoritmo que leia um valor em binrio at 6 dgitos e
escreva o nmero correspondente em decimal.
Dica: Multiplique cada dgito binrio pelo seu peso (1,2,4,8...) e some os
produtos.
algoritmo "Binrio"
var
n0,n1,n2,n3,n4,n5,n6,resto,decimal:inteiro
inicio
escreval("Fornea um n binrio com no mximo 6 dgitos")
leia(n0)
n1<-n0\100000
resto<-n0%100000
n2<-resto\10000
resto<-resto%10000
n3<-resto\1000
resto<-resto%1000
n4<-resto\100
resto<-resto%100
n5<-resto\10
resto<-resto%10
n6<-resto\1
decimal<- n6 +2*n5 + 4*n4 + 8*n3 + 16*n2 + 32*n1
escreva("O n binrio corresponde ao n decimal ",decimal)
fimalgoritmo
S00001650 - Faa um algoritmo que leia um nmero de 10 dgitos e rotacione os
dgitos uma posio para a esquerda, de modo que o primeiro dgito passe a
ocupar a ltima posio. Ex: 1234561234 deve gerar 2345612341 (todos os dgitos
foram uma posio para a esquerda e o 1 da primeira posio passou a ocupar a
ltima posio).
var a:inteiro
inicio
leia(a)
escreva(a%1000000000*10+a\1000000000)
fimalgoritmo
S00001700 - Faa um algoritmo que leia 5 nmeros inteiros e escreva a quantidade
deles que so pares. Dica:Um nmero par se o resto da sua diviso por 2
zero.

var a,b,c,d,f:inteiro
inicio
leia(a,b,c,d,f)
escreva(5-(a%2+b%2+c%2+d%2+f%2))
fimalgoritmo
S00001800 - Faa um algoritmo que leia 5 nmeros inteiros e escreva a soma dos
que forem mpares. Dica:Um nmero mpar se o resto da sua diviso por 2 um.
var n1,n2,n3,n4,n5,soma:inteiro
inicio
leia(n1,n2,n3,n4,n5)
n1<-n1 % 2 * n1
n2<-n2 % 2 * n2
n3<-n3 % 2 * n3
n4<-n4 % 2 * n4
n5<-n5 % 2 * n5
soma<-n1+n2+n3+n4+n5
escreva(soma)
fimalgoritmo
Condicionais
C00000020 - Faa um algoritmo que leia um valor e escreva: 0, se o valor zero;
1, se o valor maior que zero; -1 - se o valor negativo.
C00000040 - Faa um algoritmo que leia um valor e escreva: 0, se o valor par;
1, se o valor mpar.
C00000060 - Faa um algoritmo que leia dois valores e, atravs de uma
comparao, escreva o maior deles. Considere que os dois valores so diferentes.
C00000080 - Faa um algoritmo que leia dois valores e escreva os dois em ordem
crescente.
C00000100 - Faa um algoritmo que leia 3 valores v1, v2 e v3, e escreva-os em
ordem crescente.
var a,b,c,aux:inteiro
inicio
leia(a,b,c)
se a>b
entao aux<-a
a<-b
b<-aux
fimse
se a>c
entao aux<-a
a<-c
c<-aux
fimse
se b>c
entao aux<-b
b<-c
c<-aux
fimse
escreva(a,b,c)
fimalgoritmo
C00000200 - Faa um algoritmo que leia 3 valores v1, v2 e v3 e coloque-os em
ordem crescente, de forma que v1 contenha o menor, v2 contenha o elemento do
meio (nem o maior, nem o menor), e v3 contenha o maior. Escreva os valores
ordenados.
C00000250 - Escreva um algoritmo que leia os valores das quatro provas de um
aluno e escreva a mdia aritmtica considerando apenas as trs melhores notas.
Por exemplo, se o valores lidos foram 9, 9.5, 7, e 8, a mdia ser (9 + 9.5 +
8)/3 (a prova de nota 7 descartada). Dica:No esquea de considerar a
possibilidade de ocorrerem notas iguais.
C00000300 - Faa um algoritmo que leia 3 valores a, b e c, coeficientes de uma
equao de segundo grau, e verifique se a equao tem razes reais. Se a equao
tiver razes reais, calcule e escreva as razes da equao (em ordem crescente).
Se no tiver, escreva "A equao no possui razes reais". Dica: As razes de
uma equao podem ser calculadas pela frmula de Baskhara. Uma equao no
possui razes se reais se B*B-4*a*c < 0
inicio
leia(a,b,c)
delta<-b^2-4*a*c
se delta<0
entao escreva("no tem")
senao
x1<-(-b-raizq(delta))/(2*a)
x2<-(-b+raizq(delta))/(2*a)
se x1<x2 entao escreva(x1,x2)
senao escreva(x2,x1)
fimse
fimse
fimalgoritmo
C00000350 - Faa um algoritmo que leia 3 valores a, b e c, lados de um
tringulo, e verifique o tipo de tringulo formado escrevendo: 0 - se o
tringulo equiltero (os trs lados so iguais); 1 - se o tringulo
issceles (dois lados iguais e um diferente);2 - escaleno (3 lados diferentes).
C00000360 - Faa um algoritmo que leia 3 valores a, b e c, lados de um
tringulo, e verifique o tipo de tringulo formado escrevendo: 0 - se o
tringulo retngulo (A^2=B^2+C^2); 1 - se o tringulo acutngulo (A^2 > B^2
+ C^2) ;2 - obtusngulo (A^2 < B^2 + C^2). Lembre que, para aplicar as relaes
mostradas, o algoritmo deve garantir que o maior dos 3 lados estar em A.
algoritmo
var a,b,c,aux:inteiro
inicio
leia(a,b,c)
se a<b
entao aux<-a
a<-b
b<-aux
fimse
se a<c
entao aux<-c
c<-a
a<-aux
fimse
se a^2=b^2+c^2
entao escreva(0)
senao se a^2>b^2+c^2
entao escreva(1)
senao escreva(2)
fimse
fimse
fimalgoritmo
C00000400 - Faa um algoritmo que leia 3 valores l1,l2 e l3 e verifique se
formam um tringulo. Se formarem, calcule e escreva a rea do tringulo formado
(veja exerccio S00000900). Se no formarem, escreva -1.
var l1,l2,l3,s,area:numerico
inicio
escreval("Os Valores dos 3 lados do triangulo so:")
leia (l1,l2,l3)
se ((l1<l2+l3)e(l2<l1+l3)e(l3<l2+l1)) entao
s<-(l1+l2+l3)/2
area<-raizq(s*(s-l1)*(s-l2)*(s-l3))
escreval(" A area do triangulo :",area)
senao
escreval(-1)
fimse
fimalgoritmo
C00000410 - Faa um algoritmo que leia 3 valores l1,l2 e l3 e verifique se
formam um tringulo e, se formarem, o tipo de tringulo formado, escreva: 0 - se
no formarem tringulo; 1 - se formarem um tringulo equilatero (os trs lados
so iguais); 2 - se formarem um tringulo issceles (dois lados iguais e um
diferente); 3 - se formarem um tringulo escaleno (3 lados diferentes)
C00000450 - Faa um algoritmo que implemente uma calculadora de 4 operaes. O
algoritmo deve ler, nessa ordem: o primeiro operando, o operador (+,-,*,/) e o
segundo operando, e deve escrever o resultado da operao. Por exemplo, se o
usurio digitar 2,+,3 o algoritmo deve escrever 5. Dica: Para que uma varivel
possa receber um texto (mesmo que seja apenas o caracter "+") ela deve ser
declarada como "literal".
var a,b,resultado:numerico
op:literal
inicio
escreval("Os valores de A, operador e B so:")
leia (a,op,b)
se (op="+") entao
resultado<-a+b
senao se (op="-") entao
resultado<-a-b
senao se (op="*") entao
resultado<-a*b
senao se (op="/") entao
resultado<-a/b
fimse
fimse
fimse
fimse
escreval("O resultado :", resultado)
fimalgoritmo
C00000460 - Faa um algoritmo que leia um literal contendo uma expresso com 3
caracteres, onde o primeiro caractere um dgito entre 0 e 9, o segundo um
operador (+,-,*,/) e o terceiro caractere um dgito entre 0 e 9, e efetue o
clculo da expresso escrevendo o resultado. Dica:Use a funo subliteral para
separar os 3 caracteres e a funo val para converter os operandos em seus
valores numricos.
var lit,op1,op2,op:literal
n1,n2:inteiro
inicio
leia(lit)
op1<-subliteral(lit,1,1)
op<-subliteral(lit,2,1)
op2<-subliteral(lit,3,1)
se val(op1,n1)=falso ou val(op2,n2)=falso
entao escreva("Expresso invlida")
senao
se op="+" entao escreva(n1+n2)
senao se op="-" entao escreva(n1-n2)
senao se op="/" entao escreva(n1/n2)
senao escreva(n1*n2)
fimse
fimse
fimse
fimse
fimalgoritmo
C00000500 - Faa um algoritmo que leia 3 notas de um aluno e escreva sua mdia
harmnica. Dica: A mdia harmnica entre trs valores N1, N2 e N3 calculada
pela expresso 3/(1/N1+1/N2+1/N3). O que acontece se alguma das notas for igual
a 0? Que resultado o algoritmo deve emitir?
var n1,n2,n3:real
inicio
leia(n1,n2,n3)
se n1=0 ou n2=0 ou n3=0
entao escreva(0)
senao escreva(3/(1/n1+1/n2+1/n3))
fimse
fimalgoritmo
harmnica. Se o aluno obteve mdia abaixo de 6.0, E SOMENTE NESSE CASO, leia uma
quarta nota (da prova de recuperao) e substitua a menor das trs notas pela
nota da recuperao e recalcule a mdia harmnica. Escreva a mdia harmnica
final e o conceito obtido (0, se mdia harmnica (MH) < 6.0; 1 se 6.0 <= MH
<7.0; 2 se 7.0 <= MH < 8.0; 3 se 8.0 <= MH < 9.0; 4 se MH>=9.0).
var n1,n2,n3,media1,media2,media3,aux,mediaharmonica,recuperacao:real
inicio
escreval("Digite as tres notas de um aluno")
leia(n1,n2,n3)
Se n1=0 ou n2=0 ou n3=0
entao mediaharmonica<-0
senao
media1<-1/n1
media2<-1/n2
media3<-1/n3
mediaharmonica<- 3/(media1+media2+media3)
fimse
se mediaharmonica<6
entao escreval("Digite a nota da recuperacao")
leia(recuperacao)
se n1>n2
entao aux<-n1
n1<-n2
n2<-aux
fimse
se n1>n3
entao aux<-n3
n1<-n3
n3<-aux
fimse
Se recuperacao=0 ou n2=0 ou n3=0
entao mediaharmonica<-0
senao
media1<-1/recuperacao
media2<-1/n2
media3<-1/n3
mediaharmonica<- 3/(media1+media2+media3)
fimse
fimse
se mediaharmonica<6
entao escreval("A mdia harmonica ", mediaharmonica,"O aluno foi reprovado, o
conceito obtido ",0)
senao se mediaharmonica>=6 e mediaharmonica<7
entao escreval("a media harmonica ",mediaharmonica,"O conceito obtido
",1)
senao se mediaharmonica>=7 e mediaharmonica<8
entao escreval("a media harmonica ",mediaharmonica,"O
conceito obtido ",2)
senao se mediaharmonica >=8 e mediaharmonica<9
entao escreval("a media harmonica
",mediaharmonica,"O conceito obtido ",3)
senao se mediaharmonica>=9
entao escreval("a media harmonica
",mediaharmonica,"O conceito obtido ",4)
fimse
fimse
fimse
fimse
fimse
fimalgoritmo
C00000625 - Faa um algoritmo que leia os cdigos e as votaes dos 5 candidatos
da eleio para presidente em 1o turno. O algoritmo deve escrever, para cada
candidato, seu cdigo e seu percentual de votos. Se a eleio foi decidida no 1o
turno, i.e., um candidato obteve 50% dos votos vlidos + 1, o algoritmo deve
escrever o cdigo e o percentual de votos do eleito. Em caso contrrio, o
algoritmo deve escrever os cdigos e os percentuais de votos dos dois candidatos
que disputaro o segundo turno.
var c1,v1,c2,v2,c3,v3,c4,v4,c5,v5,soma,aux1:inteiro
p1,p2,p3,p4,p5,aux:real
inicio
leia(c1,v1,c2,v2,c3,v3,c4,v4,c5,v5)
soma<-v1+v2+v3+v4+v5
p1<-(v1/soma)*100
p2<-(v2/soma)*100
p3<-(v3/soma)*100
p4<-(v4/soma)*100
p5<-(v5/soma)*100
escreva(c1," ",p1," ",c2," ",p2," ",c3," ",p3," ",c4," ",p4," ",c5," ", p5)
se p1>50 ou p2>50 ou p3>50 ou p4>50 ou p5>50
entao
se p1>50
entao
escreva(" ",c1," ",p1)
fimse
se p2>50
entao
fimse
se p3>50
entao
fimse
se p4>50
entao
fimse
se p5>50
entao
fimse
senao
se p1>p2
entao
aux1<-c1
c1<-c2
c2<-aux1

aux<-p1
p1<-p2
p2<-aux
fimse
se p2>p3
entao
aux1<-c2
c2<-c3
c3<-aux1

aux<-p2
p2<-p3
p3<-aux
fimse

se p3>p4
entao
aux1<-c3
c3<-c4
c4<-aux1

aux<-p3
p3<-p4
p4<-aux
fimse
se p4>p5
entao
aux1<-c4
c4<-c5
c5<-aux1

aux<-p4
p4<-p5
p5<-aux
fimse

se p1>p2
entao
aux1<-c1
c1<-c2
c2<-aux1

aux<-p1
p1<-p2
p2<-aux
fimse
se p2>p3
entao
aux1<-c2
c2<-c3
c3<-aux1

aux<-p2
p2<-p3
p3<-aux
fimse

se p3>p4
entao
aux1<-c3
c3<-c4
c4<-aux1

aux<-p3
p3<-p4
p4<-aux
fimse
escreva(" ",c5," ",p5," ",c4," ",p4)

fimse
fimalgoritmo
harmnica (MH). Caso alguma das notas seja 0 (zero), MH deve receber 0 (zero).
Se o aluno obteve uma MH abaixo de 6.0 e AINDA PUDER OBTER mdia igual ou
superior a 6.0, o algoritmo deve ler uma quarta nota (da prova de recuperao)
e substituir a menor das trs notas pela nota da recuperao, recalculando MH. O
algoritmo deve escrever a MH final e o conceito obtido (0, se MH < 6.0; 1 se 6.0
<= MH <7.0; 2 se 7.0 <= MH < 8.0; 3 se 8.0 <= MH < 9.0; 4 se MH>=9.0).
Dica:No caso do aluno ter obtido mdia inferior a 6.0, uma forma de verificar se
ele pode alcanar mdia 6.0 atravs da prova de recuperao substituindo a
menor nota por 10 e verificando se a MH resultante igual ou superior a 6.0.
var n1,n2,n3,n4,m1,m2,m3,media,mx:real
inicio
leia(n1,n2,n3)
se n1=0 ou n2=0 ou n3=0
entao media<-0
senao media<-3/(1/n1+1/n2+1/n3)
fimse
se media<6
entao m1<-n1 m2<-n2 m3<-n3
se n1<=n2 e n1<=n3
entao n1<-10
senao se n2<=n1 e n2<=n3
entao n2<-10
senao n3<-10
fimse
fimse
se n1>0 e n2>0 e n3>0
entao mx<- 3/(1/n1+1/n2+1/n3)
senao mx<-0
fimse
n1<-m1 n2<-m2 n3<-m3
se mx>=6
entao
leia(n4)
se n1<=n2 e n1<=n3
entao n1<-n4
senao se n2<=n1 e n2<=n3
entao n2<-n4
senao n3<-n4
fimse
fimse
se n1=0 ou n2=0 ou n3=0
entao media<-0
senao media<-3/(1/n1+1/n2+1/n3)
fimse
fimse
fimse
escreva(media)
se media<6
entao escreva(0)
senao se media <7
entao escreva(1)
senao se media<8
entao escreva(2)
senao se media<9
entao escreva(3)
senao escreva(4)
fimse
fimse
fimse
fimse
fimalgoritmo
C00000660 - Faa um algoritmo que leia 4 valores, Hi, Mi, Hf, Mf, representando
respectivamente a hora e minuto inicial e final de um evento, e calcule a
durao do mesmo em horas e minutos. Considere que o evento pode iniciar em um
dia e terminar no dia seguinte.
C00000700 - As tarifas de um estacionamento so definidas assim: A primeira e a
segunda hora custam 5 reais cada. A terceira e a quarta hora custam 2 reais
cada. A partir da quinta hora, cada hora custa 1 real cada. Assim, se um carro
ficar 5 horas no estacionamento, o motorista pagar 15 reais (5+5+2+2+1). Faa
um algoritmo que leia dois valores He e Hs, respectivamente a hora de entrada e
sada no estacionamento (horas inteiras, sem minutos), e escreva o valor a ser
pago. Considere que o
C00000750 - Faa um algoritmo que leia, para duas barras de ouro, o seu peso e
seu valor. O algoritmo deve ler tambm o limite de peso de uma mochila, e
verificar e escrever que barra (s) devem ir na mochila de modo a maximizar o
valor dentro dela, sem exceder seu limite de peso. O algoritmo deve escrever:
0 - Se nenhuma das barras puder ser colocada na mochila sem exceder o limite de
peso
1 - Se apenas a barra 1 puder ir na mochila
2 - Se apenas a barra 2 puder ir na mochila
3 - Se ambas as barras puderem ir na mochila simultaneamente
var p1,v1,p2,v2,ps:real
inicio
leia(p1,v1,p2,v2,ps)
se p1+p2<=ps
entao escreva(3)
senao se p1>ps e p2>ps
entao escreva(0)
senao se p1<=ps e p2>ps
entao escreva(1)
senao se p2<=ps e p1>ps
entao escreva(2)
senao se v1>=v2
entao escreva(1)
senao escreva(2)
fimse
fimse
fimse
fimse
fimse
fimalgoritmo
C00000800 - Faa um algoritmo que leia 4(quatro) valores e escreva os 3 (tres)
maiores em ordem decrescente. Considere que podem ocorrer valores iguais.
C00000810 - O nmero 3025 tem a seguinte caracterstica: 30+25=55 e 55^2=3025.
Faa um algoritmo que leia um nmero de quatro dgitos e verifique se tem essa
caracterstica, escrevendo:
0 - se no tem essa caracterstica;
1 - se tem essa caracterstica.
var a,b,N:inteiro
inicio
leia(N)
a<-N\100
b<-N%100
a<-a+b
se a^2=N entao escreva(1)
senao escreva(0)
fimse
fimalgoritmos
C00000850 - Faa um algoritmo que leia as trs dimenses (largura, comprimento e
altura) de duas caixas, e verifique se a primeira caixa pode ser colocada dentro
da segunda, escrevendo 1 se possvel coloc-la, e 0 se no possvel.
Considere que as caixas no podem ser rotacionadas em nenhuma direo.
Dica: Para que uma caixa caiba na outra, cada dimenso dela deve ser menor (no
pode ser igual ou maior) que a dimenso correspondente na segunda caixa
C00000860 - Faa um algoritmo que leia as trs dimenses (largura, comprimento e
altura) de duas caixas, e verifique se a primeira caixa pode ser colocada dentro
da segunda, escrevendo 1 se possvel coloc-la, e 0 se no possvel.
Considere que as caixas podem ser rotacionadas em qualquer direo.
algoritmo
var l1,c1,a1,l2,c2,a2:real
inicio
leia(l1,c1,a1,l2,c2,a2)
se (l1<l2 e c1<c2 e a1<a2) ou
(l1<l2 e c1<a2 e a1<c2) ou
(l1<a2 e c1<c2 e a1<l2) ou
(l1<a2 e c1<l2 e a1<c2) ou
(l1<c2 e c1<l2 e a1<a2) ou
(l1<c2 e c1<a2 e a1<l2)
entao escreva(1)
senao escreva(0)
fimse
fimalgoritmos
C00000865 - Uma fbrica produz um recipiente de plstico com sua tampa (tambm
de plstico). Ambos os componentes utilizam o mesmo equipamento para fabricao
(ou seja, no podem ser fabricados ao mesmo tempo). A fabricao do recipiente
consome duas horas; a fabricao a tampa consome meia hora. Um cliente deseja o
mximo de recipientes (com tampa) para 10 dias. A fbrica trabalha 24 horas/dia
e j dispe de uma quantidade r de recipientes e t de tampas em seu estoque (no
necessariamente iguais). Faa um algoritmo que leia os valores de r e t e
informe o mximo de conjuntos recipiente-tampa que ela pode fornecer em 10 dias.
Dica:Considere 3 casos: os nmeros de recipientes e de tampas no estoque so
iguais; os nmeros de recipientes e de tampas no estoque so diferentes e H
tempo para igual-los; os nmeros de recipientes e de tampas no estoque so
diferentes e NO H tempo para igual-los (para as duas ltimas situaes, deve-
se analisar separadamente o que h a mais).
var r,t,vm,tr:real
inicio
escreva ("escreva o nmero de recipientes e tampas")
leia (r,t)
se r=t
entao vm <- (r+96)
senao se r<t
entao se (t-r)<=120
entao
tr <- 240-((t-r)*2)
vm <- t + (2*tr/5)
senao vm <- 120 + r
fimse
senao se (r-t)<=480
entao tr <- 240-((r-t)/2)
vm <- r + (2*tr/5)
senao vm <- 480 + t
fimse
fimse
fimse
escreva("O Valor mximo de produtos "," ",vm)
fimalgoritmo
C00000866 - Faa um algoritmo que leia a data de nascimento de uma pessoa e a
data atual (cada data com dia, ms e ano). O algoritmo deve escrever 1 se a
pessoa maior de idade, e 0 se ela menor de idade (maioridade: 18 anos).
C00000900 - Faa um algoritmo que leia para um trabalhador o valor que ganha por
hora, a hora de entrada e a hora de sada (valores inteiros, sem minutos) e
calcule quanto ele ganhou pelo turno. Considere que ele entra e sai no mesmo
dia.
dia, e que as horas a partir das 20:00 valem 20% a mais (adicional noturno).
dia, e que as horas antes das 6:00 da manh e a partir das 20:00 valem 20% a
mais (adicional noturno).
calcule quanto ele ganhou pelo turno. Considere que ele pode entrar em um dia e
sair no outro, mas que o total de horas trabalhadas no excede 23 horas.
sair no dia seguinte, e que se ele permanecer mais do que 8 horas, as duas horas
a partir da nona hora valem 20% a mais, e as horas a partir da dcima primeira
hora valem 50% a mais (horas extras).
Considere que as horas a partir das 20:00 valem 20% a mais (adicional noturno).
Considere tambm que as horas antes das 6:00 da manh e a partir das 20:00 valem
20% a mais (adicional noturno).
C00001500 - Faa um algoritmo que leia 5 valores entre 1 e 6, j ordenados,
correspondente ao arremesso de 5 dados no jogo do general, e escreva:
1 - Se os 5 valores s o iguais
2 - Se h 4 valores iguais e um diferente
3 - Se os 5 valores formam uma sequncia (1,2,3,4,5 ou 2,3,4,5,6)
4 - Se os valores formam um full-hand (3 valores iguais entre si, e os outros
dois valores tambm iguais entre si)
5 - Nenhuma das combinaes acima
C00001550 - Faa um algoritmo que leia trs valores Dia, Ms e Ano, e verifique
se formam uma data vlida. O algoritmo deve escrever 1 se a data for vlida, 0
em caso contrrio. Considere que ano bissexto aquele divisvel por 4 e que
abril, junho, setembro e novembro tem 30 dias, fevereiro tem 28 (29 em ano
bissexto) e todos os outros meses tem 31 dias.
C00001600 - Faa um algoritmo que leia a data de nascimento de uma pessoa e a
data atual, cada uma com dia, ms e ano, e escreva quantos anos completos a
pessoa tem.
C00001700 - Escreva um algoritmo que leia duas datas, cada uma composta de Dia,
Ms e Ano, e as escreva em ordem cronolgica crescente. Ex:se as datas so
01/04/2000 e 17/05/1988, o algoritmo deve escrever 17/05/1988 01/04/2000.
C00001750 - Escreva um algoritmo que leia trs datas, cada uma composta de Dia,
Ms e Ano, e as escreva em ordem cronolgica crescente. Ex:se as datas so
01/04/2000, 17/05/1988 e 23/10/1969, o algoritmo deve escrever 23/10/1969
17/05/1988 01/04/2000.
C00001790 - Escreva um algoritmo que leia uma data, composta por dia, ms e ano,
e verifique se a data corresponde ao ltimo dia do ms, escrevendo 1, se for o
ltimo dia do ms, e 0 se no for o ltimo dia do ms. Considere, para
simplificar o problema, que ano bissexto aquele divisvel por 4, e que
fevereiro tem 28 dias (29 em ano bissexto), setembro, abril, junho e novembro
tm 30 dias e todos os outros meses tem 31 dias.
e escreva a data correspondente ao dia seguinte. Considere, para simplificar o
problema, que ano bissexto aquele divisvel por 4, e que fevereiro tem 28 dias
(29 em ano bissexto), setembro, abril, junho e novembro tm 30 dias e todos os
outros meses tem 31 dias.
e escreva quantos dias passaram-se desde o incio do ano. Considere, para
simplificar o problema, que ano bissexto aquele divisvel por 4, e que
fevereiro tem 28 dias (29 em ano bissexto), setembro, abril, junho e novembro
tm 30 dias e todos os outros meses tem 31 dias.
C00001900 - Para enviar uma carta so necessrios um selo e um envelope. O selo
custa 12 centavos e o envelope custa 5 centavos. Faa um algoritmo que leia uma
quantia inicial de selos, envelopes e centavos, e escreva o nmero de cartas que
podem ser enviadas com esses selos, envelopes e centavos (utilizando-os para
comprar mais selos e envelopes). Considere que no possvel converter selos ou
envelopes em dinheiro.
C00001925 - Para enviar uma carta so necessrios um selo e um envelope. O selo
custa 12 centavos e o envelope custa 5 centavos. Faa um algoritmo que leia uma
quantia inicial de selos, envelopes e dinheiro (em reais), e escreva o nmero de
cartas que podem ser enviadas com esses selos, envelopes e centavos (utilizando-
os para comprar mais selos e envelopes). Escreva tambm, nessa ordem, a
quantidade de selos, envelopes e dinheiro (em centavos), que restar aps
enviadas as cartas. Considere que no possvel converter selos ou envelopes em
dinheiro.
C00001950 - Uma fbrica produz um recipiente de plstico com sua tampa (tambm
de plstico). Ambos os componentes utilizam o mesmo equipamento para fabricao
(ou seja, no podem ser fabricados ao mesmo tempo). A fabricao do recipiente
consome duas horas; a fabricao da tampa consome meia hora. Um cliente deseja
o mximo de recipientes (com tampa) para 10 dias. A fbrica trabalha 24
horas/dia e j dispe de uma quantidade r de recipientes e t de tampas em seu
estoque (no necessariamente iguais). Faa um algoritmo que leia os valores de r
e t e informe o mximo de conjuntos recipiente-tampa que ela pode fornecer em 10
dias.
C00002000 - Em uma empresa existem 5 faixas de horrios 0-8 8-12 12-14 14-18
18-24, nas faixas 0-8 12-14 18-24 o valor pago por hora trabalhada dobrado.
Faa um algoritmo que leia o valor ganho por hora pelo funcionrio, a hora de
entrada e a hora de sada, e calcule e escreva o salrio deste empregado.
Considere que ele entra e sai no mesmo dia.
C00002001 - Em uma empresa existem 5 faixas de horrios 0-8 8-12 12-14 14-18
18-24, nas faixas 0-8 12-14 18-24 o valor pago por hora trabalhada dobrado.
Faa um algoritmo que leia o valor que o funcionrio ganha por hora, a hora de
entrada e a hora de sada, calcule e escreva o salrio deste empregado. (Pode
entrar em um dia e sair no outro, mas no pode trabalhar mais de 23 horas)
C00002100 - A distncia entre dois pontos definidos pelas coordenadas (X1,Y1) e
(X2,Y2) dada por raizq((X1-X2)^2+(Y1-Y2)^2). Faa um algoritmo que leia 8
valores representando as coordenadas X e Y de 4 pontos e verifique se os pontos
formam um quadrado, escrevendo:
1 - se formam um quadrado;
0 - se no formam.
Considere que os pontos so lidos no sentido horrio, seguindo o permetro do
quadrado.
C00002150 - Faa um algoritmo que leia oito valores correspondentes s
coordenadas dos quatro vrtices de um quadriltero convexo no espao cartesiano
(X0,Y0, X1,Y1, X2,Y2, X3,Y3). O algoritmo deve identificar o tipo de polgono
formado escrevendo: 1 - se os 4 pontos formam um quadrado. 2 - se formam um
retngulo; 3 - se formam um losango; 4 - se formam um paralelograma; 5 - se
formam um papagaio (2 pares de lados adjacentes iguais. Ex: lados de tamanhos
3,3,4 e 4); 6 - se no formam nenhum dos anteriores. A distncia (tamanho dos
lados) entre dois pontos quaisquer (Xi,Yi) e (Xj,Yj) pode ser obtida atravs da
frmula distXiYiXjYj = raizq((Xi-Xj)^2 + (Yi-Yj)^2). Por exemplo, se os pontos
lidos foram (3,2), (0,5), (3,8) e (6,5), a figura formada um quadrado e o
algoritmo escreve 1. Para que a figura seja um quadrado, os comprimentos das
duas diagonais devem ser iguais, bem como os 4 lados. Se os pontos lidos foram
(4,2), (1,4), (4,6) e (7,4), a figura formada um losango. Se os pontos lidos
foram (2,3), (0,5), (3,8) e (5,6), a figura formada um retngulo. Se os pontos
lidos foram (7,3), (0,3), (2,5) e (5,5), a figura formada um trapzio e o
algoritmo escreve 6 (ao menos um lado diferente dos demais). Os pontos so
fornecidos em sentido horrio ao longo do permetro do quadriltero.
C00003000 - Escreva um algoritmo que leia dois valores D e DS, correspondentes a
um dia do mes, e ao dia da semana que corresponde a ele (1-domingo 2-segunda 3-
tera 4-quarta 5-quinta 6-sexta 7-sbado). Calcule e escreva em que dia da
semana caiu o dia primeiro do ms do dia digitado.
Exemplo: dia 10 no ms e 3 (tera) na semana. Resposta 1 (domingo)
Exemplo: dia 30 no ms e 4 (quarta) na semana. Resposta 3 (tera feira)
C00003100 - Faa um algoritmo que leia as dimenses (altura, largura e
profundidade) de duas caixas e verifique se a primeira caixa pode ser colocada
dentro da segunda. Considere que as caixas podem ser rotacionadas em qualquer
direo. Se a primeira caixa couber dentro da segunda escreva 1, caso contrrio
escreva 0.
C00003200 - Faa um algoritmo que leia dois nmeros de trs dgitos cada um, e
verifique se possuem os mesmos dgitos. Considere que pode haver dgitos
repetidos em um nmero, e que a cada dgito de um nmero deve corresponder
exatamente um dgito do outro nmero. Assim, os nmeros 221 e 112 no tem os
mesmos dgitos, porque apesar de ambos terem somente os dgitos 1 e 2, aos dois
dgitos 2 do primeiro nmero corresponde o mesmo dgito no segundo nmero. O
algoritmo deve escrever 1, caso os nmeros tenham os mesmos dgitos, e 0 em caso
contrrio.
C00003250 - Faa um algoritmo que leia um nmero de trs dgitos e escreva o
maior nmero que possui os mesmos dgitos do nmero lido. Se um dgito aparecer
repetido no nmero lido, deve ser repetido o mesmo nmero de vezes no nmero
gerado.
C00003300 - Faa um algoritmo que leia 4 valores X1,Y1,X2,Y2, correspondendo s
coordenadas do canto inferior esquerdo e canto superior direito de uma regio
retangular no plano. Leia a seguir dois valores X,Y correspondendo a um ponto no
plano e escreva: 0 - Se o ponto est fora da regio retangular; 1 - Se o ponto
est dentro da regio retangular; 2 - Se o ponto est exatamente na borda da
regio retangular.
C00003400 - Faa um algoritmo que leia um nmero de 8 dgitos e verifica se ele
palndromo. Ou seja, se a leitura da direita para a esquerda igual a leitura
da esquerda para a direita. Escrever 0 se for palndromo e 1 se no for.
C00003500 - Um nmero primo se divisvel somente por ele mesmo e por 1. Faa
um algoritmo que leia um nmero inteiro entre 2 e 100 e determine se ele ou
no um nmero primo escrevendo 1, se for primo, e 0 em caso contrrio.
C00003600 - Faa um algoritmo que leia 6 valores inteiros e escreva ao final a
quantidade de valores mpares lidos, e a soma dos valores pares lidos.
C0003650 - A locadora S Filmassos classifica os filmes em "lanamentos" e
"acervo", sendo que a diria do lanamento 5 reais e a diria do acervo 3
reais. A locadora est com uma promoo, ao locar 2 lanamentos o cliente tem
direito a um filme de acervo grtis. Faa um algoritmo que leia a quantidade de
lanamentos e a quantidade de filmes de acervo a serem locados, e calcule o
valor (mnimo) a ser pago.
C00003700 - A locadora S Filmassos classifica os filmes em "lanamentos" e
"acervo", sendo que a diria do lanamento 5 reais e a diria do acervo 3
reais. A locadora est com uma promoo, ao locar 2 lanamentos o cliente tem
direito a um filme grtis, podendo ser de acervo ou lanamento. Faa um
algoritmo que leia a quantidade de lanamentos e a quantidade de filmes de
acervo a serem locados, e calcule o valor (mnimo) a ser pago.
Iterativos
I00000100 - Faa um algoritmo que escreva os nmeros 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 - Faa um algoritmo que escreva todos os nmeros pares entre 1 e 50.
var i:inteiro
inicio
i<-2
enquanto i<=50 faca
escreva(i)
i<-i+2
fimenquanto
fimalgoritmo
I00000300 - Faa um algoritmo que escreva todos os nmeros entre 1 e 200 que so
mltiplos de 11.
var i:inteiro
inicio
i<-1
enquanto i<=200 faca
se i%11=0
entao escreva(i)
fimse
i<-i+1
fimenquanto
fimalgoritmo
I00000400 - Faa um algoritmo que leia 10 nmeros e escreva os que forem pares.
Dica: Um nmero inteiro par se o resto da sua diviso inteira por 2 igual a
0.
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 - Faa um algoritmo que leia nmeros at que seja digitado um nmero
negativo, e escreva todos que forem pares.
var a:inteiro
inicio
leia (a)
enquanto a>=0 faca
se a%2=0
entao escreva(a)
fimse
leia (a)
fimenquanto
fimalgoritmo
I00000600 - Faa um algoritmo que leia 30 valores e conte quantos esto no
intervalo [10,20], escrevendo ao final essa informao.
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
Faa um algoritmo que leia 30 valores e conte quantos esto em cada um dos
intervalos [0,25],(25,50], (50,75], (75..100], escrevendo ao final essa
informao.
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 - Faa um algoritmo que leia um valor N. Escreva a seguir os nmeros
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 - Faa 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 - Faa 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 - Faa um algoritmo que leia um valor N, e conte quantos divisores
possui, escrevendo ao final essa informao.
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 - Faa 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 - Faa um algoritmo que leia um valor N inteiro e maior do que 1, e
calcule e escreva o seu maior divisor (excetuando N).
var i,n:inteiro
inicio
leia(n)
i<-n-1
enquanto n%i<>0 faca
i<-i-1
fimenquanto
escreva(i)
fimalgoritmo
I00001155 - Faa 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.
var i,n:inteiro
inicio
leia(n)
i<-2
enquanto n%i<>0 faca
i<-i+1
fimenquanto
escreva(i)
fimalgoritmo
I00001200 - Um nmero inteiro maior do que 1 primo se ele possui como
divisores somente o 1 e ele mesmo. Faa um algoritmo que leia um nmero e
verifique se primo escrevendo: 1 - se o nmero primo; 0 - se o nmero no
primo. Dica:Pode-se tambm verificar se um nmero primo encontrando seu
primeiro divisor maior que 1. Se o primeiro divisor for o prprio nmero, 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 nmeros n1 e n2 so ditos amigos entre si se a soma dos
divisores de n1 (excluindo o prprio n1) igual a n2, e a soma dos divisores de
n2 (excluindo o prprio n2) igual a n1. Ex: 220 e 284. Faa um algoritmo que
leia 2 valores e verifique se so amigos entre si escrevendo: 1 - se so amigos;
0 - se no so 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 - Faa um algoritmo que leia 10 nmeros 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 - Faa um algoritmo que leia 10 nmeros, positivos ou negativos, e
escreva ao final o maior deles.
algoritmo
var a,i,maior:inteiro
inicio
leia(maior)
leia(a)
se a>maior
entao maior<-a
fimse
fimpara
escreva(maior)
fimalgoritmo
I00001600 - Faa um algoritmo que leia 10 nmeros e escreva ao final o maior e o
menor deles.
algoritmo
var a,i,maior,menor:inteiro
inicio
leia(maior)
menor<-maior
leia(a)
se a>maior
entao maior<-a
fimse
se a<menor
entao menor<-a
fimse
fimpara
escreva(maior,menor)
fimalgoritmo
I00001610 - Faa um algoritmo que leia um valor n (n>=1) correspondente ao
nmero de alunos de uma turma. Aps, o algoritmo l as notas das provas dos n
alunos dessa turma. As notas devero ser lidas at que sejam informadas n notas
vlidas, ou seja, no intervalo [0, 10], descartando as notas fora desse
intervalo. As notas somente podero 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 no , 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.
var n,x,cont1,cont2,porcent,menor:real
inicio
escreval("Digite um numero")
leia(n)
se n=1
entao
cont2 <- 1
escreva("Digite a nota")
leia(menor)
senao repita
escreval("Digite a nota")
leia(menor)
ate menor>=0 E menor<=10
cont1 <- 1
cont2 <- 1
repita
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
ate cont1=n
fimse
porcent <- (cont2/n)*100
escreva(menor,",",porcent)
fimalgoritmo
I00001700 - Faa 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
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 relao
peso/(altura^2). Faa 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
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 - Faa um algoritmo que leia o cdigo e a votao de cada um dos
candidatos a uma vaga no senado, at que o cdigo digitado seja 0 (no dever
ser lida a votao neste caso). O algoritmo deve escrever os cdigos e as
votaes dos dois senadores eleitos (assuma que no havero trs candidatos com
igual votao e que seja a maior votao).
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 - Faa um algoritmo que leia 10 nmeros 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<-1
rn<-raizq(n)
repita
i<-i+1
ate n%i=0 ou i>rn
se i>rn
entao escreva(n)
fimse
fimpara
fimalgoritmo
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
leia(n)
se primo(n)=1
entao escreva(n)
fimse
fimpara
fimalgoritmo
I00001950 - Faa um algoritmo que escreva os 50 primeiros nmeros primos.
algoritmo
var n,cont:inteiro
var d:inteiro
inicio
d<-2
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 - Faa um algoritmo que leia 2 nmeros N1 e N2 e escreva a soma dos
nmeros 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
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
var d:inteiro
inicio
d<-2
d<-d+1
fimenquanto
se n=d
entao retorne 1
senao retorne 0
fimse
fimfuncao
inicio
leia (n1,n2)
soma<-0
se primo(n)=1
entao soma<-soma+n
fimse
fimpara
escreva(soma)
fimalgoritmo
I00002100 - Faa um algoritmo que leia 2 nmeros N1 e N2 e escreva o produto dos
nmeros 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
cont<-0
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
var d:inteiro
inicio
d<-2
d<-d+1
fimenquanto
se n=d
entao retorne 1
senao retorne 0
fimse
fimfuncao
inicio
leia (n1,n2)
prod<-1
se primo(n)=1
entao prod<-prod*n
fimse
fimpara
escreva(prod)
fimalgoritmo
I00002200 - Faa um algoritmo que leia um nmero N e escreva os N primeiros
nmeros primos maiores que 100.
algoritmo
var n,i,cont,quant:inteiro
inicio
leia(quant)
n<-101
repita
cont<-0
se n%i=0
entao cont<-cont+1
fimse
fimpara
se cont<=2
entao escreva(n)
quant<-quant-1
fimse
n<-n+1
ate quant=0
fimalgoritmo
algoritmo
var n,cont,p:inteiro
var d:inteiro
inicio
d<-2
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 - Faa um algoritmo que leia um nmero inteiro N e escreva o maior
nmero primo menor do que N.
var N,d:inteiro
inicio
leia(N)
repita
d<-1
N<-N-1
repita
d<-d+1
ate n%d=0
ate n=d
escreva(N)
fimalgoritmo
algoritmo
var n:inteiro
var d:inteiro
inicio
d<-2
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 - Faa um algoritmo que leia um nmero inteiro N e escreva o menor
nmero primo maior do que N.
var N,d:inteiro
inicio
leia(N)
repita
N<-N+1
d<-2
enquanto N%d<>0 faca
d<-d+1
fimenquanto
ate d=N
escreva(N)
fimalgoritmo
algoritmo
var n:inteiro
var d:inteiro
inicio
d<-2
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 nmero primo um nmero natural maior que 1, que divisvel
somente por 1 e por ele mesmo. Faa um algoritmo que leia um nmero inteiro N e
escreva o nmero mais prximo a ele. Se N for primo, considere que o mais
prximo o prprio N. Se houver dois nmeros mesma distncia, escreva os dois
em ordem crescente.
var N,A,B,i,fim:inteiro
inicio
leia(N)
i<-1
repita
i<-i+1
ate N%i=0
se N=i
entao escreva(N)
senao fim<-0
A<-N-1
B<-N+1
repita
se A>1
entao i<-1
repita
i<-i+1
ate A%i=0
se i=A
entao escreva(A)
fim<-1
fimse
fimse
se B>1
entao i<-1
repita
i<-i+1
ate B%i=0
se i=B
entao escreva(B)
fim<-1
fimse
fimse
A<-A-1
B<-B+1
ate fim=1
fimse
fimalgoritmo
algoritmo
var n,p1,p2:inteiro
var d:inteiro
inicio
d<-2
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 nmero par maior que 2 pode
ser representado como a soma de dois nmeros primos. Assim, 4=2+2, 6=3+3,
8=3+5... Faa um algoritmo que leia um nmero N, par, e escreva, em ordem
crescente, os dois nmeros primos que o compem. No caso de haver mais de um par
de nmeros (p.ex:20=3+17 e 20=7+13) escreva o par que tiver o menor nmero
primo.
var d1,d2,achei,i,n:inteiro
inicio
leia(n)
d1<-2
achei<-0
repita
i<-1
repita
i<-i+1
ate d1%i=0
se d1=i
entao d2<-n-d1
i<-1
repita
i<-i+1
ate d2%i=0
se d2=i entao
escreva(d1,d2)
achei<-1
fimse
fimse
d1<-d1+1
ate achei=1
fimalgoritmo
algoritmo
var n,p1:inteiro
var d:inteiro
inicio
d<-2
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 nmero perfeito o nmero que igual soma de seus divisores,
exceto o prprio nmero (ex: 6 = 1 + 2 + 3. Faa um algoritmo que leia 10
nmeros e verifique para cada um se perfeito ou no, escrevendo: 1 - se o
nmero perfeito; 0 - se o nmero no perfeito.
algoritmo
var n,i,j,soma:inteiro
inicio
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 - Faa um algoritmo que leia, para um funcionrios: o valor que ganha
por hora e 30 pares de valores (hora de entrada e hora de sada, inteiros, sem
minutos) e calcule o quanto ganhou no ms. O funcionrio no pode trabalhar mais
de 23 horas seguidas e pode iniciar em um dia e terminar no dia seguinte. Para o
funcionrio deve ser escrito o quanto ganhou no ms.
I00002400 - Faa um algoritmo que leia, para um nmero no determinado de
funcionrios, seu cdigo (inteiro), o valor que ganha por hora e 30 pares de
valores (hora de entrada e hora de sada, inteiros, sem minutos) e calcule o
quanto ganhou no ms. O funcionrio no pode trabalhar mais de 23 horas seguidas
e pode iniciar em um dia e terminar no dia seguinte. Para cada funcionrio deve
ser escrito seu cdigo e o quanto ganhou no ms. O algoritmo termina ao ser
digitado um cdigo igual a -1 (aps o que, no 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
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 srie de fibonacci uma sequncia de nmeros que inicia por 0 e
1, e a partir do terceiro valor cada nmero dado pela soma dos dois
anteriores. Assim, os 10 primeiros termos da srie so: 0, 1, 1, 2, 3, 5, 8, 13,
21, 34. Faa um algoritmo que escreva os 100 primeiros termos da srie de
fibonacci.
algoritmo
var a,b,s,i:inteiro
inicio
a<-0
b<-1
escreval(a," ",b)
s<-a+b
escreval(s)
a<-b
b<-s
fimpara
fimalgoritmo
I00002525 - A sequncia de Fibonacci formada pelos nmeros: 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; ...
Faa um algoritmo que leia um nmero (N) e escreva o ensimo nmero da srie 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 sequncia de fibonacci uma sequncia de nmeros que inicia por 0
e 1, e a partir do terceiro valor cada nmero dado pela soma dos dois
anteriores. Assim, os 10 primeiros termos da srie so: 0, 1, 1, 2, 3, 5, 8, 13,
21, 34. Faa um algoritmo que escreva entre os 20 primeiros termos da srie de
fibonacci apenas os que so primos.
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 (mximo divisor comum) entre dois nmeros n1 e n2 o maior
nmero que divisor de n1 e de n2. Faa um algoritmo que leia dois nmeros 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 nmero N (representado por N!) o produto de todos
os nmeros de 1 a N. Assim, 4! = 1 x 2 x 3 x 4 = 24. Faa um algoritmo que leia
um nmero N e escreva seu fatorial.
algoritmo
var n,fat,i:inteiro
inicio
leia(n)
fat<-1
fat<-fat*i
fimpara
escreva(fat)
fimalgoritmo
I00002750 - O nmero de combinaes de N diferentes objetos em grupos de P
objetos, dado por N!/(P!(N-P)!). Faa 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
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 - Faa 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
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 (mnimo mltiplo comum) entre dois nmeros n1 e n2 o menor
nmero que mltiplo de n1 e de n2. Faa um algoritmo que leia dois nmeros 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 - Faa um algoritmo que leia um nmero N e efetue sua fatorao,
escrevendo os fatores que o compem. 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
repita
se n%d=0
entao escreva(d)
n<-n\d
senao d<-d+1
fimse
ate n=1
fimalgoritmo
I00003050 - Faa um algoritmo que leia um nmero e escreva seus dgitos na ordem
contrria em que aparecem no nmero. Por exemplo, se o numero lido foi 32417, o
algoritmo escreve 7,1,4,2,3.
I00003100 - Faa um algoritmo que leia 10 nmeros e para cada um escreva a soma
dos seus dgitos formantes.
algoritmo
var i,soma,n:inteiro
inicio
leia(n)
soma<-0
repita
soma<-soma+n%10
n<-n\10
ate n=0
escreva(soma)
fimpara
fimalgoritmo
I00003200 - Faa um algoritmo que leia um nmero N e o escreva com seus dgitos
invertidos.
algoritmo
var soma,n:inteiro
inicio
leia(n)
soma<-0
repita
soma<-soma*10+n%10
n<-n\10
ate n=0
escreva(soma)
fimalgoritmo
I00003300 - Faa um algoritmo que leia um nmero N at (at 9 dgitos) e retira
os dgitos impares.
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 - Faa um algoritmo que leia nmeros at que seja fornecido um nmero
negativo. O algoritmo deve escrever a mdia aritmtica dos 3 ltimos nmeros
fornecidos (excetuando o negativo indicando fim da sequncia).
I00003400 - Faa um algoritmo que leia um nmero N at 100.000.000 e verifique
se palndromo, ou seja, se se igual quando lido da esquerda para a direita e
da direita para a esquerda. Ex: 13731. Escreva 1 se for palndromo e 0 se no
for.
algoritmo
var soma,n,naux:inteiro
inicio
leia(n)
naux<-n
soma<-0
repita
soma<-soma*10+n%10
n<-n\10
ate n=0
se naux=soma
entao escreva(1)
senao escreva(0)
fimse
fimalgoritmo
I00003500 - Faa um algoritmo que escreva os primeiros 20 nmeros cuja soma dos
dgitos formantes 10.
algoritmo
var cont,n,a,s:inteiro
inicio
cont<-0
n<-1
repita
a<-n
s<-0
repita
s<-s+a%10
a<-a\10
ate a=0
se s=10
entao escreva(n)
cont<-cont+1
fimse
n<-n+1
ate cont=20
fimalgoritmo
I00003600 - Uma pessoa aplicou um determinado valor em um banco. Sabe-se que o
banco pagar 5% ao ms de juros. Fazer um algoritmo que leia o valor aplicado e
calcule e escreva a quantidade mnima de meses necessrios 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 ms ter
var valor,valinic,m:real
inicio
leia(valor)
valinic<-valor
m<-0
repita
m<-m+1
valor<-valor * 1.05
ate valor-valinic>=1000
escreva(m)
fimalgoritmo
I00003700 - Faa um algoritmo que leia 20 nmeros inteiros e escreva quantos
nmeros so iguais ao menor nmero 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
leia(n)
se n=menor
entao cont<-cont+1
senao se n<menor
entao menor<-n
cont<-1
fimse
fimse
fimpara
escreva(cont)
fimalgoritmo
I00003800 - Data juliana o nmero 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 divisvel 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 - Faa um algoritmo que leia duas datas, cada uma formada por dia, ms
e ano, e escreva o nmero de dias entre as duas, incluindo a data inicial e a
data final. Considere que ano bissexto aquele divisvel 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 - Faa um algoritmo que leia duas datas, cada uma formada por dia, ms
e ano, e escreva todas as datas entre as duas, incluindo a data inicial e a data
final. Considere que ano bissexto aquele divisvel por 4. Considere tambm que
a data inicial menor ou igual data final.
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 - Faa um algoritmo que leia 4 valores d,m,a,ds, onde d,m,a
representam uma data (dia,ms,ano) e ds representa um dia da semana (1-domingo,
2-segunda, 3-tera, 4-quarta, 5-quinta, 6-sexta, 7-sbado), e escreva as datas
das prximas 3 sextas-feiras 13, a partir da data digitada, incluindo a prpria
data, se for o caso. Considere que ano bissexto o ano divisvel por 4.
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 - Faa um algoritmo que leia o ms e o ano de uma sexta-feira 13 e
escreva o ms e ano das prximas 5 ocorrncias de sexta-feira 13. Considere que
ano bissexto o ano divisvel por 4.
algoritmo
var d,m,a,cont:inteiro
inicio
leia(m,a)
d<-13
cont<-0
repita
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
senao se d>30 e (m=4 ou m=6 ou m=9 ou m=11)
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
ate cont=5
fimalgoritmo
I00004000 - Faa um algoritmo que calcule e escreva a soma dos 100 primeiros
termos da sequncia a seguir: 1+3+5+7+9....
algoritmo
var termo,soma,i:inteiro
inicio
soma<-0
termo<-1
soma<-soma+termo
termo<-termo+2
fimpara
escreva(soma)
fimalgoritmo
I00004100 (no est no portal porque o resultado real)
Faa um algoritmo que calcule e escreva a soma dos 100 primeiros termos da
sequncia a seguir: 1/1 + 1/3 + 1/5 + 1/7 + 1/9 +...
Faa um algoritmo que leia um valor X e calcule e escreva a soma dos 100
primeiros termos da sequncia a seguir: X/1 + X/3 + X/5 + X/7 + X/9 +...
Faa um algoritmo que leia um valor X e calcule e escreva a soma dos 100
primeiros termos da sequncia a seguir: X/1 - X/3 + X/5 - X/7 + X/9 -...
Faa um algoritmo que leia um valor N e escreva a soma dos N primeiros termos da
srie a seguir:
1/2 + 1/3 + 1/5 + 1/7 + 1/11 + 1/13 + 1/17... ou seja, a srie onde os
denominadores so os nmeros primos
I00004500 - Um nmero piramidal um nmero que igual soma de 3 nmeros
primos consecutivos (ex: 15 = 3 + 5 + 7). Faa um algoritmo que leia um valor N
e escreva os 10 primeiros nmeros piramidais maiores ou iguais a N.
var
min,p2,p3,n,pir,cont,cd,i:inteiro
inicio
leia(min)
p2<-3
p3<-5
n<-7
cont<-0
repita
cd<-0
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
ate cont=10
fimalgoritmo
I00004600 - Faa um algoritmo que leia 30 nmeros. O algoritmo deve escrever ao
final a mdia dos nmeros pares digitados (soma dos pares dividido pela
quantidade de pares); quantos nmeros so primos e o produto (multiplicao) de
todos os nmeros lidos que so mltiplos de 5.
algoritmo
var qpar,qprim,somapar,i,n,cd,prod,j:inteiro
inicio
qpar<-0
qprim<-0
somapar<-0
prod<-1
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 - Faa um algoritmo que leia 20 nmeros e verifique qual a maior
sequncia estritamente crescente (isso , cada nmero maior que o anterior)
dentre os nmeros digitados, escrevendo ao final o primeiro e ltimo valor da
sequncia.
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
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 - Faa um algoritmo que leia uma sequncia de 20 nmeros e escreva: 0
- Se todos os nmeros so iguais; 1 - Se a sequncia no-decrescente (cada
nmero maior OU IGUAL ao anterior); 2 - se a sequncia estritamente
crescente (cada nmero MAIOR que o anterior); 3 - Se a sequncia no-
crescente (cada nmero menor OU IGUAL ao anterior); 4 - Se a sequncia
estritamente decrescente (cada nmero MENOR que o anterior); 5 - A sequncia
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)
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 - Faa um algoritmo que leia 15 nmeros e identifique a maior
sequncia de nmeros pares dentre os nmeros lidos, escrevendo ao final o
comprimento da sequncia identificada, bem como o primeiro e o ltimo valor da
sequncia. No caso de mais de uma sequncia 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
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 - Faa um algoritmo que leia a mdia e a quantidade de faltas para
cada aluno de um grupo de 20 alunos, e escreva ao final o percentual de alunos
aprovados. Os alunos sero considerados reprovados se no atingirem mdia 6.0.
Tambm sero reprovados os alunos que tiverem mais de 20 faltas. Os alunos com
uma quantidade de faltas entre 10 e 20 sero aprovados se obtiverem uma mdia
mnima de 7.5.
algoritmo
var i,f:inteiro
cont,m:real
inicio
cont<-0
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 - Faa um algoritmo que leia um nmero inteiro qualquer e escreva os
dgito desse nmero em ordem crescente do valor de cada dgito.
algoritmo
var n,dig,d,a:inteiro
inicio
leia(n)
para dig de 0 ate 9 faca
a<-n
repita
d<-a%10
se d=dig
entao escreva(d)
fimse
a<-a\10
ate a=0
fimpara
fimalgoritmo
I00005100 - Faa um algoritmo que leia um nmero inteiro qualquer e verifique se
possui algum dgito repetido escrevendo ao final: 0 - se ele no contem nenhum
dgito repetido; 1 - se ele contem algum dgito repetido.
algoritmo
var rep,n,dig,d,cont,a:inteiro
inicio
rep<-0
leia(n)
a<-n
cont<-0
repita
d<-a%10
se d=dig
entao cont<-cont+1
fimse
a<-a\10
ate a=0
se cont>1
entao rep<-1
fimse
fimpara
escreva(rep)
fimalgoritmo
I00005120 - Faa um algoritmo que leia um nmero inteiro e escreva quantas vezes
ocorre o dgito 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 - Faa um algoritmo que leia um nmero inteiro (mximo 5 casas - no
maior que 99999) e mostre quantos dgitos contem de cada nmero de 0 a 9
algoritmo
var N,M,dig,C:inteiro
inicio
leia(M)
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 - Faa um algoritmo que leia um nmero inteiro (mximo 5 casas - no
maior que 99999). Mostre o nmero que mais se repete. Em caso de empate, mostre
o menor deles.
var contmax,digmax,dig,naux,n,cont:inteiro
inicio
leia(naux)
contmax<-0
digmax<-0
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 nmero inteiro dito ascendente se cada um dos seus algaristmos
maior do que o algarismo imediatamente sua esquerda. Por exemplo, o nmero
3589. Faa um algoritmo que leia um nmero inteiro e verifique se ele ou no
ascendente escrevendo: 1 - se ele ascendente; 0 - se ele no ascendente.
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 - Faa um algoritmo que leia o dia e ms de uma data, e o dia da
semana (1 - domingo, 2 - segunda... 7 - sbado) e escreva o dia da semana
correspondente ao dia primeiro do ms 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 - Faa um algoritmo que leia um nmero de 8 dgitos e calcule a soma
ponderada dos seus dgitos, com peso 1 para o dgito menos significativo, peso 2
para o segundo dgito, peso 3 para o terceiro e assim por diante. Escreva a soma
calculada.
I00005400 - Faa um algoritmo que leia 20 nmeros e escreva a maior sequncia de
valores iguais entre os nmeros digitados.
I00005450 - Faa um algoritmo que leia um nmero inteiro positivo N no 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 nmero informado.
I00005500
Georg Cantor demonstrou que os nmeros racionais so enumerveis pela sequncia:
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
ensimo nmero dessa sequncia (escreva o numerador e o denominador).
I00005501
Georg Cantor demonstrou que os nmeros racionais so enumerveis pela sequncia:
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 ensimo nmero dessa sequncia (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
repita
pen<-ult
ult<- atu
atu <- (ult + X \ ult) \2
ate atu=pen
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 dgitos (999999999-99), dos quais os dois
ltimos so verificadores (controle), ou seja, a partir dos nove primeiros
dgitos pode-se determinar os ltimos dois. Considerando o CPF no formato
abcdefghi-jk, onde cada letra representa um dgito, pode-se:
- calcular o primeiro dgito verificador (j), da seguinte forma:
- somar: 10a + 9b + 8c + 7d + 6e + 5f + 4g + 3h + 2i
- encontrar o resto da diviso dessa soma por 11.
- se o resto for igual a zero ou um, o dgito zero, seno o dgito onze
menos esse resto.
- calcular o segundo dgito verificador (k):
- somar: 11a + 10b + 9c + 8d + 7e + 6f + 5g + 4h + 3i + 2j
- encontrar o resto da diviso dessa soma por 11.
- se o resto for igual a zero ou um, o dgito zero, seno o dgito onze
menos esse resto.
Fazer um algoritmo que leia o CPF (somente primeiros nove dgitos) e escreva
separadamente os verificadores (dois ltimos).
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 cdigo do curso que ele frequenta (1: engenharia;
2: computao; 3: administrao) e sua idade. Faa um algoritmo que processe
tais dados fornecendo: (a) nmero de alunos por curso; (b) nmero de alunos com
idade entre [20 25] anos por curso; e (c) cdigo do curso com a menor mdia de
idade.
Dica:So necessrios vrios contadores.
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
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
entao ci2<-ci2+1
fimse
s2<-s2+idade
senao c3<-c3+1
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 operao de diviso pode ser obtido subtraindo-se o
divisor do dividendo. Da diferena, subtramos novamente o divisor e assim
sucessivamente at que a diferena seja menor do que o divisor. A quantidade se
subtraes 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 nmero de subtraes 5. Logo, o quociente -5
(divisor e dividendo tm sinais diferentes). Faa um algoritmo que leia o
dividendo (0, positivo ou negativo) e o divisor (positivo ou negativo) e escreva
o quociente usando o algoritmo acima. NO deve ser usado o operador de diviso.
Dica: Registre, de alguma forma, os sinais dos operandos e transforme-os para
positivo.
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 operao de multiplicao, quando o multiplicador um nmero
inteiro, nada mais do que uma sucesso de somas. Assim, por exemplo,
4X5= 5+5+5+5= 20.
Escreva um algoritmo que leia o multiplicando e o multiplicador e, atravs de
uma sucesso de somas, calcule e escreva o produto. O multiplicador ,
necessariamente, um nmero inteiro. Porm, 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 nmero de subtraes 5. Logo, o quociente -5
(divisor e dividendo tm sinais diferentes). Faa um algoritmo que leia o
dividendo (0, positivo ou negativo) e o divisor (positivo ou negativo) e escreva
o quociente usando o algoritmo acima. NO deve ser usado o operador de diviso.
Dica: Registre, de alguma forma, os sinais dos operandos e transforme-os para
positivo.
I00005900 - Um nmero N dito um Meridiano Perfeito se existe um nmero M para
o qual a soma dos nmeros de 1 a N-1 igual soma dos nmeros de N+1 a M.
Assim, 6 um Meridiano Perfeito porque 1+2+3+4+5=7+8. Faa um algoritmo que
leia um nmero e verifique se um meridiano perfeito, escrevendo 1, se o nmero
um meridiano perfeito, e 0, se no 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
repita
M<-M+1
soma2<-soma2+M
ate soma2>=soma1
se soma2=soma1
entao escreva(1)
senao escreva(0)
fimse
fimalgoritmo
I00006000 - Um nmero N dito um Meridiano Perfeito se existe um nmero M para
o qual a soma dos nmeros de 1 a N-1 igual soma dos nmeros de N+1 a M.
Assim, 6 um Meridiano Perfeito porque 1+2+3+4+5=7+8. Faa 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 nmero dito regular, ou nmero de hamming (ou "5-smooth number"
ou "ugly number") se tem como fatores primos apenas 2, 3 e 5, ou seja,
divisvel somente por mltiplos de 2, 3 ou 5. Assim, os primeiros nmeros
regulares so 1 ( regular por definio, 2^0 * 3^0 * 5^0), 2, 3, 4, 5, 6, 8, 9,
10, 12, 15, 16, 18, 20, 24, 25, 27,30,32.... Faa um algoritmo que leia um
nmero N, menor ou igual a 100, e escreva os N primeiros nmeros 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
N1<-N1\3
fimenquanto
N1<-N1\5
fimenquanto
se N1=1
entao escreval(N)
i<-i+1
fimse
N<-N+1
fimenquanto
fimalgoritmo
I00006200 - Faa 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
sequncia, e escreva: 1 - se as cartas contem uma canastra; 0 - se no contem.
Considere como canastra apenas uma sequncia crescente de 7 cartas do mesmo
naipe de numerao contnua (cuja diferena entre duas cartas seja igual a 1).
Dica:Considere que podem ocorrer cartas de mesmo nmero e naipe (uso de mais de
um baralho). Nesse caso a carta de mesmo nmero e naipe no contada, mas no
quebra a sequncia.
algoritmo
var tem,vant,nant,seq,n,v,i:inteiro
inicio
tem<-0
leia(vant,nant)
seq<-1
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 - Faa um algoritmo que leia em sequencia "decrescente": O nmero de
uma carta (de 1 at 13) e seu naipe (de 1 at 4); Escreva a maior sequncia
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 sero
sequenciadas, no havendo necessidade de qualquer reorganizao ou armazenamento
de dados.
var v,n,vant,nant,seq,fim,i:inteiro
inicio
leia(vant,nant)
escreval(vant," ",nant)
seq<-1
fim<-0
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 - Faa um algoritmo que leia inicialmente duas "cartas" e em seguida,
leia a opo de jogo: (1) dar mais uma carta, (0) encerrar jogo. O jogo tambm
acaba, caso a soma das cartas na mo 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 mos caso esta
no 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;
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 - Continuao do exerccio <I6300>. Considere que agora, h um total
de 52 cartas (Baralho inteiro) e as cartas valete, rainha e rei, valem uma
pontuao 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 nmero
de cartas que ele recebeu, e a soma delas, caso no ultrapasse 21, pois neste
caso deve-se devolver "0" como resposta.
Dica:Resto de uma diviso;
I00006302 - Continuao do exerccio <I6301>. O motivo pelo qual o jogador
recebe vitoria automtica 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 situao; Logo um As e outra carta de valor 10, equivalem a soma
"11+10=21", entretanto, se o jogador possusse em mos uma soma desfavorvel: 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 est nova informao.
I00006303 - Continuao do exerccio <I6302>. O jogador, nunca joga "sozinho"
como talvez voc possa ter imaginado, afinal, ele poderia parar com o menor
nmero de cartas e sempre vencer! Por isto, ele tem neste caso, como
concorrente, a "casa", porem, esta no 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 no tiver passado de 21 ou ganho
automaticamente (tirando 21 com as duas primeiras cartas), passa para a "casa",
que diferente do jogador, s precisa ter uma quantia "maior" ou "igual" de
pontos na mo, 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
sero 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,
viro os dados com os quais a mesa joga. Considere tambm que as cartas no
passam do valor 13.
I00006400 - Baseando-se na sequncia de fibonacci (0,1,1,2,3...), verifique se
uma sequncia de cinco nmeros, faz parte da sequncia, devolvendo como resposta
"0" se faz parte, ou "1" se no faz parte. Dica:Considere que nmeros
"repetidos" fazem parte da sequncia proposta, ou seja, devem ser analisados
individualmente como os demais nmeros fornecidos.
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 mximo dos lados de um
triangulo retngulo podem assumir, sendo que os lados comeam com tamanho 3, 4 e
5 (a,b,c). Em sequencia escreva todos os tringulos retngulos em que o valor
mximo do lado n e os trs lados so inteiros. Cada triangulo deve ser escrito
uma nica vez em ordem crescente dos lados. Dica:O triangulo retngulo dado
como valido pela formula (a + b = c)
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 salrio dos 10 funcionrios de uma empresa, calcule e escreva (nessa
ordem): a mdia dos salrios dos funcionrios menores que 30 anos, dos que tem
de 30 a 45 anos e dos maiores que 45 anos, escreva tambm 1, se o menor salrio
de um homem ou 2, se for de uma mulher. Todos os valores devem ser do tipo
inteiro, inclusive as mdias, portanto utilizar o operador de diviso inteira
para efetuar o clculo da mdia. Escrever mdia zero quando no houver nenhum
funcionrio no respectivo intervalo de idade.
algoritmo
var
salario30,salario3045,salario45,conta30,conta3045,conta45,idade,salario,sexo,i,m
aiorsalario,sexomaior:inteiro
inicio
salario30<-0 conta30<-0
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
senao escreva(0)
fimse
se conta45>0
senao escreva(0)
fimse
escreva(sexomaior)
fimalgoritmos

I00006700 - Fazer um algoritmo que leia 100 nmeros inteiros e escreva os
ltimos 2 nmeros primos informados. Escreva primeiramente o penltimo depois o
ltimo. Caso no seja informado nenhum nmero primo, escreva 0; caso seja
informado apenas um primo, escreva apenas esse.
var p1,p2,i,j,n:inteiro
inicio
p1<-0
p2<-0
leia(N)
se n>1 entao
j<-1
repita
j<-j+1
ate n%j=0
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 nmeros inteiros at que seja informado
0, descartando os nmeros negativos. Escrever o menor nmero com a maior
quantidade de dgitos.
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
repita
n1<-n1\10
cont<-cont+1
ate n1=0
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 so negativos e escreva esta informao.
V00000200 - Faa um algoritmo que leia 10 valores e os escreva na ordem
contrria que foram digitados.
V00000250 - Faa um algoritmo que leia os conceitos (1, 2, 3, 4 ou 5) dos alunos
de uma turma de 20 alunos. Aps, o algoritmo desenha um histograma com os
conceitos na forma
111
2222
3333333333
44
5
se houveram trs alunos com conceito 1, quatro com conceito 2, dez com conceito
3, dois com conceito 4 e um com conceito 5.
V00000300 - Faa um algoritmo que leia 10 valores e escreva primeiramente todos
os nmeros pares digitados e em seguida os nmeros mpares.
V00000320 - Faa um algoritmo que leia uma quantidade indeterminada de nmeros
at que sejam informados 10 nmeros positivos (maiores que zero) e em seguida
escreva esses nmeros positivos em ordem contrria ordem de leitura.
V00000400 - Escrever um algoritmo que l um vetor V(10) e o escreve. Conte, a
seguir, quantos valores de V so primos e escreva esta informao.
V00000500 - Faa um algoritmo que leia dez nmeros inteiros armazenando-os em um
vetor. Aps, escreva a posio de cada nmero menor que zero desse vetor.
V00000600 - Escreva um algoritmo que l um vetor A(10) e escreva a posio de
cada elemento primo deste vetor.
V00000700 - Escrever um algoritmo que l um vetor X(10) e o escreve. Substitua,
a seguir, todos os valores negativos de X pelos seu mdulo e escreva novamente o
vetor X.
V00000800 - Escrever um algoritmo que l um vetor C(50) e o escreve. Encontre, a
seguir, o maior elemento de C e o escreva.
V00000900 - Escrever um algoritmo que l um vetor N(80) e o escreve. Encontre, a
seguir, o menor elemento e a sua posio no vetor N e escreva: "O menor elemento
de N = ... e a sua posio ... ".
V00001000 - Faa um algoritmo que leia 10 valores, calcule sua mdia e escreva
os valores que esto acima da mdia calculada.
V00001010 - A conjectura de Goldbach diz que todo nmero par maior que 2 pode
ser representado como a soma de dois nmeros primos. Assim, 4=2+2, 6=3+3,
8=3+5... Faa um algoritmo que leia um nmero N, par, e escreva, em ordem
crescente, os dois nmeros primos que o compem. No caso de haver mais de um par
de nmeros (p.ex:20=3+17 e 20=7+13) escreva o par que tiver o menor nmero
primo.
V00001050 - Faa 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
no aparece no vetor; 1 - se o valor N aparece no vetor
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 penltimo, etc at o 5 com o 6
e escreva o vetor N assim modificado.
V00001200 - Escrever um algoritmo que l um vetor N(10) e o escreve. Troque, a
seguir, cada elemento que estiver em posio mpar (o primeiro, o terceiro...)
pelo elemento da posio imediatamente a seguir. Escreva o vetor modificado.
V00001250 - Escreva um algoritmo que l em um vetor de 20 posies nmeros
positivos, at que o vetor esteja completo ou que tenha sido fornecido o valor 0
(zero). Aps, escreva o vetor. A seguir, o algoritmo deve ler um nmero positivo
qualquer e, caso ele se encontre no vetor, deve remover todas suas ocorrncias,
atravs de um deslocamento para a esquerda dos elementos que encontram-se
direita daquele a ser removido. Escreve o vetor modificado.
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 questes acertou, escrevendo para cada aluno o
nmero de acertos.
V00001400 - Faa um algoritmo que leia 10 valores e verifique se algum dos
valores aparece repetido. Escreva 1 se algum valor aparece repetido e 0 se no
houver nenhum valor repetido.
V00001450 - Faa 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 no aparece no vetor; 1 - se o valor N aparece no vetor
V00001500 - Escrever um algoritmo que l um vetor X(10) e, aps, leia um vetor
Y(10). Crie, a seguir, um terceiro vetor Z com os elementos que aparecem nos
dois vetores (interseco). Os elementos devem aparecer no vetor Z na mesma
ordem em que aparecem no vetor X. Considere que no h repetio de valores
dentro do mesmo vetor. Escreva o vetor Z (apenas as posies que foram
preenchidas).
V00001501 - Escrever um algoritmo que l um vetor X(10) e, aps, leia um vetor
Y(10). Crie, a seguir, um terceiro vetor Z com os elementos que aparecem em um X
ou em Y (unio); 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 no h repetio de valores dentro do
mesmo vetor. Escreva o vetor Z (apenas as posies que foram preenchidas).
V00001600 - Faa 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 nmero de acertos que teve.
V00001650 - Faa um algoritmo que leia um nmero N e escreva os N primeiros
nmeros primos em ordem decrescente. Considere que N no mximo igual a 100.
Ex: Se N=5, escreva 11,7,5,3,2.
V00001700 - Escrever um algoritmo que l 2 vetores X(10) e Y(10), e escreva os
elementos que aparecem no vetor X e no aparecem no vetor Y (diferena 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, aps,
o vetor Y).
V00001710 - Escrever um algoritmo que l 3 vetores A[1..10], B[1.10] e C[1..10]
e escreve os elementos que esto em A e B (interseo) mas no esto em C.
Escreva os valores na ordem em que eles aparecem no vetor A. Os trs vetores
devem ser lidos separadamente (em primeiro lugar, todo o vetor A, aps, 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 so comuns aos trs vetores (interseco). Escreva os
valores na ordem em que eles aparecem no vetor A. Os trs vetores devem ser
lidos separadamente (em primeiro lugar, todo o vetor A, aps, 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 esto 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,
aps, o vetor B).
V00001790 - Faa 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 no foram digitados nenhuma vez.
V00001800 - Faa um algoritmo que leia um vetor X(10). Compare a seguir cada
elemento com o elemento da posio 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 aps essa operao?
V00001900 - Faa 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 exerccio V00001800 for executado repetidamente sobre o
vetor?
V00002000 - Faa 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 no deve ler todos os pesos e em
seguida todas as alturas)
V00002100 - Faa 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, tambm em ordem crescente. Escreva o vetor Z.
V00002200 - Escrever um algoritmo que gera os 10 primeiros nmeros primos acima
de 100 e os armazena em um vetor X(10) escrevendo, no final, o vetor X.
V00002250 - Escrever um algoritmo que leia 20 nmeros inteiros em um vetor e
escreva o elemento que aparece MENOS vezes no vetor com o nmero de ocorrncias.
Suponha que no havero dois ou mais nmeros com o mesmo nmero mnimo de
ocorrncias.
V00002300 - Escrever um algoritmo que l um vetor X(20) possivelmente contento
repeties e o escreve. Escreva, a seguir, cada um dos valores que aparecem em X
dizendo quantas vezes cada valor aparece em X.
V00002400 - Faa um algoritmo para gerar um vetor com os nmeros primos de 1 a
1000 atravs do crivo de eratstenes. Neste mtodo o vetor (inicializado com
zeros) percorrido da segunda posio at o fim e para cada posio n que
contem 0, n um nmero primo e todas as posies mltiplas de n devem receber
1. Escreva ao final os nmeros primos. Eles so indicados pelas posies do
vetor que contem 0.
V00002500 - Faa um algoritmo que leia 30 valores inteiros entre 1 e 10 e
escreva o nmero de vezes que ocorre cada valor.
V00002600 - Faa um algoritmo que leia 10 nmeros reais armazenando-os em um
vetor. Desloque, a seguir, todos os elementos do vetor uma posio para a
esquerda (colocando na ltima posio o elemento que estava na primeira
posio). Repita isso at o que o maior elemento esteja ocupando a primeira
posio.
V00002700 - Faa um algoritmo que coloque em um vetor os 20 primeiros nmeros
primos da srie de Fibonacci
V00002800 - Faa um algoritmo que leia uma quantidade indeterminada de nmeros
at que sejam digitados 10 nmeros distintos e escreva esses 10 nmeros.
V00002900 - Faa um algoritmo que preencha um vetor com os 20 primeiros nmeros
primos e aps escreva os elementos desse vetor. Para identificar se um nmero
primo, verifique se divisvel por algum dos primos j colocados no vetor.
V00003000 - Faa um algoritmo que leia dois vetores V(15) e W(15), contendo,
cada um, um nmero de 15 dgitos, cada dgito ocupando uma posio do vetor, o
dgito menos significativo do nmero ocupando a posio 15, e calcule a soma dos
dois nmeros, 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, aps, o vetor W.
cada um, um nmero de 15 dgitos, cada dgito ocupando uma posio do vetor, e
efetue a comparao entre os dois nmeros de quinze dgitos em V e W,
escrevendo: -1 se o nmero em V menor. 0 (zero) se os nmeros em V e W so
iguais. 1, se o nmero em V maior. Leia inicialmente os 15 dgitos de V e,
aps, os 15 dgitos de W.
cada um, um nmero de 15 dgitos, cada dgito ocupando uma posio do vetor, o
dgito menos significativo do nmero ocupando a posio 15, e calcule a
diferena dos dois nmeros (V-W), colocando o resultado em um vetor S(16).
Escreva ao final o vetor S. Considere que o nmero de 15 dgitos no vetor V
maior que o nmero contido no vetor W.
V00003200 - Faa um algoritmo que leia um vetor V(15) contendo um nmero de 15
dgitos, e um valor N entre 0 e 9, e calcule o produto (multiplicao) do nmero
em V pelo valor N, colocando o resultado em um vetor P(16). Escreva o vetor P.
V00003250 - Faa um algoritmo que leia, para 5 candidatos a deputado, o seu
cadastro. Leia, a seguir, um nmero no determinado de votos (termina ao ser
digitado 0) e escreva ao final o cadastro e nmero de votos de cada candidato
(em ordem crescente de cadastro). Escreva tambm, ao final, o nmero de votos
nulos (ou seja, votos que no so iguais ao cadastro de nenhum candidato).
V00003300 - Faa um algoritmo que leia, para 20 candidatos a deputado, seu
cadastro, partido (inteiro entre 1 e 10) e nmero 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 prximo candidato.
cadastro, partido (inteiro entre 1 e 10) e nmero de votos, e escreva, para os
10 partidos, o nmero do partido e o total de votos, em ordem decrescente de
votao. Os 3 dados correspondentes a cada candidato devem ser lidos juntos,
antes de passar para o prximo candidato.
cadastro, partido (inteiro entre 1 e 10) e nmero de votos, e escreva o
cadastro, partido e nmero de votos do candidato mais votado de cada partido, em
ordem crescente de partido.
cadastro, partido e nmero de votos do candidato mais votado de cada partido, em
ordem decrescente de votao.
cadastro, partido e nmero de votos de todos os candidatos, em ordem crescente
de partido e, para o mesmo partido, em ordem crescente de nmero de votos.
V00003500 - Faa um algoritmo que leia 20 nmeros reais. Escreva a quantidade
mnima 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.
V00003600 - Faa um algoritmo que leia 10 datas, cada uma composta por dia, ms
e ano, e escreva as 10 datas em ordem cronolgica crescente.
V00003700 - Faa 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.
(entre 1 e 13). O algoritmo deve escrever quantas trincas a "mo" contm. Uma
trinca composta de trs cartas com o mesmo valor. O naipe das cartas no
importa. Cada carta pode aparecer no mximo em uma trinca.
(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 no contem. Considere como canastra
apenas uma sequencia crescente de 7 cartas do mesmo naipe de numerao contnua
(cuja diferena entre duas cartas seja igual a 1). Considere que podem ocorrer
cartas de mesmo nmero. Nesse caso a carta de mesmo nmero no contada, mas
no quebra a sequncia.
V00003900 - Faa um algoritmo que leia os 5 nmeros obtidos em um arremesso de 5
dados no jogo de General, e verifique se os nmeros contm um full-hand (3
nmeros iguais, e os outros dois nmeros iguais entre si, mas diferentes dos 3
primeiros. Ex. 3,3,3,2,2), e escreva: 1 - se os nmeros contem um full-hand; 0 -
se no contem.
V00004000 - Faa um algoritmo que encontre a maior subsequncia de elementos,
no necessariamente contguos, de um vetor de no mximo 100 elementos de tal
forma que cada elemento desta subsequncia 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
subsequncia encontrada.
V00004100 - Faa um algoritmo que encontre e escreva a maior subsequncia de
elementos, no necessariamente contguos, de um vetor de no mximo 100 elementos
de tal forma que cada elemento desta subsequncia seja menor ou igual ao
anterior. Os dados do vetor devem ser lidos at que seja digitado um valor
negativo (que deve ser descartado).
V00004150 - Faa um algoritmo que leia um vetor V(10) e um vetor W(3), e
verifique e escreva a primeira posio do vetor V a partir da qual so
encontrados, de forma contgua, os trs elementos do vetor W. Caso o vetor W no
ocorra em V, o algoritmo deve escrever -1.

V00004200 - Faa um algoritmo que leia um vetor de inteiros W[30]. Leia a seguir
um vetor V[10] e verifique se a sequncia de 10 nmeros no vetor V ocorre no
vetor W, escrevendo a posio do vetor W onde inicia a sequencia, caso ela
exista, ou 0, caso a sequencia em V no exista em W.
V00006000 - Faa 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 nmero de
ocorrncias do mesmo.
V00006100 - Crie um algoritmo que l um vetor G(13) representando o resultado de
um teste de loteria esportiva, contendo os valores 1 (coluna 2), 2 (coluna do
meio) e 4 (coluna 1). A seguir, para cada apostador, o algoritmo l o n de seu
carto e suas apostas para cada um dos 13 jogos, sendo vlidos os seguintes
valores: 1 (coluna 2), 2 (coluna do meio), 3 (coluna 2 e do meio), 4 (coluna 1),
5 (coluna 1 e 2), 6 (coluna 1 e do meio) e 7 (triplo). O algoritmo calcula, para
cada apostador, o n de acertos e escreve o n do apostador e seu nmero de
acertos. O algoritmo para de ler quando o nmero do apostador for 0.
V00006200 - Faa um algoritmo que leia valores at que seja digitado um valor
negativo e escreva os 10 ltimos valores positivos digitados. Considere que
sero digitados pelo menos 10 valores positivos. O algoritmo deve escrever os
valores na mesma ordem em que foram digitados pelo usurio.
V00006300 - Crie um algoritmo que l o nmero de matrcula de cada aluno e suas
respectivas notas em trs provas, em uma turma de 10 alunos. Aps, calcular a
mdia harmnica (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 nmero de matrcula e seu
conceito. Dica:Lembre que se uma das trs notas 0, a mdia harmnica 0.
V00006400 - Na apurao de um processo de eleio as vagas disponveis so
distribudos entre os partidos proporcionalmente aos votos obtidos pelo partido.
As sobras so distribudas da seguinte forma: enquanto houver sobras, calcula-se
para cada partido a razo entre o nmero de votos e o nmero de cadeiras j
obtidas + 1. Uma das sobras atribuda ao partido de maior razo. Isso se
repete at que no haja mais sobras. Faa um algoritmo que leia, para 10
partidos, de 1 a 10, o seu nmero de votos. Leia, a seguir, o total de vagas e
escreva, ao final, para os partidos de 1 a 10, o nmero do partido e o nmero de
cadeiras obtidas.
V00006500 - Faa um algoritmo que leia o cdigo de 5 carros com seus respectivos
preos. Ao final, escreva o cdigo do carro mais caro com seu respectivo preo.
V00006600 - Escreva um algoritmo que l um vetor V[10] e escreva, para cada
valor diferente que aparece no vetor, o valor e o nmero de vezes que o mesmo
ocorre no vetor. Escreva os valores em ordem crescente de valor.
V00006700 - Faa um algoritmo que leia um vetor V[10] e ao final escreva o
elemento que aparece mais vezes neste vetor.
V00006800 - Faa 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 posio
em que se encontra. Caso o valor no esteja no vetor, escreva -1. Tente escrever
um algoritmo da forma mais eficiente possvel.
V00006900 - Faa 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 posio correta do vetor V, de modo a mant-lo
ordenado, deslocando em uma posio para a direita todos os valores que vm aps
ele. Escreva, ao final, o vetor V (ordenao por insero).
V00007000 - Na ordenao por contagem, conta-se, para cada elemento do vetor, o
nmero de elementos menores ou iguais a ele. O valor da contagem a posio que
o elemento ocupar no vetor ordenado. Faa um algoritmo que leia um vetor V[20]
e ordene-o em ordem crescente, escrevendo o vetor ordenado. Considere que no h
repetio de valores no vetor.
V00007100 - Escreva um algoritmo que leia caracteres em dois vetores A[5] e
B[5]. Aps os dois vetores terem sido lidos, o algoritmo dever colocar em um
terceiro vetor C o resultado da unio dos dois primeiros, ou seja, os caracteres
que esto contidos em um ou outro vetor. Assuma que em um mesmo vetor no haver
caracteres repetidos, mas um caractere contido em A poder tambm estar contido
em B. Nesse caso, apenas uma ocorrncia colocada em C.
V00007150 - Uma loja decidiu fazer um sorteio de prmios para seus clientes.
Sero sorteados 10 nmeros, porm, a loja no quer que um mesmo nmero receba
mais do que um prmio. Faa um algoritmo que leia cada nmero sorteado at que
tenham sido sorteados 10 nmeros diferentes. O algoritmo escreve os 10 nmeros
(distintos) sorteados.
V00007160 - Faa um algoritmo que leia nmeros at que tenham sido lidos 5
nmeros distintos ou 20 nmeros. Escreva, ao final, os 5 nmeros distintos em
ordem crescente.
V00007200 - Faa 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 posio
em que se encontra. Caso o valor no esteja no vetor, escreva -1. Tente escrever
um algoritmo da forma mais eficiente possvel. Dica: Compare N com o valor na
posio do meio do vetor. Essa comparao dir se N est na primeira ou na
segunda metade do vetor. (pesquisa binria)
V00007300 - Crie um algoritmo que leia um vetor v[10]. Leia a seguir um valor N
e faa, no vetor V, uma rotao circular para a esquerda (rotate left) de N
posies. Na rotao circular para a esquerda, cada elemento copiado para a
posio esquerda, e o primeiro elemento copiado para a ltima posio.
Escreva, ao final, o vetor alterado.
V00007400 - Escreva um algoritmo que l em um vetor o gabarito das 20 questes
objetivas de um prova de vestibular com 4 opes: A, B, C e D. O
algoritmo deve, a seguir, ler, para cada candidato, seu codigo e as respostas
fornecidas para as 20 questes e escrever o nmero de acertos. O algoritmo pra
de ler quando o cdigo do candidato for igual a 0.
V00007500 - Crie um algoritmo que faa uma progresso aritmtica de cinco
posies, onde deve ser fornecido o primeiro termo da progresso e a razo desta
PA.
V00007600 - Faa um algoritmo que leia um nmero inteiro e escreva os dgitos
binrios correspondentes a esse nmero (mximo 64 dgitos binrios). Dica:Para
converter um nmero decimal em binrio pode-se proceder sucessivas divises por
dois at que o quociente seja igual a zero. O nmero binrio obtido
considerandos restos obtidos nas divises, mas em ordem contrria.
V00007700 - Leia um vetor de 10 posies que contem nmeros positivos e
negativos. Em seguida, descubra qual a sequencia de valores dentro dele
(intervalo de valores contguos no vetor) que resulta na maior soma, escrevendo
ao final a soma encontrada.
V00007800 - A sequencia "Look & Say" funciona da seguinte forma: O seu primeiro
termo sempre "1", e a definio do prximo termo a partir do anterior "O n
de vezes que um nmero de repete at que a sequencia seja quebrada""O nmero que
estava repetindo"...
Veja do seguinte modo:
1 Termo: 1 (Termo inicial em "1")
2 Termo: 11 (Antes tnhamos "1" vez o nmero "1")
3 Termo: 21 (Antes tnhamos "2" vezes o nmero "1")
4 Termo: 1211 (Antes tnhamos "1" vez o nmero "2" e "1" vezes o nmero "1")
5 Termo: 111221
6 Termo: 312211
...
Elabore um algoritmo que calcule o ensimo termo dessa sequncia. Considere que
o nmero muito grande e voc precisar de 1000 casas no vetor que ir
aglomer-lo.
Matrizes
M00000100 - Faa um algoritmo que leia uma matriz M[1..5,1..5] e calcule e
escreva a soma dos elementos da diagonal principal.
escreva a soma dos elementos da diagonal secundria.
escreva a soma dos elementos em toda a regio acima da diagonal principal.
escreva a soma dos elementos em toda a regio acima da diagonal secundria.
escreva a soma dos elementos que esto ao mesmo tempo acima da diagonal
principal e da secundria.
M00000400 - Faa um algoritmo que leia uma matriz M[1..5,1..5] e escreva o maior
valor existente na matriz, bem como a linha e coluna onde o valor ocorre.
M00000600 - Faa um algoritmo que leia uma matriz M[1..5,1..5] e troque cada
elemento da linha 4 com elemento correspondente da linha 2. Escreva a matriz
resultante.
M00000700 - Uma matriz identidade uma matriz que possui 1 em todos os
elementos da diagonal principal, e 0 em todas as outras posies. Faa 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 no uma matriz
identidade.
M00000800 - Faa um algoritmo que leia uma matriz M[1..5,1..5] e escreva o
nmero da linha que contenha a maior soma de seus elementos. Considere que a
matriz s contem valores positivos.
M00000900 - Faa um algoritmo que leia uma matriz M[1..5,1..5] e escreva o
nmero da linha que contenha a maior soma de seus elementos. Considere que a
matriz pode conter valores positivos e negativos.
M00001000 - Faa 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.
M00001010 - Escrever um algoritmo que l uma matriz M[1..3,1..3], contendo uma
posio 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 (no h mais lances e ningum ganhou);4 - se o
jogo ainda no terminou (h lances por jogar e ningum ainda venceu)
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 (no basta que seja igual). Faa um
algoritmo que leia uma matriz M[1..4,1..4] e verifique se diagonalmente
dominante escrevendo: 1 - Se diagonalmente dominante; 0 - Se no
diagonalmente dominante
M00001200 - Faa um algoritmo que leia uma matriz M[1..5,1..5], onde cada
posio contem um nmero entre 0 e 9 e cada linha da matriz representa um nmero
de 5 dgitos. O algoritmo deve calcular a soma dos 5 nmeros contidos na matriz
colocando o resultado em um vetor Soma[1..6]. Escreva ao final o vetor Soma.
de 5 dgitos. O algoritmo deve encontrar a linha que contem o maior dos 5
nmeros e escrever o nmero.
de 5 dgitos. O algoritmo deve ordenar os 5 nmeros em ordem crescente, e
escrever a matriz com os nmeros ordenados.
M00001500 - Faa um algoritmo que leia dois valores D e DS, correspondendo a um
dia do ms e um dia da semana (1-domingo, 2-segunda,... 7-sbado) e preencha uma
matriz Folhinha[1..6,1..7] com o calendrio correspondente ao ms 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 posies no utilizadas da matriz devem conter 0's.
M00001600 - Uma matriz de adjacncias, para um mapa rodovirio, composta de
elementos 0's e 1's, sendo que M[i,j]= 1 se existe uma ligao rodoviria da
cidade i para a cidade j e M[i,j]= 0 em caso contrrio. Essa matriz ser
simtrica se para todo caminho i,j existir o caminho j,i (estradas de mo
dupla). Uma caracterstica dessa matriz que na matriz M^2, obtida pelo produto
matricial de M por M, cada posio M[i,j] contm o nmero de caminhos entre as
cidades i e j que passam exatamente por 1 outra cidade. E M^3 contem a
quantidade de caminhos que passam por 2 outras cidades. E assim por diante.
Escreva um algoritmo que leia uma matriz de adjacncias M para um conjunto de 5
cidades e, aps, 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 - Faa 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 - Faa 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 MDULO da linha.
Escrever a matriz modificada.
M00001900 - Faa 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 no na matriz, escrevendo a posio (linha e coluna) em que
foi encontrada a primeira ocorrncia do mesmo e, caso ele no exista na matriz,
a mensagem "No tem".
M00002000 - Uma matriz dita triangular superior se todos os elementos abaixo
da diagonal principal so 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 so iguais a zero, e h pelo
menos um elemento no nulo abaixo da diagonal principal. E uma matriz dita
diagonal se os elementos no nulos ocorrem somente na diagonal principal. Faa
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 no nenhuma das anteriores
M00002100 - Uma matriz dita Matriz de Toeplitz se, em cada diagonal paralela
diagonal principal, todos os elementos so 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
Faa 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 no 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
Faa 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 no uma matriz
Circulante
M00002300 - Faa 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. Aps 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.
M00002400 - Uma matriz dita de Hadamard se todos os seus elementos so 1 ou
-1, e o produto escalar (somatrio dos produtos de cada elemento de uma linha
pelo elemento correspondente da outra linha) entre quaisquer duas linhas igual
a zero. Faa um algoritmo que leia uma matriz M[1..4,1..4] e verifique se ela
de Hadamard escrevendo: 0 - Se no de Hadamard; 1 - Se de Hadamard
M00002500 - Faa um algoritmo que leia uma matriz M[1..3,1..3] e rotacione a
matriz 90 graus no sentido horrio, escrevendo a matriz resultante.
M00004900 - Um quadrado mgico de ordem N (sendo N um nmero mpar) um arranjo
de nmero 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
mgico 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 fcil de observar: Comece com 1 no meio da
primeira linha, ento siga para cima e para a esquerda diagonalmente (quando
sair do quadrado suponha que os lados superior e inferior esto unidos ou que os
lados da direita e da esquerda esto unidos, conforme for o caso). Em cada
quadrado que passar coloque o valor do quadrado anterior mais 1 (um). Quando a
prxima casa estiver j preenchida, desa um quadrado e continue seguindo a
diagonal at ter preenchido todos os quadrados. Escrever um algoritmo que l um
nmero N mpar, menor ou igual a 99, e gere e escreva, para o nmero lido, o seu
quadrado mgico.
M00005000 - Faa um algoritmo que leia duas matrizes M[1..3,1..3] e N[1..3,1..3]
(primeiro a matriz M, e aps 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.
M00005100 - As pirmides tm 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 mximo igual a 10, e
verifique se a matriz equivalente a uma pirmide inca, ou seja, se partindo-se
do canto superior esquerdo da matriz, no sentido horrio, em espiral, a posio
seguinte na ordem o inteiro consecutivo da posio anterior. O algoritmo deve
escrever: 1 - Se a matriz forma uma pirmide inca; 0 - Em caso contrrio.
M00005200 - Escreva um algoritmo que leia duas matrizes numricas 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 posies das matrizes A e B forem iguais, e 0 em caso
contrrio. O algoritmo deve, ao final, escrever a matriz C.
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.
M00005400 - (Problema especfico da disciplina de Teoria de Grafos) Uma matriz
de adjacncias, para um mapa rodovirio, composta de elementos 0's e 1's,
sendo que M[i,j]= 1 se existe uma ligao rodoviria da cidade i para a cidade j
e M[i,j]= 0 em caso contrrio. Essa matriz ser simtrica se para todo caminho
i,j existir o caminho j,i (estradas de mo dupla). Matrizes de adjacncias so
uma das formas utilizadas para representao de grafos. Escreva um algoritmo que
leia uma matriz de adjacncias M para um conjunto de 5 cidades e, aps, 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 intermedirias e a cidade final.
24 Sequenciais
59 Condicionais
95 Iterativos
84 de Vetores
33 de Matrizes
total: 295 problemas

Lista de Problemas Com Soluções PDF

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Lista de Problemas Com Soluções PDF

Caricato da

Copyright:

Formati disponibili

Sequenciais

S00000050 - Faa um algoritmo que leia um valor N, representando o lado de um

Potrebbero piacerti anche