Biblioteca de Algoritmos

1. Entrada e Saída

Fundamentos

O "Olá Mundo" interativo. Operações básicas de entrada (leia) e saída (escreva) usando variáveis numéricas.

algoritmo "io_basico"
var
  a: inteiro
  b: inteiro
  soma: inteiro
inicio
  escreva("Digite o primeiro numero:")
  leia(a)
  escreva("Digite o segundo numero:")
  leia(b)
  
  soma = a + b
  escreva("A soma eh:")
  escreva(soma)
fimalgoritmo

Calculadora Simples

Fundamentos

Operações básicas de entrada (leia) e saída (escreva) utilizando variáveis primitivas.

algoritmo "calculadora"
var
  a: inteiro
  b: inteiro
  soma: inteiro
inicio
  escreva("Digite o primeiro numero:")
  leia(a)
  escreva("Digite o segundo numero:")
  leia(b)
  
  soma = a + b
  escreva("A soma eh:")
  escreva(soma)
fimalgoritmo

2. Condicionais (Se/Senão)

Fundamentos

Controle de fluxo baseado em decisões. Mostra como aninhar verificações para classificar idades.

algoritmo "classificacao_idade"
var
  idade: inteiro
inicio
  escreva("Digite sua idade:")
  leia(idade)
  
  se idade < 12 entao
    escreva("Classificacao: Crianca")
  senao
    se idade < 18 entao
      escreva("Classificacao: Adolescente")
    senao
      escreva("Classificacao: Adulto")
    fimse
  fimse
fimalgoritmo

3. Validação (Enquanto)

Fundamentos

Um laço de repetição que não tem fim previsível. Ele continua rodando até que a condição seja satisfeita (ex: sistema de senhas).

algoritmo "sistema_senha"
var
  senha: inteiro
inicio
  senha = 0
  
  enquanto senha != 1234 faca
    escreva("Digite a senha numerica secreta:")
    leia(senha)
    
    se senha != 1234 entao
      escreva("Senha Incorreta! Tente novamente.")
    fimse
  fimenquanto
  
  escreva("Acesso Liberado!")
fimalgoritmo

4. Manipulação de Vetor

Fundamentos

Estrutura de dados básica (Array). Como usar um laço 'Para' para preencher gavetas da memória e depois ler todas elas.

algoritmo "vetor_basico"
var
  notas: vetor[1..3] de inteiro
  i: inteiro
inicio
  // Preenchendo o vetor
  para i de 1 ate 3 faca
    escreva("Digite a nota:")
    leia(notas[i])
  fimpara
  
  escreva("--- Relatorio ---")
  // Lendo os dados armazenados
  para i de 1 ate 3 faca
    escreva(notas[i])
  fimpara
fimalgoritmo

5. Pilha (Stack)

Fundamentos

O conceito LIFO (Último a entrar, primeiro a sair). Essencial para entender como o próprio computador gerencia funções.

algoritmo "pilha_simples"
var
  pilha: vetor[1..5] de inteiro
  topo: inteiro
inicio
  topo = 0
  
  // Empilhando valores (Push)
  topo = topo + 1
  pilha[topo] = 10
  
  topo = topo + 1
  pilha[topo] = 99
  
  escreva("Desempilhando o valor do Topo (Pop):")
  escreva(pilha[topo]) // Imprime o 99
  
  // O topo desce um nivel
  topo = topo - 1
fimalgoritmo

Vetor Tridimensional (Cubo 3D)

Estrutura de Dados

Como o computador guarda um cubo 3D na memória RAM (que é 1D)? Usando 3 laços aninhados (X, Y, Z) e linearização matemática!

algoritmo "matriz_3d_linear"
var
  // Um cubo 2x2x2 possui 8 posicoes no total (2 * 2 * 2)
  cubo: vetor[1..8] de inteiro
  x: inteiro
  y: inteiro
  z: inteiro
  indice: inteiro
  contador: inteiro
inicio
  contador = 10
  escreva("--- MAPEANDO UM CUBO 3D ---")
  
  // Eixo X (Largura)
  para x de 1 ate 2 faca
    // Eixo Y (Altura)
    para y de 1 ate 2 faca
      // Eixo Z (Profundidade)
      para z de 1 ate 2 faca
        
        // Magia da Computacao: Achatando 3D para 1D
        // Formula: (x-1)*4 + (y-1)*2 + (z-1) + 1
        indice = ((x - 1) * 4) + ((y - 1) * 2) + (z - 1) + 1
        
        cubo[indice] = contador
        
        escreva("Coordenada [X, Y, Z] gravada no Indice da RAM:")
        escreva(indice)
        
        contador = contador + 10
      fimpara
    fimpara
  fimpara
  
  escreva("Valor na coordenada [X=2, Y=1, Z=2]:")
  // X=2, Y=1, Z=2 -> indice 6
  escreva(cubo[6]) 
fimalgoritmo

6. Busca Linear em Vetor

Fundamentos

