2300

Faixa de problemas: 2300-2399

Total resolvido: 39 de 100 problemas

Problemas não resolvidos (61)

2300, 2301, 2302, 2303, 2304, 2305, 2307, 2308, 2309, 2314, 2316, 2317, 2318, 2319, 2320, 2321, 2323, 2324, 2325, 2326, 2329, 2330, 2331, 2332, 2333, 2335, 2337, 2340, 2343, 2346, 2347, 2348, 2350, 2351, 2352, 2353, 2354, 2357, 2358, 2359, 2360, 2361, 2362, 2363, 2364, 2365, 2366, 2367, 2368, 2370, 2371, 2372, 2379, 2380, 2383, 2384, 2385, 2387, 2392, 2393, 2398

2306 - Escada Perfeita

Descrição do Problema: 2306 - Escada Perfeita

Categoria: Ad-Hoc · OBI 2006

n = leia_inteiro
cubos = leia_inteiros(" ")

soma = cubos.injete(0)(_ + _)
num = 2 * soma + n - n * n
den = 2 * n
a1 = num div den
resto = num mod den

resposta = se resto == 0 e a1 > 0 então
             an = a1 + n - 1
             indice = para i de a1 até an gere i fim
             cubos.zip(indice)
               .mapeie(a => (a.primeiro - a.segundo).abs)
               .injete(0)(_ + _) div 2
            senão
              -1
            fim
escreva resposta

2310 - Voleibol

Descrição do Problema: 2310 - Voleibol

Categoria: Iniciante

n = leia_inteiro
var tentativas, sucesso := [0, 0, 0]
para i de 1 até n faça
  nome = leia_texto
  a, b = leia_inteiros(" ")
  para j de 1 até 3 faça
    tentativas[j] := tentativas[j] + a[j]
    sucesso[j] := sucesso[j] + b[j]
  fim
fim

fundamentos = ["Saque", "Bloqueio", "Ataque"]
para j de 1 até 3 faça
  pontos = sucesso[j] * 100 / tentativas[j]
  escreva "Pontos de {fundamentos[j]}: {pontos formato "%.2f"} %."
fim

2311 - Saltos Ornamentais

Descrição do Problema: 2311 - Saltos Ornamentais

Categoria: Iniciante

n = leia_inteiro
para i de 1 até n faça
  nome = leia_texto
  gd = leia_real
  notas = leia_reais(" ")
            .ordene
            .descarte(1)
            .pegue(5)
  soma = notas.injete(0.0)(_ + _)
  escreva "{nome} {soma * gd formato "%.2f"}"
fim

2312 - Quadro De Medalhas

Descrição do Problema: 2312 - Quadro De Medalhas

Categoria: Ad-Hoc

tipo Pais = (Texto, Inteiro, Inteiro, Inteiro)
comparar = (a, b: Pais) =>
  se a.segundo <> b.segundo então
    a.segundo > b.segundo
  senãose a.terceiro <> b.terceiro então
    a.terceiro > b.terceiro
  senãose a.quarto <> b.quarto então
    a.quarto > b.quarto
  senão
    a.primeiro < b.primeiro
  fim

n = leia_inteiro
paises = Lista(n, leia_textos(" "))
   .mapeie(a => (a[1], a[2].inteiro, a[3].inteiro, a[4].inteiro))
ordem = paises.ordene(comparar)
escreva ordem.mapeie(a => "{a.primeiro} {a.segundo} {a.terceiro} {a.quarto}").junte("\n")

2313 - Qual Triângulo

Descrição do Problema: 2313 - Qual Triângulo

Categoria: Iniciante

lados = leia_inteiros(" ").ordene
a, b, c = lados[1], lados[2], lados[3]
se a + b > c então
  imprima "Valido-"
  escreva se a == c então
    "Equilatero"
  senãose a == b ou b == c então
    "Isoceles"
  senão
    "Escaleno"
  fim
  escreva "Retangulo: {se a * a + b * b == c * c então "S" senão "N" fim}"
senão
  escreva "Invalido"
fim

2315 - Diferença Fácil Entre Datas

Descrição do Problema: 2315 - Diferença Fácil Entre Datas

Categoria: Ad-Hoc

dias = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

data1, data2 = leia_inteiros(" ")
d1, m1 = data1[1], data1[2]
d2, m2 = data2[1], data2[2]

dias1 = d1 + dias.pegue(m1 - 1).injete(0)(_ + _)
dias2 = d2 + dias.pegue(m2 - 1).injete(0)(_ + _)

escreva dias2 - dias1

2322 - Peça Perdida

Descrição do Problema: 2322 - Peça Perdida

Categoria: Ad-Hoc · OBI 2007

