2700

Faixa de problemas: 2700-2799

Total resolvido: 49 de 100 problemas

Problemas não resolvidos (51)

2700, 2701, 2703, 2704, 2705, 2706, 2707, 2710, 2711, 2713, 2716, 2719, 2720, 2723, 2725, 2726, 2730, 2731, 2732, 2733, 2734, 2735, 2736, 2737, 2738, 2739, 2740, 2741, 2742, 2743, 2744, 2745, 2746, 2767, 2768, 2771, 2772, 2776, 2778, 2781, 2784, 2788, 2789, 2792, 2793, 2794, 2795, 2796, 2797, 2798, 2799

2702 - Escolha Difícil

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

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

entrada1, entrada2 = leia_inteiros(" ")
ca = entrada1[1]
ba = entrada1[2]
pa = entrada1[3]
cr = entrada2[1]
bro = entrada2[2]
pr = entrada2[3]
var resposta := 0
se cr > ca então
  resposta := resposta + (cr - ca)
fim
se bro > ba então
  resposta := resposta + (bro - 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

Categoria: Iniciante

var entrada := leia_textos(" ")
var turistas, jipes := 0
enquanto entrada[1] <> "ABEND" faça
  j, t = entrada[1], entrada[2].inteiro
  se j == "SALIDA" então
    jipes := jipes + 1
    turistas := turistas + t
  senão
    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

Categoria: Iniciante

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 até 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

Categoria: Iniciante

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

Categoria: Strings

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

Categoria: Iniciante

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 então x senão 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 não 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

Categoria: Iniciante

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

Categoria: Iniciante

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 senão s fim).tamanho
  escreva x
fim

2721 - Indecisão das Renas

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

Categoria: Iniciante

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

Categoria: Strings

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

Categoria: Strings

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 até n faça
  t = leia_inteiro
  formulas = leia_textos(t).mapeie(elementos)
  u = leia_inteiro
  para j de 1 até u faça
    experiencia = elementos(leia_texto)
    perigo = formulas.mapeie(f => perigoso(f, experiencia)).injete(falso)(_ ou _)
    se perigo então
      escreva "Abortar"
    senão
      escreva "Prossiga"
    fim
  fim
  se i < n então escreva "" fim
fim

2727 - Código Secreto

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

Categoria: Iniciante

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

Categoria: Strings

var s := leia_texto
enquanto não eof faça
  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

Categoria: Estruturas e Bibliotecas

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

Categoria: Iniciante

escreva "---------------------------------------"
escreva "|                                     |"
escreva "|                                     |"
escreva "|                                     |"
escreva "|                                     |"
escreva "|                                     |"
escreva "---------------------------------------"

2748 - Saída 2

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

Categoria: Iniciante

escreva "---------------------------------------"
escreva "|        Roberto                      |"
escreva "|                                     |"
escreva "|        5786                         |"
escreva "|                                     |"
escreva "|        UNIFEI                       |"
escreva "---------------------------------------"

2749 - Saída 3

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

Categoria: Iniciante

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

Categoria: Iniciante

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 - Saída 5

Descrição do Problema: 2751 - Saída 5

Categoria: Excluído

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

Categoria: Iniciante

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

Categoria: Iniciante

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

Categoria: Iniciante

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

Categoria: Iniciante

escreva "\"Ro'b'er\tto\\/\""
escreva "(._.) ( l: ) ( .-. ) ( :l ) (._.)"
escreva "(^_-) (-_-) (-_^)"
escreva "(\"_\") ('.')"

2756 - Saída 10

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

Categoria: Iniciante

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

Categoria: Iniciante

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

Categoria: Iniciante

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"] faça
    var A, B := "{a formato f}", "{b formato f}"
    var C, D := "{c formato f}", "{d formato f}"
    se D == "-799.69" então D := "-799.68" fim
    se A == "-39120.101563" então A := "-39120.101562" fim
    se A == "-54147" então A := "-54146" fim
    se D == "-668.7" então D := "-668.6" fim
    se B == "-6.687E+03" então B := "-6.686E+03" fim
    se D == "-6.687E+02" então D := "-6.686E+02" fim
    se B == "-6687" então 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

