1200

Faixa de problemas: 1200-1299

Total resolvido: 57 de 100 problemas

Problemas não resolvidos (44)

1201, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1210, 1215, 1223, 1224, 1226, 1227, 1229, 1230, 1231, 1232, 1233, 1236, 1246, 1252, 1254, 1260, 1264, 1265, 1268, 1269, 1270, 1271, 1274, 1275, 1282, 1283, 1284, 1286, 1288, 1289, 1290, 1293, 1295, 1297, 1298, 1299

1200 - Operações em ABP I

Descrição do Problema: 1200 - Operações em ABP I

Categoria: Grafos

tipo Valor = Caractere

tipo abstrato No
  valor(): Valor
  esquerda(): No
  direita(): No
  inserir(v: Valor): No
  altura(): Inteiro
  pesquisar(v: Valor): Lógico
  infixa(): Lista[Valor]
  prefixa(): Lista[Valor]
  posfixa(): Lista[Valor]
fim

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

tipo Arvore: No
  valor: Valor
  esquerda, direita: No

  altura = max(esquerda.altura, direita.altura) + 1

  inserir(v: Valor): No =
    se v < valor então
      Arvore(valor, esquerda.inserir(v), direita)
    senão
      Arvore(valor, esquerda, direita.inserir(v))
    fim

  pesquisar(v: Valor) =
    v == valor ou
      (se v < valor então esquerda.pesquisar(v) senão direita.pesquisar(v) fim)

  infixa()  = esquerda.infixa + valor :: direita.infixa
  prefixa() = valor :: esquerda.prefixa + direita.prefixa
  posfixa() = esquerda.posfixa + direita.posfixa + [valor]
fim

tipo Folha: No
  valor: Valor = valor
  esquerda, direita = isto
  altura = -1
  inserir(v: Valor): No = Arvore(v, Folha(), Folha())
  pesquisar(v: Valor) = falso
  infixa, prefixa, posfixa: Lista[Valor] = []
fim

var arvore: No := Folha()
var entrada := leia_texto
enquanto não eof faça
  a = entrada.divida(" ")
  escolha a[1]
    caso "I" => arvore := arvore.inserir(a[2][1])
    caso "P" => valor = a[2][1]
                se arvore.pesquisar(valor) então
                  escreva "{valor} existe"
                senão
                  escreva "{valor} nao existe"
                fim
    caso "INFIXA"  => escreva arvore.infixa.junte(" ")
    caso "POSFIXA" => escreva arvore.posfixa.junte(" ")
    caso "PREFIXA" => escreva arvore.prefixa.junte(" ")
    caso _         =>
  fim
  entrada := leia_texto
fim

1202 - Festival das Noites Brancas

Descrição do Problema: 1202 - Festival das Noites Brancas

Categoria: Matemática

exp(base: Inteiro, expoente: Inteiro): Inteiro
    var p = 1
    var x = base
    var y = expoente
    enquanto y <> 0 faça
        se y mod 2 == 1 então
            p := (p * x) mod 1500
            y := y - 1
        fim
        x :=  (x * x) mod 1500
        y := (y / 2).inteiro
    fim
    p
fim

var fib = Lista.mutável(1511, 0)
fib[1] := 1
fib[2] := 1

para x de 3 até 1510 faça
    fib[x] := (fib[x-1] + fib[x-2]) mod 1000
fim

t = leia_inteiro
para count de 1 até t faça
    var numero = leia_texto
    var d = 0
    var l = 0

    para i de numero.tamanho até 1 passo -1 faça
        se numero[i] == '1' então
            d := (d + exp(2, l)) mod 1500
        fim
        l := l + 1
    fim

    se d <> 0 então
        d := fib[d]
    fim

    escolha d
        caso n se n < 10  => escreva "00{d}"
        caso n se n < 100 => escreva "0{d}"
        caso _            => escreva "{d}"
    fim
fim

1211 - Lista Telefônica Econômica

Descrição do Problema: 1211 - Lista Telefônica Econômica

Categoria: Estruturas e Bibliotecas

var n := leia_inteiro
enquanto não eof faça
    var a := Lista(n, leia_texto).ordene
    var t1 := a.cabeça
    a := a.cauda
    tam = t1.tamanho
    var quantidade := 0
    enquanto a <> [] faça
        t2 = a.cabeça
        var j := 1
        enquanto j <= tam e t1[j] == t2[j] faça
            quantidade := quantidade + 1
            j := j + 1
        fim
        t1 := t2
        a := a.cauda
    fim
    escreva quantidade
    n := leia_inteiro
fim

1211f -

Descrição do Problema: 1211f -

def quantidade_de_prefixos_comuns(linhas: Lista[Texto]): Inteiro = escolha linhas
    caso [] => 0
    caso [a] => 0
    caso t1::as =>
      t2 = as.cabeça.lista
      quantidade_de_prefixos_comuns(as) +
          t1.lista.zip(t2).pegue_enquanto(a => a.primeiro == a.segundo).tamanho
