1500

Faixa de problemas: 1500-1599

Total resolvido: 33 de 100 problemas

Problemas não resolvidos (67)

1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1513, 1517, 1518, 1519, 1520, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 1535, 1538, 1539, 1543, 1544, 1545, 1550, 1552, 1554, 1556, 1560, 1562, 1563, 1565, 1568, 1569, 1570, 1571, 1572, 1575, 1576, 1577, 1578, 1579, 1583, 1584, 1586, 1587, 1588, 1590, 1591, 1592, 1593, 1594, 1595, 1596, 1597, 1598, 1599

1512 - Azulejos

Descrição do Problema: 1512 - Azulejos

Categoria: Matemática

gcd(a, b: Inteiro): Inteiro
    se b == 0 então a senão gcd(b, a mod b) fim
fim

var flag := verdadeiro
enquanto flag faça
    temp = leia_inteiros(3)
    n, a, b = temp[1], temp[2], temp[3]
    se n == 0 e a == 0 e b == 0 então
        flag := falso
    senão
        escreva (n div a) + (n div b) - (n div (a * b div gcd(a, b)))
    fim
fim

1514 - Competição

Descrição do Problema: 1514 - Competição

Categoria: Ad-Hoc

transpor(mat: Lista[Lista[Inteiro]]): Lista[Lista[Inteiro]] = 
    se mat.cabeça == [] então []
    senão mat.mapeie(_.cabeça) :: transpor(mat.mapeie(_.cauda))
    fim

total_linhas(linha: Lista[Lista[Inteiro]]): Lista[Inteiro] =
    linha.mapeie(linha => linha.injete(0)((soma, x) => soma + x))

var entrada := leia_inteiros(" ")
enquanto entrada <> [0, 0] faça
    n, m = entrada[1], entrada[2]
    matriz = para i de 1 até n gere leia_inteiros(" ") fim
    linhas = total_linhas(matriz).ordene
    colunas = total_linhas(transpor(matriz)).ordene
    pontos =  [linhas[1] > 0, linhas[n] < m, colunas[1] > 0, colunas[m] < n].selecione(x => x).tamanho
    escreva pontos
    entrada := leia_inteiros(" ")
fim

1515 - Hello Galaxy

Descrição do Problema: 1515 - Hello Galaxy

Categoria: Ad-Hoc

var n := leia_inteiro
enquanto n > 0 faça
  s = para i de 1 até n, l em [leia_textos(" ")] gere
        (l[1], l[2].inteiro - l[3].inteiro)
      fim
  r = s.injete((a, b: (Texto, Inteiro)) =>
        se a.segundo < b.segundo então a senão b fim
     )
  escreva r.primeiro
  n := leia_inteiro
fim

1516 - Imagem

Descrição do Problema: 1516 - Imagem

Categoria: Strings

var x := leia_inteiros(" ")
enquanto x[1] > 0 faça
  n, m = x[1], x[2]
  linhas = leia_textos(n)
  y = leia_inteiros(" ")
  a, b = y[1], y[2]
  s = linhas.mapeie(_.lista.mapeie(c => "{c}" * (b div m)).junte(""))
  para i de 0 até a - 1 faça
    escreva s[i div (a div n) + 1]
  fim
  escreva ""
  x := leia_inteiros(" ")
fim

1521 - O Culpado

Descrição do Problema: 1521 - O Culpado

Categoria: Ad-Hoc

var flag := verdadeiro
enquanto flag faça
    n = leia_inteiro
    se n == 0 então
        flag := falso
    senão
        alunos = leia_inteiros(n)
        var i := leia_inteiro
        enquanto alunos[i] <> i faça
            i := alunos[i]
        fim
        escreva i
    fim
fim

1533 - Detetive Watson

Descrição do Problema: 1533 - Detetive Watson

Categoria: Ad-Hoc

var n := leia_inteiro
enquanto n > 0 faça
  v = leia_inteiros(" ")
  a = v.ordene[-2]
  p = v.posicao(a)
  escreva p
  n := leia_inteiro
