3400

Faixa de problemas: 3400-3499

Total resolvido: 31 de 100 problemas

Problemas não resolvidos (69)

3400, 3401, 3402, 3403, 3404, 3406, 3409, 3410, 3411, 3413, 3414, 3415, 3417, 3418, 3419, 3420, 3421, 3423, 3425, 3426, 3427, 3428, 3429, 3430, 3431, 3434, 3435, 3436, 3437, 3438, 3439, 3440, 3441, 3442, 3443, 3447, 3448, 3449, 3451, 3452, 3453, 3457, 3458, 3459, 3460, 3461, 3462, 3463, 3466, 3470, 3472, 3478, 3480, 3481, 3482, 3483, 3484, 3485, 3486, 3489, 3490, 3491, 3492, 3493, 3495, 3496, 3497, 3498, 3499

3405 - Fatorial

Descrição do Problema: 3405 - Fatorial

Categoria: Ad-Hoc · Olimpíada IFSULDEMINAS 2022

var n := leia_inteiro
var zeros := 0
enquanto n > 0 faça
  n := n div 5
  zeros := zeros + n
fim
escreva zeros

3407 - Hora do Café

Descrição do Problema: 3407 - Hora do Café

Categoria: Ad-Hoc · Olimpíada IFSULDEMINAS 2022

m = leia_inteiros(" ")[2]
natan, samuel = leia_texto.selecione(_ == '1').tamanho
se m == natan então
  escreva "Tudo certo."
senãose m == samuel então
  escreva "Pegou de Samuel."
senão
  escreva "Pegou de um estranho."
fim

3408 - Ignore as Letras

Descrição do Problema: 3408 - Ignore as Letras

Categoria: Ad-Hoc · Olimpíada IFSULDEMINAS 2022

so_numeros(s: Texto) =
  s.selecione(c => c >= '0' e c <= '9').inteiro

n = leia_inteiro
valores = leia_textos(n)
numeros = valores.mapeie(so_numeros)
soma = numeros.injete(0)(_ + _)
escreva soma

3412 - Avaliações de Algoritmos

Descrição do Problema: 3412 - Avaliações de Algoritmos

Categoria: Ad-Hoc · Fase Zero - Maratona SBC 2022

n  = leia_inteiro
para i de 1 até n faça
  nome = leia_texto
  notas = leia_reais(" ")
  maiores = notas.pegue(3).ordene.inverta
  media = escolha notas.tamanho
    caso 1                          => (notas[1] + 0) / 2
    caso 2                          => (notas[1] + notas[2]) / 2
    caso 4 se notas[4] > maiores[3] => (maiores[1] + maiores[2] + notas[4]) / 3
    caso _                          => (notas[1] + notas[2] + notas[3]) / 3
  fim
  escreva "{nome}: {media formato "%.1f"}"
fim

3416 - Eu Quero Cafééé

Descrição do Problema: 3416 - Eu Quero Cafééé

Categoria: Ad-Hoc · Fase Zero - Maratona SBC 2022

entrada = leia_inteiros(" ")
n, l, d = entrada[1], entrada[2], entrada[3]
a = n * d / (l * 1000)
b = a.teto.inteiro
escreva b * l

3422 - José e a Súmula

Descrição do Problema: 3422 - José e a Súmula

Categoria: Ad-Hoc · Fase Zero - Maratona SBC 2022

min(a, b: Inteiro): Inteiro = se a <= b então a senão b fim

n = leia_inteiro
para i de 1 até n faça
  a = leia_textos(" ")
  o, tempo = a[1].inteiro, a[2]
  t = (se tempo == "1T" então 0 senão 45 fim) + min(45, o)
  extra = o - 45
  se extra <= 0 então
    escreva t
  senão
    escreva "{t}+{extra}"
  fim
fim

3424 - Achando os Monótonos Não-Triviais Maximais

Descrição do Problema: 3424 - Achando os Monótonos Não-Triviais Maximais

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

leia_texto
s = leia_textos("b").mapeie(_.tamanho).selecione(_ > 1)
total = s.injete(0)(_ + _)
escreva total

3432 - Interceptando Informações

Descrição do Problema: 3432 - Interceptando Informações

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

ns = leia_texto
sucesso = ns.selecione(_ == '9').tamanho == 0
se sucesso então
  escreva "S"
