1900

Faixa de problemas: 1900-1999

Total resolvido: 29 de 100 problemas

Problemas não resolvidos (71)

1900, 1902, 1903, 1904, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1915, 1916, 1917, 1918, 1920, 1922, 1923, 1925, 1926, 1927, 1928, 1931, 1932, 1934, 1935, 1937, 1938, 1939, 1941, 1942, 1945, 1946, 1947, 1948, 1949, 1950, 1951, 1952, 1954, 1955, 1956, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1974, 1975, 1976, 1977, 1978, 1979, 1981, 1982, 1988, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999

1901 - Borboletas

Descrição do Problema: 1901 - Borboletas

Categoria: Ad-Hoc

n = leia_inteiro
k = para i de 1 até n gere leia_inteiros(" ") fim
var v := [0].cauda
para i de 1 até 2*n faça
  a = leia_inteiros(" ")
  v := k[a[1]][a[2]] :: v
fim
especies = v.ordene.divida_quando(_ <> _).tamanho
escreva especies

1905 - Polícia e Ladrão

Descrição do Problema: 1905 - Polícia e Ladrão

Categoria: Grafos

policia(labirinto, caminho: Lista[Inteiro]): Lógico =
  se caminho.cabeça == 25 então
    verdadeiro
  senão
    proximos = vizinhos(caminho.cabeca).selecione(a => labirinto[a] == '0') - caminho
    proximos.injete(falso)((a, b) => a ou policia(labirinto, b :: caminho))
  fim

vizinhos(n: Inteiro) =
  [n + 5, se n mod 5 <> 0 então n + 1 senão 0 fim,
   se n mod 5 <> 1 então n - 1 senão 0 fim, n - 5].selecione(a => a >= 1 e a <= 25)

leia_labirinto()
  var lista: Lista[Inteiro] = []
  enquanto lista.tamanho < 25 faça
    a = leia_texto.lista.selecione(c => c == '1' ou c == '0').mapeie(_.inteiro)
    lista := lista + a
  fim
  lista
fim

t = leia_inteiro
para i de 1 até t faça
  labirinto = leia_labirinto
  se policia(labirinto, [-4]) então
    escreva "COPS"
  senão
    escreva "ROBBERS"
  fim
fim

1914 - De Quem é a Vez?

Descrição do Problema: 1914 - De Quem é a Vez?

Categoria: Iniciante

qt = leia_inteiro

para i de 1 até qt faça
  nomes = leia_textos(" ")
  a = leia_inteiros(" ")
  par = (a[1] + a[2]) mod 2 == 0
  se (par e nomes[2] == "PAR") ou
     (não par e nomes[2] <> "PAR") então
    escreva nomes[1]
  senão
    escreva nomes[3]
  fim
fim

1919 - Ajude Nhonho

Descrição do Problema: 1919 - Ajude Nhonho

Categoria: Ad-Hoc

comb = para a1 de 0 até 5,    a2 de a1+1 até 6,
            a3 de a2+1 até 7, a4 de a3+1 até 8,
            a5 de a4+1 até 9 gere [a1,a2,a3,a4,a5]
       fim
z = 24 * 11111
t = leia_inteiro
para i de 1 até t faça
  k = leia_inteiro
  se k < 10 * z então
    escreva "impossivel"
  senão
    resultado = comb.selecione(c => c.injete(0)(_ + _) * z == k)
    se resultado == [] então
      escreva "impossivel"
    senão
      para c em resultado faça
        escreva c.junte("{'{'}", "," ,"{'}'}")
      fim
    fim
  fim
  escreva ""
fim

1921 - Guilherme e Suas Pipas

Descrição do Problema: 1921 - Guilherme e Suas Pipas

Categoria: Matemática

n = leia_inteiro
barbantes = n / 2 * (n - 3)
escreva barbantes formato "%.0f"

1924 - Vitória e a Indecisão

Descrição do Problema: 1924 - Vitória e a Indecisão

Categoria: Iniciante

n = leia_inteiro
leia_textos(n)
escreva "Ciencia da Computacao"

1929 - Triângulo

Descrição do Problema: 1929 - Triângulo

Categoria: Iniciante · OBI 2014

n = leia_inteiros(" ").ordene
se n[1]+n[2] > n[3] ou n[2] + n[3] > n[4] então
  escreva "S"
senão
  escreva "N"
fim

1930 - Tomadas

Descrição do Problema: 1930 - Tomadas

Categoria: Iniciante · OBI 2013

escreva leia_inteiros(" ").injete(-3)(_ + _)

1933 - Tri-du

Descrição do Problema: 1933 - Tri-du

Categoria: Iniciante · Maratona SBC (1ª fase) 2015

s = leia_inteiros(" ")
a, b = s[1], s[2]
se a > b então
  escreva a
senão
  escreva b
fim