n = leia_inteiro
nums = (0 :: (n + 1) :: leia_inteiros(" ")).ordene
escreva nums.divida_quando((a, b) => b - a > 1)[2].cabeça - 1

2327 - Quadrados

Descrição do Problema: 2327 - Quadrados

Categoria: Ad-Hoc · OBI 2007

somar_linha(a: Lista[Lista[Inteiro]], n: Inteiro) =
  (f: Inteiro => (Inteiro, Inteiro)) =>
    para i de 1 até n gere
      a[f(i).primeiro][f(i).segundo]
    fim.injete(0)(_ + _)

n = leia_inteiro
a = para i de 1 até n gere leia_inteiros(" ") fim

s = somar_linha(a, n)
soma = (s(i => (i, i)) ::              # diagonal principal
         s(i => (i, n - i + 1)) ::      # diagonal secundária
         para j de 1 até n gere s(i => (j, i)) fim +
         para j de 1 até n gere s(i => (i, j)) fim).ordene

escreva se soma[1] == soma[-1] então soma[1] senão -1 fim

2328 - Chocolate

Descrição do Problema: 2328 - Chocolate

Categoria: Ad-Hoc · OBI 2007

n = leia_inteiro
a = leia_inteiros(" ")
s = a.injete(0)(_ + _) - n
escreva s

2334 - Patinhos

Descrição do Problema: 2334 - Patinhos

Categoria: Iniciante

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

2336 - ABC

Descrição do Problema: 2336 - ABC

Categoria: Strings

var s := leia_texto
enquanto não eof faça
  abc = s.lista.mapeie(_ - 'A')
  decimal = abc.injete(BigInt(0))((a,b) => (a * 26 + b) mod 1000000007)
  escreva decimal
  s := leia_texto
fim

2338 - Morse

Descrição do Problema: 2338 - Morse

Categoria: Estruturas e Bibliotecas

letras = ["=.===", "===.=.=.=", "===.=.===.=", "===.=.=", "=", "=.=.===.=",
 "===.===.=", "=.=.=.=","=.=", "=.===.===.===", "===.=.===", "=.===.=.=",
 "===.===", "===.=", "===.===.===", "=.===.===.=", "===.===.=.===",
 "=.===.=", "=.=.=", "===", "=.=.===", "=.=.=.===", "=.===.===",
 "===.=.=.===", "===.=.===.===", "===.===.=.="]
ponto = "\\."

converta_letra(letra: Texto) = (letras.posição(letra) + 96).caractere
converta_palavra(palavra: Texto) = palavra.divida(ponto * 3).mapeie(converta_letra).junte("")

t = leia_inteiro
para i de 1 até t faça
  s = leia_texto
  palavras = s.divida(ponto * 7).mapeie(converta_palavra).junte(" ")
  escreva palavras
fim

2339 - Aviões de Papel

Descrição do Problema: 2339 - Aviões de Papel

Categoria: Ad-Hoc · OBI 2009

a = leia_inteiros(" ")
c, p, f = a[1], a[2], a[3]
se c * f <= p então
  escreva "S"
senão
  escreva "N"
fim

2341 - Número de Envelopes

Descrição do Problema: 2341 - Número de Envelopes

Categoria: Ad-Hoc · OBI 2009

entrada = leia_inteiros(" ")
n, k = entrada[1], entrada[2]
xs = leia_inteiros(" ")

var envelopes = Lista.mutável(k, 0)
para x em xs faça
  envelopes[x] := envelopes[x] + 1
fim

rotulos = envelopes.ordene[1]
escreva rotulos

2342 - Overflow

Descrição do Problema: 2342 - Overflow

Categoria: Ad-Hoc · OBI 2009

n = leia_inteiro
exp = leia_textos(" ")
p, c, q = exp[1].inteiro, exp[2], exp[3].inteiro
valor = escolha c
  caso "*" => p.inteiro * q.inteiro
  caso _   => p.inteiro + q.inteiro
fim

se valor > n então
  escreva "OVERFLOW"
senão
  escreva "OK"
fim

2344 - Notas da Prova

Descrição do Problema: 2344 - Notas da Prova

Categoria: Iniciante · OBI 2009

n = leia_inteiro
escolha n
  caso 0            => escreva "E"
  caso x se x <= 35 => escreva "D"
  caso x se x <= 60 => escreva "C"
  caso x se x <= 85 => escreva "B"
  caso _            => escreva "A"
fim

2345 - Assigning Teams

Descrição do Problema: 2345 - Assigning Teams

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

x = leia_inteiros(" ")
dif = abs((x[1] + x[4]) - (x[2] + x[3]))
escreva dif

2349 - Farm Robot

Descrição do Problema: 2349 - Farm Robot

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