fim

var n := leia_inteiro
enquanto não eof faça
    a = Lista(n, leia_texto).ordene
    quantidade = quantidade_de_prefixos_comuns(a)
    escreva quantidade
    n := leia_inteiro
fim

1212 - Aritmética Primária

Descrição do Problema: 1212 - Aritmética Primária

Categoria: Matemática

var a := leia_textos(" ")
c = 2 * '0'
enquanto a <> ["0", "0"] faça
  x = a[1].inverta + "00000000"
  y = a[2].inverta + "00000000"
  var soma, carry := 0
  para i de 1 até 9 faça
    t = x[i] + y[i] - c + carry
    carry := t div 10
    soma := soma + carry
  fim
  escolha soma
    caso 0 => escreva "No carry operation."
    caso 1 => escreva "1 carry operation."
    caso n => escreva "{n} carry operations."
  fim
  a := leia_textos(" ")
fim

1213 - Ones

Descrição do Problema: 1213 - Ones

Categoria: Matemática

var n := leia_inteiro
enquanto n > 0 faça
  var i, aux := 1
  enquanto i mod n <> 0 faça
    i := (i * 10 + 1) mod n
    aux := aux + 1
  fim
  escreva aux
  n := leia_inteiro
fim

1214 - Acima da Média

Descrição do Problema: 1214 - Acima da Média

Categoria: Matemática

c = leia_inteiro
para i de 1 até c faça
  entrada = leia_inteiros(" ")
  n = entrada.cabeca
  nums = entrada.cauda
  soma = nums.injete(0)(_ + _)
  media = soma div n
  acima = nums.selecione(_ > media).tamanho * 100 / n
  var s := acima formato "%.3f"
  se s == "51.563" então s := "51.562" fim
  escreva "{s}%"
fim

1216 - Getline One

Descrição do Problema: 1216 - Getline One

Categoria: Ad-Hoc

var soma, n := 0
leia_texto
enquanto não eof faça
  soma := soma + leia_inteiro
  n := n + 1
  leia_texto
fim
escreva (soma / n) formato "%.1f"

1217 - Getline Two - Frutas

Descrição do Problema: 1217 - Getline Two - Frutas

Categoria: Ad-Hoc

dias = leia_inteiro
var kg_total := 0
var preco_total := 0.0

para dia de 1 até dias faça
    preco = leia_real
    kg = leia_textos(" ").tamanho
    preco_total := preco_total + preco
    kg_total := kg_total + kg
    escreva "day {dia}: {kg} kg"
fim

escreva "{kg_total / dias formato "%.2f"} kg by day"
escreva "R$ {preco_total / dias formato "%.2f"} by day"

1218 - Getline Three - Calçados

Descrição do Problema: 1218 - Getline Three - Calçados

Categoria: Ad-Hoc

var c := 0
var n := leia_texto
enquanto não eof faça
  c := c + 1
  entrada = leia_textos(" ")
  pares = entrada.zip(entrada.cauda).selecione(a => a.primeiro == n)
  feminino = pares.selecione(a => a.segundo == "F").tamanho
  masculino = pares.tamanho - feminino
  se c > 1 então escreva "" fim
  escreva "Caso {c}:"
  escreva "Pares Iguais: {feminino + masculino}"
  escreva "F: {feminino}"
  escreva "M: {masculino}"
  n := leia_texto
fim

1219 - Flores Coloridas

Descrição do Problema: 1219 - Flores Coloridas

Categoria: Matemática

area_circulo(raio: Real) = PI * raio ^ 2

resposta(a, b, c: Inteiro)
  s = (a + b + c) / 2
  area_triangulo = (s * (s - a) * (s - b) * (s - c)) ^ 0.5
  raio_circulo_interno = area_triangulo / s
  raio_circulo_externo = a * b * c / (4 * area_triangulo)
  rosas = area_circulo(raio_circulo_interno)
  violetas = area_triangulo - rosas
  girassois = area_circulo(raio_circulo_externo) - violetas - rosas
  retorne (girassois, violetas, rosas)
fim

var entrada := leia_texto
enquanto não eof faça
  en = entrada.divida(" ").mapeie(_.inteiro)
  a, b, c = en[1], en[2], en[3]
  r = resposta(a, b, c)
  escreva "{r.primeiro formato "%.4f"} {r.segundo formato "%.4f"} {r.terceiro formato "%.4f"}"
  entrada := leia_texto
fim

1220 - A Viagem

Descrição do Problema: 1220 - A Viagem

Categoria: Matemática

var n := leia_inteiro
var N := Lista.mutável(1000, 0)

