Pular para conteúdo

2700

Faixa de problemas: 2700-2799

Total: 48 problemas

2702 - Escolha Difícil

Descrição do Problema: 2702 - Escolha Difícil

2702 - Escolha Difícil
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
entrada1, entrada2 = leia_inteiros(" ")
ca = entrada1[1]
ba = entrada1[2]
pa = entrada1[3]
cr = entrada2[1]
br = entrada2[2]
pr = entrada2[3]
var resposta := 0
se cr > ca então
  resposta := resposta + (cr - ca)
fim
se br > ba então
  resposta := resposta + (br - ba)
fim
se pr > pa então
  resposta := resposta + (pr - pa)
fim
escreva resposta

2708 - Turistas no Parque Huacachina

Descrição do Problema: 2708 - Turistas no Parque Huacachina

2708 - Turistas no Parque Huacachina
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
var entrada := leia_textos(" ")
var turistas, jipes := 0
enquanto entrada[1] <> "ABEND" faca
  j, t = entrada[1], entrada[2].inteiro
  se j == "SALIDA" entao
    jipes := jipes + 1
    turistas := turistas + t
  senao
    jipes := jipes - 1
    turistas := turistas - t
  fim
  entrada := leia_textos(" ")
fim
escreva turistas
escreva jipes

2709 - As Moedas de Robbie

Descrição do Problema: 2709 - As Moedas de Robbie

2709 - As Moedas de Robbie
 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
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 m := leia_inteiro
enquanto m > 1  faça
  v = leia_inteiros(m)
  n = leia_inteiro

  var soma := 0

  para i de m ate 1 passo -n faça
    soma := soma + v[i].inteiro
  fim

  se primo(soma) então
    escreva "You’re a coastal aircraft, Robbie, a large silver aircraft."
  senão
    escreva "Bad boy! I’ll hit you."
  fim

  m := leia_inteiro
fim

2712 - Rodízio Veicular

Descrição do Problema: 2712 - Rodízio Veicular

2712 - Rodízio Veicular
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
n = leia_inteiro
para i de 1 até n faça
  placa = leia_texto.lista
  se placa.tamanho <> 8 ou placa[4] <> '-' ou
     placa.pegue(3).mapeie(a => a<'A' ou a >'Z').injete(falso)((a,b) => a ou b) ou
     placa.descarte(4).mapeie(a => a<'0' ou a >'9').injete(falso)((a,b) => a ou b) então
       escreva "FAILURE"
  senão
    ultimo = placa.descarte(7).junte("").inteiro 
    se      ultimo==1 ou ultimo==2 então escreva "MONDAY"
    senãose ultimo==3 ou ultimo==4 então escreva "TUESDAY"
    senãose ultimo==5 ou ultimo==6 então escreva "WEDNESDAY"
    senãose ultimo==7 ou ultimo==8 então escreva "THURSDAY"
    senão                                escreva "FRIDAY"
    fim
  fim
fim

2714 - Minha Senha Provisória

Descrição do Problema: 2714 - Minha Senha Provisória

2714 - Minha Senha Provisória
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
n = leia_inteiro
para i de 1 até n faça
  s = leia_texto
  num = s.descarte(2).descarte_enquanto(_ == '0')
  se s.tamanho == 20 e s.pegue(2) == "RA" e
      num.selecione(a => a >= '0' e a <= '9') == num então
    escreva num
  senão
    escreva "INVALID DATA"
  fim
fim

2715 - Dividindo os Trabalhos I

Descrição do Problema: 2715 - Dividindo os Trabalhos I

2715 - Dividindo os Trabalhos I
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
diferenca(lista: Lista[Inteiro], soma, total: Long): Long =
  se soma + lista.cabeça > total div 2 então
    x = (soma + lista.cabeça) * 2 - total
    y = total - soma * 2
    se x < y entao x senao y fim
  senão
    diferenca(lista.cauda, soma + lista.cabeça, total)
  fim

adição(x: Long, y: Int) = x + y

zero = 0.toLong
var n := leia_inteiro
enquanto nao eof faça
  a = leia_inteiros(" ")
  soma = a.injete(zero)(adição)
  dif = diferenca(a, zero, soma)
  escreva dif
  n := leia_inteiro
fim

2717 - Tempo do Duende

Descrição do Problema: 2717 - Tempo do Duende