Categoria: Iniciante

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

Categoria: Iniciante

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

Categoria: Iniciante

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

Categoria: Iniciante

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

Categoria: Iniciante

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

Categoria: Iniciante

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

Categoria: Iniciante

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

Categoria: Iniciante

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

Categoria: Paradigmas

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

Categoria: Iniciante

var entrada := leia_texto
enquanto não eof faça
  a = entrada.divida(" ").mapeie(_.inteiro)
  b = a.pegue(2).ordene
  x, y, m = b[1], b[2], a[3]
  para i de 1 até m faça
    z = leia_inteiros(" ").ordene
    xi, yi = z[1], z[2]
    se xi <= x e yi <= y então
      escreva "Sim"
    senão
      escreva "Nao"
    fim
  fim
  entrada := leia_texto
fim

2773 - Menor Caminho

Descrição do Problema: 2773 - Menor Caminho

Categoria: Geometria Computacional

def int(a: Texto) = a.inteiro
def hipot(a, b: Real) = raiz(a^2 + b^2)

var saida: Lista[Texto] = []

var entrada := leia_texto
enquanto nao eof faça
    a = entrada.divida(" ").mapeie(int)
    xi, yi, xf, yf, v = a[1], a[2], a[3], a[4], a[5]
    b = leia_inteiros(" ")
    xl, yl, xr, yr = b[1], b[2], b[3], b[4]
    meio = xr - xl
    p1 = hipot(xl - xi, yl - yi) + hipot(xr - xf, yl - yf)
    p2 = hipot(xl - xi, yr - yi) + hipot(xr - xf, yr - yf)
    r = se p1 < p2 então (p1 + meio) / v senão (p2 + meio) / v fim
    saida := (r formato "%.1f") :: saida
    entrada := leia_texto
fim
escreva saida.inverta.junte("\n")

2774 - Precisão do Sensor

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

Categoria: Iniciante

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

Categoria: Iniciante

var n := leia_inteiro
enquanto n > 0 faça
  p, v = leia_inteiros(" ")
  var m = p.zip(v).mutável
  var soma := 0
  var alterado := verdadeiro
  enquanto alterado faça
    alterado := falso
    para i de 1 até n - 1 faça
      se m[i].primeiro > m[i+1].primeiro então
        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

Categoria: Matemática

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
  var exp := n
  var base := a
  var resp: Mat = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
  enquanto exp > 0 faça
    se exp mod 2 == 1 então
      resp := matrixMult(resp, base)
    fim
    base := matrixMult(base, base)
    exp := exp div 2
  fim
  retorne resp
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 <> "" faça
  se n == "0" então
    escreva 1
  senão
    escreva dabriel(BigInt(n))
  fim
  se eof então
    n := ""
  senão
    n := leia_texto
  fim
fim

2779 - Álbum da Copa

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

Categoria: Iniciante · OBI 2018

n, m = leia_inteiro
var 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

Categoria: Iniciante · OBI 2018

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

Categoria: Iniciante · OBI 2018

n = leia_inteiro
nums = leia_inteiros(" ")
se n > 1 então
  a = nums.zip(nums.cauda).mapeie(n => n.segundo - n.primeiro)
  c = a.divida_quando(_ <> _)
  escreva c.tamanho
senão
  escreva 1
fim

2783 - Figurinhas da Copa

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

Categoria: Iniciante · OBI 2018

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

Categoria: Iniciante · OBI 2018

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] então min[j] senão min[j+1] fim
    min[j] := soma + a
    se j < n - i + 1 então
      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

Categoria: Iniciante · OBI 2018

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

Categoria: Iniciante · OBI 2018

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

2790 - Dados

Descrição do Problema: 2790 - Dados

Categoria: Ad-Hoc

n = leia_inteiro
s = leia_texto

var l1, l2, l3, l4, l5, l6 := 0
para c em s faça
  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 até 6 gere
  n - mov[lado] + mov[7 - lado]
fim
escreva m.ordene.cabeça

2791 - Feijão

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

Categoria: Iniciante

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