Documentação Oficial - AlgoSimulator

1. Como começar? (A Estrutura)

Analogia: Pense num programa de computador como uma receita de bolo. Primeiro você dá um nome à receita, depois separa os ingredientes (variáveis) e, por fim, escreve o modo de preparo (início ao fim).

Todo código no AlgoSimulator precisa seguir este esqueleto básico. Copie e cole na IDE para testar:

algoritmo "meu_primeiro_programa"
var
  // Aqui você separa os "ingredientes" (variáveis)
inicio
  // Aqui vai o "modo de preparo" (suas ordens)
fimalgoritmo

2. Variáveis e Tipos

Analogia: Uma variável é como uma caixa de papelão com uma etiqueta. Você escreve "Idade" na etiqueta e guarda o número 20 lá dentro. O computador usa a memória RAM para guardar essas caixas.

Declaramos as variáveis usando nome : tipo. Para guardar um valor na caixa, usamos o sinal de igual =.

var
  idade: inteiro
  peso: real
inicio
  idade = 20
  peso = 75.5
fimalgoritmo

3. Falando com o Computador (I/O)

Analogia: leia() é o computador te fazendo uma pergunta e esperando você digitar a resposta. escreva() é o computador te mostrando um recado na tela.

var
  ano_nascimento: inteiro
  idade: inteiro
inicio
  // O PC vai pausar e pedir para você digitar algo
  leia(ano_nascimento) 
  
  idade = 2026 - ano_nascimento
  
  // O PC vai imprimir o resultado no console escuro
  escreva(idade) 
fimalgoritmo

4. Tomando Decisões (SE / SENÃO)

Analogia: Você chegou em uma encruzilhada. "SE estiver chovendo, vou pelo caminho A de guarda-chuva. SENÃO, vou pelo caminho B de óculos de sol".

var
  nota: inteiro
inicio
  nota = 8
  
  se nota >= 7 entao
    escreva(1) // 1 significa Aprovado
  senao
    escreva(0) // 0 significa Reprovado
  fimse
fimalgoritmo

5. Repetindo Ações (Laços)

Analogia: Imagine que você está de castigo e precisa escrever "Não vou bagunçar" 100 vezes no quadro. Em vez de escrever 100 linhas de código, você usa um laço para dizer: "Repita isso de 1 até 100".

var
  i: inteiro
inicio
  // Laço PARA: Sabe exatamente quantas vezes vai rodar
  para i de 1 ate 5 faca
    escreva(i)
  fimpara

  // Laço ENQUANTO: Roda até a condição virar falsa
  i = 1
  enquanto i <= 5 faca
    escreva(i)
    i = i + 1
  fimenquanto
fimalgoritmo

6. Listas e Vetores (Arrays)

Analogia: Em vez de ter 10 caixas soltas pela casa, um Vetor é como uma caixa de ovos ou um armário de remédios com várias gavetinhas numeradas. Você acessa a gaveta usando o número dela nos colchetes: armario[3].

var
  gavetas: vetor[1..3] de inteiro
inicio
  gavetas[1] = 100
  gavetas[2] = 200
  gavetas[3] = gavetas[1] + gavetas[2]
  
  escreva(gavetas[3]) // Vai imprimir 300
fimalgoritmo

7. Criando Funções e Recursão

Analogia: Uma função é como contratar um ajudante especializado. Você dá o nome dele de "Somador", entrega dois números na mão dele, ele faz o trabalho em uma salinha separada, e te "retorna" o resultado pronto.

funcao somador(x: inteiro, y: inteiro) : inteiro
inicio
  retorna x + y
fimfuncao

var
  resultado: inteiro
inicio
  resultado = somador(10, 5)
  escreva(resultado) // Imprime 15
fimalgoritmo

8. A Magia dos Ponteiros

Analogia: Um ponteiro é um mapa do tesouro. Ele não guarda o tesouro de verdade, ele guarda apenas as coordenadas (endereço da memória) de onde o tesouro está enterrado.

Use & para "pegar o endereço" e * para "cavar o tesouro" (desreferenciar).

var
  bau: inteiro
  mapa: ponteiro
inicio
  bau = 50
  mapa = &bau   // O mapa agora sabe onde o baú está
  *mapa = 100   // Usamos o mapa para achar o baú e colocar 100 dentro
  
  escreva(bau)  // Imprime 100!
fimalgoritmo

9. Estruturas Avançadas: Pilhas (Stacks)

Analogia: Pense numa pilha de pratos sujos na pia. Você só consegue colocar um prato novo no TOPO, e só consegue tirar o prato que está no TOPO. O último a entrar é o primeiro a sair (LIFO).

var
  pilha: vetor[1..5] de inteiro
  topo: inteiro
inicio
  topo = 0
  
  // Colocando um prato (PUSH)
  topo = topo + 1
  pilha[topo] = 10
  
  // Colocando outro prato (PUSH)
  topo = topo + 1
  pilha[topo] = 20
  
  // Tirando o prato do topo (POP)
  escreva(pilha[topo]) // Imprime 20
  topo = topo - 1
fimalgoritmo

10. Estruturas Avançadas: Filas (Queues)

Analogia: É literalmente uma fila de banco. O primeiro cliente que chega é o primeiro a ser atendido (FIFO - First In, First Out). Novas pessoas entram no FIM, pessoas são atendidas no INÍCIO.

var
  fila: vetor[1..5] de inteiro
  inicio_fila: inteiro
  fim_fila: inteiro
inicio
  inicio_fila = 1
  fim_fila = 0
  
  // Cliente chega (ENQUEUE)
  fim_fila = fim_fila + 1
  fila[fim_fila] = 10
  
  // Outro cliente chega (ENQUEUE)
  fim_fila = fim_fila + 1
  fila[fim_fila] = 20
  
  // Primeiro cliente é atendido (DEQUEUE)
  escreva(fila[inicio_fila]) // Imprime 10
  inicio_fila = inicio_fila + 1
fimalgoritmo

11. Memória Dinâmica: Registros e Árvores

Analogia: Um Registro é como uma ficha médica com vários campos (nome, peso, etc). A função alocar() é como pedir para a prefeitura construir um terreno novo no meio da cidade para guardar essa ficha, enquanto os ponteiros são as ruas que ligam os terrenos.

registro Ficha
  valor: inteiro
  proximo: ponteiro
fimregistro

var
  primeira_ficha: ponteiro
  segunda_ficha: ponteiro
inicio
  // Constrói os terrenos reais na memória (Heap)
  alocar(primeira_ficha, Ficha)
  alocar(segunda_ficha, Ficha)
  
  primeira_ficha.valor = 100
  segunda_ficha.valor = 200
  
  // Uma ficha aponta para a outra! (Lista Encadeada)
  primeira_ficha.proximo = segunda_ficha
  
  // Acessando a segunda através da primeira
  escreva(primeira_ficha.proximo.valor) // Imprime 200
fimalgoritmo