senão
  escreva "F"
fim

3433 - Jogando 23

Descrição do Problema: 3433 - Jogando 23

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

menor(a, b: Inteiro) = se a < b então a senão b fim
soma(lista: Lista[Inteiro]) =
  lista.mapeie(a => menor(a, 10)).injete(0)(_ + _)

cartas_disponiveis(lista: Lista[Inteiro]) =
  (para i de 1 até 13, j de 1 até 4 gere i fim - lista)
    .ordene.divida_quando(_ <> _).mapeie(_.cabeça)

n = leia_inteiro
j, m, comum = leia_inteiros(" ")
joao  = soma(j + comum)
maria = soma(m + comum)
cartas = cartas_disponiveis(j + m + comum)
var carta := -1
para c em cartas.inverta faça
  se maria + menor(c, 10) == 23 ou
     maria + menor(c, 10) < 23 e joao + menor(c, 10) > 23 então
       carta := c
  fim
fim
escreva carta

3444 - Dobras da Cidade

Descrição do Problema: 3444 - Dobras da Cidade

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

pot2(k: Inteiro, p: BigInt) = BigInt(2).pow(k) - (p + 1)

a = leia_textos(" ")
n = a[1].inteiro
var p, h := BigInt(a[2]) - 1 , BigInt(a[3]) - 1

w = para k de n até 1 passo -1 gere
  c = pot2(k - 1, h) <= -1
  se c então h := pot2(k, h) fim 
  c
fim

V, F = verdadeiro, falso
saida = para k de n até 1 passo -1 gere
  pk1 = pot2(k - 1, p)
  p := escolha (w[k], pk1 >= 0)
    caso (V, V) => pk1           # L
    caso (F, F) => -(pk1 + 1)    # L
    caso (V, F) => pot2(k, p)    # R
    caso (F, V) => p             # R
  fim
  se w[k] == (pk1 >= 0) então 'L' senão 'R' fim
fim.junte("")

escreva saida

3445 - Passeios cotidianos

Descrição do Problema: 3445 - Passeios cotidianos

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

entrada = leia_inteiros(" ")
n = entrada[1]
var h, w := entrada[2], entrada[3]
para i de 1 até n faça
  chuva = leia_textos(" ")
  H = se chuva[1] == "Y" ou w == 0 então h := h - 1 w := w + 1 "Y" senão "N" fim
  W = se chuva[2] == "Y" ou h == 0 então w := w - 1 h := h + 1 "Y" senão "N" fim
  escreva "{H} {W}"
fim

3446 - Quadrados Vazios

Descrição do Problema: 3446 - Quadrados Vazios

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

vazios(x, y: Inteiro, livres: Lista[Inteiro]) =
  para peça1 em livres.selecione(_ <= x) + [0],
       peça2 em livres.selecione(_ <= x - peça1) - [peça1] + [0],
       peça3 em livres.selecione(_ <= y)         - [peça1, peça2] + [0],
       peça4 em livres.selecione(_ <= y - peça3) - [peça1, peça2, peça3] + [0] gere
         x + y - (peça1 + peça2 + peça3 + peça4)
  fim.ordene.cabeça

a = leia_inteiros(" ")
E, K, D = a[3], a[2], a[1] - a[2] - a[3]
x = se E < 5 então E senão 0 fim
y = se D < 5 então D senão 0 fim
peças = [1, 2, 3, 4] - [K]
escreva vazios(x, y, peças)

3450 - Participando de uma Maratona

Descrição do Problema: 3450 - Participando de uma Maratona

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

tipo Corredor
  nums: Lista[Inteiro]
  t = nums[1]
  s = nums[2]
fim

tipo Foto
  nums: Lista[Inteiro]
  u = nums[1]
  a = nums[2]
  b = nums[3]
fim

está_na_foto(f: Foto, c: Corredor): Lógico
  p = (f.u - c.t) * c.s
  retorne f.u >= c.t e f.a <= p e p <= f.b
fim

há_corredor_na_foto(foto: Foto, corredores: Lista[Corredor])
  f(cs: Lista[Corredor]): Lógico =
    se      cs.tamanho == 0               então falso
    senãose está_na_foto(foto, cs.cabeça) então verdadeiro
                                          senão f(cs.cauda)
    fim
  retorne f(corredores)
