[PROIBIDO PARA SENIORS] - Porque você deve sempre questionar o ChatGPT, e porque juniors certamente terão dificuldades em fazer isso
Vamos imaginar um exemplo louco, aqui: eu tenho um conjunto com X palavras, organizadas aleatoriamente, e quero organiza-las como se fosse um jogo de dominó, onde a última letra de uma palavra precisa ser idêntica à primeira letra da palavra seguinte, como no exemplo abaixo:
>>> ESTADO - OVO - ORGANIZAR - RAQUETE - ELUCIDAR - REVÉS - SANTOS - SUBIDA - AMORA - ...
Pedi ao ChatGPT para criar um código em Python que realize essa organização. A resposta foi essa:
import random
def organizar_palavras(banco_palavras):
palavra_inicial = random.choice(banco_palavras)
banco_palavras.remove(palavra_inicial)
resultado = [palavra_inicial]
while banco_palavras:
ultima_letra = resultado[-1][-1]
proxima_palavra = None
for palavra in banco_palavras:
if palavra[0] == ultima_letra:
proxima_palavra = palavra
break
if proxima_palavra:
resultado.append(proxima_palavra)
banco_palavras.remove(proxima_palavra)
else:
break
return resultado
Se você estudou Análise de Algoritmos, já deve ter percebido qual é o problema. Para localizar a próxima palavra na ordenação, os nossos dois laços percorrem o conjunto todo!
Se o nosso conjunto tem 10 palavras, são 100 iterações; para 100 palavras, 10.000 iterações; para 10.000 palavras...
Entendeu? O negócio escala exponencialmente. E isso é horrível em termos de processamento. Imaginem só 100 mil usuarios acessando a nossa aplicação ao mesmo tempo? Não basta pedir pro tiozinho da infra escalar máquina. A pergunta é: "vai sair do bolso de quem?" 🤡
Então perguntei ao ChatGPT se não haveria uma solução mais econômica (a.k.a. com menor complexidade) para este problema. Só então o Gepeto propos algo melhor:
#Gepeto: "Sim, podemos melhorar a complexidade de tempo
#utilizando um grafo direcionado para representar as conexões
#entre as palavras. Dessa forma, podemos usar uma busca em
#profundidade (DFS) para encontrar uma ordem válida.
#A complexidade de tempo será O(n), onde n é o número de palavras.
#Aqui está uma implementação usando esse conceito:"
from collections import defaultdict
def construir_grafo(banco_palavras):
grafo = defaultdict(list)
for palavra in banco_palavras:
grafo[palavra[0]].append(palavra)
return grafo
def busca_em_profundidade(grafo, palavra, visitados, resultado):
resultado.append(palavra)
visitados.add(palavra)
for proxima_palavra in grafo[palavra[-1]]:
if proxima_palavra not in visitados:
busca_em_profundidade(grafo, proxima_palavra, visitados, resultado)
def organizar_palavras(banco_palavras):
grafo = construir_grafo(banco_palavras)
resultado = []
for palavra in banco_palavras:
visitados = set()
busca_em_profundidade(grafo, palavra, visitados, resultado)
if len(resultado) == len(banco_palavras):
return resultado
return None
Ou seja
Por mais que LLMs sejam boas geradoras de código, ainda é necessário conhecimento por parte de quem utiliza a ferramenta, ou os resultados podem ser catastróficos. Ou então você sempre estará refem da máxima: "você não sabe o que você não sabe". Afinal, como você vai questionar a complexidade do código se você sequer sabe da existência disso?
Reforço aqui a necessidade em mergulharmos na teoria: engenharia, arquitetura, como funcionam as linguagens, VMs, compiladores... Só assim teremos condições de utilizar essas novas ferramentas e extrair o melhor delas.
DICAS DE ESTUDO RELACIONADAS AO TEXTO
- Análise de algoritmos
- Teoria dos grafos
- Busca em profundidade
SOBRE O "PROIBIDO PARA SENIORS"
O objetivo dessa série é trazer assuntos que já são de domínio de quem já tem mais experiência na área, mas que ainda podem ser pouco claro aos iniciantes. Conto com o feedback de seniores e juniores. Mas que os seniors lembrem: aqui é proibido para vocês! :)