Varre todas as posições do vetor, uma a uma, à procura de um valor específico usando uma variável de controlo (flag).

algoritmo "busca_linear"
var
  numeros: vetor[1..5] de inteiro
  alvo: inteiro
  i: inteiro
  encontrado: inteiro
  posicao: inteiro
inicio
  // Preenchendo o vetor com valores fixos
  numeros[1] = 15
  numeros[2] = 42
  numeros[3] = 8
  numeros[4] = 99
  numeros[5] = 23
  
  encontrado = 0
  posicao = 0
  
  escreva("--- SISTEMA DE BUSCA ---")
  escreva("Qual valor deseja procurar no vetor?")
  leia(alvo)
  
  // O laco percorre todas as gavetas do vetor
  para i de 1 ate 5 faca
    se numeros[i] == alvo entao
      encontrado = 1
      posicao = i
    fimse
  fimpara
  
  // Avalia o resultado da busca
  se encontrado == 1 entao
    escreva("Sucesso! Valor encontrado na posicao:")
    escreva(posicao)
  senao
    escreva("Falha. O valor nao existe no vetor.")
  fimse
fimalgoritmo

6. Introdução a Ponteiros

Fundamentos

O terror dos universitários simplificado! Como modificar uma variável à distância usando o endereço de memória dela.

algoritmo "magia_dos_ponteiros"
var
  bau: inteiro
  mapa: ponteiro
inicio
  bau = 15
  escreva("Valor original do bau:")
  escreva(bau)
  
  // O mapa recebe a localizacao (&) do bau na memoria
  mapa = &bau
  
  // Alteramos o bau a distancia usando o asterisco (*)
  *mapa = 99
  
  escreva("Novo valor alterado via ponteiro:")
  escreva(bau)
fimalgoritmo

Número Primo

Matemática

Verifica a primalidade contando os divisores através do cálculo manual do módulo (resto da divisão).

algoritmo "primo"
var
  n: inteiro
  i: inteiro
  divisores: inteiro
inicio
  divisores = 0
  escreva("Digite um numero:")
  leia(n)
  
  para i de 1 ate n faca
    se n - ((n / i) * i) == 0 entao
      divisores = divisores + 1
    fimse
  fimpara
  
  se divisores == 2 entao
    escreva("Eh Primo!")
  senao
    escreva("Nao eh primo.")
  fimse
fimalgoritmo

Sequência de Fibonacci

Matemática

O próximo número é gerado pela soma dos dois anteriores. Excelente para treinar reatribuição de variáveis.

algoritmo "fibonacci"
var
  limite: inteiro
  a: inteiro
  b: inteiro
  c: inteiro
  i: inteiro
inicio
  a = 0
  b = 1
  escreva("Deseja ir ate qual limite?")
  leia(limite)
  
  escreva(a)
  escreva(b)
  
  para i de 3 ate limite faca
    c = a + b
    escreva(c)
    a = b
    b = c
  fimpara
fimalgoritmo

Fórmula de Bhaskara

Álgebra

Calcula as raízes de uma equação do 2º grau. Este exemplo simula o cálculo do discriminante (Delta).

algoritmo "bhaskara_simplificado"
var
  a: inteiro
  b: inteiro
  c: inteiro
  delta: inteiro
inicio
  escreva("Valor de A:")
  leia(a)
  escreva("Valor de B:")
  leia(b)
  escreva("Valor de C:")
  leia(c)
  
  // Delta = b^2 - 4ac
  delta = (b * b) - (4 * a * c)
  
  escreva("O valor de Delta eh:")
  escreva(delta)
  
  se delta < 0 entao
    escreva("Nao possui raizes reais.")
  senao
    escreva("Possui raizes reais.")
  fimse
fimalgoritmo

1. Algoritmo de Euclides (MDC)

Matemática

Calcula o Máximo Divisor Comum de forma muito rápida usando divisões sucessivas. O console explica cada troca de variáveis.

algoritmo "mdc_euclides"
var
  a: inteiro
  b: inteiro
  resto: inteiro
inicio
  a = 48
  b = 18
  escreva("--- Algoritmo de Euclides (MDC) ---")
  escreva("Vamos achar o MDC de 48 e 18")
  
  enquanto b != 0 faca
    // Calculando o resto da divisao (Modulo)
    resto = a - ((a / b) * b)
    
    escreva("Resto atual encontrado:")
    escreva(resto)
    
    // As variaveis escorregam para o proximo calculo
    a = b
    b = resto
  fimenquanto
  
  escreva("--- FIM ---")
  escreva("O MDC final eh:")
  escreva(a)
fimalgoritmo

2. Decimal para Binário

Matemática

Como o computador pensa? Este algoritmo divide o número por 2 e guarda o resto para formar os bits (0 e 1).

algoritmo "decimal_binario"
var
  n: inteiro
  bit: inteiro