fim

# programa principal
corredores = para i de 1 até leia_inteiro gere
  Corredor(leia_inteiros(" "))
fim

fotos = para i de 1 até leia_inteiro gere
  Foto(leia_inteiros(" "))
fim.selecione(foto => não há_corredor_na_foto(foto, corredores))

para i de 1 até leia_inteiro faça
  johnny = Corredor(leia_inteiros(" "))
  descartes = fotos.selecione(foto => não está_na_foto(foto, johnny)).tamanho
  escreva descartes
fim

3454 - Alice no País do Jogo da Velha

Descrição do Problema: 3454 - Alice no País do Jogo da Velha

Categoria: Ad-Hoc · Fase Zero - Maratona SBC 2023

linha = leia_texto
resultado = escolha linha
  caso "XOX" => "*"
  caso "XXO" => "Alice"
  caso "OXX" => "Alice"
  caso _     => "?"
fim
escreva resultado

3455 - Banco Nacional de Questões

Descrição do Problema: 3455 - Banco Nacional de Questões

Categoria: Ad-Hoc · Fase Zero - Maratona SBC 2023

m = leia_reais(" ")
a, b, c = m[1], m[2], m[3]
x = leia_texto[1]

d = escolha x
      caso 'A' => 2
      caso 'B' => 3
      caso  _  => 5
    fim

t = (a * 2 + b * 3 + c * 5) / d

escreva (t - 0.5) formato "%.0f"

3456 - Divisibilidade por 7

Descrição do Problema: 3456 - Divisibilidade por 7

Categoria: Ad-Hoc · Fase Zero - Maratona SBC 2023

var a := BigInt(leia_texto)
escreva a
enquanto a > 9 faça
  a := a div 10 * 3 + a mod 10
  escreva a
fim

3464 - Latência na Rede

Descrição do Problema: 3464 - Latência na Rede

Categoria: Ad-Hoc · Fase Zero - Maratona SBC 2023

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

a = leia_inteiros(" ")
n, m = a[1], a[2]
s = leia_inteiro

var area_coberta := 0
para i de 1 até s faça
  b = leia_inteiros(" ")
  x, y, r = b[1], b[2], b[3]
  xo = max(1, x - r)
  xi = min(n, x + r)
  yo = max(1, y - r)
  yi = min(m, y + r)
  area_coberta := area_coberta + (xi - xo + 1) * (yi - yo + 1)
fim
media = area_coberta / (n * m)
escreva media.inteiro

3465 - Cimba

Descrição do Problema: 3465 - Cimba

Categoria: Ad-Hoc · Olimpíada IFSULDEMINAS 2023

abc = leia_inteiros(" ")
a, b, c = abc[1], abc[2], abc[3]
s = (a + b + c) / 2
area = (s * (s - a) * (s - b) * (s - c)) ^ 0.5
escreva "{area formato "%.3f"} m2"

3467 - Esse é o meu lugar!

Descrição do Problema: 3467 - Esse é o meu lugar!

Categoria: Ad-Hoc · Olimpíada IFSULDEMINAS 2023

var entrada := leia_texto
enquanto não eof faça
  se entrada == "xxL"
    então escreva "Esse eh o meu lugar"
    senão escreva "Oi, Leonard"
  fim
  entrada := leia_texto
fim

3468 - Faça mais, mas faça melhor!

Descrição do Problema: 3468 - Faça mais, mas faça melhor!

Categoria: Ad-Hoc · Olimpíada IFSULDEMINAS 2023

ideia = leia_texto

se ideia.minúsculo == "oposicao" ou ideia.minúsculo == "contrariedade" então
    escreva "mas"
senão
    escreva "mais"
fim

3469 - In Site

Descrição do Problema: 3469 - In Site

Categoria: Ad-Hoc · Olimpíada IFSULDEMINAS 2023

n = leia_inteiro
p = leia_inteiros(" ").ordene
mediana = p.descarte((n-1) div 2)
se n mod 2 == 1 então
  escreva mediana.cabeça
senão
  escreva (mediana[1] + mediana[2]) div 2
fim

3471 - Kashmir

Descrição do Problema: 3471 - Kashmir

Categoria: Ad-Hoc · Olimpíada IFSULDEMINAS 2023

