1800

Faixa de problemas: 1800-1899

Total resolvido: 31 de 100 problemas

Problemas não resolvidos (69)

1801, 1804, 1806, 1809, 1810, 1811, 1812, 1813, 1814, 1815, 1817, 1818, 1819, 1820, 1821, 1822, 1823, 1824, 1825, 1826, 1829, 1830, 1831, 1832, 1833, 1834, 1835, 1838, 1839, 1840, 1841, 1842, 1843, 1844, 1845, 1846, 1850, 1851, 1852, 1853, 1854, 1856, 1857, 1859, 1860, 1861, 1862, 1863, 1870, 1872, 1878, 1879, 1880, 1881, 1882, 1883, 1884, 1885, 1886, 1887, 1888, 1889, 1891, 1892, 1894, 1895, 1896, 1897, 1899

1800 - Onde Estão Minhas Chaves

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

Categoria: Ad-Hoc

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

Categoria: Ad-Hoc

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

Categoria: Strings

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

Categoria: Matemática

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

1807 - Triângulo Trinomial, a Vingança

Descrição do Problema: 1807 - Triângulo Trinomial, a Vingança

Categoria: Matemática

def exp(n, md: Long): Long =
  se n == 0 então
    1
  senãose n mod 2 == 1 então
    (3 * exp(n - 1, md)) mod md
  senão
    valor = exp(n div 2, md)
    a = (valor * valor) mod md
    a
  fim

entrada = leia_inteiro
escreva exp(entrada, 2147483647)

1808 - O Retorno do Rei

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

Categoria: Ad-Hoc · Maratona SBC (2ª fase) 2014

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"

1816 - Vikings em Praga?

Descrição do Problema: 1816 - Vikings em Praga?

Categoria: Ad-Hoc

var instancia := 0

enquanto leia_inteiro > 0 faça
    numeros = leia_inteiros(" ")
    var letras := para c de 'A' até 'Z' gere c fim
    texto = para n em numeros gere
        letras := letras[n] :: letras.pegue(n-1) + letras.descarte(n)
        letras.cabeça
    fim
    instancia := instancia + 1
    escreva "Instancia {instancia}"
    escreva texto.junte("")
    escreva ""
fim

1827 - Matriz Quadrada IV

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

Categoria: Iniciante

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!

Categoria: Iniciante

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!

Categoria: Ad-Hoc

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

Categoria: Iniciante

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!

Categoria: Iniciante

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

Categoria: Iniciante

para i de 1 até 3 faça
  var s := leia_texto
  var soma := 0
  enquanto s <> "caw caw" faça
    se s[1] == '*' então soma := soma + 4 fim
    se s[2] == '*' então soma := soma + 2 fim
    se s[3] == '*' então soma := soma + 1 fim
    s := leia_texto
  fim
  escreva soma
fim

1849 - Dracarys!

Descrição do Problema: 1849 - Dracarys!

Categoria: Ad-Hoc

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

Categoria: Grafos

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

Categoria: Iniciante

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

Categoria: Iniciante

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

Categoria: Iniciante · Olimpíada IFSULDEMINAS 2015

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

Categoria: Iniciante · Olimpíada IFSULDEMINAS 2015

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

Categoria: Ad-Hoc · Olimpíada IFSULDEMINAS 2015

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

Categoria: Strings · Olimpíada IFSULDEMINAS 2015

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

Categoria: Matemática · Olimpíada IFSULDEMINAS 2015

digito(n: BigInt) =
  se n > 9 então (n.toInt + 55).caractere senão (n.toInt + 48).caractere fim

base32(n: BigInt): Texto =
  se n > 0 então base32(n div 32) + digito(n mod 32) senão "" fim

var a := BigInt(1)
enquanto a > 0 faça
  a := BigInt(leia_texto)
  se a > 0 então escreva base32(a) senão escreva 0 fim
fim

1871 - Zero vale Zero

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

Categoria: Strings · Olimpíada IFSULDEMINAS 2015

var a := leia_inteiros(" ")
enquanto a[1] <> 0 faça
  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

Categoria: Strings · Olimpíada IFSULDEMINAS 2015

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 até c faça
  s = leia_texto
  se rajesh.contém(s) então
    escreva "rajesh"
  senãose empate.contém(s) então
    escreva "empate"
  senão
    escreva "sheldon"
  fim
fim

1874 - Empurrando Blocos

Descrição do Problema: 1874 - Empurrando Blocos

Categoria: Estruturas e Bibliotecas · Olimpíada IFSULDEMINAS 2015

def transposta(matriz: Matriz[Inteiro]): Matriz[Inteiro] = escolha matriz
  caso []::as => []
  caso _      => matriz.mapeie(_.cabeça) :: transposta(matriz.mapeie(_.cauda))
fim

def preencher(pilhas, blocos_novos: Lista[Inteiro], h: Inteiro): Matriz[Inteiro] = escolha pilhas
  caso a::as => (Lista(a, 1) + blocos_novos.pegue(h-a)) :: preencher(as, blocos_novos.descarte(h-a), h)
  caso _ => []
fim

def somar(pilha: Lista[Inteiro]): Inteiro = escolha pilha
  caso a::as => a + somar(as)
  caso _     => 0
fim

var a := leia_inteiros(" ")
enquanto a <> [0, 0, 0] faça
  h, p, f = a[1], a[2], a[3]
  blocos = Lista(h, leia_inteiros(" "))
  pilhas = transposta(blocos).mapeie(p => somar(p)).inverta
  blocos_novos = leia_inteiros(" ") + Lista(h*p, 0)

  escreva transposta(preencher(pilhas, blocos_novos, h).inverta)
            .inverta
            .mapeie(linha => linha.junte(" "))
            .junte("\n")
   a := leia_inteiros(" ")
fim

1875 - Tribol

Descrição do Problema: 1875 - Tribol

Categoria: Geometria Computacional · Olimpíada IFSULDEMINAS 2015

c = leia_inteiro
para i de 1 até c faça
  p = leia_inteiro
  var r, g, b := 0
  para k de 1 até p faça
    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 então  escreva "trempate"
  senãose r > g e r > b então  escreva "red"
  senãose g > r e g > b então  escreva "green"
  senãose b > g e b > r então  escreva "blue"
  senão                        escreva "empate"
  fim
fim

1876 - Rabiola

Descrição do Problema: 1876 - Rabiola

Categoria: Ad-Hoc · Olimpíada IFSULDEMINAS 2015

var s := leia_textos("x")
enquanto não eof faça
  a = s.mapeie(_.tamanho)
  a1 = se a[1] > a[-1] então a[1] senão a[-1] fim
  b = a.descarte(1).pegue(a.tamanho - 2).mapeie(_ div 2)
  maior = b.injete(a1)((x,y) => se x > y então x senão 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

Categoria: Ad-Hoc

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 então 1 senão 0 fim)
picos = x.injete(0)(_ + _)
se picos == k então
  escreva "beautiful"
senão
  escreva "ugly"
fim

1890 - Emplacando os Tuk-tuks

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

Categoria: Ad-Hoc

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

Categoria: Ad-Hoc

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

Categoria: Strings

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"