fim

1534 - Matriz 123

Descrição do Problema: 1534 - Matriz 123

Categoria: Iniciante

var n := leia_inteiro
enquanto n > 0 faça
  mat = para i de 1 até n gere
    para j de 1 até n gere
      se i + j == n + 1 então 2 senãose i == j então 1 senão 3 fim
    fim.junte("")
  fim
  escreva mat.junte("\n")
  n := leia_inteiro
fim

1536 - Libertadores

Descrição do Problema: 1536 - Libertadores

Categoria: Ad-Hoc

n = leia_inteiro
para i de 1 até n faça
  a, b = leia_inteiros(" ")
  se a == b então
    escreva "Penaltis"
  senãose a[1]+b[3] > a[3]+b[1] então
    escreva "Time 1"
  senãose a[1]+b[3] < a[3]+b[1] então
    escreva "Time 2"
  senãose b[3] > a[3] então
    escreva "Time 1"
  senão
    escreva "Time 2"
  fim
fim

1537 - Fila do Banco

Descrição do Problema: 1537 - Fila do Banco

Categoria: Matemática

var anterior := 1.toLong
f = 0 :: 0 :: 1 :: para i de 4 até 100000 gere
  anterior := i * anterior mod 1000000009
  anterior.toInt
fim

var n := leia_inteiro
enquanto n > 0 faça
  escreva f[n]
  n := leia_inteiro
fim

1540 - Planejando a Energia

Descrição do Problema: 1540 - Planejando a Energia

Categoria: Ad-Hoc

n = leia_inteiro
para i de 1 até n faça
    en = leia_inteiros(4)
    valor = abs(en[2] - en[4]) / abs(en[3] - en[1])
    escreva ((valor * 100).piso div 100 formato "%.2f").divida("\\.").junte(",")
fim

1541 - Construindo Casas

Descrição do Problema: 1541 - Construindo Casas

Categoria: Iniciante

var parametros := leia_inteiros(" ")
enquanto parametros[1] <> 0 faça
  x = 10 * raiz(parametros[1] * parametros[2] / parametros[3])
  escreva x.inteiro
  parametros := leia_inteiros(" ")
fim

1542 - Lendo Livros

Descrição do Problema: 1542 - Lendo Livros

Categoria: Ad-Hoc

var a := leia_inteiros(" ")
enquanto a[1] > 0 faça
  paginas = a[1] * a[2] * a[3] div (a[3] - a[1])
  se paginas > 1 então
    escreva "{paginas} paginas"
  senão
    escreva "{paginas} pagina"
  fim
  a := leia_inteiros(" ")
fim

1546 - Feedback

Descrição do Problema: 1546 - Feedback

Categoria: Ad-Hoc

membros = ["Rolien", "Naej", "Elehcim", "Odranoel"]
n = leia_inteiro
para i de 1 até n faça
  t = leia_inteiro
  para j de 1 até t faça
    escreva membros[leia_inteiro]
  fim
fim

1547 - Adivinha

Descrição do Problema: 1547 - Adivinha

Categoria: Ad-Hoc

n = leia_inteiro
para i de 1 até n faça
  a = leia_inteiros(" ")
  s = a[2]
  nums = leia_inteiros(" ")
  var p, i, diff := 0, 0, 100
  para x em nums faça
    i := i + 1
    se (s - x).abs < diff então
      p := i
      diff := (s - x).abs
    fim
  fim
  escreva p
fim

1548 - Fila do Recreio

Descrição do Problema: 1548 - Fila do Recreio

Categoria: Estruturas e Bibliotecas

n = leia_inteiro
para i de 1 até n faça
  m = leia_inteiro
  p = leia_inteiros(" ")
  r = p.ordene.inverta
  a = para i de 1 até m se p[i] == r[i] gere 1 fim
  escreva a.tamanho
fim

1549 - Dividindo a Coca

