1100

Faixa de problemas: 1100-1199

Total resolvido: 74 de 100 problemas

Problemas não resolvidos (26)

1100, 1102, 1106, 1108, 1109, 1111, 1112, 1119, 1121, 1122, 1123, 1125, 1126, 1127, 1128, 1130, 1135, 1137, 1139, 1141, 1147, 1148, 1152, 1167, 1191, 1194

1101 - Sequência de Números e Soma

Descrição do Problema: 1101 - Sequência de Números e Soma

Categoria: Iniciante

var entrada := leia_inteiros(" ")
enquanto entrada[1] > 0 e entrada[2] > 0 faça
  a = se entrada[1] < entrada[2] então entrada[1] senão entrada[2] fim
  b = se entrada[1] < entrada[2] então entrada[2] senão entrada[1] fim
  var soma := 0
  para i de a até b faça
    imprima "{i} "
    soma := soma + i
  fim
  escreva "Sum={soma}"
  entrada := leia_inteiros(" ")
fim

1103 - Alarme Despertador

Descrição do Problema: 1103 - Alarme Despertador

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

var entrada := leia_inteiros(" ")
enquanto entrada <> [0,0,0,0] faça
  h1 = entrada[1]
  m1 = entrada[2]
  h2 = entrada[3]
  m2 = entrada[4]
  tempo = ((24 + h2 - h1) * 60 + m2 - m1) mod (24 * 60)
  escreva tempo
  entrada := leia_inteiros(" ")
fim

1104 - Troca de Cartas

Descrição do Problema: 1104 - Troca de Cartas

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

distintas(cartas: Lista[Inteiro]) =
  cartas.divida_quando(_ <> _).mapeie(_.cabeca)

var entrada := leia_texto
enquanto entrada <> "0 0" faça
  alice, beatriz = distintas(leia_inteiros(" "))
  a, b = alice.tamanho, beatriz.tamanho
  iguais = a - (alice - beatriz).tamanho
  trocas = se a < b então a - iguais senão b - iguais fim
  escreva trocas
  entrada := leia_texto
fim

1105 - Sub-prime

Descrição do Problema: 1105 - Sub-prime

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

var n := leia_inteiros(2)
enquanto n[1] <> 0 ou n[2] <> 0 faça
    var reservas = leia_inteiros(n[1])

    para i de 1 até n[2] faça
        m = leia_inteiros(3)
        reservas[m[2]] := reservas[m[2]] + m[3]
        reservas[m[1]] := reservas[m[1]] - m[3]
    fim

    se reservas.selecione(_ < 0).tamanho > 0 então
        escreva "N"
    senão
        escreva "S"
    fim

    n := leia_inteiros(2)
fim

1107 - Escultura à Laser

Descrição do Problema: 1107 - Escultura à Laser

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

var entrada := leia_inteiros(2)
enquanto entrada[1] <> 0 faça
  altura, comprimento = entrada[1], entrada[2]
  xs = leia_inteiros(" ")
  var quantidade, anterior := altura - xs[1], xs[1]
  para x em xs.cauda faça
    se x < anterior então
      quantidade := quantidade + anterior - x
    fim
    anterior := x
  fim
  escreva quantidade
  entrada := leia_inteiros(2)
fim

1110 - Jogando Cartas Fora

Descrição do Problema: 1110 - Jogando Cartas Fora

Categoria: Estruturas e Bibliotecas

var n := leia_inteiro
impar = para i de 1 até 50 passo 2 gere i fim
par = para i de 2 até 50 passo 2 gere i fim
vazia = [0].cauda
enquanto n > 0 faça
  var cartas := par.pegue(n div 2)
  var descartes, pilha: Lista[Inteiro] := []
  var descartar := n mod 2 == 0
  enquanto cartas.tamanho + pilha.tamanho > 1 faça
    se cartas == [] então
      cartas := pilha.inverta
      pilha := vazia
    fim
    topo = cartas.cabeca
    cartas := cartas.cauda
    se descartar então
      descartes := topo :: descartes
    senão
      pilha := topo :: pilha
    fim
    descartar := não descartar
  fim
  descartes := impar.pegue((n+1) div 2) + descartes.inverta
  escreva "Discarded cards: {descartes.junte(", ")}"
  escreva "Remaining card: {(cartas + pilha).cabeca}"
  n := leia_inteiro
fim

1113 - Crescente e Decrescente

Descrição do Problema: 1113 - Crescente e Decrescente

Categoria: Iniciante

