1800

Faixa de problemas: 1800-1899

Total: 28 problemas

1800 - Onde Estão Minhas Chaves

Descrição do Problema: 1800 - Onde Estão Minhas Chaves

q = leia_inteiros(" ")[1]
c = leia_inteiros(" ")
var visitas := Lista(1000, 1)
para a em c faça
  visitas[a] := 0
fim
para i de 1 até q faça
  a = leia_inteiro
  escreva visitas[a]
  visitas[a] := 0
fim

1802 - Catálogo de Livros

Descrição do Problema: 1802 - Catálogo de Livros

soma(a, b: Inteiro) = a + b

p, m, f, q, b = leia_inteiros(" ").cauda
k = leia_inteiro
conjuntos = para pi em p, mi em m, fi em f,
                 qi em q, bi em b gere
                   pi + mi + fi + qi + bi
            fim.ordene.inverta
total = conjuntos.pegue(k).injete(0)(soma)
escreva total

1803 - Matring

Descrição do Problema: 1803 - Matring

entrada1 = leia_texto
entrada2 = leia_texto
entrada3 = leia_texto
entrada4 = leia_texto

f = (entrada1.cabeça.texto +
     entrada2.cabeça.texto +
     entrada3.cabeça.texto +
     entrada4.cabeça.texto).inteiro

l = (entrada1.último.texto +
     entrada2.último.texto +
     entrada3.último.texto +
     entrada4.último.texto).inteiro

var palavra := ""
para i de 2 até (entrada1.tamanho - 1) faça
    caractere = ((f *
                    (entrada1[i].texto +
                     entrada2[i].texto +
                     entrada3[i].texto +
                     entrada4[i].texto).inteiro + l) mod 257).caractere

    palavra := palavra + caractere
fim

escreva palavra

1805 - Soma Natural

Descrição do Problema: 1805 - Soma Natural

s = leia_reais(" ")
a, b = s[1], s[2]
soma = (a + b) * (b - a + 1) / 2
escreva soma formato "%.0f"

1808 - O Retorno do Rei

Descrição do Problema: 1808 - O Retorno do Rei

numeros = leia_texto.lista.mapeie(_ - '0')

soma = numeros
         .mapeie(a => se a == 0 então 9 senão a fim)
         .injete(0)(_ + _)

media = soma / numeros.selecione(_ > 0).tamanho

escreva media formato "%.2f"

1827 - Matriz Quadrada IV

Descrição do Problema: 1827 - Matriz Quadrada IV

var n := leia_inteiro
enquanto n > 0 faça
  a = n div 3
  b = n - a
  m = n div 2 + 1
  s = para i de 1 até n gere
        para j de 1 até n gere
          escolha (i, j)
            caso (i, j) se i == m e j == m                 => '4'
            caso (i, j) se i > a e i <= b e j > a e j <= b => '1'
            caso (i, j) se i == j                          => '2'
            caso (i, j) se i + j == n + 1                  => '3'
            caso _                                         => '0'
          fim
        fim.junte("")
      fim
  escreva s.junte("", "\n", "\n")
  n := leia_inteiro
fim

1828 - Bazinga!

Descrição do Problema: 1828 - Bazinga!

t = leia_inteiro
nomes = ["tesoura", "papel", "pedra", "lagarto", "Spock"]
para i de 1 até t faça
  s = leia_textos(" ")
  a = nomes.posição(s[1])
  b = nomes.posição(s[2])
  c = (b - a + 5) mod 5
  resultado =
    se c == 0 então
      "De novo"
    senãose c mod 2 == 1 então
      "Bazinga"
    senão
      "Raj trapaceou"
    fim
  escreva "Caso #{i}: {resultado}!"
fim

1836 - Pokémon!

Descrição do Problema: 1836 - Pokémon!

