Pular para conteúdo

2600

Faixa de problemas: 2600-2699

Total: 35 problemas

2600 - Tustin e Seu Dado Novo

Descrição do Problema: 2600 - Tustin e Seu Dado Novo

2600 - Tustin e Seu Dado Novo
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
n = leia_inteiro
para i de 1 até n faça
    valores = [leia_inteiro] + leia_inteiros(4) + [leia_inteiro]
    dado = valores.ordene == [1, 2, 3, 4, 5, 6]
    se dado e valores[1] + valores[6] == 7 e 
        valores[2] + valores[4] == 7 e valores[3] + valores[5] == 7 então
        escreva "SIM"    
    senão
        escreva "NAO"
    fim
fim

2601 - Tustin e Seu Dado Antigo

Descrição do Problema: 2601 - Tustin e Seu Dado Antigo

2601 - Tustin e Seu Dado Antigo
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
n = leia_inteiro
para i de 1 até n faça
  valores = leia_inteiros(6)
  somas = [valores[1] + valores[6], valores[2] + valores[4], valores[3] + valores[5]]
  possibilidades = escolha somas.selecione(_ == 0).tamanho
    caso 0 => 1    #             1
    caso 1 => 2    #         2 * 1
    caso 2 => 8    #     4 * 2 * 1
    caso 3 => 48   # 6 * 4 * 2 * 1
  fim
  escreva possibilidades
fim

2602 - Select Básico

Descrição do Problema: 2602 - Select Básico

2602 - Select Básico
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
use sql

tipo Clientes: Tabela
    _tabela = "customers"
    nome = campo("name")
    estado = campo("state")
fim

c = Clientes()
consulta = Selecionar()
            .tabela(c)
            .campos([c.nome])
            .onde(c.estado == "RS")
            .sql

escreva consulta

2603 - Endereço dos Clientes

Descrição do Problema: 2603 - Endereço dos Clientes

2603 - Endereço dos Clientes
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
use sql

tipo Clientes: Tabela
    _tabela = "customers"
    nome = campo("name")
    rua = campo("street")
    cidade = campo("city")
fim

c = Clientes()
consulta = Selecionar()
            .tabela(c)
            .campos([c.nome, c.rua])
            .onde(c.cidade == "Porto Alegre")
            .sql

escreva consulta

2604 - Menores que 10 ou Maiores que 100

Descrição do Problema: 2604 - Menores que 10 ou Maiores que 100

2604 - Menores que 10 ou Maiores que 100
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
use sql

tipo Produtos: Tabela
    _tabela = "products"
    id = campo("id")
    nome = campo("name")
    preco = campo("price")
fim

p = Produtos()

consulta = Selecionar()
            .tabela(p)
            .campos([p.id, p.nome])
            .onde(p.preco < 10 ou p.preco > 100)
            .sql

escreva consulta

2605 - Representantes Executivos

Descrição do Problema: 2605 - Representantes Executivos

2605 - Representantes Executivos
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
use sql

tipo Produtos: Tabela
    _tabela = "products"
    id = campo("id")
    nome = campo("name")
    id_fornecedor = campo("id_providers")
    id_categoria = campo("id_categories")
fim

tipo Fornecedores: Tabela
    _tabela = "providers"
    id = campo("id")
    nome = campo("name")
fim

p = Produtos()
f = Fornecedores()

consulta = Selecionar()
            .tabela(p)
            .juntar(prov, f.id == p.id_fornecedor)
            .campos([p.nome, f.nome])
            .onde(p.id_categoria == 6)
            .sql

escreva consulta

2606 - Categorias

Descrição do Problema: 2606 - Categorias

2606 - Categorias
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
use sql

tipo Produtos: Tabela
    _tabela = "products"
    id = campo("id")
    nome = campo("name")
    id_categoria = campo("id_categories")
fim

tipo Categorias: Tabela
    _tabela = "categories"
    id = campo("id")
    nome = campo("name")
fim

p = Produtos()
c = Categorias()

consulta = Selecionar()
            .tabela(p)
            .juntar(c, c.id == p.id_categoria)
            .campos([p.id, p.nome])
            .onde(c.nome =~ "super%")
            .sql

escreva consulta

2607 - Cidades em Ordem Alfabética

Descrição do Problema: 2607 - Cidades em Ordem Alfabética

2607 - Cidades em Ordem Alfabética
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
use sql

tipo Fornecedores: Tabela
    _tabela = "providers"
    cidade = campo("city")
fim

f = Fornecedores()