var n := leia_inteiros(" ")
enquanto n[1] <> n[2] faça
  se n[1] > n[2] então
    escreva "Decrescente"
  senão
    escreva "Crescente"
  fim
  n := leia_inteiros(" ")
fim

1114 - Senha Fixa

Descrição do Problema: 1114 - Senha Fixa

Categoria: Iniciante

var n := leia_inteiro
enquanto n <> 2002 faça
  escreva "Senha Invalida"
  n := leia_inteiro
fim
escreva "Acesso Permitido"

1115 - Quadrante

Descrição do Problema: 1115 - Quadrante

Categoria: Iniciante

var entrada := leia_inteiros(" ")
enquanto entrada[1] * entrada[2] <> 0 faça
  x, y = entrada[1], entrada[2]
  se x > 0 e y > 0 então
    escreva "primeiro"
  senãose x < 0 e y > 0 então
    escreva "segundo"
  senãose x < 0 então
    escreva "terceiro"
  senão
    escreva "quarto"
  fim
  entrada := leia_inteiros(" ")
fim

1116 - Dividindo X por Y

Descrição do Problema: 1116 - Dividindo X por Y

Categoria: Iniciante

n = leia_inteiro
para i de 1 até n faça
  entrada = leia_inteiros(" ")
  x = entrada[1]
  y = entrada[2]
  se y == 0 então
    escreva "divisao impossivel"
  senão
    escreva (x / y) formato "%.1f"
  fim
fim

1117 - Validação de Nota

Descrição do Problema: 1117 - Validação de Nota

Categoria: Iniciante

var soma := 0.0
var válidas := 0
enquanto válidas < 2 faça
  n = leia_real
  se n >= 0.0 e n <= 10.0 então
    soma := soma + n
    válidas := válidas + 1
  senão
    escreva "nota invalida"
  fim
fim
escreva "media = {(soma / 2) formato "%.2f"}"

1118 - Várias Notas Com Validação

Descrição do Problema: 1118 - Várias Notas Com Validação

Categoria: Iniciante

var resposta := "1"
enquanto resposta == "1" faça
  var n1, n2 := leia_real
  enquanto n1<0 ou n1>10 faça
    escreva "nota invalida"
    n1 := leia_real
  fim
  enquanto n2<0 ou n2>10 faça
    escreva "nota invalida"
    n2 := leia_real
  fim
  escreva "media = {(n1 + n2) / 2 formato "%.2f"}"

  resposta := ""
  enquanto resposta <> "1" e resposta <> "2" faça
    escreva "novo calculo (1-sim 2-nao)"
    resposta := leia_texto
  fim
fim

1120 - Revisão de Contrato

Descrição do Problema: 1120 - Revisão de Contrato

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

var a := leia_textos(" ")
enquanto a <> ["0", "0"] faça
  d, n = a[1][1], a[2]
  v = n.selecione(_ <> d).descarte_enquanto(_ == '0')
  escreva se v == "" então 0 senão v fim
  a := leia_textos(" ")
fim

1124 - Elevador

Descrição do Problema: 1124 - Elevador

Categoria: Geometria Computacional · Maratona SBC (1ª fase) 2010

def cabe(largura, altura, r1, r2: Real) = 
    largura >= r1 * 2 e altura >= r1 * 2 e
    largura >= r2 * 2 e altura >= r2 * 2 e
    raiz((largura - r1 - r2) ^ 2 + (altura - r1 - r2) ^ 2) >= r1 + r2

var entrada := leia_inteiros(" ")
enquanto entrada <> [0, 0, 0, 0] faça
    l, c, r1, r2 = entrada[1], entrada[2], entrada[3], entrada[4]
    se cabe(l, c, r1, r2)
        então escreva "S"
        senão escreva "N"
    fim
    entrada := leia_inteiros(" ")
fim

1129 - Leitura Ótica

Descrição do Problema: 1129 - Leitura Ótica

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

var n := leia_inteiro
enquanto n > 0 faça
  para i de 1 até n faça
    respostas = leia_inteiros(" ").mapeie(_ <= 127)
    pretos = respostas.selecione(_ == verdadeiro).tamanho
    se pretos == 1 então
      escreva "ABCDE"[respostas.posicao(verdadeiro)]
    senão
      escreva "*"
    fim
  fim
  n := leia_inteiro
fim

1131 - Grenais

Descrição do Problema: 1131 - Grenais

Categoria: Iniciante