mdc(a, b: Inteiro): Inteiro = se b == 0 então a senão mdc(b, a mod b) fim

entrada = leia_inteiros(" ")
a = entrada[1]
b = entrada[2]
escreva mdc(a, b)

3473 - Alerte o próximo!

Descrição do Problema: 3473 - Alerte o próximo!

Categoria: Ad-Hoc · Olimpíada IFSULDEMINAS 2023

a = leia_inteiro
escreva a+1

3474 - Boa divisão

Descrição do Problema: 3474 - Boa divisão

Categoria: Ad-Hoc · Olimpíada IFSULDEMINAS 2023

a = leia_reais(" ")
valor = a[1] / a[2]
escreva valor formato "%.2f"

3475 - Conversor

Descrição do Problema: 3475 - Conversor

Categoria: Ad-Hoc · Olimpíada IFSULDEMINAS 2023

numeros = ["zero", "um", "dois", "tres", "quatro",
           "cinco","seis", "sete", "oito", "nove"]
a = leia_texto
p = numeros.posicao(a) - 1
n = numeros[a.inteiro + 1]
se p >= 0 então
  escreva p
senão
  escreva n
fim

3476 - A união faz a força!

Descrição do Problema: 3476 - A união faz a força!

Categoria: Ad-Hoc · Olimpíada IFSULDEMINAS 2023

a = leia_inteiros(" ")
s, b, c = a[1], a[2], a[3]
tempo = 1 / (1/s + 1/b + 1/c)
escreva tempo formato "%.3f"

3477 - Baú Danificado

Descrição do Problema: 3477 - Baú Danificado

Categoria: Ad-Hoc · Olimpíada IFSULDEMINAS 2023

a = leia_inteiros(" ")
x, y, z = a[1], a[2], a[3]
se x*x == y*y + z*z então
  area = (y + 3 * z / 4) * z / 2
  escreva "AREA = {area.inteiro}"
senão
  escreva "Nao eh retangulo!"
fim

3479 - Horo e os copos

Descrição do Problema: 3479 - Horo e os copos

Categoria: Ad-Hoc · Olimpíada IFSULDEMINAS 2023

data = leia_texto.divida("/").inverta.junte("")
signo = escolha data
  caso d se d <= "0119" => "capricornio"
  caso d se d <= "0218" => "aquario"
  caso d se d <= "0320" => "peixes"
  caso d se d <= "0420" => "aries"
  caso d se d <= "0520" => "touro"
  caso d se d <= "0620" => "gemeos"
  caso d se d <= "0722" => "cancer"
  caso d se d <= "0822" => "leao"
  caso d se d <= "0922" => "virgem"
  caso d se d <= "1022" => "libra"
  caso d se d <= "1121" => "escorpiao"
  caso d se d <= "1221" => "sargitario"
  caso _                => "capricornio"
fim
escreva signo

3487 - Firmware - Substring Manipulation

Descrição do Problema: 3487 - Firmware - Substring Manipulation

Categoria: Ad-Hoc

var s := leia_texto
parte = leia_texto
tam = parte.tamanho
var achou := verdadeiro
enquanto achou faça
  var i := 0
  achou := falso
  enquanto (i <= s.tamanho - tam) e não achou faça
    se s.descarte(i).pegue(tam) == parte então
      s := s.pegue(i) + s.descarte(i + tam)
      achou := verdadeiro
    fim
    i := i + 1
  fim
fim

se s <> "" então
  escreva s
senão
  escreva "null value"
fim

3488 - Binary/Hexadecimal Number Systems

Descrição do Problema: 3488 - Binary/Hexadecimal Number Systems

Categoria: Ad-Hoc

n = leia_real
a = log(n) / log(2)
b = a.inteiro
se abs(a-b) < 0.000000001 então
  escreva "true"
senão
  escreva "false"
fim

3494 - Palavras transformadas

Descrição do Problema: 3494 - Palavras transformadas

Categoria: Iniciante · Olimpíada IFSULDEMINAS 2025

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

def min(a, b: Inteiro) = se a <= b então a senão b fim

def distancia(a, b: Caractere)
  d = abs(a - b)
  retorne min(d, 26 - d)
fim

s, t = leia_texto

dist = para i de 1 até s.tamanho
         gere distancia(s[i], t[i])
       fim
         .injete(0)(soma)

escreva dist