consulta = Selecionar()
            .tabela(f)
            .distinto()
            .campos([f.cidade])
            .ordenarPor(f.cidade)
            .sql

escreva consulta

2608 - Maior e Menor Preço

Descrição do Problema: 2608 - Maior e Menor Preço

2608 - Maior e Menor Preço
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
use sql

tipo Produtos: Tabela
    _tabela = "products"
    preco = campo("price")
fim

p = Produtos()

consulta = Selecionar()
            .tabela(p)
            .campos([
                maximo(p.preco),
                minimo(p.preco)
            ])
            .sql

escreva consulta

2609 - Produtos por Categorias

Descrição do Problema: 2609 - Produtos por Categorias

2609 - Produtos por Categorias
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
use sql

tipo Produtos: Tabela
    _tabela = "products"
    id = campo("id")
    id_categoria = campo("id_categories")
    quantidade = campo("amount")
fim

tipo Categorias: Tabela
    _tabela = "categories"
    id = campo("id")
    nome = campo("name")
fim

p = Produtos()
c = Categorias()

consulta = Selecionar()
            .tabela(p)
            .juntar(c, c.id == p.id_categoria)
            .campos([
                c.nome,
                soma(p.quantidade)
            ])
            .agruparPor([c.nome])
            .sql

escreva consulta

2610 - Valor Médio dos Produtos

Descrição do Problema: 2610 - Valor Médio dos Produtos

2610 - Valor Médio dos Produtos
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
use sql

tipo Produtos: Tabela
    _tabela = "products"
    preco = campo("price")
fim

p = Produtos()

consulta = Selecionar()
            .tabela(p)
            .campos([
                media(p.preco).arredondar(2)
            ])
            .sql

escreva consulta

2611 - Filmes de Ação

Descrição do Problema: 2611 - Filmes de Ação

2611 - Filmes de Ação
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
use sql

tipo Filmes: Tabela
    _tabela = "movies"
    id = campo("id")
    nome = campo("name")
    id_generos = campo("id_genres")
fim

tipo Generos: Tabela
    _tabela = "genres"
    id = campo("id")
    descricao = campo("description")
fim

f = Filmes()
g = Generos()

consulta = Selecionar()
            .tabela(f)
            .juntar(g, g.id == f.id_generos)
            .campos([f.id, f.nome])
            .onde(g.descricao == "Action")
            .sql

escreva consulta

2626 - Turma do JB6

Descrição do Problema: 2626 - Turma do JB6

2626 - Turma do JB6
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
dodo   = "Os atributos dos monstros vao ser inteligencia, sabedoria..."
leo    = "Iron Maiden's gonna get you, no matter how far!"
pepper = "Urano perdeu algo muito precioso..."
empate = "Putz vei, o Leo ta demorando muito pra jogar..."
var a := leia_texto
enquanto nao eof faca
  resultado = escolha a
    caso "pedra tesoura tesoura" => dodo
    caso "papel pedra pedra"     => dodo
    caso "tesoura papel papel"   => dodo
    caso "tesoura pedra tesoura" => leo
    caso "pedra papel pedra"     => leo
    caso "papel tesoura papel"   => leo
    caso "tesoura tesoura pedra" => pepper
    caso "pedra pedra papel"     => pepper
    caso "papel papel tesoura"   => pepper
    caso _                       => empate
  fim
  escreva resultado
  a := leia_texto
fim

2630 - Escala de Cinza

Descrição do Problema: 2630 - Escala de Cinza

2630 - Escala de Cinza
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
t = leia_inteiro
para i de 1 ate t faca
  conversao = leia_texto
  rgb = leia_inteiros(" ")
  r, g, b = rgb[1], rgb[2], rgb[3]
  imprima "Caso #{i}: "
  escreva escolha conversao
    caso "min"  => rgb.ordene[1]
    caso "max"  => rgb.ordene[3]
    caso "mean" => (r + g + b) div 3
    caso _      => (r * 30 + g * 59 + b * 11) div 100
  fim
fim

2632 - Magic and Sword

Descrição do Problema: 2632 - Magic and Sword

2632 - Magic and Sword
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
magia_dano(magia: Texto) = escolha magia
    caso "fire" => 200
    caso "water" => 300
    caso "earth" => 400
    caso _ => 100
fim