var inter, gremio, empate := 0
var novo := "1"
enquanto novo == "1" faça
  gols = leia_inteiros(" ")
  se gols[1] > gols[2] então
    inter := inter + 1
  senãose gols[2] > gols[1] então
    gremio := gremio + 1
  senão
    empate := empate + 1
  fim
  escreva "Novo grenal (1-sim 2-nao)"
  novo := leia_texto
fim
grenais = inter + gremio + empate

escreva "{grenais} grenais"
escreva "Inter:{inter}"
escreva "Gremio:{gremio}"
escreva "Empates:{empate}"
se inter > gremio então
  escreva "Inter venceu mais"
senãose gremio > inter então
  escreva "Gremio venceu mais"
senão
  escreva "Nao houve vencedor"
fim

1132 - Múltiplos de 13

Descrição do Problema: 1132 - Múltiplos de 13

Categoria: Iniciante

a, b = leia_inteiro
p = se a<b então 1 senão -1 fim
var soma := 0
para i de a até b passo p faça
  se i mod 13 <> 0 então
    soma := soma + i
  fim
fim
escreva soma

1133 - Resto da Divisão

Descrição do Problema: 1133 - Resto da Divisão

Categoria: Iniciante

var x, y := leia_inteiro
se x > y então
  x, y := y, x
fim
para i de x + 1 até y - 1 faça
  se i mod 5 == 2 ou i mod 5 == 3 então
    escreva i
  fim
fim

1134 - Tipo de Combustível

Descrição do Problema: 1134 - Tipo de Combustível

Categoria: Iniciante

var n := leia_inteiro
var cont1, cont2, cont3 := 0
enquanto n <> 4 faça
  escolha n
    caso 1 => cont1 := cont1 + 1
    caso 2 => cont2 := cont2 + 1
    caso 3 => cont3 := cont3 + 1
    caso _ =>
  fim
  n := leia_inteiro
fim
escreva "MUITO OBRIGADO"
escreva "Alcool: {cont1}"
escreva "Gasolina: {cont2}"
escreva "Diesel: {cont3}"

1136 - Bingo!

Descrição do Problema: 1136 - Bingo!

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

var a := leia_inteiros(" ")
enquanto a[1] > 0 faça
  n, b = a[1], a[2]
  var p := Lista(n, 0) #.mutável
  var cont := 0
  nums = leia_inteiros(" ").ordene
  var i, j := 1, nums.tamanho
  enquanto cont < n e i < nums.tamanho faça
    x = nums[j] - nums[i]
    se p[x] == 0 então
      p[x] := 1
      cont := cont + 1
    fim
    j := j - 1
    se j == i então
      i := i + 1
      j := nums.tamanho
    fim
  fim
  se cont == n então
    escreva "Y"
  senão
    escreva "N"
  fim
  a := leia_inteiros(" ")
fim

1138 - Contagem de Dígitos

Descrição do Problema: 1138 - Contagem de Dígitos

Categoria: Matemática · Maratona SBC (2ª fase) 2010

var valores := leia_inteiros(" ")
var a, b := valores[1], valores[2]

digitos(n, d: Inteiro)
    var resultado := 0
    var potencia := 1
    var resto := 0
    var x   := 0
    var count := n
    enquanto count <> 0 faça
        x := count mod 10
        count := (count / 10).inteiro

        se x > d então
            resultado := resultado + (count + 1) * potencia
        senão
            resultado := resultado + count * potencia
        fim

        se x == d então
            resultado := resultado + resto + 1
        fim

        se d == 0 então
            resultado := resultado - potencia
        fim

        resto := resto + potencia * x

        potencia := potencia * 10

    fim

    retorne resultado
fim

enquanto a <> 0 e b <> 0 faça

    escreva para i de 0 até 9 gere "{digitos(b, i) - digitos(a-1, i)}" fim.junte(" ")

    valores := leia_inteiros(" ")
    a, b := valores[1], valores[2]
fim

1140 - Flores Florescem da França

Descrição do Problema: 1140 - Flores Florescem da França

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

var frase := leia_texto
enquanto frase <> "*" faça
  palavras = frase.maiúsculo.divida(" ")
  primeira = palavras[1].cabeca
  tamanho = palavras.tamanho
  var tautograma, i := verdadeiro, 1
  enquanto tautograma e i <= tamanho faça
    tautograma := palavras[i].cabeca == primeira
    i := i + 1
  fim
  # tautograma = palavras.mapeie(_.cabeca == primeira).injete(verdadeiro)(_ e _)
  se tautograma então
    escreva "Y"
  senão
    escreva "N"
  fim
  frase := leia_texto