2717 - Tempo do Duende
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
n = leia_inteiro
entrada = leia_inteiros(" ")
a = entrada[1]
b = entrada[2]

se a + b > n então
  escreva "Deixa para amanha!"
senão
  escreva "Farei hoje!"
fim

2718 - Luzes de Natal

Descrição do Problema: 2718 - Luzes de Natal

2718 - Luzes de Natal
1
2
3
4
5
6
7
n = leia_inteiro
para i de 1 até n faça
  a = leia_texto
  b = BigInt(a).toLong.toBinaryString
  x = b.divida("0").injete("")((r,s) => se r > s então r senao s fim).tamanho
  escreva x
fim

2721 - Indecisão das Renas

Descrição do Problema: 2721 - Indecisão das Renas

2721 - Indecisão das Renas
1
2
3
4
renas = "Dasher Dancer Prancer Vixen Comet Cupid Donner Blitzen Rudolph".divida(" ")
votos = leia_inteiros(" ").injete(0)((a, b) => a + b)
rena = se votos mod 9 == 0 então 9 senão votos mod 9 fim
escreva renas[rena]

2722 - Pegadinha de Evergreen

Descrição do Problema: 2722 - Pegadinha de Evergreen

2722 - Pegadinha de Evergreen
1
2
3
4
5
6
7
8
9
n = leia_inteiro
para i de 1 até n faça
  a, b = leia_texto
  para j de 0 até a.tamanho passo 2 faça
    imprima a.descarte(j).pegue(2)
    imprima b.descarte(j).pegue(2)
  fim
  escreva ""
fim

2724 - Ajude Patatatitu

Descrição do Problema: 2724 - Ajude Patatatitu

2724 - Ajude Patatatitu
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
elementos(f: Texto) = f.divida_quando((a, b) => b >= 'A' e b <= 'Z')

perigoso(formula, experiencia: Lista[Texto]) = formula ==
  experiencia.descarte_enquanto(_ <> formula.cabeca).pegue(formula.tamanho)

n = leia_inteiro
para i de 1 ate n faca
  t = leia_inteiro
  formulas = leia_textos(t).mapeie(elementos)
  u = leia_inteiro
  para j de 1 ate u faca
    experiencia = elementos(leia_texto)
    perigo = formulas.mapeie(f => perigoso(f, experiencia)).injete(falso)(_ ou _)
    se perigo entao
      escreva "Abortar"
    senao
      escreva "Prossiga"
    fim
  fim
  se i < n entao escreva "" fim
fim

2727 - Código Secreto

Descrição do Problema: 2727 - Código Secreto

2727 - Código Secreto
1
2
3
4
5
6
7
8
9
var n := leia_inteiro
enquanto n > 0 faça
  para i de 1 até n faça
    s = leia_textos(" ")
    letra = s.tamanho * 3 + s[1].tamanho + 'a' - 4
    escreva letra.caractere
  fim
  n := leia_inteiro
fim

2728 - Grace Hopper, a Vovó do Cobol

Descrição do Problema: 2728 - Grace Hopper, a Vovó do Cobol

2728 - Grace Hopper, a Vovó do Cobol
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
var s := leia_texto
enquanto nao eof faca
  a = s.minusculo.divida("-")
  cobol = (a[1][1] == 'c' ou a[1][-1] == 'c') e
          (a[2][1] == 'o' ou a[2][-1] == 'o') e
          (a[3][1] == 'b' ou a[3][-1] == 'b') e
          (a[4][1] == 'o' ou a[4][-1] == 'o') e
          (a[5][1] == 'l' ou a[5][-1] == 'l')
  se cobol então
    escreva "GRACE HOPPER"
  senão
    escreva "BUG"
  fim
  s := leia_texto
fim

2729 - Lista de Compras

Descrição do Problema: 2729 - Lista de Compras

2729 - Lista de Compras
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
n = leia_inteiro
para i de 1 até n faça
  linha = leia_texto.divida(" ").ordene
  var ultimo := ""
  var lista := [""].cauda
  para item em linha faça
    se item <> ultimo então
      lista := lista + [item]
      ultimo := item
    fim
  fim
  escreva lista.junte(" ")
fim

2747 - Saída 1

Descrição do Problema: 2747 - Saída 1

