1200

Faixa de problemas: 1200-1299

Total: 50 problemas

1200 - Operações em ABP I

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

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 nao 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

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

1212 - Aritmética Primária

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

var a := leia_textos(" ")
c = 2 * '0'
enquanto a <> ["0", "0"] faca
  x = a[1].inverta + "00000000"
  y = a[2].inverta + "00000000"
  var soma, carry := 0
  para i de 1 ate 9 faca
    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

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

c = leia_inteiro
para i de 1 ate c faca
  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" entao s := "51.562" fim
  escreva "{s}%"
fim

1216 - Getline One

Descrição do Problema: 1216 - Getline One

var soma, n := 0
leia_texto
enquanto nao eof faca
  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

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

var c := 0
var n := leia_texto
enquanto nao eof faca
  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 entao 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

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 nao 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

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

enquanto (n <> 0) faca

    var total := 0.0

    para i de 1 até n faca
        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 faca
        se N[l] < total entao
            valorMenor := valorMenor + (total - N[l]).inteiro / 100.0
        senao
            valorMaior := valorMaior + (N[l] - total).inteiro / 100.0
        fim
    fim

    se (valorMenor > valorMaior) entao
        escreva "${valorMenor formato "%.2f"}"
    senao
        escreva "${valorMaior formato "%.2f"}"
    fim
    n := leia_inteiro
fim

1221 - Primo Rápido

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

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) entao
    escreva "Prime"
  senão
    escreva "Not Prime"
  fim
fim

1222 - Concurso de Contos

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

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 ate lista_palavras.tamanho faca
    palavra = lista_palavras[i]
    x = palavra.tamanho
    se (letras + x + 1) <= c entao
      letras := letras + x + 1
    senao
      linhas := linhas + 1
      se linhas > l entao
        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

var n := leia_inteiro
enquanto n > 0 faca
  notas = leia_inteiros(" ")
  soma = notas.injete(0)(_ + _)
  se soma mod n == 0 entao
    media = soma div n
    resposta = 1 + notas.descarte_enquanto(_ < media).mapeie(_ - media).injete(0)(_ + _)
    escreva resposta
  senao
    escreva -1
  fim
  n := leia_inteiro
fim

1228 - Grid de Largada

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

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

var s:= leia_texto
enquanto nao eof faca
  r, t = s.maiúsculo, s.minúsculo
  var maiúsculo := verdadeiro
  para i de 1 ate s.tamanho faca
    maiúsculo := maiúsculo <> (r[i] >= 'A' e r[i] <= 'Z')
    imprima se maiúsculo entao t[i] senao r[i] fim
  fim
  escreva ""
  s:= leia_texto
fim

1235 - De Dentro para Fora

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

n = leia_inteiro
para i de 1 ate n faca
  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

pos(s: Texto, c: Caractere, n: Inteiro): Inteiro
  var i := n
  enquanto i <= s.tamanho e s[i] <> c faca
    i := i + 1
  fim
  se i <= s.tamanho entao i senao 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] entao
    soma
  senao
    comparar(a, b, p_a + 1, p_b + 1, soma + 1)
  fim

var a := leia_texto
enquanto nao eof faca
  b = leia_texto
  var resposta := 0
  para inicio_a de 1 ate a.tamanho faca
    var inicio_b := pos(b, a[inicio_a], 1)
    enquanto inicio_b > 0 faca
      tam = comparar(a, b, inicio_a, inicio_b, 0)
      se tam > resposta entao
        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

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

sub(texto: Texto, chr: Caractere, tag1, tag2: Texto)
  f(s: Texto, inicio: Logico): Texto
    p = s.posicao(chr)
    se p > 0 entao
      f(s.pegue(p-1) + (se inicio entao tag1 senao tag2 fim) + s.descarte(p), nao inicio)
    senao
      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 nao eof faca
  escreva bold(italic(texto))
  texto := leia_texto
fim

1240 - Encaixa ou Não I

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

n = leia_inteiro
para i de 1 ate n faca
  s = leia_textos(" ")
  a, b = s[1], s[2]
  se a.descarte(a.tamanho - b.tamanho) == b entao
    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

n = leia_inteiro
para i de 1 ate n faca
  s = leia_textos(" ")
  a, b = s[1], s[2]
  se a.descarte(a.tamanho - b.tamanho) == b entao
    escreva "encaixa"
  senao
    escreva "nao encaixa"
  fim
fim

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

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

var enunciado := leia_texto
enquanto nao 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

n = leia_inteiro
para i de 1 ate n faca
  palavras = leia_textos(" ")
  s = palavras.ordene(- _.tamanho).junte(" ")
  escreva s
fim

1245 - Botas Perdidas

Descrição do Problema: 1245 - Botas Perdidas

var n := leia_inteiro
enquanto nao eof faca
  var esq, dir := Lista(31, 0)
  para i de 1 ate n faca
    a = leia_textos(" ")
    x = a[1].inteiro - 29
    se a[2] == "E" entao
      esq[x] := esq[x] + 1
    senao
      dir[x] := dir[x] + 1
    fim
  fim
  pares = esq.zip(dir).mapeie(
    a => se a.primeiro < a.segundo entao a.primeiro senao a.segundo fim
  ).injete(0)(_ + _ )
  escreva pares
  n := leia_inteiro
fim

1247 - Guarda Costeira

Descrição do Problema: 1247 - Guarda Costeira

var a := leia_inteiros(" ")
enquanto nao eof faca
  d, vf, vg = a[1], a[2], a[3]
  c = raiz(144 + d^2) / 12
  se vg >= vf * c entao
    escreva "S"
  senao
    escreva "N"
  fim
  a := leia_inteiros(" ")
