Anotações da faculdade - Matemática - Teoria dos conjuntos
Published: 2024-05-21 17:56:40

### Testando algumas linguagens de programação para expressar um conjunto.

## F = {x | x² = 9}

O conjunto de valores de x, tal que x² = 9, é o conjunto {-3; 3}.

---

### Python

A primeira coisa que lembrei foi como a expressão do conjuntos `F = {x | x² = 9` era parecida com python.

Python consegue fazer comprehension de diversas estruturas como listas, dicionários e conjuntos e fica muito parecido com a notação matemática.

A sintaxe é bem simples e ocupa pouquíssimo espaço no código e eu não preciso dizer que quero um conjunto como resultado final pois o uso de chaves {} já determina isso.

```python
set = {x for x in range(-10, 10) if x ** 2 == 9}

print(set)
```

```bash
{-3, 3}
```

---

### Elixir

Como trabalho com Elixir foi natural usa-la em sequencia para resolver o mesmo problema. Usando a estrutura **for** de 3 argumentos e a sintaxe inline do **for** é possível ter o mesmo resultado do python de forma simples e elegante.

Elixir também é capaz de fazer comprehension em diversas estruturas como listas, mapas e conjuntos.

Não fica tão parecido com a notação matemática mas é simples de de fácil compreensão.
import java.util.HashSet;
import java.util.Set;
Nota: Eu poderia ter usado o **for** de 2 argumentos o resultado seria uma lista, então usei o terceiro argumento, `into: MapSet.new()`, para que o resultado final fosse um conjunto.

```elixir
set = for x <- -10..10, x ** 2 == 9, into: MapSet.new(), do: x

IO.inspect(set)
```

```bash
MapSet.new([-3, 3])
```

---

### Java

Java não fornece uma construção sintática para este conceito, então o que podemos fazer é usar o **for** tradicional com os tipos HashSet e Set para termos o nosso conjunto. Java também não usa o operador de potenciação `**` como Python e Elixir então chamamos `Math.pow` para isso.

```java
import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();

        for (int i = -10; i < 10; i++) {
            if (Math.pow(i, 2) == 9) {
                set.add(i);
            }
        }
        System.out.println(set);
    }
}

```

```bash
[-3, 3]
```

---

### JavaScript

Essa aqui eu pedi para o ChatGPT fazer pra mim 😅.

JavaScript também não possui uma construção sintática para comprehension, então usamos o bom e velho for tradicional e o tipo Set para termos um conjunto.

Nota: Existia uma proposta para incluir list comprehension em JavaScript mas nunca chegou a ser incorporado oficialmente.

```javascript
let set = new Set();

for (let i = -10; i <= 10; i++) {
  if (i ** 2 === 9) {
    set.add(i);
  }
}

console.log(set);
```

```bash
{ -3, 3 }
```

---

### Lua

Aproveitando que mexi com Lua recentemente então nada mais justo do que incluir uma versão em Lua.

Lua não possui estruturas como listas, conjuntos e tuplas como outras linguagens, apenas tabelas, que são parecidas como os arrays e são usadas para tudo na linguagem, construção de módulos, classes, estruturas de chave-valor e etc. Então aqui um "conjunto" nada mais é que uma tabela. Usamos o **for** para ir inserindo os valores no nosso conjunto e no final para imprimir de maneira formatada os valores na tela.

```lua
local write = io.write
local set = {}

for x = -10, 10 do
    if x ^ 2 == 9 then
        table.insert(set, x)
    end
end

write("{")
for i, v in ipairs(set) do
    write(v)
    if i < #set then
        write(", ")
    end
end
write("}")

```

```bash
{-3, 3}
```