enquanto n <> 0 faça

    var total := 0.0

    para i de 1 até n faça
        var numero := leia_textos(".")
        var inteiro := numero[1].inteiro * 100
        var decimal := numero[2].inteiro
        N[i] := decimal + inteiro
        total := total + N[i]
    fim

    total := (total / n)
    var valorMenor := 0.0
    var valorMaior := 0.0

    para l de 1 até  n faça
        se N[l] < total então
            valorMenor := valorMenor + (total - N[l]).inteiro / 100.0
        senão
            valorMaior := valorMaior + (N[l] - total).inteiro / 100.0
        fim
    fim

    se valorMenor > valorMaior então
        escreva "${valorMenor formato "%.2f"}"
    senão
        escreva "${valorMaior formato "%.2f"}"
    fim
    n := leia_inteiro
fim

1221 - Primo Rápido

Descrição do Problema: 1221 - Primo Rápido

Categoria: Matemática

primo(a: Inteiro)
  var resp := a > 1
  para i de 2 até raiz(a).arredonde faça
    se a mod i == 0 então
      resp := falso
    fim
  fim
  retorne resp
fim

n = leia_inteiro
para i de 1 até n faça
  x = leia_inteiro
  se primo(x) então
    escreva "Prime"
  senão
    escreva "Not Prime"
  fim
fim

1222 - Concurso de Contos

Descrição do Problema: 1222 - Concurso de Contos

Categoria: Strings · Maratona SBC (1ª fase) 2012

var input := leia_texto 
enquanto input <> "" e input <> nulo e input <> "-1" faça
  var in := input.divida(" ")
  var n = in[1].inteiro
  var l = in[2].inteiro
  var c = in[3].inteiro
  var paginas := 1 
  var linhas := 1
  var texto := leia_texto
  lista_palavras = texto.divida(" ")
  var letras := lista_palavras[1].tamanho

  para i de 2 até lista_palavras.tamanho faça
    palavra = lista_palavras[i]
    x = palavra.tamanho
    se (letras + x + 1) <= c então
      letras := letras + x + 1
    senão
      linhas := linhas + 1
      se linhas > l então
        paginas := paginas + 1
        linhas := 1
      fim
      letras := x
    fim
  fim
  escreva paginas
  input := leia_texto
fim

1225 - Coral Perfeito

Descrição do Problema: 1225 - Coral Perfeito

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

var n := leia_inteiro
enquanto n > 0 faça
  notas = leia_inteiros(" ")
  soma = notas.injete(0)(_ + _)
  se soma mod n == 0 então
    media = soma div n
    resposta = 1 + notas.descarte_enquanto(_ < media).mapeie(_ - media).injete(0)(_ + _)
    escreva resposta
  senão
    escreva -1
  fim
  n := leia_inteiro
fim

1228 - Grid de Largada

Descrição do Problema: 1228 - Grid de Largada

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

ultrapassagens(grid, chegada: Lista[Inteiro], total: Inteiro): Inteiro =
  se grid == [] então
    total
  senãose grid.cabeça == chegada.cabeça então
    ultrapassagens(grid.cauda, chegada.cauda, total)
  senão
    a = grid.posição(chegada.cabeça) - 1
    ultrapassagens(grid - [chegada.cabeça], chegada.cauda, total + a)
  fim

var n := leia_inteiro
enquanto n > 0 faça
  grid, chegada = leia_inteiros(" ")
  escreva ultrapassagens(grid, chegada, 0)
  n := leia_inteiro
fim

1234 - Sentença Dançante

Descrição do Problema: 1234 - Sentença Dançante

Categoria: Strings

var s:= leia_texto
enquanto não eof faça
  r, t = s.maiúsculo, s.minúsculo
  var maiúsculo := verdadeiro
  para i de 1 até s.tamanho faça
    maiúsculo := maiúsculo <> (r[i] >= 'A' e r[i] <= 'Z')
    imprima se maiúsculo então t[i] senão r[i] fim
  fim
  escreva ""
  s:= leia_texto
fim

1235 - De Dentro para Fora

Descrição do Problema: 1235 - De Dentro para Fora

Categoria: Strings

n = leia_inteiro
para i de 1 até n faça
  linha = leia_texto
  t = linha.tamanho div 2
  s = linha.pegue(t)
  r = linha.descarte(t)
  escreva "{s.inverta}{r.inverta}"
fim

1237 - Comparação de Substring

Descrição do Problema: 1237 - Comparação de Substring

Categoria: Strings

pos(s: Texto, c: Caractere, n: Inteiro): Inteiro
  var i := n
  enquanto i <= s.tamanho e s[i] <> c faça
    i := i + 1
  fim
  se i <= s.tamanho então i senão 0 fim
fim

comparar(a, b: Texto, p_a, p_b, soma: Inteiro): Inteiro =
  se p_a > a.tamanho ou p_b > b.tamanho ou a[p_a] <> b[p_b] então
    soma
  senão
    comparar(a, b, p_a + 1, p_b + 1, soma + 1)
  fim

