Pular para conteúdo

1700

Faixa de problemas: 1700-1799

Total: 20 problemas

1708 - Volta

Descrição do Problema: 1708 - Volta

1708 - Volta
1
2
3
4
a = leia_inteiros(" ")
x, y = a[1], a[2]
voltas = (x / (y - x)).teto.inteiro + 1
escreva voltas

1709 - Baralho Embaralhado

Descrição do Problema: 1709 - Baralho Embaralhado

1709 - Baralho Embaralhado
1
2
3
4
5
6
p = leia_inteiro
embaralhar(a, c: Inteiro): Inteiro
  b = se 2 * a <= p entao 2 * a senao 2 * a - (p + 1) fim
  retorne se b == 1 entao c senao embaralhar(b, c + 1) fim
fim
escreva embaralhar(1, 1)

1715 - Handebol

Descrição do Problema: 1715 - Handebol

1715 - Handebol
1
2
3
4
5
6
n = leia_inteiros(" ")[1]
cont = para i de 1 até n
         se leia_inteiros(" ").injete(verdadeiro)((a, b) => a e b > 0) gere
           1
       fim.tamanho
escreva cont

1743 - Máquina de Verificação Automatizada

Descrição do Problema: 1743 - Máquina de Verificação Automatizada

1743 - Máquina de Verificação Automatizada
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
x, y = leia_texto
var compativel := verdadeiro
para i de 1 ate 9 passo 2 faca
  se x[i] == y[i] entao compativel := falso fim
fim
se compativel então
  escreva "Y"
senão
  escreva "N"
fim

1754 - A Sala do Tempo

Descrição do Problema: 1754 - A Sala do Tempo

1754 - A Sala do Tempo
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
n = leia_inteiro
para i de 1 ate n faça
  xy = leia_textos(" ")
  x, y = BigInt(xy[1]), xy[2].inteiro
  k = (x + y - 1) div y
  se k < 2 então
    escreva 2
  senão
    escreva k
  fim
fim

1759 - Ho Ho Ho

Descrição do Problema: 1759 - Ho Ho Ho

1759 - Ho Ho Ho
1
escreva "Ho " * (leia_inteiro - 1) + "Ho!"

1760 - Floco de Neve de Koch

Descrição do Problema: 1760 - Floco de Neve de Koch

1760 - Floco de Neve de Koch
1
2
3
4
5
6
var l := leia_inteiro
enquanto l <> 0 faça
  area = l ^ 2 * 0.6928203230275509
  escreva area formato "%.2f"
  l := leia_inteiro
fim

1761 - Decoração Natalina

Descrição do Problema: 1761 - Decoração Natalina

1761 - Decoração Natalina
1
2
3
4
5
6
7
8
9
var s := leia_texto
rg =  3.141592654/180
enquanto nao eof faca
  r = s.divida(" ").mapeie(_.real)
  a, b, c = r[1], r[2], r[3]
  x = c + b * tg(a * rg)
  escreva 5 * x formato "%.2f"
  s := leia_texto
fim

1763 - Tradutor do Papai Noel

Descrição do Problema: 1763 - Tradutor do Papai Noel

1763 - Tradutor do Papai Noel
 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
natal = [
  ("alemanha", "Frohliche Weihnachten!"),
  ("antardida", "Merry Christmas!"),
  ("argentina", "Feliz Navidad!"),
  ("australia", "Merry Christmas!"),
  ("austria", "Frohe Weihnacht!"),
  ("belgica", "Zalig Kerstfeest!"),
  ("brasil", "Feliz Natal!"),
  ("canada", "Merry Christmas!"),
  ("chile", "Feliz Navidad!"),
  ("coreia", "Chuk Sung Tan!"),
  ("espanha", "Feliz Navidad!"),
  ("estados-unidos", "Merry Christmas!"),
  ("grecia", "Kala Christougena!"),
  ("inglaterra", "Merry Christmas!"),
  ("irlanda", "Nollaig Shona Dhuit!"),
  ("italia", "Buon Natale!"),
  ("japao", "Merii Kurisumasu!"),
  ("libia", "Buon Natale!"),
  ("marrocos", "Milad Mubarak!"),
  ("mexico", "Feliz Navidad!"),
  ("portugal", "Feliz Natal!"),
  ("siria", "Milad Mubarak!"),
  ("suecia", "God Jul!"),
  ("turquia", "Mutlu Noeller")
]

