Pular para conteúdo

1400

Faixa de problemas: 1400-1499

Total: 17 problemas

1410 - Ele Está Impedido!

Descrição do Problema: 1410 - Ele Está Impedido!

1410 - Ele Está Impedido!
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
var ad := leia_inteiro
enquanto ad > 0 faça
  atacantes, defensores = leia_inteiros(" ").ordene
  se atacantes[1] < defensores[2] então
    escreva "Y"
  senão
    escreva "N"
  fim
  ad := leia_inteiro
fim

1414 - Copa do Mundo

Descrição do Problema: 1414 - Copa do Mundo

1414 - Copa do Mundo
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
var flag := verdadeiro
enquanto flag faça
    temp1 = leia_inteiros(" ")
    t, n = temp1[1], temp1[2]
    se t == 0 e n == 0 então
        flag := falso
    senão
        var total := 0
        para i de 1 até t faça
            temp2 = leia_textos(" ")
            total := total + temp2[2].inteiro
        fim
        escreva n * 3 - total
    fim
fim

1426 - Coloque Tijolos na Parede

Descrição do Problema: 1426 - Coloque Tijolos na Parede

1426 - Coloque Tijolos na Parede
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
tijolos(x: Lista[Lista[Inteiro]])
  para i de 1 até 9 gere
    para j de 1 até i gere
      a = i div 2
      b = (j + 1) div 2
      escolha (i mod 2, j mod 2)
        caso (0, 1) => (x[a][b] + x[a+1][b] - x[a+1][b+1]) div 2
        caso (0, 0) => (x[a][b] - x[a+1][b] + x[a+1][b+1]) div 2
        caso (1, 0) => (x[a][b] - x[a+1][b] - x[a+1][b+1]) div 2
        caso _      => x[a+1][b]
      fim
    fim
  fim
fim

t = leia_inteiro
para i de 1 até t faça
  x = Lista(5, leia_inteiros(" "))
  escreva tijolos(x).mapeie(_.junte(" ")).junte("\n")
fim

1428 - Procurando Nessy

Descrição do Problema: 1428 - Procurando Nessy

1428 - Procurando Nessy
1
2
3
4
5
6
t = leia_inteiro
para i de 1 ate t faca
  a = leia_inteiros(" ")
  n, m = a[1], a[2]
  escreva (n div 3) * (m div 3)
fim

1429 - Fatorial de Novo!

Descrição do Problema: 1429 - Fatorial de Novo!

1429 - Fatorial de Novo!
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
f = [1, 2, 6, 24, 120]

var s := leia_texto
enquanto s <> "0" faca
  r = s.lista.inverta.mapeie(_.inteiro - '0')
  var d := 0
  para i de 1 ate r.tamanho faca
    d := d + r[i] * f[i]
  fim
  escreva d
  s := leia_texto
fim

1430 - Composição de Jingles

Descrição do Problema: 1430 - Composição de Jingles

1430 - Composição de Jingles
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
d = para i de 'A' ate 'Z' gere 2 ^ (1 - "WHQESTX".posicao(i)) fim
valor(id: Caractere) = d[id - 'A' + 1]
soma(valor: Caractere => Real) =
  (n: String) => n.lista.mapeie(valor).injete(0.0)(_ + _)
duracao = soma(valor)

var entrada := leia_texto
enquanto entrada <> "*" faca
  compassos = entrada.divida("/")
  duracoes = compassos.mapeie(duracao)
  escreva duracoes.selecione(_ == 1.0).tamanho
  entrada := leia_texto
fim

1435 - Matriz Quadrada I

Descrição do Problema: 1435 - Matriz Quadrada I

1435 - Matriz Quadrada I
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
min(a, b:Inteiro) = se a > b então b senão a fim

var n := leia_inteiro
enquanto n <> 0 faça
  para linha de 1 até n faça
    a = min(linha, n - linha + 1)
    escreva
      para coluna de 1 até n gere
        b = min(coluna, n - coluna + 1)
        min(a, b) formato "%3d"
      fim
      .junte(" ")
  fim
  escreva ""
  n := leia_inteiro
fim

1436 - Jogo do Tijolo

Descrição do Problema: 1436 - Jogo do Tijolo

1436 - Jogo do Tijolo
1
2
3
4
5
6
7
8
t = leia_inteiro
para i de 1 ate t faca
  entrada = leia_inteiros(" ")
  n = entrada.cabeca
  nums = entrada.cauda
  meio = nums.ordene[(n + 2) div 2]
  escreva "Case {i}: {meio}"
fim

1437 - Esquerda, Volver!

Descrição do Problema: 1437 - Esquerda, Volver!

1437 - Esquerda, Volver!
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
dir(c: Caractere) = se c == 'D' entao 1 senao -1 fim
direcoes = "LSONLSO"
var n := leia_inteiro
enquanto n > 0 faca
  comandos = leia_texto
  frente = comandos.lista.mapeie(dir).injete(0)(_ + _)
  direcao = direcoes[frente mod 4 + 4]
  escreva direcao
  n := leia_inteiro
fim

1441 - Sequências de Granizo

Descrição do Problema: 1441 - Sequências de Granizo