1936 - Fatorial

Descrição do Problema: 1936 - Fatorial

Categoria: Ad-Hoc · Maratona SBC (1ª fase) 2015

f = [362880, 40320, 5040, 720, 120, 24, 6, 2, 1]

var n := leia_inteiro
var c := 0
para a em f faça
  c := c + n div a
  n := n mod a
fim
escreva c

1940 - Jogo da Estratégia

Descrição do Problema: 1940 - Jogo da Estratégia

Categoria: Ad-Hoc · Maratona SBC (1ª fase) 2015

tipo Matriz = Lista[Lista[Inteiro]]

def fatias(l: Lista[Inteiro], tamanho: Inteiro): Matriz = escolha l
  caso [] => []
  caso xs => xs.pegue(tamanho) :: fatias(xs.descarte(tamanho), tamanho)
fim

def soma_colunas(m: Matriz): Lista[Inteiro] = escolha m
  caso [] :: xs => []
  caso xs => soma(xs.mapeie(_.cabeça)) :: soma_colunas(xs.mapeie(_.cauda))
fim

def soma(l: Lista[Inteiro]) = l.injete(0)(_ + _)

def enumerado(l: Lista[Inteiro]): Lista[(Inteiro, Inteiro)] =
  l.zip(para i de 1 até l.tamanho gere i fim)

j = leia_inteiros(" ")[1]

jogadores = soma_colunas(fatias(leia_inteiros(" "), j))

var maior, vencedor := 0

para (pontos, k) em enumerado(jogadores) faça
  se pontos >= maior então
    maior, vencedor := pontos, k
  fim
fim

escreva vencedor

1943 - Top N

Descrição do Problema: 1943 - Top N

Categoria: Ad-Hoc

k = leia_inteiro
top = se      k ==  1 então 1
      senãose k <=  3 então 3
      senãose k <=  5 então 5
      senãose k <= 10 então 10
      senãose k <= 25 então 25
      senãose k <= 50 então 50
      senão                 100
      fim

escreva "Top {top}"

1944 - BRINDE FACE 2015

Descrição do Problema: 1944 - BRINDE FACE 2015

Categoria: Estruturas e Bibliotecas

inicial = ["E C A F"]
var painel := inicial
n = leia_inteiro
var brindes := 0
para i de 1 até n faça
  a = leia_texto
  se a == painel.cabeça então
    painel := painel.cauda
    brindes := brindes + 1
    se painel == [] então
      painel := inicial
    fim
  senão
    painel := a.inverta :: painel
  fim
fim
escreva brindes

1953 - Roberto e a Sala Desenfreada

Descrição do Problema: 1953 - Roberto e a Sala Desenfreada

Categoria: Ad-Hoc

var n := leia_inteiro
enquanto n > 0 faça
    var epr, ehd := 0
    para i de 1 até n faça
        a = leia_textos(" ")[2]
        escolha a
            caso "EPR" => epr := epr + 1
            caso "EHD" => ehd := ehd + 1
            caso _ =>
        fim
    fim
    escreva "EPR: {epr}"
    escreva "EHD: {ehd}"
    escreva "INTRUSOS: {n - epr - ehd}"
    n := leia_inteiro
fim

1957 - Converter para Hexadecimal

Descrição do Problema: 1957 - Converter para Hexadecimal

Categoria: Iniciante

var v := leia_inteiro
var s := ""
ns = "0123456789ABCDEF"
enquanto v > 0 faça
  h = v mod 16
  s := ns[h+1] + s
  v := v div 16
fim
escreva s

1958 - Notação Científica

Descrição do Problema: 1958 - Notação Científica

Categoria: Iniciante

x = leia_real
escreva x formato "%+.4E"

1959 - Polígonos Regulares Simples

Descrição do Problema: 1959 - Polígonos Regulares Simples

Categoria: Iniciante

entrada = leia_reais(" ")
n = entrada[1]
l = entrada[2]
escreva (n * l) formato "%.0f"

1960 - Numeração Romana para Números de Página

Descrição do Problema: 1960 - Numeração Romana para Números de Página

Categoria: Iniciante

n = leia_texto
a = ("00" + n).lista.inverta.pegue(3).mapeie(_ - '0')
r = "IVXLCDM"

var s := ""
para i de 3 até 1 passo -1 faça
  d = r.descarte(i * 2 - 2).pegue(3)
  s := s + (escolha a[i]
    caso 9          => "{d[1]}{d[3]}"
    caso x se x > 4 => "{d[2]}" + "{d[1]}" * (x - 5)
    caso 4          => "{d[1]}{d[2]}"
    caso x se x > 0 => "{d[1]}" * x
    caso _          => ""
  fim)
fim
escreva s

1961 - Pula Sapo

Descrição do Problema: 1961 - Pula Sapo

Categoria: Iniciante