var pais := leia_texto
enquanto nao eof faca
  x = natal.selecione(a => a.primeiro == pais)
  escolha x
    caso a :: as => escreva a.segundo
    caso _       => escreva "--- NOT FOUND ---"
  fim
  pais := leia_texto
fim

1765 - Trapézios de Natal

Descrição do Problema: 1765 - Trapézios de Natal

1765 - Trapézios de Natal
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
var t := leia_inteiro
enquanto t <> 0 faça
    para c de 1 ate t faça
        dados = leia_reais(3)
        escreva "Size #{c}:"
        escreva "Ice Cream Used: {((dados[2] + dados[3]) * 5) / 2 * dados[1] formato "%.2f"} cm2"
    fim
    escreva ""
    t := leia_inteiro
fim

1766 - O Elfo das Trevas

Descrição do Problema: 1766 - O Elfo das Trevas

1766 - O Elfo das Trevas
 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
tipo Rena
  nome: Texto
  peso: Inteiro
  idade: Inteiro
  altura: Real
fim

lt = (r1, r2: Rena) =>
  se r1.peso <> r2.peso entao
    r1.peso > r2.peso
  senaose r1.idade <> r2.idade entao
    r1.idade < r2.idade
  senao
    r1.altura < r2.altura
  fim

t = leia_inteiro
para i de 1 ate t faca
  a = leia_inteiros(" ")
  n, m = a[1], a[2]
  renas = para i de 1 ate n gere
    b = leia_textos(" ")
    Rena(b[1], b[2].inteiro, b[3].inteiro, b[4].real)
  fim
  treno = renas.ordene(lt)
  escreva "CENARIO {'{'}{i}{'}'}"
  para j de 1 ate m faca
    escreva "{j} - {treno[j].nome}"
  fim
fim

1768 - Árvore de Natal

Descrição do Problema: 1768 - Árvore de Natal

1768 - Árvore de Natal
 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
var n := leia_inteiro

enquanto n <> 0 faça
    meio = (n / 2).inteiro + 1

    para i de 1 até meio faça

        para j de i até (n / 2).inteiro faça
            imprima " "
        fim

        numeroImpar = 2 * i - 1
        para j de 1 até numeroImpar faça
            imprima "*"
        fim

        escreva ""
    fim

    var count := 1

    enquanto count <= 2 faça

        para j de count até (n / 2).inteiro faça
            imprima " "
        fim

        numeroImpar = 2 * count - 1
        para j de 1 até numeroImpar faça
            imprima "*"
        fim

        escreva ""
        count := count + 1
    fim

    n := leia_inteiro
    escreva ""
fim

1769 - CPF 1

Descrição do Problema: 1769 - CPF 1

1769 - CPF 1
 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
pesos = [1,2,3,4,5,6,7,8,9]
sosep = pesos.inverta

verificadores(digitos: Lista[Inteiro])
  soma1 = digitos.zip(pesos).mapeie(a => a.primeiro * a.segundo).injete(0)(_ + _)
  soma2 = digitos.zip(sosep).mapeie(a => a.primeiro * a.segundo).injete(0)(_ + _)
  b1 = soma1 mod 11 mod 10
  b2 = soma2 mod 11 mod 10
  retorne (b1, b2)
fim

var entrada := leia_texto
enquanto nao eof faça
    a123 = entrada.pegue(3)
    a456 = entrada.descarte(4).pegue(3)
    a789 = entrada.descarte(8).pegue(3)
    digitos = "{a123}{a456}{a789}".lista.mapeie(_ - '0')
    v = verificadores(digitos)
    b12 = "{v.primeiro}{v.segundo}"
    se b12 == entrada.descarte(12) entao
      escreva "CPF valido"
    senao
      escreva "CPF invalido"
    fim
    entrada := leia_texto
fim

1781 - Guga e a String

Descrição do Problema: 1781 - Guga e a String

1781 - Guga e a String
 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
montar(posicoes, vogais, consoantes: Texto) = (d_vogais, d_consoantes: Inteiro) => faca
  t_vogais, t_consoantes, t = vogais.tamanho, consoantes.tamanho, posicoes.tamanho
  var a := se t_vogais > 0 entao t_vogais - d_vogais mod t_vogais - 1 senao 0 fim
  var b := se t_consoantes > 0 entao t_consoantes - d_consoantes mod t_consoantes - 1 senao 0 fim
  para i de 1 ate t gere
    se posicoes[i] == 'a' entao
      a := (a + 1) mod t_vogais
      vogais[a + 1]
    senao
      b := (b + 1) mod t_consoantes
      consoantes[b + 1]
    fim
  fim.junte("")
