# Código que podes executar

Exemplos de Python, C, C++, Java, Haskell, Prolog, PHP e SQL. Pré-visualizações web, DartPad e Ripes.

Página: https://resumos.rgo.pt/exemplo/codigo/

Muda o código e carrega em **Executar**, ou usa `Ctrl+Enter` (`⌘+Enter` no Mac). O primeiro arranque descarrega o motor da linguagem. Os editores de código correm no teu navegador. O DartPad, mais abaixo, usa um serviço de compilação externo.

## Python

Este programa soma os primeiros cinco números naturais. Muda o limite do `range` e compara o resultado.

```python
numeros = range(1, 6)
print(sum(numeros))
```

## C

`printf` escreve o resultado. Aqui, o ciclo soma os números de 1 a 5 e mostra `15`.

```c
#include <stdio.h>

int main(void) {
    int soma = 0;
    for (int n = 1; n <= 5; n++) soma += n;
    printf("%d\n", soma);
    return 0;
}
```

## C++

Os dados de entrada já contêm o número 5. O programa lê esse número e calcula o quadrado. Podes mudar ambos antes de executar.

```cpp
#include <iostream>

int main() {
    int n;
    std::cin >> n;
    std::cout << n * n << "\n";
}
```

## Java

Usa a classe `Main` como ponto de entrada. Este exemplo conta os elementos de uma lista.

```java
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        java.util.List<String> nomes = Arrays.asList("Ana", "Rui", "Inês");
        System.out.println(nomes.size());
    }
}
```

## JavaScript

Aqui, `filter` guarda os números pares. Este editor executa JavaScript sem a página web. Para experimentar o DOM, usa o exemplo de HTML abaixo.

```javascript
const numeros = [1, 2, 3, 4, 5, 6];
console.log(numeros.filter(n => n % 2 === 0).join(", "));
```

## SQL

Cada execução começa com uma base de dados vazia. Cria a tabela, insere os dados e faz a consulta no mesmo bloco.

```sql
CREATE TABLE notas (nome TEXT, valor INTEGER);
INSERT INTO notas VALUES ('Ana', 16), ('Rui', 14), ('Inês', 18);
SELECT nome, valor FROM notas WHERE valor >= 16;
```

## Haskell

`filter even` guarda os pares; `map (^2)` calcula os seus quadrados. O resultado é `[4,16,36]`. Muda a lista e volta a executar. Este motor usa GHC e aceita um programa com `main`, sem entrada interativa.

```haskell
main :: IO ()
main = print (map (^2) (filter even [1..6]))
```

## Prolog

Os factos dizem quem é progenitor de quem. A regra `avo` liga duas gerações. `findall` junta as respostas numa lista, que aqui é `[ana]`.

```prolog
progenitor(ana, rui).
progenitor(rui, ines).

avo(X, Y) :- progenitor(X, Z), progenitor(Z, Y).

main :- findall(X, avo(X, ines), Avos), writeln(Avos).
```

O motor é SWI-Prolog. O código comum funciona, mas as bibliotecas específicas de SICStus, usado em PFL, podem ser diferentes.

## PHP

`array_sum` soma os valores do array. `count` conta-os. A divisão dá a média, `16`.

```php
<?php
$notas = [14, 16, 18];
echo array_sum($notas) / count($notas), "\n";
```

## HTML, CSS e JavaScript

O botão muda o texto do parágrafo. Abre **CSS e JavaScript** para veres como. Carrega em **Pré-visualizar** depois de fazeres alterações.

```html
<p id="mensagem">Olá, FEUP!</p> <button id="botao">Mudar mensagem</button>
```



```css
body { color: #8c2d3b; } button { padding: 8px 16px; cursor: pointer; }
```



```js
document.querySelector("#botao").onclick = () => { document.querySelector("#mensagem").textContent = "Funcionou!"; };
```

## Dart e Flutter

Para exemplos de ES, podes usar o DartPad. Abre o menu de exemplos do próprio editor para escolher Dart ou Flutter.

## Assembly RISC-V

Este programa soma os números de 1 a 5 no registo `t0` e mostra `15`. `addi` incrementa o contador; `ble` repete o ciclo enquanto o contador não ultrapassar 5.

```riscv
.text
.globl main
main:
  li t0, 0
  li t1, 1
  li t2, 5
soma:
  add t0, t0, t1
  addi t1, t1, 1
  ble t1, t2, soma
  mv a0, t0
  li a7, 1
  ecall
  li a0, 10
  li a7, 11
  ecall
  li a7, 10
  ecall
```

O editor usa RISC-V de 32 bits e as chamadas de sistema do RARS. `ecall` com `a7 = 1` escreve um inteiro, `a7 = 11` escreve um carácter e `a7 = 10` termina. As chamadas de sistema são convenções do simulador, não instruções adicionais de RISC-V.

Para veres como cada instrução altera os registos e a memória, abre o Ripes e avança uma instrução de cada vez.

## Usar numa página

Numa página MDX, importa `CodePlayground.astro` e passa a linguagem e o código. O campo `input` é opcional.

```
import CodePlayground from '../../../components/CodePlayground.astro';

<CodePlayground language="python" code={'print(2 + 3)'} />
```

Os exemplos servem para programas pequenos. Python inclui a biblioteca padrão, C usa C17, C++ usa C++17, Java usa Java 8 e PHP usa PHP 8.4. Estes editores não substituem o ambiente de uma cadeira: não incluem Minix, processos POSIX, MPI, Laravel ou pacotes de terceiros. O botão **Parar** termina a execução.