fim

1142 - PUM

Descrição do Problema: 1142 - PUM

Categoria: Iniciante

n = leia_inteiro
para i de 1 até n faça
  escreva "{i*4-3} {i*4-2} {i*4-1} PUM"
fim

1143 - Quadrado e ao Cubo

Descrição do Problema: 1143 - Quadrado e ao Cubo

Categoria: Iniciante

n = leia_inteiro
para i de 1 até n faça
  escreva "{i} {i*i} {i*i*i}"
fim

1144 - Sequência Lógica

Descrição do Problema: 1144 - Sequência Lógica

Categoria: Iniciante

n = leia_inteiro
para a de 1 até n faça
  b = a * a
  c = b * a
  escreva "{a} {b} {c}"
  escreva "{a} {b+1} {c+1}"
fim

1145 - Sequência Lógica 2

Descrição do Problema: 1145 - Sequência Lógica 2

Categoria: Iniciante

entrada = leia_inteiros(" ")
x = entrada[1]
y = entrada[2]

para i de 1 até y faça
  imprima i
  se i mod x == 0 ou i == y então
    escreva ""
  senão
    imprima " "
  fim
fim

1146 - Sequências Crescentes

Descrição do Problema: 1146 - Sequências Crescentes

Categoria: Iniciante

lista = para i de 1 até 10000 gere i fim
var n := leia_inteiro
enquanto n <> 0 faça
  escreva lista.pegue(n).junte(" ")
  n := leia_inteiro
fim

1149 - Somando Inteiros Consecutivos

Descrição do Problema: 1149 - Somando Inteiros Consecutivos

Categoria: Iniciante

num = leia_inteiros(" ").selecione(a => a > 0)
a = num[1]
n = num[2]
escreva a * n + n * (n-1) div 2

1150 - Ultrapassando Z

Descrição do Problema: 1150 - Ultrapassando Z

Categoria: Iniciante

var x, z := leia_inteiro
enquanto x>=z faça
  z := leia_inteiro
fim
var i := 0
enquanto x <= z faça
  z := z - (i + x)
  i := i + 1
fim
escreva i + 1

1151 - Fibonacci Fácil

Descrição do Problema: 1151 - Fibonacci Fácil

Categoria: Iniciante

var fib := [1, 0]
enquanto fib.tamanho < 50 faça
  fib := (fib[1] + fib[2]) :: fib
fim
n = leia_inteiro
escreva fib.inverta.pegue(n).junte(" ")

1153 - Fatorial Simples

Descrição do Problema: 1153 - Fatorial Simples

Categoria: Iniciante

n = leia_inteiro
fat = (para i de 1 até n gere i fim).injete(1)(_ * _)
escreva fat

1154 - Idades

Descrição do Problema: 1154 - Idades

Categoria: Iniciante

var idade := leia_inteiro
var soma, n := 0
enquanto idade >= 0 faça
  soma := soma + idade
  n := n + 1
  idade := leia_inteiro
fim
escreva soma / n formato "%.2f"

1155 - Sequência S

Descrição do Problema: 1155 - Sequência S

Categoria: Iniciante

escreva "5.19"

1156 - Sequência S II

Descrição do Problema: 1156 - Sequência S II

Categoria: Iniciante

escreva "6.00"

1157 - Divisores I

Descrição do Problema: 1157 - Divisores I

Categoria: Iniciante

n = abs(leia_inteiro)
para i de 1 até n faça
  se n mod i == 0 então
    escreva i
  fim
fim

1158 - Soma de Ímpares Consecutivos III

Descrição do Problema: 1158 - Soma de Ímpares Consecutivos III

Categoria: Iniciante

n = leia_inteiro
para i de 1 até n faça
  entrada = leia_inteiros(" ")
  x = entrada[1].inteiro div 2 * 2 + 1
  y = entrada[2].inteiro
  escreva (x + y - 1)* y
fim

1159 - Soma de Pares Consecutivos

Descrição do Problema: 1159 - Soma de Pares Consecutivos

Categoria: Iniciante

var x := leia_inteiro
enquanto x <> 0 faça
  inicio = se x mod 2 == 0 então x senão x + 1 fim
  soma = 5 * inicio + 20
  escreva soma
  x := leia_inteiro
fim

1160 - Crescimento Populacional

Descrição do Problema: 1160 - Crescimento Populacional

Categoria: Iniciante