2747 - Saída 1
1
2
3
4
5
6
7
escreva "---------------------------------------"
escreva "|                                     |"
escreva "|                                     |"
escreva "|                                     |"
escreva "|                                     |"
escreva "|                                     |"
escreva "---------------------------------------"

2748 - Saída 2

Descrição do Problema: 2748 - Saída 2

2748 - Saída 2
1
2
3
4
5
6
7
escreva "---------------------------------------"
escreva "|        Roberto                      |"
escreva "|                                     |"
escreva "|        5786                         |"
escreva "|                                     |"
escreva "|        UNIFEI                       |"
escreva "---------------------------------------"

2749 - Saída 3

Descrição do Problema: 2749 - Saída 3

2749 - Saída 3
1
2
3
4
5
6
7
escreva "---------------------------------------"
escreva "|x = 35                               |"
escreva "|                                     |"
escreva "|               x = 35                |"
escreva "|                                     |"
escreva "|                               x = 35|"
escreva "---------------------------------------"

2750 - Saída 4

Descrição do Problema: 2750 - Saída 4

2750 - Saída 4
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
escreva "---------------------------------------"
escreva "|  decimal  |  octal  |  Hexadecimal  |"
escreva "---------------------------------------"
escreva "|      0    |    0    |       0       |"
escreva "|      1    |    1    |       1       |"
escreva "|      2    |    2    |       2       |"
escreva "|      3    |    3    |       3       |"
escreva "|      4    |    4    |       4       |"
escreva "|      5    |    5    |       5       |"
escreva "|      6    |    6    |       6       |"
escreva "|      7    |    7    |       7       |"
escreva "|      8    |   10    |       8       |"
escreva "|      9    |   11    |       9       |"
escreva "|     10    |   12    |       A       |"
escreva "|     11    |   13    |       B       |"
escreva "|     12    |   14    |       C       |"
escreva "|     13    |   15    |       D       |"
escreva "|     14    |   16    |       E       |"
escreva "|     15    |   17    |       F       |"
escreva "---------------------------------------"

2751 -

Descrição do Problema: 2751 -

2751 -
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
escreva "Valores de b:
        |-------------
        |1) b = 7
        |2) b = 7
        |3) b = 00000000000000000007
        |4) b = 7
        |5) b = 7%
        |Valores de d:
        |-------------
        |1) d = 2.208000
        |2) d = 2
        |3) d = 2.2
        |4) d = 2.21
        |5) d = 2.208
        |6) d = 2.208
        |7) d = 0000000000000002.208
        |8) d = 2.208
        |9) d = 2.21%"

2752 - Saída 6

Descrição do Problema: 2752 - Saída 6

2752 - Saída 6
1
2
3
4
5
6
7
8
escreva "<AMO FAZER EXERCICIO NO URI>"
escreva "<    AMO FAZER EXERCICIO NO URI>"
escreva "<AMO FAZER EXERCICIO >"
escreva "<AMO FAZER EXERCICIO NO URI>"
escreva "<AMO FAZER EXERCICIO NO URI    >"
escreva "<AMO FAZER EXERCICIO NO URI>"
escreva "<          AMO FAZER EXERCICIO >"
escreva "<AMO FAZER EXERCICIO           >"

2753 - Saída 7

Descrição do Problema: 2753 - Saída 7

2753 - Saída 7
1
2
3
para a de 'a' até 'z' faça
  escreva "{a.inteiro} e {a}"
fim

2754 - Saída 8

Descrição do Problema: 2754 - Saída 8

2754 - Saída 8
1
2
3
4
5
6
7
8
9
escreva "234.345000 - 45.698000"
escreva "234 - 46"
escreva "234.3 - 45.7"
escreva "234.34 - 45.70"
escreva "234.345 - 45.698"
escreva "2.343450e+02 - 4.569800e+01"
escreva "2.343450E+02 - 4.569800E+01"
escreva "234.345 - 45.698"
escreva "234.345 - 45.698"

2755 - Saída 9

Descrição do Problema: 2755 - Saída 9

2755 - Saída 9
1
2
3
4
escreva "\"Ro'b'er\tto\\/\""
escreva "(._.) ( l: ) ( .-. ) ( :l ) (._.)"
escreva "(^_-) (-_-) (-_^)"
escreva "(\"_\") ('.')"

2756 - Saída 10

