Forem: Enzo Lanze

Estrutura de dados: Set - Golang

Enzo Lanze — Fri, 19 Jul 2024 22:08:33 +0000

Olá Pessoal, tudo bem? Hoje quero trazer um conteúdo relacionado a Go, que consiste em criar uma estrutura de dados chamada `Set`. Vamos para a explicação!

Afinal, o que é um Set?

Set é um conjunto de dados linear que possui uma coleção de valores que não se repetem. Um Set pode armazenar valores exclusivos sem qualquer ordem específica.

Afinal, existe Set em Go?

A resposta é não. Em Go, não temos a estrutura de dados Set ou HashSet igual em Java ou C#, por exemplo. Mas a Hashicorp, uma grande empresa de tecnologia dona do Terraform, tem uma biblioteca que resolve esse tipo de problema para nós no mundo Go. Vou deixar o link do repositório no final do artigo.

Quais problemas Set resolve?

Verificação de pertinência: Conjuntos se sobressaem em verificar rapidamente se um elemento existe dentro deles. Isso ocorre porque os conjuntos geralmente usam técnicas de hash para pesquisas rápidas, oferecendo uma complexidade de tempo média de O(1) para verificação de pertinência.
Encontrando elementos únicos: Contar ou encontrar elementos distintos em uma lista se torna eficiente com conjuntos. Simplesmente adicione todos os elementos a um conjunto, e ele só conterá entradas exclusivas. Isso elimina a necessidade de loops de comparação complexos.
Operações de conjuntos: Conjuntos oferecem funções integradas para operações como união (combinar elementos de dois conjuntos), interseção (encontrar elementos comuns a dois conjuntos) e diferença (elementos em um conjunto, mas não no outro). Essas operações são muito úteis para manipulação e análise de dados.
Aqui estão alguns exemplos específicos de problemas onde os conjuntos podem ser uma ótima opção:
Encontrar elementos duplicados em uma lista: Adicione todos os elementos a um conjunto. Se o tamanho do conjunto for menor que o tamanho da lista original, há duplicados.
Encontrar a interseção de duas listas: Use a operação de interseção de conjuntos para encontrar elementos presentes em ambas as listas.
Identificando elementos frequentes em um conjunto de dados: Adicione elementos a um conjunto e conte suas ocorrências. O conjunto elimina duplicados, permitindo que você se concentre em elementos únicos e sua frequência.
Verificar se uma string é um palíndromo: Converta a string em um conjunto e verifique seu tamanho. Se o tamanho permanecer igual após remover duplicados, é um palíndromo (todos os caracteres aparecem apenas uma vez).

Certo, a explicação do código eu vou com uma abordagem nova que é explicar o fluxo dentro do código através dos comentários.

import "fmt"

// Criamos nossa estrutura para definir um map
type Set struct {
    integerMap map[int]bool
}

// Criamos nosso "construtor" para inicializar o map
func (s *Set) newSet() {
    s.integerMap = make(map[int]bool)
}

// Aqui temos a função que vai verificar se o elemento é false, por padrão é sempre falso, e se o elemento retornar false é porque esse valor não existe no nosso map e então podemos adicioná-lo. Mas se essa função retornar true, no nosso addElement ele nem vai adicionar ao mapa.
func (s *Set) containsElement(el int) bool {
    var exists bool
    _, exists = s.integerMap[el]
    return exists
}

// Responsável pela adição do elemento no mapa.
// Aqui, esse if verifica se o elemento contido é falso; se for falso, ele não tem uma duplicata e então pode ser adicionado à lista.
// Agora, se o resultado de contains for true, ele nem vai cair dentro desse if e por tanto não vai adicionar a lista.
func (s *Set) addElement(el int) {
    if !s.containsElement(el) {
        s.integerMap[el] = true
    }
}

// Aqui um delete simples
func (s *Set) deleteEl(el int) {
    delete(s.integerMap, el)
}

// Aqui damos um findAll que lista todos os elementos, sendo seu Big O O(n)
func (s *Set) allElements() {
    for k := range s.integerMap {
        fmt.Println(k)
    }
}

// Aqui temos a função que tem o length, que vai ser o tamanho do nosso integerMap, e a variável c, que pode ser chamada de collection, pois vai ser nossa coleção das chaves do nosso map, ou seja, uma lista.
// Dentro do nosso for, fazemos esse loop para descobrir se c[x] é maior do que c[n + 1], ou seja, a próxima posição na nossa lista.
// Criamos o initialValue que vai ser o valor em relação à posição da lista.
// Depois, atribuimos a c[x] o próximo valor da iteração, ou seja, c[x+1].
// E por fim, atribuimos o valor de c[x+1] = initialValue.
// Assim, fazemos com que os maiores valores da lista sejam trocados, jogando os maiores para o final da lista. O maior número SEMPRE tem que estar no fim da lista.
// Em outros termos, estamos fazendo uma ordenação por bolha ou bubblesort.
// Seu Big O é de O(n) no melhor caso e no pior caso é O(n^2).
// Mas sua complexidade espacial é muito boa, sendo O(1).
func (s *Set) maximumElements() {
    length := len(s.integerMap)

    c := s.allElements()

    for n := 0; x < length-1; x++ {
        if c[x] > c[x+1] {
            initialValue := c[x]
            c[x] = c[x+1]
            c[x+1] = initialValue
        }
    }
    maximumValue := c[length-1]
    fmt.Printf("MaximumValue: %d\n", maximumValue)
}