n = leia_inteiro
para i de 1 até n faça
  linha = leia_textos(" ")
  var pa, pb := linha[1].inteiro, linha[2].inteiro
  g1, g2 = 1 + linha[3].real/100, 1 + linha[4].real/100
  var ano := 0
  enquanto ano <= 100 e pa <= pb faça
    ano := ano + 1
    pa := (pa * g1).inteiro
    pb := (pb * g2).inteiro
  fim
  se ano > 100 então
    escreva "Mais de 1 seculo."
  senão
    escreva "{ano} anos."
  fim
fim

1161 - Soma de Fatoriais

Descrição do Problema: 1161 - Soma de Fatoriais

Categoria: Matemática

var fat := Lista(21, BigInt(1))
para i de 1 até 20 faça
  fat[i+1] := fat[i] * i
fim

enquanto não eof faça
  s = leia_inteiros(" ")
  se não eof então
    escreva fat[s[1] + 1] + fat[s[2] + 1]
  fim
fim

1162 - Organizador de Vagões

Descrição do Problema: 1162 - Organizador de Vagões

Categoria: Estruturas e Bibliotecas

n = leia_inteiro
para a de 1 até n faça
  l = leia_inteiro
  var vagões := leia_inteiros(" ")
  var cont := 0
  var p := 1
  enquanto vagões <> [] faça
    se vagões[1] == p então
        vagões := vagões.cauda
    senão
        pos = vagões.posição(p)
        vagões := vagões.remova(pos)
        cont := cont + pos - 1
    fim
    p := p + 1
  fim
  escreva "Optimal train swapping takes {cont} swaps."
fim

1163 - Angry Ducks

Descrição do Problema: 1163 - Angry Ducks

Categoria: Matemática

PI = 3.14159
G = 9.80665

var input := leia_texto
enquanto input <> nulo e input <> "" faça
    var h := input.real
    pares = leia_reais(" ")
    p1, p2 = pares[1], pares[2]

    n = leia_inteiro

    para i de 1 até n faça
      x = leia_reais(" ")
      a, v = x[1], x[2]
      alfa = a * PI  / 180
      vox = v * cos(alfa)
      voy = v * sen(alfa)

      ts = voy / G
      H = (voy*voy) / (2 * G) + h
      vfy = raiz(2 * G * H)
      td = vfy / G
      tt = ts + td
      D = vox * tt

      var d = D.arredonde(5).texto
      tamanho_fracao = d.descarte_enquanto(letra => letra <> '.').tamanho
      se tamanho_fracao < 6 então
        para i de 1 até (6 - tamanho_fracao) faça
          d := d + '0'
        fim
      fim

      se D > p1 e D < p2 então
        escreva "{d} -> DUCK"
      senão
        escreva "{d} -> NUCK"
      fim
    fim

    input := leia_texto
fim

1164 - Número Perfeito

Descrição do Problema: 1164 - Número Perfeito

Categoria: Iniciante

n = leia_inteiro
para i de 1 até n faça
  a = leia_inteiro
  var soma := 1
  rz = raiz(a).inteiro
  para j de 2 até rz se a mod j == 0 faça
    soma := soma + j + a div j
  fim
  se rz * rz == a então
    soma := soma - rz
  fim
  se soma == a então
    escreva "{a} eh perfeito"
  senão
    escreva "{a} nao eh perfeito"
  fim
fim

1165 - Número Primo

Descrição do Problema: 1165 - Número Primo

Categoria: Iniciante

n = leia_inteiro
para i de 1 até n faça
  x = leia_inteiro
  var primo := verdadeiro
  para j de 2 até raiz(x).inteiro faça
    se x mod j == 0 então
      primo := falso
    fim
  fim
  se primo então
    escreva "{x} eh primo"
  senão
    escreva "{x} nao eh primo"
  fim
fim

1166 - Torre de Hanoi, Novamente!

Descrição do Problema: 1166 - Torre de Hanoi, Novamente!

Categoria: Paradigmas

bolas = para i de 1 até 50 gere (i + 1) * (i + 1) div 2 - 1 fim
t = leia_inteiro
para i de 1 até t faça
  n = leia_inteiro
  escreva bolas[n]
fim

1168 - LED

Descrição do Problema: 1168 - LED

Categoria: Strings

n = leia_inteiro
leds = [6, 2, 5, 5, 4, 5, 6, 3, 7, 6]
para i de 1 até n faça
  num = leia_texto
  var soma := 0
  para s em num faça
    soma := soma + leds[(s - '0').inteiro + 1]
  fim
  escreva "{soma} leds"