magia_raio(magia: Texto, lv: Texto) = escolha (magia, lv)
    caso  ("fire", "1") => 20
    caso  ("fire", "2") => 30
    caso  ("fire", "3") => 50
    caso  ("water", "1") => 10
    caso  ("water", "2") => 25
    caso  ("water", "3") => 40
    caso  ("earth", "1") => 25
    caso  ("earth", "2") => 55
    caso  ("earth", "3") => 70
    caso  ("air", "1") => 18
    caso  ("air", "2") => 38
    caso  _ => 60
fim

intercessao(cx: Inteiro, cy: Inteiro, raio: Inteiro, rx: Inteiro, ry: Inteiro, largura: Inteiro, altura: Inteiro)
    cDx = abs(cx - (rx + largura / 2))
    cDy = abs(cy - (ry + altura / 2))

    se (cDx > (largura / 2 + raio)) ou (cDy > (altura / 2 + raio)) então
        falso
    senãose (cDx <= largura / 2) ou (cDy <= altura / 2) então
        verdadeiro
    senão
        ((cDx - largura/2)^2 + (cDy - altura/2)^2) <= raio^2
    fim
fim

t = leia_inteiro
para i de 1 ate t faca
    posicao = leia_inteiros(" ")
    w, h, x0, y0 = posicao[1], posicao[2], posicao[3], posicao[4]
    ataque = leia_textos(" ")
    magia, lv, cx, cy = ataque[1], ataque[2], ataque[3].inteiro, ataque[4].inteiro

    se intercessao(cx, cy, magia_raio(magia, lv), x0, y0, w, h) então
        escreva magia_dano(magia)
    senão
        escreva 0
    fim

fim

2633 - Churras no Yuri

Descrição do Problema: 2633 - Churras no Yuri

2633 - Churras no Yuri
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
var n := leia_inteiro
enquanto nao eof faca
  list = leia_textos(n)
           .mapeie(_.divida(" "))
           .mapeie(a => (a[1], a[2].inteiro))
           .ordene(a => a.segundo)
           .mapeie(a => a.primeiro)
  escreva list.junte(" ")
  n := leia_inteiro
fim

2635 - Navegador Web

Descrição do Problema: 2635 - Navegador Web

2635 - Navegador Web
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
n = leia_inteiro
palavras = Lista(n, 0).mapeie(a => leia_texto)
q = leia_inteiro
para i de 1 ate q faca
  s = leia_texto
  t = s.tamanho
  c = palavras.selecione(palavra => palavra.pegue(t) == s)
  maior = c.injete(-1)((a, b) => se b.tamanho > a entao b.tamanho senao a fim)
  se c.tamanho > 0 entao
    escreva "{c.tamanho} {maior}"
  senao
    escreva -1
  fim
fim

2650 - Construindo Muralhas

Descrição do Problema: 2650 - Construindo Muralhas

2650 - Construindo Muralhas
1
2
3
4
5
6
7
8
a = leia_inteiros(" ")
n, w = a[1], a[2]
para i de 1 ate n faca
  s = leia_textos(" ")
  se s[-1].inteiro > w entao
    escreva s.pegue(s.tamanho - 1).junte(" ")
  fim
fim

Descrição do Problema: 2651 - Link Bolado

2651 - Link Bolado
1
2
3
4
5
6
7
s = "|"+leia_texto.minusculo+"|"
a = s.divida("zelda").tamanho
se a > 1 entao
  escreva "Link Bolado"
senao
  escreva "Link Tranquilo"
fim

2653 - Dijkstra

Descrição do Problema: 2653 - Dijkstra

2653 - Dijkstra
1
2
3
4
5
6
7
8
var joias := Lista(0, "")
var joia := leia_texto
enquanto nao eof faca
  joias := joia :: joias
  joia := leia_texto
fim
tamanho = joias.ordene.divida_quando(_ <> _).tamanho
escreva tamanho

2654 - Godofor

Descrição do Problema: 2654 - Godofor

2654 - Godofor
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
tipo Ser
  nome: Texto
  poder, kill, morte: Inteiro
fim

lt = (s1, s2: Ser) =>
  se s1.poder <> s2.poder entao s1.poder > s2.poder
  senaose s1.kill <> s2.kill entao s1.kill > s2.kill
  senaose s1.morte <> s2.morte entao s1.morte < s2.morte
  senao s1.nome < s2.nome
  fim

n = leia_inteiro
seres = para i de 1 ate n gere
  a = leia_textos(" ")
  Ser(a[1], a[2].inteiro, a[3].inteiro, a[4].inteiro)
fim
godofor = seres.ordene(lt).cabeca
escreva godofor.nome

2661 - Despojados