n = leia_inteiros(3)
var pos := 1
var cont := se n[3] == 1 então 1 senão 0 fim
para comando em leia_inteiros(n[2]) faça
    pos := pos + comando
    se pos > n[1] então 
        pos := 1
    senãose pos < 1 então 
        pos := n[1]
    fim
    se pos == n[3] então
        cont := cont + 1
    fim
fim
escreva cont

2355 - Brasil e Alemanha

Descrição do Problema: 2355 - Brasil e Alemanha

Categoria: Ad-Hoc

var n := leia_inteiro
enquanto n > 0 faça
  brasil = (n / 90).piso.inteiro
  alemanha = (n / 90 * 7).teto.inteiro
  escreva "Brasil {brasil} x Alemanha {alemanha}"
  n := leia_inteiro
fim

2356 - Bactéria I

Descrição do Problema: 2356 - Bactéria I

Categoria: Strings

var d := leia_texto
enquanto não eof faça
  s = leia_texto
  var i := 0
  enquanto i < d.tamanho - s.tamanho + 1 faça
    se d.descarte(i).pegue(s.tamanho) == s então
      escreva "Resistente"
      i := d.tamanho
    senão
      i := i + 1
    fim
  fim
  se i < d.tamanho então
    escreva "Nao resistente"
  fim
  d := leia_texto
fim

2369 - Conta de Água

Descrição do Problema: 2369 - Conta de Água

Categoria: Ad-Hoc · OBI 2010

n = leia_inteiro
var conta := 7
se n > 10 então
  conta := conta + (n - 10)
fim
se n > 30 então
  conta := conta + (n - 30)
fim
se n > 100 então
  conta := conta + (n - 100) * 3
fim
escreva conta

2373 - Garçom

Descrição do Problema: 2373 - Garçom

Categoria: Ad-Hoc · OBI 2010

n = leia_inteiro
var total := 0
para i de 1 até n faça
  a = leia_inteiros(" ")
  l, c = a[1], a[2]
  se l > c então total := total + c fim
fim
escreva total

2374 - Pneu

Descrição do Problema: 2374 - Pneu

Categoria: Ad-Hoc · OBI 2010

n, m = leia_inteiro
escreva n - m

2375 - Sedex

Descrição do Problema: 2375 - Sedex

Categoria: Ad-Hoc · OBI 2010

n = leia_inteiro
entrada = leia_inteiros(" ")

a = entrada[1]
b = entrada[2]
c = entrada[3]

se n <= a e n <= b e n <= c então
  escreva "S"
senão
  escreva "N"
fim

2376 - Copa do Mundo

Descrição do Problema: 2376 - Copa do Mundo

Categoria: Ad-Hoc · OBI 2010

jogos = para i de 1 até 15 gere
  a = leia_inteiros(" ")
  a[1] > a[2]
fim

jogo1 =
  se jogos[15] então
    se jogos[13] então
      se jogos[9] então 1 senão 2 fim
    senão
      se jogos[10] então 3 senão 4 fim
    fim
  senão
    se jogos[14] então
      se jogos[11] então 5 senão 6 fim
    senão
      se jogos[12] então 7 senão 8 fim
    fim
  fim

campeao = se jogos[jogo1] então jogo1 * 2 - 1 senão jogo1 * 2 fim
escreva "ABCDEFGHIJKLMNOP"[campeao]

2377 - Pedágio

Descrição do Problema: 2377 - Pedágio

Categoria: Ad-Hoc · OBI 2010

linha1, linha2 = leia_inteiros(" ")
l = linha1[1]
d = linha1[2]
k = linha2[1]
p = linha2[2]

pedagios = l div d
custo = l * k + pedagios * p
escreva custo

2378 - Elevador

Descrição do Problema: 2378 - Elevador

Categoria: Ad-Hoc · OBI 2010

a = leia_inteiros(" ")
n, c = a[1], a[2]
var excedida := "N"
var pessoas := 0
var i := 0
enquanto i < n faça
  b = leia_inteiros(" ")
  pessoas := pessoas + b[2] - b[1]
  se pessoas > c então
    excedida := "S"
    i := n
  fim
  i := i + 1
fim
escreva excedida

2381 - Lista de Chamada

Descrição do Problema: 2381 - Lista de Chamada

Categoria: Ad-Hoc · OBI 2010

a = leia_inteiros(" ")
n, k = a[1], a[2]
nomes = leia_textos(n)
escreva nomes.ordene[k]

2382 - Sedex Marciano

Descrição do Problema: 2382 - Sedex Marciano

Categoria: Ad-Hoc · OBI 2010