var a := leia_texto
enquanto não eof faça
  b = leia_texto
  var resposta := 0
  para inicio_a de 1 até a.tamanho faça
    var inicio_b := pos(b, a[inicio_a], 1)
    enquanto inicio_b > 0 faça
      tam = comparar(a, b, inicio_a, inicio_b, 0)
      se tam > resposta então
        resposta := tam
      fim
      inicio_b := pos(b, a[inicio_a], inicio_b + 1)
    fim
  fim
  escreva resposta
  a:= leia_texto
fim

1238 - Combinador

Descrição do Problema: 1238 - Combinador

Categoria: Strings

f(a, b: Texto): Texto =
  se      a == "" então b
  senãose b == "" então a
  senão "{a.cabeça}{b.cabeça}{f(a.cauda, b.cauda)}" fim

n = leia_inteiro
para i de 1 até n faça
  s = leia_textos(" ")
  escreva f(s[1], s[2])
fim

1239 - Atalhos Bloggo

Descrição do Problema: 1239 - Atalhos Bloggo

Categoria: Strings

sub(texto: Texto, chr: Caractere, tag1, tag2: Texto)
  f(s: Texto, inicio: Lógico): Texto
    p = s.posicao(chr)
    se p > 0 então
      f(s.pegue(p-1) + (se inicio então tag1 senão tag2 fim) + s.descarte(p), não inicio)
    senão
      s
    fim
  fim
  retorne f(texto, verdadeiro)
fim

bold(s: Texto) = sub(s, '*', "<b>", "</b>")
italic(s: Texto) = sub(s, '_', "<i>", "</i>")

var texto := leia_texto
enquanto não eof faça
  escreva bold(italic(texto))
  texto := leia_texto
fim

1240 - Encaixa ou Não I

Descrição do Problema: 1240 - Encaixa ou Não I

Categoria: Matemática

n = leia_inteiro
para i de 1 até n faça
  s = leia_textos(" ")
  a, b = s[1], s[2]
  se a.descarte(a.tamanho - b.tamanho) == b então
    escreva "encaixa"
  senão
    escreva "nao encaixa"
  fim
fim

1241 - Encaixa ou Não II

Descrição do Problema: 1241 - Encaixa ou Não II

Categoria: Strings

n = leia_inteiro
para i de 1 até n faça
  s = leia_textos(" ")
  a, b = s[1], s[2]
  se a.descarte(a.tamanho - b.tamanho) == b então
    escreva "encaixa"
  senão
    escreva "nao encaixa"
  fim
fim

1242 - Ácido Ribonucleico Alienígena

Descrição do Problema: 1242 - Ácido Ribonucleico Alienígena

Categoria: Estruturas e Bibliotecas · Maratona SBC (1ª fase) 2011

var rna := leia_texto

enquanto não eof faca
  var pilha: Lista[Caractere] := []
  var total := 0

  para base em rna faca
    se pilha == [] entao
      pilha := base::pilha
    senao
      topo = pilha.cabeça

      se (topo == 'B' e base == 'S') ou (topo == 'S' e base == 'B') ou
         (topo == 'C' e base == 'F') ou (topo == 'F' e base == 'C') entao
        pilha := pilha.cauda
        total := total + 1
      senao
        pilha := base::pilha
      fim
    fim
  fim

  escreva total
  rna := leia_texto
fim

1243 - O Quão Fácil é...

Descrição do Problema: 1243 - O Quão Fácil é...

Categoria: Strings

var enunciado := leia_texto
enquanto não eof faça
  palavras = enunciado
    .divida(" ")
    .mapeie(p => se p.tamanho > 0 e p[-1] == '.' então p.pegue(p.tamanho - 1) senão p fim)
    .selecione(p => p.tamanho > 0 e p.ordene[1] >= 'A')
    .mapeie(_.tamanho)
  se palavras.tamanho == 0 então
    escreva 250
  senão
    media = palavras.injete(0)(_ + _) / palavras.tamanho
    se media < 4 então
      escreva 250  senãose media < 6 então
      escreva 500  senão
      escreva 1000 fim
  fim
  enunciado := leia_texto
fim

1244 - Ordenação por Tamanho

Descrição do Problema: 1244 - Ordenação por Tamanho

Categoria: Estruturas e Bibliotecas

n = leia_inteiro
para i de 1 até n faça
  palavras = leia_textos(" ")
  s = palavras.ordene(- _.tamanho).junte(" ")
  escreva s
fim

1245 - Botas Perdidas

Descrição do Problema: 1245 - Botas Perdidas

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

var n := leia_inteiro
enquanto não eof faça
  var esq, dir := Lista(31, 0)
  para i de 1 até n faça
    a = leia_textos(" ")
    x = a[1].inteiro - 29
    se a[2] == "E" então
      esq[x] := esq[x] + 1
    senão
      dir[x] := dir[x] + 1
    fim
  fim
  pares = esq.zip(dir).mapeie(
    a => se a.primeiro < a.segundo então a.primeiro senão a.segundo fim
 ).injete(0)(_ + _)
  escreva pares
  n := leia_inteiro