Descrição do Problema: 2661 - Despojados

2661 - Despojados
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
descolado(x: Real) = se x == 1.0 então falso senão
  var i := 2
  r = raiz(x).inteiro
  var primo, resultado := verdadeiro
  enquanto i <= r e resultado faça
    se x mod i^2 == 0.0 então
      resultado := falso
    senãose x mod i == 0.0
      primo := falso
    fim
    i := i + 1
  fim
  resultado e primo
fim

n = leia_real
var resp := 0
para i de 1 até raiz(n).inteiro faça
  se n mod i == 0.0 então
    se descolado(i) então
      resp := resp + 1
    fim
    se i <> n/i e descolado(n/i) então
      resp := resp + 1
    fim
  fim
fim
escreva (2^resp - resp - 1).arredonde

2663 - Fase

Descrição do Problema: 2663 - Fase

2663 - Fase
1
2
3
4
5
n, k = leia_inteiro
numeros = leia_inteiros(n).ordene.inverta
minimo = numeros[k]
s = numeros.pegue_enquanto(num => num >= minimo).tamanho
escreva s

2667 - Jogo de Boca

Descrição do Problema: 2667 - Jogo de Boca

2667 - Jogo de Boca
1
2
3
4
5
6
n = leia_texto
var s := 0
para i de 1 até n.tamanho faça
  s := s + (n[i]-'0')
fim
escreva s mod 3

2670 - Máquina de Café

Descrição do Problema: 2670 - Máquina de Café

2670 - Máquina de Café
1
2
3
4
5
6
7
8
9
a, b, c = leia_inteiro
t1 = 2 * b + 4 * c
t2 = 2 * a + 2 * c
t3 = 4 * a + 2 * b
menor = se t1 <= t2 e t1 <= t3 então t1
        senãose t2 <= t3       então t2
                               senão t3
        fim
escreva menor

2674 - Super Primos: Ativar!

Descrição do Problema: 2674 - Super Primos: Ativar!

2674 - Super Primos: Ativar!
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
primo(a: Inteiro)
  var resp := a > 1
  para i de 2 até raiz(a).arredonde faça
    se a mod i == 0 então
      resp := falso
    fim
  fim
  retorne resp
fim

var n:= leia_inteiro
enquanto n > 0 faça
  se primo(n) entao
    se n.texto - "014689" == n.texto entao
      escreva "Super"
    senão
      escreva "Primo"
    fim
  senão
    escreva "Nada"
  fim
  n:= leia_inteiro
fim

2679 - Sucessor Par

Descrição do Problema: 2679 - Sucessor Par

2679 - Sucessor Par
1
2
3
4
5
6
n = leia_inteiro
se n mod 2 == 0 então
  escreva n + 2
senão
  escreva n + 1
fim

2681 - Macacos da Torre de Hanoi

Descrição do Problema: 2681 - Macacos da Torre de Hanoi

2681 - Macacos da Torre de Hanoi
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
tipo Mat = Lista[Lista[BigInt]]
m = 24*60*60

matrixMult(a, b: Mat): Mat
  var result := Lista(a.tamanho, Lista(a[1].tamanho, BigInt(0)))
  para i de 1 até a.tamanho, j de 1 até b.tamanho, k de 1 até b.tamanho faça
    result[i][j] := (result[i][j] + a[i][k] * b[k][j]) mod m
  fim
  retorne result
fim

matrixPow(a: Mat, n: BigInt): Mat =
  se n == 1 então
    a
  senão
    b = matrixPow(a, n div 2)
    c = matrixMult(b, b)
    se n mod 2 == 0 então c senão matrixMult(a, c) fim
  fim
# [f(1) f(n-1)] * T = [f(1) f(n)]
# f(1) * T11 + f(n-1) * T21 = f(1)  -> T11 = 1, T21 = 0
# f(1) * T12 + f(n-1) * T22 = f(n)  -> T12 = 1, T22 = 2
dabriel(n: BigInt): BigInt
  x0: Mat = [[1, 2]]
  a: Mat =  [[1, 0], [1, 2]]
  xn: Mat = matrixMult(x0, matrixPow(a, n - 1))
  retorne xn[1][1]
fim

var n := leia_texto
se n == "1" então
  escreva "00:00:01"
senão
  x = dabriel(BigInt(n))
  escreva "{x div 3600 formato "%02d"}:{x mod 3600 div 60 formato "%02d"}:{x mod 60 formato "%02d"}"
fim

2685 - A Mudança

Descrição do Problema: 2685 - A Mudança