d = leia_inteiros(4)
lados = d.pegue(3).ordene(_ > _)
l1, l2 = lados[1], lados[2]
r = d[4]
se l1 * l1 + l2 * l2 <= 4 * r * r então
  escreva "S"
senão
  escreva "N"
fim

2386 - Telescópio

Descrição do Problema: 2386 - Telescópio

Categoria: Ad-Hoc · OBI 2010

a, n = leia_inteiro
z = 40000000 / a
var soma := 0
para i de 1 até n faça
  f = leia_inteiro
  se f >= z então
    soma := soma + 1
  fim
fim
escreva soma

2388 - Tacógrafo

Descrição do Problema: 2388 - Tacógrafo

Categoria: Ad-Hoc · OBI 2010

n = leia_inteiro
var soma := 0
para i de 1 até n faça
  linha = leia_inteiros(" ")
  t, v = linha[1], linha[2]
  soma := soma + t * v
fim
escreva soma

2389 - Floresta

Descrição do Problema: 2389 - Floresta

Categoria: Ad-Hoc · OBI 2010

x = leia_inteiro
limite = raiz(x / 2).inteiro

var combinações := 0
para n de 1 até limite faça
  se (n + x) mod (2 * n + 1) == 0 então
    combinações := combinações + 1
  fim
fim
escreva combinações

# combinações = para n de 1 até limite se (n + x) mod (2 * n + 1) == 0 gere 1 fim.tamanho

2390 - Escada Rolante

Descrição do Problema: 2390 - Escada Rolante

Categoria: Ad-Hoc · OBI 2010

n = leia_inteiro
var tempo, anterior := 0, -1
para i de 1 até n faça
    atual = leia_inteiro
    dif = atual - anterior
    se anterior <> -1 e dif < 10 então
        tempo := tempo - (10 - dif)
    fim
    anterior := atual
    tempo := tempo + 10
fim
escreva tempo

2391 - Progressões Aritméticas

Descrição do Problema: 2391 - Progressões Aritméticas

Categoria: Ad-Hoc · OBI 2011

pas(nums: Lista[Inteiro], tamanho, total: Inteiro): Inteiro =
  se tamanho < 3                           então total
  senãose nums[1] + nums[3] == 2 * nums[2] então pas(nums.cauda, tamanho - 1, total)
                                           senão pas(nums.descarte(2), tamanho - 2, total + 1)
  fim

n = leia_inteiro
a = leia_inteiros(" ")
escreva pas(a, n, 1)

# # Imperativo
# var n := leia_inteiro
# var a := leia_inteiros(" ")
# var total := 1
# enquanto n > 2 faça
#   se a[1] + a[3] == 2 * a[2] então
#     a := a.descarte(1)
#     n := n - 1
#   senão
#     a := a.descarte(2)
#     n := n - 2
#     total := total + 1
#   fim
# fim
# escreva total

2394 - Corrida 1

Descrição do Problema: 2394 - Corrida 1

Categoria: Ad-Hoc · OBI 2011

n  = leia_inteiro
tempos = para i de 1 até n gere leia_inteiros(" ").injete(0)(_ + _) fim
menor = tempos.ordene.cabeca
ganhador = tempos.posicao(menor)
escreva ganhador

2395 - Transporte de Contêineres

Descrição do Problema: 2395 - Transporte de Contêineres

Categoria: Ad-Hoc · OBI 2011

c = leia_inteiros(" ")
n = leia_inteiros(" ")
escreva (n[1] div c[1]) * (n[2] div c[2]) * (n[3] div c[3])

2396 - Corrida

Descrição do Problema: 2396 - Corrida

Categoria: Ad-Hoc · OBI 2011

n  = leia_inteiro
tempos = para i de 1 até n gere leia_inteiros(" ").injete(0)(_ + _) fim
primeiros = tempos.ordene
escreva tempos.posicao(primeiros[1])
escreva tempos.posicao(primeiros[2])
escreva tempos.posicao(primeiros[3])

2397 - Triângulos

Descrição do Problema: 2397 - Triângulos

Categoria: Ad-Hoc · OBI 2011

lados = leia_inteiros(" ").ordene
a, b, c = lados[1], lados[2], lados[3]

d = c * c - (a * a + b * b)
escolha d
  caso d se d >= 2 * a * b => escreva "n"
  caso d se d > 0          => escreva "o"
  caso d se d < 0          => escreva "a"
  caso _                   => escreva "r"
fim

2399 - Campo Minado

Descrição do Problema: 2399 - Campo Minado

Categoria: Ad-Hoc · OBI 2011

n = leia_inteiro
a = 0::leia_inteiros(n) + [0]
para i de 2 até a.tamanho - 1 faça
  soma = a[i-1] + a[i] + a[i+1]
  escreva soma
fim