fim

é_vogal = (c: Caractere) => c == 'a' ou c == 'e' ou c == 'i' ou c == 'o' ou c == 'u'

t = leia_inteiro
para i de 1 ate t faca
  escreva "Caso #{i}:"
  s = leia_texto
  vogais = s.selecione(é_vogal)
  consoantes = s.selecione(nao é_vogal(_))
  var d_v, d_c := 0
  posicoes = s.mapeie(c => se é_vogal(c) entao 'a' senao 'b' fim)
  q = leia_inteiro
  para i de 1 ate q faca
    x = leia_texto
    y = x.descarte(2).inteiro
    m = montar(posicoes, vogais, consoantes)
    escolha x.cabeca
      caso '0' => d_v := d_v + y
      caso '1' => d_c := d_c + y
      caso  _  => escreva m(d_v, d_c)
    fim
  fim
fim

1786 - CPF 2

Descrição do Problema: 1786 - CPF 2

1786 - CPF 2
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
pesos = [1,2,3,4,5,6,7,8,9]
sosep = pesos.inverta

verificadores(digitos: Lista[Inteiro])
  soma1 = digitos.zip(pesos).mapeie(a => a.primeiro * a.segundo).injete(0)(_ + _)
  soma2 = digitos.zip(sosep).mapeie(a => a.primeiro * a.segundo).injete(0)(_ + _)
  b1 = soma1 mod 11 mod 10
  b2 = soma2 mod 11 mod 10
  retorne (b1, b2)
fim

var entrada := leia_texto
enquanto nao eof faça
    digitos = entrada.lista.mapeie(_ - '0')
    v = verificadores(digitos)
    a123 = entrada.pegue(3)
    a456 = entrada.descarte(3).pegue(3)
    a789 = entrada.descarte(6)
    b12 = "{v.primeiro}{v.segundo}"
    escreva "{a123}.{a456}.{a789}-{b12}"
    entrada := leia_texto
fim

1789 - A Corrida de Lesmas

Descrição do Problema: 1789 - A Corrida de Lesmas

1789 - A Corrida de Lesmas
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
var n := leia_inteiro

enquanto n <> 0 faça
  velocidades = leia_inteiros(" ")
  maior_velocidade = velocidades.injete(0)((a, b) => se a > b então a senão b fim)

  escolha maior_velocidade
    caso velocidade se velocidade < 10 => escreva 1
    caso velocidade se velocidade < 20 => escreva 2
    caso _                             => escreva 3
  fim

  n := leia_inteiro
fim

1793 - Escada Rolante

Descrição do Problema: 1793 - Escada Rolante

1793 - Escada Rolante
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
enquanto leia_inteiro > 0 faca
  t = leia_inteiros(" ")
  d = t.divida_quando((a, b) => b - a > 10)
  var tempo := 0
  para p em d faca
    dt = 10 + p[-1] - p[1]
    tempo := tempo + dt
  fim
  escreva tempo
fim

1794 - Lavanderia

Descrição do Problema: 1794 - Lavanderia

1794 - Lavanderia
1
2
3
4
5
6
7
8
9
n = leia_inteiro
l = leia_inteiros(" ")
s = leia_inteiros(" ")

se (l[1] <= n) e (n <= l[2]) e (s[1] <= n) e (n <= s[2]) então
  escreva "possivel"
senão
  escreva "impossivel"
fim

1795 - Triângulo Trinomial

Descrição do Problema: 1795 - Triângulo Trinomial

1795 - Triângulo Trinomial
1
2
3
n = leia_inteiro
resp = [1, 3, 9, 27, 81, 243, 729, 2187, 6561, 19683, 59049, "177147", "531441", "1594323", "4782969", "14348907", "43046721", "129140163", "387420489", "1162261467", "3486784401"]
escreva resp[n + 1]

1796 - Economia Brasileira

Descrição do Problema: 1796 - Economia Brasileira

1796 - Economia Brasileira
1
2
3
4
5
6
7
8
q = leia_inteiro
v = leia_inteiros(" ")
satisfeitos = v.injete(0)(_ + _).tamanho
se satisfeitos > q div 2 entao
  escreva "Y"
senao
  escreva "N"
fim