entrada = leia_inteiros(" ")
linha = leia_inteiros(" ")
p = entrada[1]
n = entrada[2]
var gameover := falso
para i de 2 até n faça
  se linha[i-1] - linha[i] > p ou linha[i] - linha[i-1] > p então
    gameover := verdadeiro
  fim
fim
se gameover então
  escreva "GAME OVER"
senão
  escreva "YOU WIN"
fim

1962 - Há Muito, Muito Tempo Atrás

Descrição do Problema: 1962 - Há Muito, Muito Tempo Atrás

Categoria: Iniciante

n = leia_inteiro
para i de 1 até n faça
  a = leia_inteiro
  se a < 2015 então
    escreva "{2015 - a} D.C."
  senão
    escreva "{a - 2014} A.C."
  fim
fim

1963 - O Filme

Descrição do Problema: 1963 - O Filme

Categoria: Iniciante

entrada = leia_reais(" ")
a = entrada[1]
b = entrada[2]
c = (b / a - 1) * 100
escreva "{c formato "%.2f"}%"

1973 - Jornada nas Estrelas

Descrição do Problema: 1973 - Jornada nas Estrelas

Categoria: Iniciante

n = leia_inteiro
var x = leia_inteiros(" ").mutável
var total := x.injete(BigInt(0))(_ + _)
var atacadas = Lista.mutável(n, falso)
var i := 1

enquanto i > 0 e i <= n faça
  lado = x[i] mod 2 <> 0
  se x[i] > 0 então
    x[i] := x[i] - 1
    atacadas[i] := verdadeiro
    total := total - 1
  fim
  se lado então
    i := i + 1
  senão
    i := i - 1
  fim
fim
escreva "{atacadas.selecione(_ == verdadeiro).tamanho} {total}"

1980 - Embaralhando

Descrição do Problema: 1980 - Embaralhando

Categoria: Ad-Hoc

fat(n: Inteiro): BigInt = se n > 1 então fat(n-1) * n senão 1 fim

var s := leia_texto
enquanto s <> "0" faça
    letras_repetidas = s.ordene.divida_quando(_ <> _).mapeie(_.tamanho).selecione(_ > 1).ordene
    anagramas = letras_repetidas.injete(fat(s.tamanho))((a, b) => a div fat(b))
    escreva anagramas
    s := leia_texto
fim

1983 - O Escolhido

Descrição do Problema: 1983 - O Escolhido

Categoria: Iniciante

n = leia_inteiro
var maior_nome, maior_nota := "Minimum note not reached", 8.0
para i de 1 até n faça
  a = leia_textos(" ")
  nome, nota = a[1], a[2].real
  se nota >= maior_nota então
    maior_nome := nome
    maior_nota := nota
  fim
fim
escreva maior_nome

1984 - O Enigma do Pronalândia

Descrição do Problema: 1984 - O Enigma do Pronalândia

Categoria: Iniciante

a = leia_texto
escreva a.inverta

1985 - MacPRONALTS

Descrição do Problema: 1985 - MacPRONALTS

Categoria: Iniciante

n = leia_inteiro
var soma := 0.0
para i de 1 até n faça
  in = leia_inteiros(" ")
  p, q = in[1], in[2]
  soma := soma + (p - 999.5) * q
fim
escreva soma formato "%.2f"

1986 - Perdido em Marte

Descrição do Problema: 1986 - Perdido em Marte

Categoria: Ad-Hoc

hex2dec = (c: Caractere) => se c < 65 então c - 48 senão c - 55 fim
hex2tex = (s: Texto) => (hex2dec(s[1]) * 16 + hex2dec(s[2])).caractere

n = leia_inteiro
nums = leia_textos(" ")
mensagem = nums.mapeie(hex2tex).junte("")
escreva mensagem

1987 - Divisibilidade Por 3

Descrição do Problema: 1987 - Divisibilidade Por 3

Categoria: Ad-Hoc

# eof = falso
var entrada := leia_texto
enquanto não eof faça
    numeros = entrada.divida()[2]
    soma = numeros.injete(0)((x, y) => x + y) - 48 * numeros.tamanho
    se soma mod 3 == 0 então
        escreva "{soma} sim"
    senão
        escreva "{soma} nao"
    fim
    entrada := leia_texto
fim

1989 - Fazendo Nada

Descrição do Problema: 1989 - Fazendo Nada

Categoria: Matemática

var entrada := leia_inteiros(" ")
enquanto entrada <> [-1, -1] faça
  n, m = entrada[1], entrada[2]
  episodios = leia_inteiros(" ").zip(para i de n até 1 passo -1 gere i fim)
  duração = episodios.injete(0.0)((total, p) => total + p.primeiro * p.segundo)
  escreva m * duração formato "%.0f"
  entrada := leia_inteiros(" ")
fim