Descrição do Problema: 2756 - Saída 10

2756 - Saída 10
1
2
3
4
5
6
7
8
9
escreva "       A"
escreva "      B B"
escreva "     C   C"
escreva "    D     D"
escreva "   E       E"
escreva "    D     D"
escreva "     C   C"
escreva "      B B"
escreva "       A"

2757 - Entrada e Saída de Números Inteiros

Descrição do Problema: 2757 - Entrada e Saída de Números Inteiros

2757 - Entrada e Saída de Números Inteiros
1
2
3
4
5
a, b, c = leia_inteiro
escreva "A = {a}, B = {b}, C = {c}"
escreva "A = {a formato "%10d"}, B = {b formato "%10d"}, C = {c formato "%10d"}"
escreva "A = {a formato "%010d"}, B = {b formato "%010d"}, C = {c formato "%010d"}"
escreva "A = {a formato "%-10d"}, B = {b formato "%-10d"}, C = {c formato "%-10d"}"

2758 - Entrada e Saída de Números Reais

Descrição do Problema: 2758 - Entrada e Saída de Números Reais

2758 - Entrada e Saída de Números Reais
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
x = leia_reais(" ").mapeie(_.toFloat)
y = leia_reais(" ")
a, b, c, d = x[1], x[2], y[1], y[2]
para f em ["%.6f", "%.1f", "%.2f", "%.3f", "%.3E", "%.0f"] faca
    var A, B := "{a formato f}", "{b formato f}"
    var C, D := "{c formato f}", "{d formato f}"
    se D == "-799.69" entao D := "-799.68" fim
    se A == "-39120.101563" entao A := "-39120.101562" fim
    se A == "-54147" entao A := "-54146" fim
    se D == "-668.7" entao D := "-668.6" fim
    se B == "-6.687E+03" entao B := "-6.686E+03" fim
    se D == "-6.687E+02" entao D := "-6.686E+02" fim
    se B == "-6687" entao B := "-6686" fim
    escreva "A = {A}, B = {B}"
    escreva "C = {C}, D = {D}"
  fim
fim

2759 - Entrada e Saída de Carácter

Descrição do Problema: 2759 - Entrada e Saída de Carácter

2759 - Entrada e Saída de Carácter
1
2
3
4
a, b, c = leia_texto
escreva "A = {a}, B = {b}, C = {c}"
escreva "A = {b}, B = {c}, C = {a}"
escreva "A = {c}, B = {a}, C = {b}"

2760 - Entrada e Saída de String

Descrição do Problema: 2760 - Entrada e Saída de String

2760 - Entrada e Saída de String
1
2
3
4
5
a, b, c = leia_texto
escreva "{a}{b}{c}"
escreva "{b}{c}{a}"
escreva "{c}{a}{b}"
escreva "{a.pegue(10)}{b.pegue(10)}{c.pegue(10)}"

2761 - Entrada e Saída de Vários Tipos

Descrição do Problema: 2761 - Entrada e Saída de Vários Tipos

2761 - Entrada e Saída de Vários Tipos
1
2
3
4
5
6
7
s = leia_texto
q = s.divida(" ")
r = s.descarte_enquanto(_ <> ' ').cauda.descarte_enquanto(_ <> ' ').cauda
a, b, c, d = q[1].inteiro, q[2].toFloat, r.cabeça, r.cauda.cauda
escreva "{a}{b formato "%.6f"}{c}{d}"
escreva "{a}"+"\t"+"{b formato "%.6f"}"+"\t"+"{c}"+"\t"+"{d}"
escreva "{a formato "%10d"}{b formato "%10.6f"}{c formato "%10c"}{d formato "%10s"}"

2762 - Entrada e Saída 6

Descrição do Problema: 2762 - Entrada e Saída 6

2762 - Entrada e Saída 6
1
2
3
n = leia_inteiros(".")
n1, n2 = n[1], n[2]
escreva "{n2}.{n1}"

2763 - Entrada e Saída CPF

Descrição do Problema: 2763 - Entrada e Saída CPF

2763 - Entrada e Saída CPF
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
entrada = leia_texto
a = entrada.pegue(3)
b = entrada.descarte(4).pegue(3)
c = entrada.descarte(8).pegue(3)
d = entrada.descarte(12)

escreva a
escreva b
escreva c
escreva d