fim

1249 - Rot13

Descrição do Problema: 1249 - Rot13

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 ate 255 gere rot13(i) fim.junte("")

var entrada := leia_texto
enquanto nao eof faça
  escreva entrada.mapeie(c => rot[c])
  entrada := leia_texto
fim

1250 - KiloMan

Descrição do Problema: 1250 - KiloMan

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

1251 - Diga-me a Frequência

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

var s := leia_texto
var b := falso
enquanto nao eof faca
  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 entao escreva "" senao 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

n = leia_inteiro
para i de 1 ate n faca
  s = leia_texto
  p = leia_inteiro
  d = 'A' + p - 26
  escreva s.mapeie(c => ((c - d) mod 26 + 'A').caractere)
fim

1255 - Frequência de Letras

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

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 faca
    letras[c - 96] := letras[c - 96] + 1
    se letras[c - 96] > mais entao mais := letras[c - 96] fim
  fim
  saida = para c de 'a' ate 'z' se letras[c - 96] == mais gere c fim
  escreva saida.junte("")
fim

1256 - Tabelas Hash

Descrição do Problema: 1256 - Tabelas Hash

tipo Valor chave: Inteiro valor: Texto fim

valores = para j de 0 ate 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

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

comp = (a, b: (Texto, Texto, Texto)) =>
  se a.segundo <> b.segundo entao
    a.segundo < b.segundo
  senaose a.terceiro <> b.terceiro
    a.terceiro > b.terceiro
  senao
    a.primeiro < b.primeiro
  fim

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

1259 - Pares e Ímpares

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

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

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

var s := leia_texto
enquanto nao eof faca
  p = leia_inteiro
  x = s.divida_quando(_ <> _)
  y = x.mapeie(a => se a[1] == 'W' entao a.tamanho senao (a.tamanho / p).teto.inteiro fim)
  escreva y.injete(0)(_ + _)
  s := leia_texto
fim

1263 - Aliteração

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

var s := leia_textos(" ")
enquanto nao eof faca
  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!

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' entao
            se inicio == 0 então
                zero := zero + 1
            fim
            postes := postes + 1
        senao
            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

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

n = leia_inteiro
para i de 1 ate n faca
  s = leia_textos(" ").selecione(_ <> "")
  r = s.mapeie(_[1]).junte("")
  escreva r
fim

1273 - Justificador

Descrição do Problema: 1273 - Justificador

var n := leia_inteiro
enquanto n > 0 faca
  s = leia_textos(n)
  tam = s.injete(0)((a, b) => se b.tamanho > a entao b.tamanho senao a fim)
  para linha em s faca
    escreva linha formato "%{tam}s"
  fim
  n := leia_inteiro
  se n > 0 entao escreva "" fim
fim

1276 - Faixa de Letras

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

var linha := leia_texto
enquanto nao eof faca
  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

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

var n := leia_inteiro
enquanto n > 0 faca
  linhas = leia_textos(n).mapeie(_.descarte_enquanto(_ == ' ').divida(" ").junte(" "))
  tamanho = linhas.injete(0)((a, b) => se b.tamanho > a entao b.tamanho senao a fim)
  alinhamento = "%{tamanho}s"
  para i de 1 ate n faca
    escreva linhas[i] formato alinhamento
  fim
  n := leia_inteiro
  se n > 0 entao escreva "" fim
fim

1279 - Ano Bissexto ou Ano não Bissexto

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

somar(digitos: Lista[Inteiro], soma: Inteiro): Inteiro =
  se digitos <> [] entao
    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 entao
    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

1281 - Ida à Feira

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

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 == [] entao
    0.0
  senaose preços.cabeça.produto == produtos.cabeça.produto entao
    preços.cabeça.valor * produtos.cabeça.quantidade + total(preços.cauda, produtos.cauda)
  senao
    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 ate m gere
             a = leia_textos(" ")
             Preço(a[1], a[2].real)
           fim.ordene(_.produto)
  p = leia_inteiro
  produtos = para j de 1 ate 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

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 ate 5001 gere
  d = c
  se sem_repeticao(i) entao c:= c + 1 fim
  d
fim

var a := leia_texto
enquanto nao eof faca
  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

var s := leia_texto
enquanto nao eof faca
  x = s.selecione(c => c <> ',' e c <> ' ')
       .mapeie(c => escolha c
                      caso 'l' => '1'
                      caso 'o' => '0'
                      caso 'O' => '0'
                      caso  _  => c
                    fim )
        .injete("")((a, b) => se a == "0" entao "{b}" senao "{a}{b}" fim)

  erro = x.selecione(c => c < '0' ou c > '9') <> ""
  se x <> "" e nao erro e (x.tamanho < 10 ou x.tamanho == 10 e x <="2147483647") entao
    escreva x.inteiro
  senao
    escreva "error"
  fim
  s := leia_texto
fim

1292 - Problema com um Pentágono

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

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

1296 - Medianas

Descrição do Problema: 1296 - Medianas

var entrada := leia_texto
enquanto nao eof faca
  l = entrada.divida(" ").mapeie(_.real).ordene
  a, b, c = l[1], l[2], l[3]
  se c < a + b entao
    s = (a + b + c) / 2
    area = 4 / 3 * (s * (s - a) * (s - b) * (s - c)) ^ (1 / 2)
    escreva area formato "%.3f"
  senao
    escreva "-1.000"
  fim
  entrada := leia_texto
fim