// Com a explicação do maximumElements, aqui é a mesma coisa,só que o menor número também tem que estar no final da lista.
func (s *Set) minumumElements() {

    c := s.allElements()
    length := len(s.integerMap)

    for x := 0; x < length-1; x++ {
        if c[x] < c[x+1] {
            initialValue := c[x]
            c[x] = c[x+1]
            c[x+1] = initialValue
        }
    }

    m := c[length-1]
    fmt.Printf("Minimum value %d\n", m)
}

// aqui temos nosso sizeOfSet que basicamente vai printar na tela o tamanho do nossa lista
func (s *Set) sizeOfSet() {
    fmt.Printf("Length of List: %v\n", len(s.allElements()))
}

func printValues(values []int) {

    fmt.Printf("List of Values: %v\n", values)
}

func main() {
    set := &Set{}
    set.newSet()
    set.addElement(3)
    set.addElement(6)
    set.addElement(8)
    set.addElement(9)
    set.addElement(10)
    set.addElement(14)
    set.addElement(3)
    set.addElement(2)
    set.addElement(14)

    values := set.allElements()
    printValues(values)

    set.maximumElements()
    set.minumumElements()

    fmt.Printf("Contains Value: %v\n", set.containsElement(1))

    set.sizeOfSet()

    set.deleteElements(14)
    set.deleteElements(2)
    fmt.Println("--------------------------------")
    valuesAfterDelete := set.allElements()
    set.maximumElements()
    set.minumumElements()
    printValues(valuesAfterDelete)
}

Resposta do console

List of Values: [8 9 10 14 2 3 6]
MaximumValue: 14
Minimum value: 2
Contains Value: false
Length of List: 7
--------------------------------
MaximumValue: 10
Minimum value: 3
List of Values: [9 10 3 6 8]

Pretendo trazer uma segunda parte falando sobre Intersect e Union, que é um assunto bastante interessante.

Por hoje é isso pessoal, espero que vocês tenham compreendido um pouco mais como utilizar os Sets em Go ou que também tenham entendido esse tema. Pretendo fazer uma Parte 2 sobre esse assunto. Boa noite e até a próxima!

Link do Repositório da Hashicorp: https://github.com/hashicorp/go-set
Site para entender melhor sobre BigO: https://www.bigocheatsheet.com/
Estou criando uma CLI que serve como uma ferramenta para acelerar sua produtividade em Go, dê uma olhada: https://github.com/YlanzinhoY/Sollievo

Event Loop - Parte 2

Enzo Lanze — Fri, 17 May 2024 21:48:41 +0000

Olá, pessoal, tudo bem? Como eu disse no último post do Event Loop, parte 1, eu iria trazer algum exemplo para explicar melhor, na prática, o que acontece com o Event Loop. Vamos lá.

Aqui temos um código que está mexendo diretamente com Futures (em breve terá o conteúdo mais aprofundado sobre Futures e async/await) e com nossas microtasks.
O código pode parecer confuso, mas vamos destrinchar o que está acontecendo aqui. Primeiro, temos uma conta aritmética padrão que vai imprimir nossa multiplicação. Abaixo do print(c), temos uma scheduleMicrotask. Qual você acha que vai executar primeiro? Se você viu a imagem na primeira parte, pode ver que ele executa primeiro o main(), tudo que é síncrono e depois escuta a fila de microtasks e de eventos. Ou seja, tudo que for síncrono é executado primeiro dentro do event loop, então nossos dois print() serão executados.
Depois, temos nosso scheduleMicrotask #1 que está solto dentro do main. Ele vai ser executado após nossos print() e depois temos dois Future, um com delay e outro sem delay. O Future sem delay será executado primeiro, e aqui temos algo que é uma "pegadinha". Você pode ver que ele tem um scheduleMicrotask dentro e pode pensar que essa microtask vai ser executada primeiro. Mas não! Por quê? Porque o Future vai passar pela função anônima primeiro, que é o print("future #2"), e depois vai executar o callback dele que está no then(). E aqui, não importa a ordem da scheduleMicrotask, ela sempre vai ser executada por último dentro de um Future, porque o event loop vai vê-la e vai agendá-la e depois que o Future terminar de executar ele dispara a fila de microtask.
E nosso proximo carinha é oFuture.delayed(), que nesse tempo de explicação ele acabou de terminar. Aqui vai acontecer a mesma coisa com o Future sem delay, ele vai executar o callback e depois agendar a microtask #2, e pronto, ela vai ser executada depois que o Future.delayed finalizar.
Deixei abaixo a resposta do log e vocês podem ver que tudo que está no future é executado primeiro, e as schedulesMicrotask seram agendadas pelo event loop e executadas depois.