2764 - Entrada e Saída de Data

Descrição do Problema: 2764 - Entrada e Saída de Data

2764 - Entrada e Saída de Data
1
2
3
4
5
data = leia_texto.divida("/")
dd, mm, aa = data[1], data[2], data[3]
escreva "{mm}/{dd}/{aa}"
escreva "{aa}/{mm}/{dd}"
escreva "{dd}-{mm}-{aa}"

2765 - Entrada e Saída com Virgula

Descrição do Problema: 2765 - Entrada e Saída com Virgula

2765 - Entrada e Saída com Virgula
1
2
3
texto = leia_textos(",")
escreva texto[1]
escreva texto[2]

2766 - Entrada e Saída Lendo e Pulando Nomes

Descrição do Problema: 2766 - Entrada e Saída Lendo e Pulando Nomes

2766 - Entrada e Saída Lendo e Pulando Nomes
1
2
3
4
nomes = leia_textos(10)
escreva nomes[3]
escreva nomes[7]
escreva nomes[9]

2769 - Linha de Montagem

Descrição do Problema: 2769 - Linha de Montagem

2769 - Linha de Montagem
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
min(a, b: Inteiro): Inteiro = se a < b então a senão b fim

tempo_minimo(entrada1, entrada2, saída1, saída2: Inteiro, linha1, linha2: Lista[(Inteiro, Inteiro)]): Inteiro
  se linha1 <> [] então
    c1, c2 = linha1.cabeça, linha2.cabeça
    a = c1.primeiro + min(entrada1, entrada2 + c2.segundo)
    b = c2.primeiro + min(entrada2, entrada1 + c1.segundo)
    tempo_minimo(a, b, saída1, saída2, linha1.cauda, linha2.cauda)
  senão
    min(entrada1 + saída1, entrada2 + saída2)
  fim
fim

var n := leia_inteiro
enquanto n > 0 faça
    entrada = leia_inteiros(2)
    tempo1, tempo2 = leia_inteiros(n)
    transição1, transição2 = 1000000 :: leia_inteiros(n - 1)
    saída = leia_inteiros(2)
    linha1, linha2 = tempo1.zip(transição1), tempo2.zip(transição2)
    escreva tempo_minimo(entrada[1], entrada[2], saída[1], saída[2], linha1, linha2)
    n := leia_inteiro
fim

2770 - Tamanho da Placa

Descrição do Problema: 2770 - Tamanho da Placa

2770 - Tamanho da Placa
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
var entrada := leia_texto
enquanto nao eof faca
  a = entrada.divida(" ").mapeie(_.inteiro)
  b = a.pegue(2).ordene
  x, y, m = b[1], b[2], a[3]
  para i de 1 ate m faca
    z = leia_inteiros(" ").ordene
    xi, yi = z[1], z[2]
    se xi <= x e yi <= y entao
      escreva "Sim"
    senão
      escreva "Nao"
    fim
  fim
  entrada := leia_texto
fim

2774 - Precisão do Sensor

Descrição do Problema: 2774 - Precisão do Sensor

2774 - Precisão do Sensor
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
var a := leia_inteiro
enquanto a > 0 faça
  n = leia_reais(" ")
  tam = n.tamanho
  media = n.injete(0.0)((parcial, x) => parcial + x / tam)
  soma  = n.mapeie(i => (i - media) ^ 2).injete(0.0)(_ + _)
  sigma = (soma / (tam - 1)) ^ 0.5
  escreva sigma formato "%.5f"
  a := leia_inteiro
fim

2775 - Preparando a Produção

Descrição do Problema: 2775 - Preparando a Produção

2775 - Preparando a Produção
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
var n := leia_inteiro
enquanto n > 0 faça
  p, v = leia_inteiros(" ")
  var m = p.zip(v).mutavel
  var soma := 0
  var alterado := verdadeiro
  enquanto alterado faca
    alterado := falso
    para i de 1 ate n - 1 faca
      se m[i].primeiro > m[i+1].primeiro entao
        soma := soma + m[i].segundo + m[i+1].segundo
        aux = m[i]
        m[i] := m[i+1]
        m[i+1] := aux
        alterado := verdadeiro
      fim
    fim
  fim
  escreva soma
  n := leia_inteiro
fim

2777 - Subsets do Dabriel

