1500

Faixa de problemas: 1500-1599

Total: 33 problemas

1512 - Azulejos

Descrição do Problema: 1512 - Azulejos

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

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

var n := leia_inteiro
enquanto n > 0 faca
  s = para i de 1 ate 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 entao a senao b fim
      )
  escreva r.primeiro
  n := leia_inteiro
fim

1516 - Imagem

Descrição do Problema: 1516 - Imagem

var x := leia_inteiros(" ")
enquanto x[1] > 0 faca
  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 ate a - 1 faca
    escreva s[i div (a div n) + 1]
  fim
  escreva ""
  x := leia_inteiros(" ")
fim

1521 - O Culpado

Descrição do Problema: 1521 - O Culpado

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

var n := leia_inteiro
enquanto n > 0 faca
  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

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

n = leia_inteiro
para i de 1 ate n faça
  a, b = leia_inteiros(" ")
  se a == b então
    escreva "Penaltis"
  senaose a[1]+b[3] > a[3]+b[1] então
    escreva "Time 1"
  senaose a[1]+b[3] < a[3]+b[1] então
    escreva "Time 2"
  senaose 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

var anterior := 1.toLong
f = 0 :: 0 :: 1 :: para i de 4 ate 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

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

1541 - Construindo Casas

Descrição do Problema: 1541 - Construindo Casas

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

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 entao
    escreva "{paginas} paginas"
  senao
    escreva "{paginas} pagina"
  fim
  a := leia_inteiros(" ")
fim

1546 - Feedback

Descrição do Problema: 1546 - Feedback

membros = ["Rolien", "Naej", "Elehcim", "Odranoel"]
n = leia_inteiro
para i de 1 ate n faca
  t = leia_inteiro
  para j de 1 ate t faca
    escreva membros[leia_inteiro]
  fim
fim

1547 - Adivinha

Descrição do Problema: 1547 - Adivinha

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 entao
      p := i
      diff := (s - x).abs
    fim
  fim
  escreva p
fim

1548 - Fila do Recreio

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

n = leia_inteiro
para i de 1 ate n faca
  m = leia_inteiro
  p = leia_inteiros(" ")
  r = p.ordene.inverta
  a = para i de 1 ate 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

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

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

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

n = leia_inteiro
para i de 1 ate 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

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

var n := leia_inteiro
enquanto nao eof faca
  a = raiz(n div 2).inteiro
  yes = para i de 0 ate a gere
    b = n - i * i
    c = raiz(b).inteiro
    c * c == b
  fim
  se yes.contem(verdadeiro) entao
    escreva "YES"
  senao
    escreva "NO"
  fim
  n := leia_inteiro
fim

1559 - 2048

Descrição do Problema: 1559 - 2048

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

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
        linhax = linhas[x]
        colunax = para j de 1 até 4 gere linhas[j][x] fim
        para a de 1 até 3 faca
            xa, xb, ax, bx = linhax[a], linhax[a+1], colunax[a], colunax[a+1]
            xa0, xb0, xab, abx, ax0, bx0 = xa == 0, xb == 0, xa == xb, ax == bx, ax == 0, bx == 0
            left  := left  ou (não xb0 e (xa0 ou xab)) 
            right := right ou (não xa0 e (xb0 ou xab))
            up    := up    ou (não bx0 e (ax0 ou abx))
            down  := down  ou (não ax0 e (bx0 ou abx))
        fim
    fim

    jogadas = mov(" DOWN", down) + mov(" LEFT", left) + mov(" RIGHT", right) + mov(" UP", up)
    se jogadas == "" ou linhas.injete([0])(_ + _).posição(2048) > 0 então
        escreva "NONE"
    senão
        escreva jogadas.cauda
    fim
fim

1561 - Relógio Binário

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

p(n: Inteiro) = (a: Inteiro) => se n mod (a * 2) div a == 1 então 'o'  senao ' ' 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?

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

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?

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

var s := leia_inteiros(" ")
enquanto s[1] <> 0 faca
  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ô

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!

fat(n: Inteiro) = para i de 2 ate 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

n = leia_inteiro
para i de 1 ate n faca
  k = leia_inteiro
  s = leia_textos(k)
  primeiro = s.cabeca
  iguais = s.cauda.injete(verdadeiro)((a,b) => a e b == primeiro)
  se iguais entao
    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

mdc(a, b: Inteiro): Inteiro =
  se a > b       entao mdc(b, a - b)
  senaose a == b entao a
  senao                mdc(b, a)
  fim

var entrada := leia_texto
enquanto nao eof faca
  num = entrada.divida(" ").mapeie(_.inteiro).ordene
  cateto1, cateto2, hipotenusa = num[1], num[2], num[3]

  se cateto1 ^ 2 + cateto2 ^ 2 <> hipotenusa ^ 2 entao
    escreva "tripla"
  senaose mdc(mdc(num[1], num[2]), num[3]) == 1 entao
    escreva "tripla pitagorica primitiva"
  senao
    escreva "tripla pitagorica"
  fim
  entrada := leia_texto
fim

1585 - Fazendo Pandorgas

Descrição do Problema: 1585 - Fazendo Pandorgas

n = leia_inteiro
para i de 1 ate n faca
  a = leia_texto
  tamanho = se a[3] == ' ' entao
    a.pegue(2).inteiro * a.descarte(3).inteiro div 2
  senao
    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

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