Pular para conteúdo

2600

Faixa de problemas: 2600-2699

Total resolvido: 35 de 100 problemas

Problemas não resolvidos (65)

2612, 2613, 2614, 2615, 2616, 2617, 2618, 2619, 2620, 2621, 2622, 2623, 2624, 2625, 2627, 2628, 2629, 2631, 2634, 2636, 2637, 2638, 2639, 2640, 2641, 2642, 2643, 2644, 2645, 2646, 2647, 2648, 2649, 2652, 2655, 2656, 2657, 2658, 2659, 2660, 2662, 2664, 2665, 2666, 2668, 2669, 2671, 2672, 2673, 2675, 2676, 2677, 2678, 2680, 2682, 2683, 2684, 2688, 2689, 2692, 2695, 2696, 2697, 2698, 2699

2600 - Tustin e Seu Dado Novo

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

Categoria: Ad-Hoc

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

Categoria: Ad-Hoc

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

Categoria: SQL

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

Categoria: SQL

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

Categoria: SQL

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

Categoria: SQL

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

Categoria: SQL

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

Categoria: SQL

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

Categoria: SQL

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

Categoria: SQL

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

Categoria: SQL

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

Categoria: SQL

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

Categoria: Iniciante

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 não eof faça
  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

Categoria: Iniciante

2630 - Escala de Cinza
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
t = leia_inteiro
para i de 1 até t faça
  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

Categoria: Iniciante

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 até t faça
    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

Categoria: Estruturas e Bibliotecas

2633 - Churras no Yuri
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
var n := leia_inteiro
enquanto não eof faça
  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

Categoria: Strings

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 até q faça
  s = leia_texto
  t = s.tamanho
  c = palavras.selecione(palavra => palavra.pegue(t) == s)
  maior = c.injete(-1)((a, b) => se b.tamanho > a então b.tamanho senão a fim)
  se c.tamanho > 0 então
    escreva "{c.tamanho} {maior}"
  senão
    escreva -1
  fim
fim

2650 - Construindo Muralhas

Descrição do Problema: 2650 - Construindo Muralhas

Categoria: Ad-Hoc · Olimpíada IFSULDEMINAS 2017

2650 - Construindo Muralhas
1
2
3
4
5
6
7
8
a = leia_inteiros(" ")
n, w = a[1], a[2]
para i de 1 até n faça
  s = leia_textos(" ")
  se s[-1].inteiro > w então
    escreva s.pegue(s.tamanho - 1).junte(" ")
  fim
fim

Descrição do Problema: 2651 - Link Bolado

Categoria: Strings · Olimpíada IFSULDEMINAS 2017

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

2653 - Dijkstra

Descrição do Problema: 2653 - Dijkstra

Categoria: Iniciante · Olimpíada IFSULDEMINAS 2017

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

2654 - Godofor

Descrição do Problema: 2654 - Godofor

Categoria: Estruturas e Bibliotecas · Olimpíada IFSULDEMINAS 2017

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 então s1.poder > s2.poder
  senãose s1.kill <> s2.kill então s1.kill > s2.kill
  senãose s1.morte <> s2.morte então s1.morte < s2.morte
  senão s1.nome < s2.nome
  fim

n = leia_inteiro
seres = para i de 1 até 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

Categoria: Matemática · Maratona SBC (1ª fase) 2017

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

Categoria: Iniciante · Maratona SBC (1ª fase) 2017

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

Categoria: Matemática · Maratona SBC (1ª fase) 2017

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é

Categoria: Iniciante · Maratona SBC (1ª fase) 2017

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!

Categoria: Matemática

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) então
    se n.texto - "014689" == n.texto então
      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

Categoria: Ad-Hoc

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

Categoria: Matemática

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

Categoria: Iniciante

2685 - A Mudança
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
var entrada := leia_texto
enquanto não 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!!

Categoria: Iniciante

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 não 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

Categoria: Grafos

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
  var 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

Categoria: Strings

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

Categoria: Strings

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 até 10 faça
    se x == y então
      escreva "{x} x {t} = {x*t}"
    senão
      escreva "{x} x {t} = {x * t} && {y} x {t} = {y * t}"
    fim
  fim
fim

2693 - Van

Descrição do Problema: 2693 - Van

Categoria: Estruturas e Bibliotecas

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 então
    a.terceiro < b.terceiro
  senãose a.segundo <> b.segundo então
    a.segundo < b.segundo
  senão
    a.primeiro < b. primeiro
  fim

var q := leia_inteiro
enquanto q > 0 faça
  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

Categoria: Strings

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