1441 - Sequências de Granizo
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
var maior := leia_inteiro
enquanto maior > 0 faça
  var h := maior
  enquanto h > 1 faça
    se h > maior então
      maior := h
    fim
    h := se h mod 2 == 0 então h div 2 senão 3 * h + 1 fim
  fim
  escreva maior
  maior := leia_inteiro
fim

1444 - Corrida dos Marrecos

Descrição do Problema: 1444 - Corrida dos Marrecos

1444 - Corrida dos Marrecos
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
var n := leia_inteiro
enquanto n > 0 faça
  var a := 0
  enquanto n > 1 faça
    se n mod 3 == 0 então
      n := n div 3
    senão
      n := n div 3 + 1
    fim
    a := a + n
  fim
  escreva a
  n := leia_inteiro
fim

1448 - Telefone Sem Fio

Descrição do Problema: 1448 - Telefone Sem Fio

1448 - Telefone Sem Fio
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
t = leia_inteiro
para i de 1 até t faça
  frase, time1, time2 = leia_texto
  var c1, c2, desempate := 0

  para j de 1 até frase.tamanho faça
    se frase[j] == time1[j] então
      c1 := c1 + 1
      se desempate == 0 e frase[j] <> time2[j] então
        desempate := 1
      fim
    fim
    se frase[j] == time2[j] então
      c2 := c2 + 1
      se desempate == 0 e frase[j] <> time1[j] então
        desempate := 2
      fim
    fim
  fim

  escreva "Instancia {i}"
  se c1 == c2 e desempate == 0 então
    escreva "empate"
  senãose c1 > c2 então
    escreva "time 1"
  senãose c1 < c2 então
    escreva "time 2"
  senão
    escreva "time {desempate}"
  fim
  escreva ""
fim

1457 - Oráculo de Alexandria

Descrição do Problema: 1457 - Oráculo de Alexandria

1457 - Oráculo de Alexandria
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
kfat(n, k: Inteiro, total: BigInt): BigInt =
  se n > 1 entao kfat(n - k, k, total * n) senao total fim

t = leia_inteiro
para i de 1 ate t faca
  s = leia_texto
  n = s.inteiro
  k = s.descarte_enquanto(_ <> '!').tamanho
  escreva kfat(n, k, 1)
fim

1466 - Percurso em Árvore por Nível

Descrição do Problema: 1466 - Percurso em Árvore por Nível

1466 - Percurso em Árvore por Nível
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
tipo Valor = Inteiro

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

tipo TipoFila = No

tipo Fila
  entrada, saida: Lista[TipoFila]

  inserir(valor: TipoFila): Fila =
    se saida == [] então
      Fila([], (valor :: entrada).inverta)
    senão
      Fila(valor :: entrada, saida)
    fim

  cabeça(): TipoFila = saida.cabeça

  vazia() = entrada == [] e saida == []

  remover(): Fila =
    se saida == [] então
      Fila([], entrada.inverta.cauda)
    senãose saida.cauda == [] então
      Fila([], entrada.inverta)
    senão
      Fila(entrada, saida.cauda)
    fim
fim

fila_vazia = Fila([], [])

folha: No = Folha()
c = leia_inteiro
para i de 1 até c faça
  leia_texto
  num = leia_inteiros(" ")
  arvore = num.injete(folha)((a, b) => a.inserir(b))
  var fila := fila_vazia.inserir(arvore)
  var list: Lista[Inteiro] = []
  enquanto não fila.vazia faça
    a = fila.cabeça
    list := a.valor :: list
    fila := fila.remover()
    se a.esquerda <> folha então fila := fila.inserir(a.esquerda) fim
    se a.direita <> folha então fila := fila.inserir(a.direita) fim
  fim
  escreva "Case {i}:"
  escreva list.inverta.junte(" ")
  escreva ""
fim

1467 - Zerinho ou Um

Descrição do Problema: 1467 - Zerinho ou Um

1467 - Zerinho ou Um
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
var s := leia_texto
enquanto nao eof faca
  se s == "1 0 0" ou s == "0 1 1" entao
    escreva "A"
  senaose s == "0 1 0" ou s == "1 0 1" entao
    escreva "B"
  senaose s == "0 0 1" ou s == "1 1 0" entao
    escreva "C"
  senao
    escreva "*"
  fim
  s := leia_texto
fim

1471 - Mergulho

Descrição do Problema: 1471 - Mergulho

1471 - Mergulho
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
# https://www.beecrowd.com.br/judge/pt/homeworks/view/29206
var a := leia_texto
enquanto nao eof faça
  n, r = a.divida(" ")[1].inteiro, a.divida(" ")[2].inteiro
  se n == r então
    leia_texto
    escreva "*"
  senão
    numeros = ((n + 1) :: leia_inteiros(" ")).ordene
    var i := 0
    para num em numeros faca
      i := i + 1
      enquanto i < num faça
        imprima "{i} "
        i := i + 1
      fim
    fim
    escreva ""
  fim
  a := leia_texto
fim

1478 - Matriz Quadrada II

Descrição do Problema: 1478 - Matriz Quadrada II

1478 - Matriz Quadrada II
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
var n := leia_inteiro

enquanto n <> 0 faça
  para linha de 1 até n faça
    escreva (para c de linha até 1 passo -1 gere
      c formato "%3d"
    fim + para c de 2 até n - linha + 1 gere
      c formato "%3d"
    fim).junte(" ")
  fim
  escreva ""
  n := leia_inteiro
fim