t = leia_inteiro
para i de 1 até t faça
  a = leia_textos(" ")
  n, l = a[1], a[2].inteiro

  escreva "Caso #{i}: {n} nivel {l}"
  para j de 1 até 4 faça
    b = leia_inteiros(" ")
    bs, iv, ev = b[1], b[2], b[3]
    temp = se j == 1 então
      (iv + bs + raiz(ev) / 8 + 50) * l / 50 + 10
    senão
      (iv + bs + raiz(ev) / 8) * l / 50 + 5
    fim
    escreva "{["HP", "AT", "DF", "SP"][j]}: {temp.inteiro}"
  fim
fim

1837 - Prefácio

Descrição do Problema: 1837 - Prefácio

s = leia_inteiros(" ")
a, b = s[1], s[2]
q, r = a.abs div b.abs, a.abs mod b.abs
saida = escolha (a, b)
  caso (a, b) se r == 0         => (a div b, 0)
  caso (a, b) se a > 0 e b > 0  => (q, r)
  caso (a, b) se a > 0          => (-q, r)
  caso (a, b) se b > 0          => (-(q + 1), b.abs - r)  
  caso _                        => (q + 1, b.abs - r)
fim
escreva "{saida.primeiro} {saida.segundo}"

1847 - Bem-vindos e Bem-vindas ao Inverno!

Descrição do Problema: 1847 - Bem-vindos e Bem-vindas ao Inverno!

a = leia_inteiros(" ")
x = a[2] - a[1]
y = a[3] - a[2]
se y > x ou (x == y e x > 0) então
  escreva ":)"
senão
  escreva ":("
fim

1848 - Corvo Contador

Descrição do Problema: 1848 - Corvo Contador

para i de 1 ate 3 faca
  var s := leia_texto
  var soma := 0
  enquanto s <> "caw caw" faca
    se s[1] == '*' entao soma := soma + 4 fim
    se s[2] == '*' entao soma := soma + 2 fim
    se s[3] == '*' entao soma := soma + 1 fim
    s := leia_texto
  fim
  escreva soma
fim

1849 - Dracarys!

Descrição do Problema: 1849 - Dracarys!

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

n = leia_inteiros(4)
escreva (min(min(n[1], n[2]) + min(n[3], n[4]), min(max(n[1], n[2]), max(n[3], n[4]))) ^ 2).inteiro

1855 - Mapa do Meistre

Descrição do Problema: 1855 - Mapa do Meistre

n, m = leia_inteiro
a = leia_textos(m)

dfs(x, y, dx, dy: Inteiro, vis: Lista[(Inteiro, Inteiro)]): Lógico =
  se x < 1 ou x > m ou y < 1 ou y > n ou vis.contém((x, y))
    falso
  senão
    vis2 = (x, y) :: vis
    escolha a[x][y]
      caso '*' => verdadeiro
      caso '>' => dfs(x, y + 1, 0, 1, vis2)
      caso '<' => dfs(x, y - 1, 0, -1, vis2)
      caso '^' => dfs(x - 1, y, -1, 0, vis2)
      caso 'v' => dfs(x + 1, y, 1, 0, vis2)
      caso  _  => dfs(x + dx, y + dy, dx, dy, vis)
    fim
  fim

ans = dfs(1, 1, 0, 1, [])

se ans então
  escreva "*"
senão
  escreva "!"
fim

1858 - A Resposta de Theon

Descrição do Problema: 1858 - A Resposta de Theon

n = leia_inteiro
numeros = leia_inteiros(" ")
var menor := 1
para i de 2 até n faça
  se numeros[i] < numeros[menor] então
    menor := i
  fim
fim
escreva menor

1864 - Nossos Dias Nunca Voltarão

Descrição do Problema: 1864 - Nossos Dias Nunca Voltarão

s = "LIFE IS NOT A PROBLEM TO BE SOLVED"
n = leia_inteiro
escreva s.pegue(n)

1865 - Mjölnir