import 'dart:async';

void main() {
const a = 10;
const b = 20;
const c = a * b;

print(c);

scheduleMicrotask(() => print("microtask #1"));

Future.delayed(Duration(seconds: 1), () => {
print("future #1"),
scheduleMicrotask(
() => print("Microtask #2"),
)}).then((_) => print("future #1b"));


Future(() => print("future #2")).then((_) => print("future #2b"))
    .then((_) => scheduleMicrotask(() => print("microtask #3")));

print(a / b);

}

200
0.5
microtask #1
future #2
future #2b
microtask #3
future #1
future #1b
Microtask #2

Por fim, é isso mesmo, galera. Finalizei essa parte dois e provavelmente será a última sobre o Event Loop em si, mas ainda temos vários outros assuntos sobre Dart que eu vou trazer nas próximas semanas.

Texto Feito por Enzo Lanzellotti
Revisado pelo Gemini

Event Loop - Parte 1

Enzo Lanze — Thu, 09 May 2024 01:12:12 +0000

O que é o Event looping?

Event Looping usa uma estrutura de dados chamada Queue, pense na queue como quando você vai a um drive-thru, você entra em uma fila de carros até ser atendido, ou seja, o primeiro a chegar é o primeiro a sair, certo? Isso chamamos de FIFO (First-in-first-out). O Dart usa as queue para agendar as tarefas e executá-las em sua isolate principal. O event loop tem 2 queues, uma para eventos e outra para microtasks.

A queue de eventos é usada para eventos quando você toca em alguma parte da tela ou quando você tem dados vindo de um servidor. Segue a imagem abaixo.

Como pode ser visto, nossa queue de microtask é sempre a prioridade dentro do event loop.

Tarefas síncronas na nossa isolate principal são sempre executadas imediatamente. Você não pode interrompê-las.

Se o Dart achar qualquer tarefa longa que concorde em ser adiada, Dart irá colocá-la na queue de eventos.

Quando o Dart termina de executar uma tarefa síncrona, o event loop checa a queue de microtask. Se a tarefa de microtask tiver alguma tarefa, o event loop as coloca na thread principal para executá-las. O event loop fica checando a queue de microtask até ela estar vazia.

Se uma tarefa síncrona e uma queue de microtask estiverem ambas vazias, o event loop deixará a próxima tarefa em espera para a event queue executar na thread principal. Uma vez na event queue, o código é executado de forma síncrona.

Se novas microtasks entrarem na queue de microtask, o event loop irá lidar com elas antes do próximo evento na fila de queues.

Esse processo continuará até que todas as queues estejam vazias.

Link da documentação do Dart em chinês para mais exemplos com event loop. https://dart.cn/articles/archive/event-loop
em resumo de toda essa explicação é que temos as queues de tarefas normais que podem ser adiadas e a de microtask, a de microtask sempre vai ser prioridade para o Event loop. Se você vem de uma linguagem como javascript usando Node.JS saiba que o event loop de la é bem parecido com o do Dart.

Essa foi a primeira parte do conteúdo sobre event loop, em breve irei trazer a segunda parte e com mais exemplos em código mesmo. Por enquanto, é mais uma teoria de como funciona. Espero vocês na segunda parte.

Const x Final em Dart. Você sabe a diferença?

Enzo Lanze — Fri, 03 May 2024 21:34:09 +0000

Em Dart, temos as palavras-chave `final` e `const`, o que pode parecer confuso à primeira vista, mas há uma diferença bem sutil entre elas, que é a seguinte:

const é imutável e é instanciada em tempo de compilação, ou seja, sempre antes do seu programa rodar, os valores constantes serão inseridos na memória, fazendo com que o compilador faça uma otimização inicial. Portanto, sempre que você tem certeza de que o valor de x nunca vai mudar, pode declará-lo como const.

const pi = 3.14;

final também é imutável, mas é instanciada em tempo de execução, ou seja, sempre que seu aplicativo estiver rodando você quer pegar um input do usuário, ou precisa fazer um fetch de valores vindo do servidor, qualquer valor que você não conhece, use o final.

final time = DateTime.now();

foi um Texto bem curtinho mas é sempre bom pra quem está começando no mundo do dart/flutter, aprender essa diferença logo de cara, estudem dart antes do flutter, sempre!

