1100

Faixa de problemas: 1100-1199

Total: 73 problemas

1101 - Sequência de Números e Soma

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

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

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

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

var entrada := leia_texto
enquanto entrada <> "0 0" faca
  alice, beatriz = distintas(leia_inteiros(" "))
  a, b = alice.tamanho, beatriz.tamanho
  iguais = a - (alice - beatriz).tamanho
  trocas = se a < b entao a - iguais senao b - iguais fim
  escreva trocas
  entrada := leia_texto
fim

1105 - Sub-prime

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

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

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 faca
    se x < anterior entao
      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

var n := leia_inteiro
impar = para i de 1 ate 50 passo 2 gere i fim
par = para i de 2 ate 50 passo 2 gere i fim
vazia = [0].cauda
enquanto n > 0 faca
  var cartas := par.pegue(n div 2)
  var descartes, pilha: Lista[Inteiro] := []
  var descartar := n mod 2 == 0
  enquanto cartas.tamanho + pilha.tamanho > 1 faca
    se cartas == [] entao
      cartas := pilha.inverta
      pilha := vazia
    fim
    topo = cartas.cabeca
    cartas := cartas.cauda
    se descartar entao
      descartes := topo :: descartes
    senao
      pilha := topo :: pilha
    fim
    descartar := nao 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

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

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

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

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

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

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

var a := leia_textos(" ")
enquanto a <> ["0", "0"] faca
  d, n = a[1][1], a[2]
  v = n.selecione(_ <> d).descarte_enquanto(_ == '0')
  escreva se v == "" entao 0 senao v fim
  a := leia_textos(" ")
fim

1129 - Leitura Ótica

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

var n := leia_inteiro
enquanto n > 0 faca
  para i de 1 ate n faca
    respostas = leia_inteiros(" ").mapeie(_ <= 127)
    pretos = respostas.selecione(_ == verdadeiro).tamanho
    se pretos == 1 entao
      escreva "ABCDE"[respostas.posicao(verdadeiro)]
    senao
      escreva "*"
    fim
  fim
  n := leia_inteiro
fim

1131 - Grenais

Descrição do Problema: 1131 - Grenais

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

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 se i mod 13 <> 0 faça
  soma := soma + i
fim
escreva soma

1133 - Resto da Divisão

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

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

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!

var a := leia_inteiros(" ")
enquanto a[1] > 0 faca
  n, b = a[1], a[2]
  var p := Lista(n, 0) #.mutavel
  var cont := 0
  nums = leia_inteiros(" ").ordene
  var i, j := 1, nums.tamanho
  enquanto cont < n e i < nums.tamanho faca
    x = nums[j] - nums[i]
    se p[x] == 0 entao
      p[x] := 1
      cont := cont + 1
    fim
    j := j - 1
    se j == i entao
      i := i + 1
      j := nums.tamanho
    fim
  fim
  se cont == n entao
    escreva "Y"
  senao
    escreva "N"
  fim
  a := leia_inteiros(" ")
fim

1138 - Contagem de Dígitos

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

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

var frase := leia_texto
enquanto frase <> "*" faca
  palavras = frase.maiúsculo.divida(" ")
  primeira = palavras[1].cabeca
  tamanho = palavras.tamanho
  var tautograma, i := verdadeiro, 1
  enquanto tautograma e i <= tamanho faca
    tautograma := palavras[i].cabeca == primeira
    i := i + 1
  fim
  # tautograma = palavras.mapeie(_.cabeca == primeira).injete(verdadeiro)(_ e _)
  se tautograma entao
    escreva "Y"
  senao
    escreva "N"
  fim
  frase := leia_texto
fim

1142 - PUM

Descrição do Problema: 1142 - PUM

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

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

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

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

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

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

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

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

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

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

escreva "5.19"

1156 - Sequência S II

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

escreva "6.00"

1157 - Divisores I

Descrição do Problema: 1157 - Divisores I

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

1158 - Soma de Ímpares Consecutivos III

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

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

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

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

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

enquanto nao eof faça
  s = leia_inteiros(" ")
  se nao eof entao
    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

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

PI = 3.14159
G = 9.80665

var input := leia_texto
enquanto input <> nulo e input <> "" faca
    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

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

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!

bolas = para i de 1 ate 50 gere (i + 1) * (i + 1) div 2 - 1 fim
t = leia_inteiro
para i de 1 ate t faca
  n = leia_inteiro
  escreva bolas[n]
fim

1168 - LED

Descrição do Problema: 1168 - LED

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

n = leia_inteiro
para i de 1 ate n faca
  x = leia_inteiro
  var trigo := BigInt(1)
  para j de 1 ate x faca
    trigo := trigo * 2
  fim
  escreva "{trigo div 12000} kg"
fim

1170 - Blobs

Descrição do Problema: 1170 - Blobs

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

n = leia_inteiro
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

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

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

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

1175 - Troca em Vetor I

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

n = leia_inteiro
para i de 1 ate n faca
  a = leia_texto
  x = a[1] - '0'
  y = a[3] - '0'
  c = a[2]
  se x == y entao
    escreva x * x
  senaose c >= 'a' e c <= 'z' entao
    escreva x + y
  senão
    escreva y - x
  fim
fim

1193 - Conversão entre Bases

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

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

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

teclas = "`1234567890-=QWERTYUIOP[]\\ASDFGHJKL;\'ZXCVBNM,./"
var entrada := leia_texto
enquanto nao eof faca
  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

var s := leia_inteiros(" ")
enquanto nao 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

var entrada := leia_texto
enquanto nao eof faca
  se entrada.tamanho > 11 entao
    s = entrada.divida(" ").mapeie(BigInt(_))
    a, b = s[1], s[2]
    escreva (b - a).abs
  senao
    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

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