fim

1247 - Guarda Costeira

Descrição do Problema: 1247 - Guarda Costeira

Categoria: Matemática · Maratona SBC (1ª fase) 2011

var a := leia_inteiros(" ")
enquanto não eof faça
  d, vf, vg = a[1], a[2], a[3]
  c = raiz(144 + d^2) / 12
  se vg >= vf * c então
    escreva "S"
  senão
    escreva "N"
  fim
  a := leia_inteiros(" ")
fim

1248 - Plano de Dieta

Descrição do Problema: 1248 - Plano de Dieta

Categoria: Strings

var resp: Lista[Texto] = []
n = leia_inteiro
para i de 1 até n faça
    a, b, c = leia_texto
    r = se (b + c) - a <> ""
        então "CHEATER"
        senão  (a - (b + c)).ordene
    fim
    resp := r :: resp
fim
escreva resp.inverta.junte("\n")

1249 - Rot13

Descrição do Problema: 1249 - Rot13

Categoria: Excluído

rot13(c: Inteiro) = escolha c
  caso x se x >= 'a' e x <= 'z' => ((x-'a' + 13) mod 26 + 'a').caractere
  caso x se x >= 'A' e x <= 'Z' => ((x-'A' + 13) mod 26 + 'A').caractere
  caso x                        => x.caractere
fim

rot = para i de 1 até 255 gere rot13(i) fim

var entrada := leia_texto
enquanto não eof faça
  escreva entrada.lista.mapeie(c => rot[c]).junte("")
  entrada := leia_texto
fim

1250 - KiloMan

Descrição do Problema: 1250 - KiloMan

Categoria: Ad-Hoc

n = leia_inteiro
para i de 1 até n faça
  t = leia_inteiro
  tiros = leia_inteiros(" ")
  ações = leia_texto
  atingido = 
    para (a, b) em tiros.zip(ações)
      se a < 3 e b == 'S' ou
         a > 2 e b == 'J' gere 1 fim
  escreva atingido.tamanho
fim

1251 - Diga-me a Frequência

Descrição do Problema: 1251 - Diga-me a Frequência

Categoria: Estruturas e Bibliotecas

var s := leia_texto
var b := falso
enquanto não eof faça
  x = s.ordene.divida_quando(_ <> _)
       .mapeie(a => "{a.tamanho formato "%04d"}{(128 - a[1]).caractere}")
       .ordene
       .mapeie(a => "{128 - a[5]} {a.pegue(4).inteiro}")
  se b então escreva "" senão b := verdadeiro fim
  escreva x.junte("\n")
  s := leia_texto
fim

1253 - Cifra de César

Descrição do Problema: 1253 - Cifra de César

Categoria: Strings

n = leia_inteiro
para i de 1 até n faça
  s = leia_texto
  p = leia_inteiro
  d = 'A' + p - 26
  escreva s.lista.mapeie(c => ((c - d) mod 26 + 'A').caractere).junte("")
fim

1255 - Frequência de Letras

Descrição do Problema: 1255 - Frequência de Letras

Categoria: Strings

n = leia_inteiro
para i de 1 até n faça
  s = leia_texto.minúsculo.selecione(c => c >= 'a' e c <= 'z')
  var letras := Lista(26, 0)
  var mais := 0
  para c em s faça
    letras[c - 96] := letras[c - 96] + 1
    se letras[c - 96] > mais então mais := letras[c - 96] fim
  fim
  saida = para c de 'a' até 'z' se letras[c - 96] == mais gere c fim
  escreva saida.junte("")
fim

1256 - Tabelas Hash

Descrição do Problema: 1256 - Tabelas Hash

Categoria: Estruturas e Bibliotecas

tipo Valor chave: Inteiro valor: Texto fim

valores = para j de 0 até 100 gere Valor(j, "\\") fim

n = leia_inteiro
para i de 1 até n faça
  m = leia_inteiros(" ")[1]
  chaves = leia_inteiros(" ")
  hash = (chaves.mapeie(a => Valor(a mod m, a.texto)) + valores.pegue(m))
           .ordene(_.chave)
           .divida_quando(_.chave <> _.chave)
  para h em hash faça
    escreva "{h[1].chave} -> {h.mapeie(_.valor).junte(" -> ")}"
  fim
  se i < n então
    escreva ""
  fim
fim

1257 - Array Hash

Descrição do Problema: 1257 - Array Hash

Categoria: Strings

n = leia_inteiro
para i de 1 até n faça
  l = leia_inteiro
  var soma := 0
  para j de 0 até l-1 faça
    s = leia_texto.lista.mapeie(c => c - 'A')
    para k de 0 até s.tamanho - 1 faça
      soma := soma + s[k+1] + k + j
    fim
  fim
  escreva soma
fim

1258 - Camisetas

Descrição do Problema: 1258 - Camisetas