Descrição do Problema: 1549 - Dividindo a Coca

Categoria: Geometria Computacional

x = leia_inteiro
para i de 1 até x faça
    a = leia_inteiros(2)
    b = leia_inteiros(3)
    media = a[2] / a[1]
    temp = (media * 3 * (b[2] - b[1]) / (PI * b[3]) + b[1] ^ 3) ^ (1/3)
    escreva media * 3 / (PI * (temp ^ 2 + temp * b[1] + b[1] ^ 2)) formato "%.2f"
fim

1551 - Frase Completa

Descrição do Problema: 1551 - Frase Completa

Categoria: Strings

n = leia_inteiro
para i de 1 até n faça
  var letras := Lista.mutável(26, 0)
  s = leia_texto.selecione(c => c >= 'a' e c <= 'z').lista
  para c em s faça
    letras[c - 'a' + 1] := 1
  fim
  escolha letras.selecione(_ == 1).tamanho
    caso 26          => escreva "frase completa"
    caso x se x > 13 => escreva "frase quase completa"
    caso _           => escreva "frase mal elaborada"
  fim
fim

1553 - Perguntas mais Frequentes

Descrição do Problema: 1553 - Perguntas mais Frequentes

Categoria: Ad-Hoc

var k := leia_inteiros(" ")[2]
enquanto k > 0 faça
  p = leia_inteiros(" ")
       .ordene
       .divida_quando((a,b) => a <> b)
       .selecione(_.tamanho >= k)
       .tamanho
  escreva p
  k := leia_inteiros(" ")[2]
fim

1555 - Funções

Descrição do Problema: 1555 - Funções

Categoria: Matemática

n = leia_inteiro
para i de 1 até n faça
  a = leia_inteiros(" ")
  x, y = a[1], a[2]
  rafael =    9 * x * x +      y * y
  beto   =    2 * x * x + 25 * y * y
  carlos = -100 * x     +      y * y * y
  se rafael > beto e rafael > carlos então
    escreva "Rafael ganhou"
  senãose beto > carlos então
    escreva "Beto ganhou"
  senão
    escreva"Carlos ganhou"
  fim
fim

1557 - Matriz Quadrada III

Descrição do Problema: 1557 - Matriz Quadrada III

Categoria: Iniciante

pot = para i de 0 até 38 gere (2 ^ i).inteiro fim
var n := leia_inteiro
enquanto n > 0 faça
  tam = "%{pot[2 * n - 1].texto.tamanho}d"
  para i de 1 até n faça
    imprima pot[i] formato tam
    para j de 2 até n faça
      imprima " {pot[i + j - 1] formato tam}"
    fim
    escreva ""
  fim
  escreva ""
  n := leia_inteiro
fim

1558 - Soma de Dois Quadrados

Descrição do Problema: 1558 - Soma de Dois Quadrados

Categoria: Ad-Hoc

var n := leia_inteiro
enquanto não eof faça
  a = raiz(n div 2).inteiro
  yes = para i de 0 até a gere
    b = n - i * i
    c = raiz(b).inteiro
    c * c == b
  fim
  se yes.contém(verdadeiro) então
    escreva "YES"
  senão
    escreva "NO"
  fim
  n := leia_inteiro
fim

1559 - 2048

Descrição do Problema: 1559 - 2048

Categoria: Ad-Hoc

mov(dir: Texto, b: Boolean) = se b então dir senão "" fim

pode_mover(a, b: Inteiro) = (a == b) <> (b == 0) 

n = leia_inteiro
para i de 1 até n faça
    linhas = para j de 1 até 4 gere leia_inteiros(" ") fim
    var up, down, left, right := falso
    para x de 1 até 4 faça
        linha = linhas[x]
        coluna = para j de 1 até 4 gere linhas[j][x] fim
        para a de 1 até 3 faça
            left  := left  ou pode_mover(linha[a+1], linha[a])
            right := right ou pode_mover(linha[a], linha[a+1])
            up    := up    ou pode_mover(coluna[a+1], coluna[a])
            down  := down  ou pode_mover(coluna[a], coluna[a+1])
        fim
    fim

    jogadas = (mov(" DOWN", down) + mov(" LEFT", left) + mov(" RIGHT", right) + mov(" UP", up)).descarte(1)

    fim_de_jogo = linhas.injete([0])(_ + _).posição(2048) > 0

    se jogadas == "" ou fim_de_jogo então
        escreva "NONE"
    senão
        escreva jogadas
    fim