fim

1169 - Trigo no Tabuleiro

Descrição do Problema: 1169 - Trigo no Tabuleiro

Categoria: Matemática

n = leia_inteiro
para i de 1 até n faça
  x = leia_inteiro
  var trigo := BigInt(1)
  para j de 1 até x faça
    trigo := trigo * 2
  fim
  escreva "{trigo div 12000} kg"
fim

1170 - Blobs

Descrição do Problema: 1170 - Blobs

Categoria: Matemática

n = leia_inteiro
para i de 1 até n faça
  c = leia_real
  dias = (log(c) / log(2)).teto.inteiro
  escreva "{dias} dias"
fim

1171 - Frequência de Números

Descrição do Problema: 1171 - Frequência de Números

Categoria: Ad-Hoc

n = leia_inteiro
var x := Lista.mutável(2000, 0)
para i de 1 até n faça
  a = leia_inteiro
  x[a] := x[a] + 1
fim
para i de 1 até 2000 faça
  se x[i] > 0 então
    escreva "{i} aparece {x[i]} vez(es)"
  fim
fim

1172 - Substituição em Vetor I

Descrição do Problema: 1172 - Substituição em Vetor I

Categoria: Iniciante

vetor = leia_inteiros(10)
resultado = vetor.mapeie(n => se n<=0 então 1 senão n fim)
para i de 1 até resultado.tamanho faça
  escreva "X[{i-1}] = {resultado[i]}"
fim

1173 - Preenchimento de Vetor I

Descrição do Problema: 1173 - Preenchimento de Vetor I

Categoria: Iniciante

v = leia_inteiro
var n := v
para i de 0 até 9 faça
  escreva "N[{i}] = {n}"
  n := 2 * n
fim

1174 - Seleçao em Vetor I

Descrição do Problema: 1174 - Seleçao em Vetor I

Categoria: Iniciante

a = leia_reais(100)
para i de 1 até 100 faça
  se a[i] <= 10.0 então
    escreva "A[{i-1}] = {a[i] formato "%.1f"}"
  fim
fim

1175 - Troca em Vetor I

Descrição do Problema: 1175 - Troca em Vetor I

Categoria: Iniciante

num = leia_inteiros(20)
para i de 0 até 19 faça
  escreva "N[{i}] = {num[20-i]}"
fim

1176 - Fibonacci em Vetor

Descrição do Problema: 1176 - Fibonacci em Vetor

Categoria: Iniciante

var fib = Lista(61, BigInt(0))
fib[2] := 1
para i de 3 até 61 faça
  fib[i] := fib[i-2] + fib[i-1]
fim
n = leia_inteiro
para i de 1 até n faça
  x = leia_inteiro
  escreva "Fib({x}) = {fib[x+1]}"
fim

1177 - Preenchimento de Vetor II

Descrição do Problema: 1177 - Preenchimento de Vetor II

Categoria: Iniciante

t = leia_inteiro
para i de 0 até 999 faça
  escreva "N[{i}] = {i mod t}"
fim

1178 - Preenchimento de Vetor III

Descrição do Problema: 1178 - Preenchimento de Vetor III

Categoria: Iniciante

var x := leia_real
para i de 0 até 99 faça
  escreva "N[{i}] = {x formato "%.4f"}"
  x := x / 2
fim

1179 - Preenchimento de Vetor IV

Descrição do Problema: 1179 - Preenchimento de Vetor IV

Categoria: Iniciante

esvaziar(a: Lista[Inteiro], nome: Texto)
  l = a.inverta
  para i de 1 até l.tamanho faça
    escreva "{nome}[{i-1}] = {l[i]}"
  fim
fim

num = leia_inteiros(15)
var par, impar = [0].cauda
para n em num faça
  se n mod 2 == 0 então
    par := n :: par
  senão
    impar := n :: impar
  fim
  se par.tamanho >= 5 então
    esvaziar(par, "par")
    par := [0].cauda
  fim
  se impar.tamanho >= 5 então
    esvaziar(impar, "impar")
    impar := [0].cauda
  fim
fim
esvaziar(impar, "impar")
esvaziar(par, "par")

1180 - Menor e Posição

Descrição do Problema: 1180 - Menor e Posição

Categoria: Iniciante

n = leia_inteiro
num = leia_inteiros(" ")
menor = num.ordene.primeiro
posição = num.posição(menor) - 1

escreva "Menor valor: {menor}"
escreva "Posicao: {posição}"

1181 - Linha na Matriz