Patterns no Terminal: Desvende a Magia da Arte ASCII com Star Pattern, Number Pattern e Mais! Usando Dart 🔵💙

Enzo Lanze — Mon, 29 Apr 2024 16:34:59 +0000

Olá, Bugmakers! Tudo bem? Hoje, vamos desvendar o mundo dos patterns, algoritmos que transformam seu terminal em uma tela de arte! Preparem-se para criar desde estrelinhas brilhantes (Star Pattern) ✨ até números mágicos (Number Pattern)! E para começar, vamos desenhar uma borboleta encantadora (Butterfly Pattern)!

Este pattern cria uma linda borboleta usando estrelas (como o nome sugere) no seu terminal. 🦋

main() {
  int n = 5;

  for (var i = 1; i <= n; i++) {
    for (int j = 1; j <= i; j++) {
      stdout.write("*");
    }

    for (int k = 1; k <= 2 * (n - i); k++) {
      stdout.write(" ");
    }

    for (var l = 1; l <= i; l++) {
      stdout.write("*");
    }
    print("");
  }

  for (var i = n; i >= 1; i--) {
    for (int j = 1; j <= i; j++) {
      stdout.write("*");
    }

    for (int k = 1; k <= 2 * (n - i); k++) {
      stdout.write(" ");
    }

    for (var l = 1; l <= i; l++) {
      stdout.write("*");
    }
    print("");
  }
}

Como podemos ver, esse é um código bem extenso. Temos duas partes: na primeira, iteramos com i++, e na segunda, decrementamos com i--. O restante do código é igual nas duas partes. Não vou explicar o fluxo completo aqui, pois o post ficaria muito extenso. No entanto, é importante entender que a variável n representa a quantidade de linhas que serão impressas no terminal. Isso ficará mais claro em outros exemplos, onde utilizei o nome lines. Neste exemplo, vamos analisar a conta matemática para imprimir os espaços em branco. Observando os loops, a estrutura for parece simples para quem já está familiarizado com ela. Vejamos a primeira conta como exemplo.

## primeira iteração
5 - 1 = 4
2 x 4 = 8

## segunda
5 - 2 = 3 
2 x 3 = 6

## terceira
5 - 3 = 2
2 x 2 = 4

## quarta 
5 - 4 = 1
2 x 1 = 2

## 5 e ultima
5 - 5 = 0
2 x 0 = 0

Pronto, o primeiro resultado deu 8. Ou seja, se você quiser contar os espaços, temos 8 espaços entre a estrela da esquerda e a da direita neste primeiro loop. Lembrando que quem imprime as estrelas são os laços J e L.

*        *
**      **
***    ***
****  ****
**********
**********
****  ****
***    ***
**      **
*        *

Agora, vamos para o Diamond Pattern! Como o nome sugere, este pattern imprime um diamante no seu terminal. Embora seja mais simples que o Butterfly Pattern, a lógica é a mesma: loops para linhas, espaços em branco e estrelas.

main() {
  int lines = 4;

  for (var i = 1; i <= lines; i++) {
    for (var j = 1; j <= lines - i; j++) {
      stdout.write(" ");
    }
    for (int k = 1; k <= 2 * i - 1; k++) {
      stdout.write("*");
    }
    print("");
  }

  for (var i = lines; i >= 1; i--) {
    for (var j = 1; j <= lines - i; j++) {
      stdout.write(" ");
    }
    for (int k = 1; k <= 2 * i - 1; k++) {
      stdout.write("*");
    }
    print("");
  }
}

Podemos ver que o loop k possui uma conta aritmética para imprimir as estrelas. Se você analisar, verá que a conta está correta. Na primeira iteração, o i vale 1 e a conta fica fácil. Vejamos o exemplo.

## primeira iteração
i = 1 
2 x i - 1 = 1

## segunda
i = 2 
2 x i - 1 = 3

## terceira

i = 3
2 x i - 1 = 5

# quarta e ultima
i = 4 
2 x i - 1 = 7

Este resultado é a primeira parte do diamante. A segunda parte consiste em decrementar nosso i até que ele seja igual a lines, obtendo assim o resultado final.

   *
  ***
 *****
*******
*******
 *****
  ***
   *

Chegamos ao fim deste post! Ainda vou pegando o ritmo de como fazer postagem, mas ainda há muitos outros padrões que quero abordar, como o "hollow rectangle". Prometo trazer mais conteúdo sobre algoritmos em Dart para enriquecer nossa comunidade. E quando eu desenvolver um projeto legal, prometo publicar aqui no dev.to o passo a passo completo. Até a próxima, devs!

qualquer explicação errada que eu tenha me equivocado, deixe aqui nos comentários, vamos aprender juntos. 👊🏻💙

Escrito por Enzo Lanzellotti.
Revisado pelo Gemini.