2685 - A Mudança
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
var entrada := leia_texto
enquanto nao eof faça
  grau = entrada.real mod 360
  se grau < 90 então
      escreva "Bom Dia!!"
  senãose grau < 180 então
      escreva "Boa Tarde!!"
  senãose grau < 270 então
      escreva "Boa Noite!!"
  senão
      escreva "De Madrugada!!"
  fim
  entrada := leia_texto
fim

2686 - A Mudança Continua!!

Descrição do Problema: 2686 - A Mudança Continua!!

2686 - A Mudança Continua!!
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
var entrada := leia_texto
enquanto nao eof faça
  grau = entrada.real mod 360
  se grau < 90 então
      escreva "Bom Dia!!"
  senãose grau < 180 então
      escreva "Boa Tarde!!"
  senãose grau < 270 então
      escreva "Boa Noite!!"
  senão
      escreva "De Madrugada!!"
  fim
  angulo = (grau + 90) mod 360
  horas = (angulo / 15).inteiro
  minutos = ((angulo - horas * 15) * 4).inteiro
  segundos = (angulo - horas * 15 - minutos / 4).inteiro
  escreva "{horas formato "%02d"}:{minutos formato "%02d"}:{segundos formato "%02d"}"
  entrada := leia_texto
fim

2687 - Dominação Bacteriana

Descrição do Problema: 2687 - Dominação Bacteriana

2687 - Dominação Bacteriana
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
q = leia_inteiro
para i de 1 até q faça
  l = leia_inteiro
  grid = para j de 1 até l gere leia_inteiros(" ").mutável fim.mutável
  var pontos = Lista(0, 0)
  para j de 1 até l faça
    pontos := [100 + j, 100 * l + j, 100 * j + 1, 100 * j + l] + pontos
  fim
  var area := l * l / 2
  enquanto pontos.tamanho > 0 faça
    ponto = pontos.cabeça
    pontos := pontos.cauda
    x, y = ponto div 100, ponto mod 100
    se x > 0 e y > 0 e x <= l e y <= l e grid[x][y] == 0 então
      area := area - 0.5
      grid[x][y] := -1
      pontos := [ponto - 100, ponto + 100, ponto + 1, ponto - 1] + pontos
    fim
  fim
  escreva area formato "%.2f"
fim

2690 - Nova Senha RA

Descrição do Problema: 2690 - Nova Senha RA

2690 - Nova Senha RA
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
n = leia_inteiro
letras = ["ISblv","EOYcmw","FPZdnx","JTeoy", "DNXfpz", "AKUgq", "CMWhr", "BLVis", "HRjt", "GQaku"]
para i de 1 até n faça
  s = leia_texto.selecione(_ <> ' ').pegue(12)
  para k em s, j de 1 até 10 faça
    se letras[j].contém(k) então
      imprima j mod 10
    fim
  fim
  escreva ""
fim

2691 - O Matemático

Descrição do Problema: 2691 - O Matemático

2691 - O Matemático
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
n = leia_inteiro
para i de 1 até n faça
  entrada = leia_inteiros("x")
  x, y = entrada[1], entrada[2]
  para t de 5 ate 10 faca
    se x == y entao
      escreva "{x} x {t} = {x*t}"
    senao
      escreva "{x} x {t} = {x * t} && {y} x {t} = {y * t}"
    fim
  fim
fim

2693 - Van

Descrição do Problema: 2693 - Van

2693 - Van
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
f = (a, b: (Texto, Texto, Inteiro)) =>
  se a.terceiro <> b.terceiro entao
    a.terceiro < b.terceiro
  senaose a.segundo <> b.segundo entao
    a.segundo < b.segundo
  senao
    a.primeiro < b. primeiro
  fim

var q := leia_inteiro
enquanto q > 0 faca
  alunos = Lista(q, leia_textos(" "))
             .mapeie(a => (a[1], a[2], a[3].inteiro))
  ordem = alunos.ordene(f)
  escreva ordem.mapeie(_.primeiro).junte("\n")
  q := leia_inteiro
fim

2694 - Problema com a Calculadora

Descrição do Problema: 2694 - Problema com a Calculadora

2694 - Problema com a Calculadora
1
2
3
4
5
6
7
8
9
n = leia_inteiro
para i de 1 até n faça
  s = leia_texto
  a = s.descarte(2).inteiro
  b = s.descarte(5).inteiro
  c = s.descarte(11).inteiro
  soma = a + b + c
  escreva soma
fim