Descrição do Problema: 1865 - Mjölnir

n = leia_inteiro
para i de 1 até n faça
  nome = leia_textos(" ").cabeça
  se nome == "Thor" então
    escreva "Y"
  senão
    escreva "N"
  fim
fim

1866 - Conta

Descrição do Problema: 1866 - Conta

n = leia_inteiro
para i de 1 até n faça
  escreva leia_inteiro mod 2
fim

1867 - Maior Número de Um Algarismo

Descrição do Problema: 1867 - Maior Número de Um Algarismo

var entrada := leia_texto.divida(" ")
enquanto entrada <> ["0", "0"] faça
  var a, b := 0
  para i em entrada[1] faça
    a := a + (i - '0')
    se a > 9 então a:= a - 9 fim
  fim
  para i em entrada[2] faça
    b := b + (i - '0')
    se b > 9 então b:= b - 9 fim
  fim

  se a > b então
    escreva 1
  senãose b > a então
    escreva 2
  senão
    escreva 0
  fim
  entrada := leia_texto.divida(" ")
fim

1868 - Espiral Quadrada

Descrição do Problema: 1868 - Espiral Quadrada

var n := leia_inteiro
var g := Lista(n, Lista(n, "O"))
var x,y := 0, 0

dx = [0,-1,0,1]
dy = [1,0,-1,0]

mostrar_solução()
    para i de 1 até g.tamanho faça
        para j de 1 até g.tamanho faça
            imprima g[i][j]
        fim
        escreva ""
    fim
    escreva "@"
fim

mover(iter : Inteiro, dir : Inteiro)
    var flag := verdadeiro
    tm = g.tamanho

    para j de 1 até iter faça
        nx = x + dx[dir]
        ny = y + dy[dir]

        se ((nx >= 1) e (nx <= tm) e (ny >= 1) e (ny <= tm)) então
            g[x][y] := "O"
            x := nx
            y := ny
            g[x][y] := "X"
            mostrar_solução()
        senão
            flag := falso
        fim

    fim
    retorne flag
fim

solução(tm: Inteiro)
    g := Lista(tm, Lista(tm, "O"))

    x := (n / 2).inteiro + 1
    y := (n / 2).inteiro + 1
    var iter := 0

    g[x][y] := "X"
    mostrar_solução()

    var condicao := verdadeiro
    enquanto condicao faça
        iter := iter + 1

        se condicao e não(mover(iter, 1)) então
            condicao := falso
        fim

        se condicao e não(mover(iter, 2)) então
            condicao := falso
        fim

        iter := iter + 1

        se condicao e não(mover(iter, 3)) então
            condicao := falso
        fim

        se condicao e não(mover(iter, 4)) então
            condicao := falso
        fim
    fim

fim


enquanto n <> 0 faça
    solução(n)
    n := leia_inteiro
fim

1869 - Base 32

Descrição do Problema: 1869 - Base 32

digito(n: BigInt) =
  se n > 9 entao (n.toInt + 55).caractere senao (n.toInt + 48).caractere fim

base32(n: BigInt): Texto =
  se n > 0 entao base32(n div 32) + digito(n mod 32) senao "" fim

var a := BigInt(1)
enquanto a > 0 faca
  a := BigInt(leia_texto)
  se a > 0 entao escreva base32(a) senao escreva 0 fim
fim

1871 - Zero vale Zero

Descrição do Problema: 1871 - Zero vale Zero

var a := leia_inteiros(" ")
enquanto a[1] <> 0 faca
  m, n = a[1], a[2]
  soma = m + n
  s = soma.texto.selecione(_ <> '0')
  escreva s
  a := leia_inteiros(" ")
fim

1873 - Pedra-papel-tesoura-lagarto-Spock

Descrição do Problema: 1873 - Pedra-papel-tesoura-lagarto-Spock