inicio
  n = 13
  escreva("--- DECODIFICADOR BINARIO ---")
  escreva("Convertendo o numero 13:")
  
  enquanto n > 0 faca
    // Pega o resto da divisao por 2
    bit = n - ((n / 2) * 2)
    
    escreva("Bit gerado:")
    escreva(bit)
    
    // Corta o numero pela metade para o proximo passo
    n = n / 2
  fimenquanto
  
  escreva("DICA: Leia os bits de baixo para cima!")
fimalgoritmo

3. Número Primo Detalhado

Matemática

Narra o teste de divisão. Um número só é primo se possuir exatamente dois divisores: o 1 e ele mesmo.

algoritmo "primo_detalhado"
var
  n: inteiro
  i: inteiro
  divisores: inteiro
inicio
  divisores = 0
  escreva("Digite um numero para testar:")
  leia(n)
  
  escreva("Iniciando varredura de divisores...")
  
  para i de 1 ate n faca
    se n - ((n / i) * i) == 0 entao
      escreva("Opa! Achei um divisor:")
      escreva(i)
      divisores = divisores + 1
    fimse
  fimpara
  
  escreva("Total de divisores encontrados:")
  escreva(divisores)
  
  se divisores == 2 entao
    escreva("Conclusao: EH UM NUMERO PRIMO!")
  senao
    escreva("Conclusao: NAO eh primo.")
  fimse
fimalgoritmo

4. Progressão de Fibonacci

Matemática

A proporção áurea. O console explica a matemática da soma dos dois números anteriores para gerar o próximo.

algoritmo "fibonacci_narrado"
var
  limite: inteiro
  a: inteiro
  b: inteiro
  c: inteiro
  i: inteiro
inicio
  a = 0
  b = 1
  escreva("--- SEQUENCIA DE FIBONACCI ---")
  escreva("Quantos termos deseja calcular?")
  leia(limite)
  
  escreva("Base:")
  escreva(a)
  escreva(b)
  
  para i de 3 ate limite faca
    c = a + b
    escreva("Somando os dois ultimos...")
    escreva(c)
    
    // Desloca os valores para a proxima iteracao
    a = b
    b = c
  fimpara
fimalgoritmo

Média de um Vetor

Estatística

Armazena múltiplos dados estatísticos em um Vetor e percorre todos os índices para extrair a média aritmética.

algoritmo "media_vetor"
var
  dados: vetor[1..4] de inteiro
  soma: inteiro
  media: inteiro
  i: inteiro
inicio
  soma = 0
  
  para i de 1 ate 4 faca
    escreva("Informe o dado estatistico:")
    leia(dados[i])
    soma = soma + dados[i]
  fimpara
  
  media = soma / 4
  escreva("A media dos dados eh:")
  escreva(media)
fimalgoritmo

Neurônio Perceptron

I.A.

A base do Deep Learning! Simula um neurônio artificial calculando o produto escalar e usando uma função de ativação.

algoritmo "neuronio_simples"
var
  entrada1: inteiro
  entrada2: inteiro
  peso1: inteiro
  peso2: inteiro
  soma: inteiro
inicio
  // Pesos sinapticos treinados
  peso1 = 2
  peso2 = -1
  
  escreva("Sinal de Entrada 1:")
  leia(entrada1)
  escreva("Sinal de Entrada 2:")
  leia(entrada2)
  
  // Produto escalar
  soma = (entrada1 * peso1) + (entrada2 * peso2)
  
  // Funcao de ativacao (Step Function)
  se soma >= 0 entao
    escreva("Neuronio ATIVADO (1)")
  senao
    escreva("Neuronio DESATIVADO (0)")
  fimse
fimalgoritmo

Busca Binária O(log n)

I.A. e Otimização

Algoritmo de busca essencial. Encontra um alvo dividindo a área de busca pela metade a cada iteração.

algoritmo "busca_binaria"
var
  inicio_busca: inteiro
  fim_busca: inteiro
  meio: inteiro
  alvo: inteiro
inicio
  inicio_busca = 1
  fim_busca = 100
  alvo = 42 // Numero que a IA tenta achar
  
  enquanto inicio_busca <= fim_busca faca
    meio = (inicio_busca + fim_busca) / 2
    
    se meio == alvo entao
      escreva("Alvo encontrado!")
      inicio_busca = 999 // Forca a saida do laco
    senao
      se meio < alvo entao
        inicio_busca = meio + 1
      senao
        fim_busca = meio - 1
      fimse
    fimse
  fimenquanto
fimalgoritmo

Biblioteca de Scripts

1. Entrada e Saída

Calculadora Simples

2. Condicionais (Se/Senão)

3. Validação (Enquanto)

4. Manipulação de Vetor

5. Pilha (Stack)

Vetor Tridimensional (Cubo 3D)

6. Busca Linear em Vetor

6. Introdução a Ponteiros

Número Primo

Sequência de Fibonacci

Fórmula de Bhaskara

1. Algoritmo de Euclides (MDC)

2. Decimal para Binário

3. Número Primo Detalhado

4. Progressão de Fibonacci

Média de um Vetor

Neurônio Perceptron

Busca Binária O(log n)