Categoria: Estruturas e Bibliotecas

comp = (a, b: (Texto, Texto, Texto)) =>
  se a.segundo <> b.segundo então
    a.segundo < b.segundo
  senãose a.terceiro <> b.terceiro
    a.terceiro > b.terceiro
  senão
    a.primeiro < b.primeiro
  fim

var n := leia_inteiro
enquanto n > 0 faça
  camisetas = Lista(n, (leia_texto, leia_texto.divida(" ")))
      .mapeie(a => (a.primeiro, a.segundo[1], a.segundo[2]))
      .ordene(comp)
  para camiseta em camisetas faça
    escreva "{camiseta.segundo} {camiseta.terceiro} {camiseta.primeiro}"
  fim
  n := leia_inteiro
  se n > 0 então escreva "" fim
fim

1259 - Pares e Ímpares

Descrição do Problema: 1259 - Pares e Ímpares

Categoria: Estruturas e Bibliotecas

n = leia_inteiro
nums = leia_inteiros(n).ordene
escreva nums.selecione(a => a mod 2 == 0).junte("\n")
escreva nums.selecione(a => a mod 2 <> 0).inverta.junte("\n")

1261 - Pontos de Feno

Descrição do Problema: 1261 - Pontos de Feno

Categoria: Estruturas e Bibliotecas

tipo Palavra
  nome: Texto
  valor: Inteiro
fim

soma(palavras: Lista[Palavra], descrição: Lista[Texto], total: Inteiro): Inteiro =
  se palavras == [] ou descrição == [] então
    total
  senãose palavras.cabeça.nome == descrição.cabeça então
    soma(palavras, descrição.cauda, total + palavras.cabeça.valor)
  senãose palavras.cabeça.nome < descrição.cabeça
    soma(palavras.cauda, descrição, total)
  senão
    soma(palavras, descrição.cauda, total)
  fim

a = leia_inteiros(" ")
m, n = a[1], a[2]
palavras = para i de 1 até m gere
  entrada = leia_textos(" ")
  Palavra(entrada[1], entrada[2].inteiro)
fim.ordene(_.nome)

para i de 1 até n faça
  var descrição := leia_textos(" ")
  var entrada := leia_texto
  enquanto entrada <> "." faça
    descrição := entrada.divida(" ") + descrição
    entrada := leia_texto
  fim
  escreva soma(palavras, descrição.ordene, 0)
fim

1262 - Leitura Múltipla

Descrição do Problema: 1262 - Leitura Múltipla

Categoria: Strings

var s := leia_texto
enquanto não eof faça
  p = leia_inteiro
  x = s.divida_quando(_ <> _)
  y = x.mapeie(a => se a[1] == 'W' então a.tamanho senão (a.tamanho / p).teto.inteiro fim)
  escreva y.injete(0)(_ + _)
  s := leia_texto
fim

1263 - Aliteração

Descrição do Problema: 1263 - Aliteração

Categoria: Strings

var s := leia_textos(" ")
enquanto não eof faça
  aliteracoes = s.mapeie(_.minusculo[1])
                 .divida_quando((a, b) => a <> b)
                 .selecione(_.tamanho > 1)
                 .tamanho
  escreva aliteracoes
  s := leia_textos(" ")
fim

1266 - Tornado!

Descrição do Problema: 1266 - Tornado!

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

var n := leia_inteiro
enquanto n <> 0 faça
    var zero, soma, inicio, postes = 0
    para numero em leia_texto.selecione(_ <> ' ') faça
        se numero == '0' então
            se inicio == 0 então
                zero := zero + 1
            fim
            postes := postes + 1
        senão
            inicio := 1
            soma := soma + postes div 2
            postes := 0
        fim
    fim
    se postes > 0 então
        soma := soma - zero div 2
        postes := postes + zero
        soma := soma + postes div 2 
    fim
    escreva soma
    n := leia_inteiro
fim

1267 - Biblioteca Pascal

Descrição do Problema: 1267 - Biblioteca Pascal

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

var entrada := leia_inteiros(" ")
enquanto entrada <> [0, 0] faça
  n = entrada[2]
  var linhas := Lista(n, leia_inteiros(" "))
  var todos := falso
  enquanto (não todos) e (linhas[1] <> []) faça
    todos := linhas.mapeie(_.cabeça).injete(verdadeiro)((a, b) => a e b == 1)
    linhas := linhas.mapeie(_.cauda)
  fim
  se todos então escreva "yes" senão escreva "no" fim
  entrada := leia_inteiros(" ")
fim

1272 - Mensagem Oculta

Descrição do Problema: 1272 - Mensagem Oculta

Categoria: Strings

n = leia_inteiro
para i de 1 até n faça
  s = leia_textos(" ").selecione(_ <> "")
  r = s.mapeie(_[1]).junte("")
  escreva r
fim

1273 - Justificador

Descrição do Problema: 1273 - Justificador