fim

1561 - Relógio Binário

Descrição do Problema: 1561 - Relógio Binário

Categoria: Ad-Hoc

p(n: Inteiro) = (a: Inteiro) => se n mod (a * 2) div a == 1 então 'o'  senão ' ' fim

var horario := leia_inteiros(":")
enquanto não eof faça
  h, m = p(horario[1]), p(horario[2])
  escreva " ____________________________________________"
  escreva "|                                            |"
  escreva "|    ____________________________________    |_"
  escreva "|   |                                    |   |_)"
  escreva "|   |   8         4         2         1  |   |"
  escreva "|   |                                    |   |"
  escreva "|   |   {h(8)}         {h(4)}         {h(2)}         {h(1)}  |   |"
  escreva "|   |                                    |   |"
  escreva "|   |                                    |   |"
  escreva "|   |   {m(32)}     {m(16)}     {m(8)}     {m(4)}     {m(2)}     {m(1)}  |   |"
  escreva "|   |                                    |   |"
  escreva "|   |   32    16    8     4     2     1  |   |_"
  escreva "|   |____________________________________|   |_)"
  escreva "|                                            |"
  escreva "|____________________________________________|"
  escreva ""
  horario := leia_inteiros(":")
fim

1564 - Vai Ter Copa?

Descrição do Problema: 1564 - Vai Ter Copa?

Categoria: Iniciante

var n := leia_inteiro
enquanto n >= 0 faça
  r = se n == 0 então "copa" senão "duas" fim
  escreva "vai ter {r}!"
  s = leia_texto
  n := se eof então -1 senão s.inteiro fim
fim

1566 - Altura

Descrição do Problema: 1566 - Altura

Categoria: Estruturas e Bibliotecas

tipo Num numero: Inteiro quantidade: Inteiro fim

min(x, y: Inteiro) = se x < y então x senão y fim

f(entrada: Texto, p:Inteiro) = entrada.pegue(p - 1)
                                      .divida(" ")
                                      .ordene
                                      .divida_quando(_ <> _)
                                      .mapeie(a => Num(a.cabeça.inteiro, a.tamanho))

g(nums: Lista[Num]) = nums.ordene(_.numero)
                          .divida_quando(_.numero <> _.numero)
                          .mapeie(a => Num(a.cabeça.numero, a.injete(0)(_ + _.quantidade)))

nc = leia_inteiro
para i de 1 até nc faça
  var n := leia_inteiro
  var entrada := leia_texto + " "
  var result := Lista(0, Num(0, 0))
  enquanto entrada <> "" faça
    var p := min(50000, entrada.tamanho)
    enquanto entrada[p] <> ' ' e p < entrada.tamanho faça p := p + 1 fim
    result := result + f(entrada, p)        
    entrada := entrada.descarte(p)
  fim
  result := g(result)          
  imprima result[1].numero
  result[1] := Num(result[1].numero, result[1].quantidade - 1)
  para r em result faça
    imprima " {r.numero}" * (r.quantidade)
  fim
  escreva ""
fim

1567 - (2/3/4)-D Sqr/Rects/Cubes/Boxes?

Descrição do Problema: 1567 - (2/3/4)-D Sqr/Rects/Cubes/Boxes?

Categoria: Matemática

var n := leia_inteiro