Descrição do Problema: 1181 - Linha na Matriz

Categoria: Iniciante

l = leia_inteiro
t = leia_texto
numeros = leia_reais(144)
var soma := 0.0
para i de l*12 + 1 até (l+1)*12 gere
  soma := soma + numeros[i]
fim
se t == "S" então
  escreva soma formato "%.1f"
senão
  escreva (soma / 12) formato "%.1f"
fim

1182 - Coluna na Matriz

Descrição do Problema: 1182 - Coluna na Matriz

Categoria: Iniciante

l = leia_inteiro
t = leia_texto
numeros = leia_reais(144)
var soma := 0.0
para i de l+1 até 144 passo 12 faça
  soma := soma + numeros[i]
fim
se t == "S" então
  escreva soma formato "%.1f"
senão
  escreva (soma / 12) formato "%.1f"
fim

1183 - Acima da Diagonal Principal

Descrição do Problema: 1183 - Acima da Diagonal Principal

Categoria: Iniciante

o = leia_texto
nums = leia_reais(144)
var soma := 0.0
para i de 0 até 11, j de i + 2 até 12 faça
  soma := soma + nums[i * 12 + j]
fim
se o == "S" então
  escreva soma formato "%.1f"
senão
  escreva soma / 66 formato "%.1f"
fim

1184 - Abaixo da Diagonal Principal

Descrição do Problema: 1184 - Abaixo da Diagonal Principal

Categoria: Iniciante

o = leia_texto
nums = leia_reais(144)
var soma := 0.0
para i de 0 até 11, j de 1 até i faça
  soma := soma + nums[i * 12 + j]
fim
se o == "S" então
  escreva soma formato "%.1f"
senão
  escreva soma / 66 formato "%.1f"
fim

1185 - Acima da Diagonal Secundária

Descrição do Problema: 1185 - Acima da Diagonal Secundária

Categoria: Iniciante

o = leia_texto
nums = leia_reais(144)
var soma := 0.0
para i de 0 até 11, j de 1 até 11-i faça
  soma := soma + nums[i * 12 + j]
fim
se o == "S" então
  escreva soma formato "%.1f"
senão
  escreva soma / 66 formato "%.1f"
fim

1186 - Abaixo da Diagonal Secundária

Descrição do Problema: 1186 - Abaixo da Diagonal Secundária

Categoria: Iniciante

o = leia_texto
nums = leia_reais(144)
var soma := 0.0
para i de 0 até 11, j de 13 - i até 12 faça
  soma := soma + nums[i * 12 + j]
fim
se o == "S" então
  escreva soma formato "%.1f"
senão
  escreva soma / 66 formato "%.1f"
fim

1187 - Área Superior

Descrição do Problema: 1187 - Área Superior

Categoria: Iniciante

o = leia_texto
nums = leia_reais(144)
var soma := 0.0
para i de 0 até 11, j de i + 2 até 11 - i faça
  soma := soma + nums[i * 12 + j]
fim
se o == "S" então
  escreva soma formato "%.1f"
senão
  escreva soma / 30 formato "%.1f"
fim

1188 - Área Inferior

Descrição do Problema: 1188 - Área Inferior

Categoria: Iniciante

o = leia_texto
nums = leia_reais(144)
var soma := 0.0
para i de 0 até 11, j de 13 - i até i faça
  soma := soma + nums[i * 12 + j]
fim
se o == "S" então
  escreva soma formato "%.1f"
senão
  escreva soma / 30 formato "%.1f"
fim

1189 - Área Esquerda

Descrição do Problema: 1189 - Área Esquerda

Categoria: Iniciante

o = leia_texto
nums = leia_reais(144)
var soma := 0.0
para j de 1 até 12, i de j até 11-j faça
  soma := soma + nums[i * 12 + j]
fim
se o == "S" então
  escreva soma formato "%.1f"
senão
  escreva soma / 30 formato "%.1f"
fim

1190 - Área Direita

Descrição do Problema: 1190 - Área Direita

Categoria: Iniciante

o = leia_texto
nums = leia_reais(144)
var soma := 0.0
para j de 1 até 12, i de 13 - j até j - 2 faça
  soma := soma + nums[i * 12 + j]
fim
se o == "S" então
  escreva soma formato "%.1f"
senão
  escreva soma / 30 formato "%.1f"
fim

1192 - O jogo Matemático de Paula

Descrição do Problema: 1192 - O jogo Matemático de Paula

Categoria: Ad-Hoc