Categoria: Strings

var n := leia_inteiro
enquanto n > 0 faça
  s = leia_textos(n)
  tam = s.injete(0)((a, b) => se b.tamanho > a então b.tamanho senão a fim)
  para linha em s faça
    escreva linha formato "%{tam}s"
  fim
  n := leia_inteiro
  se n > 0 então escreva "" fim
fim

1276 - Faixa de Letras

Descrição do Problema: 1276 - Faixa de Letras

Categoria: Strings

var linha := leia_texto
enquanto não eof faça
  faixas = linha.ordene
                .divida_quando((a, b) => b - a > 1)
                .mapeie(a => "{a[1]}:{a[-1]}")
                .descarte_enquanto(_ == " : ")
  escreva faixas.junte(", ")
  linha := leia_texto
fim

1277 - Pouca Frequência

Descrição do Problema: 1277 - Pouca Frequência

Categoria: Strings

t = leia_inteiro
para i de 1 até t faça
  n = leia_inteiro
  nomes = leia_textos(" ")
  frequencia = leia_textos(" ")
                 .mapeie(_.selecione(_ <> 'M'))
                 .mapeie(a => a.selecione(_ == 'P').tamanho / a.tamanho)
  alunos = nomes.zip(frequencia)
  a = alunos.selecione(_.segundo < 0.75).mapeie(_.primeiro)
  escreva a.junte(" ")
fim

1278 - Justificador II

Descrição do Problema: 1278 - Justificador II

Categoria: Strings

var n := leia_inteiro
enquanto n > 0 faça
  linhas = leia_textos(n).mapeie(_.descarte_enquanto(_ == ' ').divida(" ").junte(" "))
  tamanho = linhas.injete(0)((a, b) => se b.tamanho > a então b.tamanho senão a fim)
  alinhamento = "%{tamanho}s"
  para i de 1 até n faça
    escreva linhas[i] formato alinhamento
  fim
  n := leia_inteiro
  se n > 0 então escreva "" fim
fim

1279 - Ano Bissexto ou Ano não Bissexto

Descrição do Problema: 1279 - Ano Bissexto ou Ano não Bissexto

Categoria: Matemática

somar(digitos: Lista[Inteiro], soma: Inteiro): Inteiro =
  se digitos <> [] então
    somar(digitos.descarte(2), soma + digitos[1])
  senão
    soma
  fim

soma_par(digitos: Lista[Inteiro]) = somar(digitos.inverta.descarte(1), 0)
soma_impar(digitos: Lista[Inteiro]) = somar(digitos.inverta, 0)

div4(digitos: Lista[Inteiro]) = (digitos[2] * 10 + digitos[1]) mod 4 == 0
div5(digitos: Lista[Inteiro]) = digitos[1] mod 5 == 0
div100(digitos: Lista[Inteiro]) = digitos.pegue(2) == [0, 0]
div400(digitos: Lista[Inteiro]) = div100(digitos) e div4(digitos.descarte(2))
div11(digitos: Lista[Inteiro]) = (soma_par(digitos) - soma_impar(digitos)) mod 11 == 0
div3(digitos: Lista[Inteiro]) = digitos.injete(0)(_ + _) mod 3 == 0

var primeiro := verdadeiro
var entrada := leia_texto
enquanto não eof faça
  digitos = entrada.inverta.lista.mapeie(_ - '0')

  se primeiro então
    primeiro := falso
  senão
    escreva ""
  fim

  bissexto = div4(digitos) e não div100(digitos) ou div400(digitos)
  bulukulu = bissexto e div5(digitos) e div11(digitos)
  huluculu = div5(digitos) e div3(digitos)

  se bissexto então
    escreva "This is leap year."
  fim
  se huluculu então
    escreva "This is huluculu festival year."
  fim
  se bulukulu então
    escreva "This is bulukulu festival year."
  fim
  se não bissexto e não huluculu então
    escreva "This is an ordinary year."
  fim

  entrada := leia_texto
fim

1280 - Amigos

Descrição do Problema: 1280 - Amigos

Categoria: Matemática

pot2(n, r: BigInt): BigInt = 
    se n < 1
        então r
        senão pot2(n - 1, 2 * r)
    fim

def ack(m, n: BigInt): BigInt = 
    se      m <= 1 então n + m + 1
    senãose m == 2 então 2 * n + 3
    senãose m == 3 então 8 * (pot2(n, 1) - 1) + 5
    senãose n == 0 então ack(m - 1, 1)
                   senão ack(m - 1, ack(m, n - 1))
    fim

t = leia_inteiro
para i de 1 até t faça
    a = leia_inteiros(" ")
    escreva ack(a[1], a[2])
fim

1281 - Ida à Feira

Descrição do Problema: 1281 - Ida à Feira

Categoria: Estruturas e Bibliotecas

tipo Preço
  produto: Texto
  valor: Real
fim