enquanto não eof faça
  a = n * (n + 1)
  b = a div 2
  bb = BigInt(b * b)
  bbb = bb * b
  bbbb = bb * bb

  s2 = a * (2 * n + 1) div 6
  s3 = bb
  s4 = (para i de 1 até n gere i*i*i*i fim).injete(0)(_ + _)

  r2 = s3 - s2
  r3 = bbb - s3
  r4 = bbbb - s4

  escreva "{s2} {r2} {s3} {r3} {s4} {r4}"

  n := leia_inteiro
fim

1573 - Fábrica de Chocolate

Descrição do Problema: 1573 - Fábrica de Chocolate

Categoria: Ad-Hoc

var s := leia_inteiros(" ")
enquanto s[1] <> 0 faça
  a, b, c = s[1], s[2], s[3]
  x = (a * b * c) ^ (1/3)
  escreva x.inteiro
  s := leia_inteiros(" ")
fim

1574 - Instruções do Robô

Descrição do Problema: 1574 - Instruções do Robô

Categoria: Ad-Hoc

t = leia_inteiro
para i de 1 até t faça
  n = leia_inteiro
  var instruções := Lista(0, 0)
  para j de 1 até n faça
    a = leia_textos(" ")
    instruções := (escolha a
      caso ["LEFT"]   => -1
      caso ["RIGHT"]  => 1
      caso _          => instruções[j - a[3].inteiro]
    fim) :: instruções
  fim
  escreva instruções.injete(0)(_ + _)
fim

1580 - Quid Est Veritas? Est Vir Qui Adest!

Descrição do Problema: 1580 - Quid Est Veritas? Est Vir Qui Adest!

Categoria: Matemática

fat(n: Inteiro) = para i de 2 até n gere i fim.injete(BigInt(1))(_ * _)

var s:= leia_texto
enquanto s <> "" faça
    f = fat(s.tamanho)
    r = s.ordene.divida_quando(_ <> _).mapeie(_.tamanho).mapeie(fat)
    x = r.injete(BigInt(1))(_ * _)
    escreva f div x mod BigInt(1000000007)
    s := leia_texto
fim

1581 - Conversa Internacional

Descrição do Problema: 1581 - Conversa Internacional

Categoria: Strings

n = leia_inteiro
para i de 1 até n faça
  k = leia_inteiro
  s = leia_textos(k)
  primeiro = s.cabeca
  iguais = s.cauda.injete(verdadeiro)((a,b) => a e b == primeiro)
  se iguais então
    escreva s.cabeca
  senão
    escreva "ingles"
  fim
fim

1582 - O Teorema de Pitágoras

Descrição do Problema: 1582 - O Teorema de Pitágoras

Categoria: Matemática

mdc(a, b: Inteiro): Inteiro =
  se a > b       então mdc(b, a - b)
  senãose a == b então a
  senão                mdc(b, a)
  fim

var entrada := leia_texto
enquanto não eof faça
  num = entrada.divida(" ").mapeie(_.inteiro).ordene
  cateto1, cateto2, hipotenusa = num[1], num[2], num[3]

  se cateto1 ^ 2 + cateto2 ^ 2 <> hipotenusa ^ 2 então
    escreva "tripla"
  senãose mdc(mdc(num[1], num[2]), num[3]) == 1 então
    escreva "tripla pitagorica primitiva"
  senão
    escreva "tripla pitagorica"
  fim
  entrada := leia_texto
fim

1585 - Fazendo Pandorgas

Descrição do Problema: 1585 - Fazendo Pandorgas

Categoria: Matemática

n = leia_inteiro
para i de 1 até n faça
  a = leia_texto
  tamanho = se a[3] == ' ' então
    a.pegue(2).inteiro * a.descarte(3).inteiro div 2
  senão
    a.pegue(3).inteiro * a.descarte(4).inteiro div 2
  fim
  escreva "{tamanho} cm2"
fim

1589 - Bob Conduite

Descrição do Problema: 1589 - Bob Conduite

Categoria: Iniciante

t = leia_inteiro
para i de 1 até t faça
  r = leia_inteiros(" ")
  escreva r[1]+r[2]
fim