rajesh = [
  "tesoura papel", "papel pedra", "pedra lagarto", "lagarto spock", "spock tesoura",
  "tesoura lagarto", "lagarto papel", "papel spock", "spock pedra", "pedra tesoura"
]

empate = ["papel", "pedra", "tesoura", "lagarto", "spock"].mapeie(a => "{a} {a}")

c = leia_inteiro
para i de 1 ate c faca
  s = leia_texto
  se rajesh.contem(s) entao
    escreva "rajesh"
  senaose empate.contem(s) entao
    escreva "empate"
  senao
    escreva "sheldon"
  fim
fim

1875 - Tribol

Descrição do Problema: 1875 - Tribol

c = leia_inteiro
para i de 1 ate c faca
  p = leia_inteiro
  var r, g, b := 0
  para k de 1 ate p faca
    ms = leia_texto
    escolha ms
      caso "R G" => r := r + 2
      caso "G B" => g := g + 2
      caso "B R" => b := b + 2
      caso "R B" => r := r + 1
      caso "G R" => g := g + 1
      caso _     => b := b + 1
    fim
  fim
  se    r == g e g == b entao  escreva "trempate"
  senaose r > g e r > b entao  escreva "red"
  senaose g > r e g > b entao  escreva "green"
  senaose b > g e b > r entao  escreva "blue"
  senao                        escreva "empate"
  fim
fim

1876 - Rabiola

Descrição do Problema: 1876 - Rabiola

var s := leia_textos("x")
enquanto nao eof faca
  a = s.mapeie(_.tamanho)
  a1 = se a[1] > a[-1] entao a[1] senao a[-1] fim
  b = a.descarte(1).pegue(a.tamanho - 2).mapeie(_ div 2)
  maior = b.injete(a1)((x,y) => se x > y entao x senao y fim)
  escreva maior
  s := leia_textos("x")
fim

1877 - O Castelo de Neve de Sansa

Descrição do Problema: 1877 - O Castelo de Neve de Sansa

zip3(a, b, c: Lista[Inteiro]) = a.zip(b).zip(c)
   .mapeie(x => (x.primeiro.primeiro, x.primeiro.segundo, x.segundo))
k = leia_inteiros(" ")[2]
h = leia_inteiros(" ")
s = zip3(h, h.cauda, h.cauda.cauda)
x = s.mapeie(a => a.primeiro < a.segundo e a.segundo > a.terceiro)
     .mapeie(pico => se pico entao 1 senao 0 fim)
picos = x.injete(0)(_ + _)
se picos == k entao
  escreva "beautiful"
senao
  escreva "ugly"
fim

1890 - Emplacando os Tuk-tuks

Descrição do Problema: 1890 - Emplacando os Tuk-tuks

t = leia_inteiro
para i de 1 até t faça
  entrada = leia_inteiros(" ")
  c, d = entrada[1], entrada[2]
  placas = 26 ^ c * 10 ^ d
  se placas > 1 então
    escreva placas formato "%.0f"
  senão
    escreva 0
  fim
fim

1893 - Fases da Lua

Descrição do Problema: 1893 - Fases da Lua

a = leia_inteiros(" ")
lua = escolha (a[2], a[2] - a[1])
  caso (n, m) se n >= 3 e n <= 96 e m < 0 => "minguante"
  caso (n, _)     se n <= 2               => "nova"
  caso (n, _)     se n >= 97              => "cheia"
  caso _                                  => "crescente"
fim
escreva lua

1898 - Soma de Propina

Descrição do Problema: 1898 - Soma de Propina

numerico(c: Caractere) = c >= '0' e c <= '9' ou c == '.'
linha1, linha2 = leia_texto.selecione(numerico)
cpf = linha1.pegue(11)
n1 = (linha1.descarte(11).real * 100).piso / 100
n2 = (linha2.real * 100).piso / 100
soma = n1 + n2
escreva "cpf {cpf}"
escreva soma formato "%.2f"