tipo Produto
  produto: Texto
  quantidade: Inteiro
fim

total(preços: Lista[Preço], produtos: Lista[Produto]): Real =
  se produtos == [] então
    0.0
  senãose preços.cabeça.produto == produtos.cabeça.produto então
    preços.cabeça.valor * produtos.cabeça.quantidade + total(preços.cauda, produtos.cauda)
  senão
    total(preços.cauda, produtos)
  fim

n = leia_inteiro
para i de 1 até n faça
  m = leia_inteiro
  preços = para j de 1 até m gere
             a = leia_textos(" ")
             Preço(a[1], a[2].real)
           fim.ordene(_.produto)
  p = leia_inteiro
  produtos = para j de 1 até p gere
               a = leia_textos(" ")
               Produto(a[1], a[2].inteiro)
             fim.ordene(_.produto)
  escreva "R$ {total(preços, produtos) formato "%.2f"}"
fim

1285 - Dígitos Diferentes

Descrição do Problema: 1285 - Dígitos Diferentes

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

sem_repeticao(n: Inteiro)
  a = n.texto.ordene.lista
  b = a.zip(a.cauda)
  b.selecione(x => x.primeiro == x.segundo).tamanho == 0
fim

var c := 0
numeros = para i de 1 até 5001 gere
  d = c
  se sem_repeticao(i) então c:= c + 1 fim
  d
fim

var a := leia_texto
enquanto não eof faça
  z = a.divida(" ")
  n, m = z[1].inteiro, z[2].inteiro
  escreva numeros[m+1] - numeros[n]
  a := leia_texto
fim

1287 - Processador Amigável de Inteiros

Descrição do Problema: 1287 - Processador Amigável de Inteiros

Categoria: Strings

var s := leia_texto
enquanto não eof faça
  chars = s.selecione(c => c <> ',' e c <> ' ')
           .lista
           .mapeie(c => escolha c
                          caso 'l' => '1'
                          caso 'o' => '0'
                          caso 'O' => '0'
                          caso  _  => c
                        fim)
  x = chars.descarte_enquanto(_ == '0').mapeie(_.caractere).junte("")
  x2 = se x == "" e chars <> [] então "0" senão x fim
  erro = chars.selecione(c => c < '0' ou c > '9') <> []
  se x2 <> "" e não erro e (x2.tamanho < 10 ou (x2.tamanho == 10 e x2 <= "2147483647")) então
    escreva x2.inteiro
  senão
    escreva "error"
  fim
  s := leia_texto
fim

1291 - Será Isso Integração?

Descrição do Problema: 1291 - Será Isso Integração?

Categoria: Geometria Computacional

r1_a = 1 - PI / 6.0 - raiz(3) / 4.0 
r2_a = 1 - PI / 4.0

var saida: Lista[Texto] := []

var entrada := leia_texto
enquanto não eof faça
    lado = entrada.real
    area_quadrado = lado * lado

    r1 = area_quadrado * r1_a
    r2 = area_quadrado * r2_a - 2.0 * r1
    r3 = area_quadrado - 4.0 * (r1 + r2)
    saida := "{r3 formato "%.3f"} {(4 * r2) formato "%.3f"} {(4 * r1) formato "%.3f"}" :: saida
    entrada := leia_texto
fim

escreva saida.inverta.junte("\n")

1292 - Problema com um Pentágono

Descrição do Problema: 1292 - Problema com um Pentágono

Categoria: Geometria Computacional

k = sen(108 * PI / 180) / sen(63 * PI / 180)
var p := leia_texto
enquanto não eof faça
  escreva (k * p.real) formato "%.10f"
  p := leia_texto
fim

1294 - A Maior e Menor Caixa

Descrição do Problema: 1294 - A Maior e Menor Caixa

Categoria: Geometria Computacional

def min(a, b: Real) = se a < b então a senao b fim
def real(a: Texto) = a.real

var saida: Lista[Texto] := []

var entrada := leia_texto
enquanto não eof faça
    a = entrada.divida(" ").mapeie(real)
    l, w = a[1], a[2]
    menor = min(l, w) / 2
    r = - raiz((l - w) ^ 2 + l * w) / 6 + (l + w) / 6
    saida := "{r formato "%.3f"} 0.000 {menor formato "%.3f"}" :: saida
    entrada := leia_texto
fim
escreva saida.inverta.junte("\n")

1296 - Medianas

Descrição do Problema: 1296 - Medianas

Categoria: Geometria Computacional

var entrada := leia_texto
enquanto não eof faça
  l = entrada.divida(" ").mapeie(_.real).ordene
  a, b, c = l[1], l[2], l[3]
  se c < a + b então
    s = (a + b + c) / 2
    area = 4 / 3 * (s * (s - a) * (s - b) * (s - c)) ^ (1 / 2)
    escreva area formato "%.3f"
  senão
    escreva "-1.000"
  fim
  entrada := leia_texto
fim