n = leia_inteiro
para i de 1 até n faça
  a = leia_texto
  x = a[1] - '0'
  y = a[3] - '0'
  c = a[2]
  se x == y então
    escreva x * x
  senãose c >= 'a' e c <= 'z' então
    escreva x + y
  senão
    escreva y - x
  fim
fim

1193 - Conversão entre Bases

Descrição do Problema: 1193 - Conversão entre Bases

Categoria: Matemática

dec_para_bin(num: Inteiro)
    Integer.toBinaryString(num)
fim

dec_para_hex(num:Inteiro)
    Integer.toHexString(num)
fim

bin_para_dec(num: Texto)
    Integer.parseInt(num, 2)
fim

bin_para_hex(num: Texto)
    dec_para_hex(bin_para_dec(num))
fim

hex_para_dec(num: Texto)
    Integer.parseInt(num, 16)
fim

hex_para_bin(num: Texto)
    dec_para_bin(hex_para_dec(num))
fim


vezes = leia_inteiro
para i de 1 até vezes faça
    input = leia_textos(" ")
    num,base = input[1], input[2]

    escreva "Case {i}:"
    escolha base
        caso "bin" => escreva "{bin_para_dec(num)} dec"
                      escreva "{bin_para_hex(num)} hex"
        caso "dec" => escreva "{dec_para_hex(num.inteiro)} hex"
                      escreva "{dec_para_bin(num.inteiro)} bin"
        caso _     => escreva "{hex_para_dec(num)} dec"
                      escreva "{hex_para_bin(num)} bin"
    fim
    escreva ""
fim

1195 - Árvore Binária de Busca

Descrição do Problema: 1195 - Árvore Binária de Busca

Categoria: Grafos

tipo Valor = Inteiro

tipo abstrato No
  valor(): Valor
  esquerda(): No
  direita(): No
  inserir(v: Valor): No
  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

  inserir(v: Valor): No =
    se v < valor então
      Arvore(valor, esquerda.inserir(v), direita)
    senão
      Arvore(valor, esquerda, direita.inserir(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 = 0
  esquerda, direita = isto
  inserir(v: Valor): No = Arvore(v, Folha(), Folha())
  infixa, prefixa, posfixa: Lista[Valor] = []
fim

folha: No = Folha()
c = leia_inteiro
para i de 1 até c faça
  leia_texto
  numeros = leia_inteiros(" ")
  arvore = numeros.injete(folha)((a, b) => a.inserir(b))
  escreva "Case {i}:"
  escreva "Pre.: {arvore.prefixa.junte(" ")}"
  escreva "In..: {arvore.infixa.junte(" ")}"
  escreva "Post: {arvore.posfixa.junte(" ")}"
  escreva ""
fim

1196 - WERTYU

Descrição do Problema: 1196 - WERTYU

Categoria: Ad-Hoc

teclas = "`1234567890-=QWERTYUIOP[]\\ASDFGHJKL;\'ZXCVBNM,./"
var entrada := leia_texto
enquanto não eof faça
  mensagem = para c em entrada gere
    se c == ' ' então ' ' senão teclas[teclas.posição(c) - 1] fim
  fim.junte("")
  escreva mensagem
  entrada := leia_texto
fim

1197 - Volta à Faculdade de Física

Descrição do Problema: 1197 - Volta à Faculdade de Física

Categoria: Matemática

var s := leia_inteiros(" ")
enquanto não eof faça
  v, t = s[1], s[2]
  escreva v * t * 2
  s := leia_inteiros(" ")
fim

1198 - O Bravo Guerreiro Hashmat

Descrição do Problema: 1198 - O Bravo Guerreiro Hashmat

Categoria: Matemática

var entrada := leia_texto
enquanto não eof faça
  se entrada.tamanho > 11 então
    s = entrada.divida(" ").mapeie(BigInt(_))
    a, b = s[1], s[2]
    escreva (b - a).abs
  senão
    s = entrada.divida(" ").mapeie(_.inteiro)
    a, b = s[1], s[2]
    escreva (b - a).abs
  fim
  entrada := leia_texto
fim

1199 - Conversão Simples de Base

Descrição do Problema: 1199 - Conversão Simples de Base

Categoria: Matemática

var input = leia_texto
enquanto input <> "-1" faça
    se input.contém('x') então
        escreva "{Integer.parseInt(input.descarte(2), 16)}"
    senão
        escreva "0x{Integer.toHexString(input.inteiro).maiúsculo}"
    fim
    input := leia_texto
fim