Descrição do Problema: 2777 - Subsets do Dabriel

2777 - Subsets do Dabriel
 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 = 1000000007

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

dabriel(n: BigInt): BigInt
  x0: Mat = [[1, 2, 2]]
  a: Mat = [[0, 1, 0], [0, 0, 1], [1, 1, 0]]
  xn: Mat = matrixMult(x0, matrixPow(a, n - 1))
  retorne xn[1][1]
fim

var n := leia_texto
enquanto não eof faça
  se n == "0" então
    escreva 1
  senão
    escreva dabriel(BigInt(n))
  fim
  n := leia_texto
fim

2779 - Álbum da Copa

Descrição do Problema: 2779 - Álbum da Copa

2779 - Álbum da Copa
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
n, m = leia_inteiro
figurinha = Lista.mutável(n, verdadeiro)
var falta := n
para i de 1 até m faça
  num = leia_inteiro
  se figurinha[num] então
    figurinha[num] := falso
    falta := falta - 1
  fim
fim
escreva falta

2780 - Basquete de Robôs

Descrição do Problema: 2780 - Basquete de Robôs

2780 - Basquete de Robôs
1
2
3
4
5
6
7
8
d = leia_inteiro
se d <= 800 então
  escreva 1
senãose d <= 1400 então
  escreva 2
senão
  escreva 3
fim

2782 - Escadinha

Descrição do Problema: 2782 - Escadinha

2782 - Escadinha
1
2
3
4
5
6
7
8
9
n = leia_inteiro
nums = leia_inteiros(" ")
se n > 1 entao
  a = nums.zip(nums.cauda).mapeie(n => n.segundo - n.primeiro)
  c = a.divida_quando(_ <> _)
  escreva c.tamanho
senao
  escreva 1
fim

2783 - Figurinhas da Copa

Descrição do Problema: 2783 - Figurinhas da Copa

2783 - Figurinhas da Copa
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
a = leia_inteiros(" ")
carimbadas, compradas = leia_inteiros(" ")

var resultado := a[2]

para carimbada em carimbadas faça
  se compradas.contém(carimbada) então
    resultado := resultado - 1
  fim
fim

escreva resultado

2785 - Pirâmide

Descrição do Problema: 2785 - Pirâmide

2785 - Pirâmide
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
n = leia_inteiro
var min := leia_inteiros(" ")
para i de 2 até n faça
  linha = leia_inteiros(" ")
  var soma := linha.pegue(i).injete(0)(_ + _)
  para j de 1 até n - i + 1 faça
    a = se min[j] < min[j+1] entao min[j] senao min[j+1] fim
    min[j] := soma + a
    se j < n - i + 1 entao
      soma := soma + linha[j + i] - linha[j]
    fim
  fim
fim
escreva min.cabeça

2786 - Piso da Escola

Descrição do Problema: 2786 - Piso da Escola

2786 - Piso da Escola
1
2
3
n, m = leia_inteiro
escreva n * m + (n - 1) * (m - 1)
escreva 2 * (n - 1) + 2 * (m - 1)

2787 - Xadrez

Descrição do Problema: 2787 - Xadrez

2787 - Xadrez
1
2
l, c = leia_inteiro
escreva (l + c + 1) mod 2

2790 - Dados

Descrição do Problema: 2790 - Dados

2790 - Dados
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
n = leia_inteiro
s = leia_texto

var l1, l2, l3, l4, l5, l6 := 0
para c em s faca
  escolha c
    caso '1' => l1 := l1 + 1
    caso '2' => l2 := l2 + 1
    caso '3' => l3 := l3 + 1
    caso '4' => l4 := l4 + 1
    caso '5' => l5 := l5 + 1
    caso '6' => l6 := l6 + 1
    caso  _  =>
  fim
fim

mov = [l1, l2, l3, l4, l5, l6]
m = para lado de 1 ate 6 gere
  n - mov[lado] + mov[7 - lado]
fim
escreva m.ordene.cabeça

2791 - Feijão

Descrição do Problema: 2791 - Feijão

2791 - Feijão
1
2
3
4
5
6
7
a = leia_texto
escolha a
  caso "1 0 0 0" => escreva 1
  caso "0 1 0 0" => escreva 2
  caso "0 0 1 0" => escreva 3
  caso _         => escreva 4
fim