🚀 **Depurando Blocos de Código (xBase)** 🚀 Interessante a abordagem de **Blocos de Código** no **Harbour**! Eles funcionam literalmente como "cidadãos de primeira classe", permitindo até mesmo depuração passo a passo. 🔍 **Exemplo Prático:** ```xBase Eval( {|aFunTst as array| LOCAL lValid AS LOGICAL LOCAL i AS NUMERIC FOR i := 1 TO Len(aFunTst) // Verifica resultado esperado lValid := aFunTst[i][3] IF lValid SetColor("g+/n") QOut("(" + aFunTst[i][2] + "): passed") SetColor("") ELSE SetColor("r+/n") QOut("(" + aFunTst[i][2] + "): failed") SetColor("") ENDIF NEXT i RETURN NIL }, aFunTst ) ``` 🤔 **Pergunta aos escovadores de bit de plantão:** É pos...
_Créditos das imagens: ChatGPT
A seguir, apresento uma análise detalhada do desafio [Valid Parentheses](https://leetcode.com/problems/valid-parentheses/description/) do LeetCode e como ele foi implementado em Harbour em três soluções distintas. Confira o artigo abaixo!
---
## Introdução
O desafio "Valid Parentheses" propõe que, dada uma _string_ contendo apenas os caracteres `(`, `)`, `{`, `}`, `[` e `]`, determine se a _string_ é válida. Para ser considerada válida, a _string_ deve obedecer a duas regras:
- Cada parêntese de abertura deve ser fechado pelo mesmo tipo de parêntese;
- A ordem de abertura e fechamento deve ser correta.
Em termos de prática, o problema pode ser resolvido de diversas formas, como utilizando uma estrutura de _stack_ (pilha) ou, alternativamente, técnicas de substituição com expressões regulares.
---
## Soluções Propostas em Harbour
Foram disponibilizadas três soluções em Harbour, cada uma com sua abordagem e particularidades. Abaixo, destrinchamos cada uma delas:
### Solução 1: Abordagem com Pilha Tradicional
**Link (raw):**
[valid_parentheses.20.1.prg](https://raw.githubusercontent.com/naldodj/naldodj-xbase-leetcode-solutions/refs/heads/main/src/hb/020/valid_parentheses.20.1.prg)
**Link (GitHub):**
[valid_parentheses.20.1.prg](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/020/valid_parentheses.20.1.prg)
Nesta solução, a estratégia adotada é a clássica utilização de uma pilha para armazenar os parênteses de abertura. Conforme o programa percorre a _string_, ele:
- **Empilha** os caracteres de abertura.
- Ao encontrar um caractere de fechamento, verifica se o topo da pilha contém o par correspondente.
- Se houver discrepância ou se a pilha estiver vazia quando um fechamento for encontrado, a _string_ é considerada inválida.
- Ao final, se a pilha estiver vazia, significa que todos os parênteses foram devidamente fechados.
Essa abordagem é bastante intuitiva e reflete a lógica que muitos programadores aplicam para resolver problemas semelhantes.
---
### Solução 2: Pilha com Interrupção Antecipada
**Link (raw):**
[valid_parentheses.20.2.prg](https://raw.githubusercontent.com/naldodj/naldodj-xbase-leetcode-solutions/refs/heads/main/src/hb/020/valid_parentheses.20.2.prg)
**Link (GitHub):**
[valid_parentheses.20.2.prg](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/020/valid_parentheses.20.2.prg)
A segunda versão também utiliza uma estrutura de pilha, porém com uma leve modificação: a utilização do bloco `begin sequence` para interromper imediatamente a execução do laço assim que um erro de correspondência é detectado. Dessa forma, a função:
- Realiza o empilhamento e desempilhamento conforme o caractere analisado.
- Se detectar um fechamento sem um correspondente ou um par incorreto, utiliza o `break` para sair do laço e retornar `false` imediatamente.
- Ao final, a _string_ é considerada válida se a pilha estiver vazia.
Essa abordagem é útil para cenários em que a detecção antecipada de um erro pode reduzir o tempo de processamento, principalmente em entradas de tamanho maior.
---
### Solução 3: Abordagem com Expressão Regular
**Link (raw):**
[valid_parentheses.20.3.prg](https://raw.githubusercontent.com/naldodj/naldodj-xbase-leetcode-solutions/refs/heads/main/src/hb/020/valid_parentheses.20.3.prg)
**Link (GitHub):**
[valid_parentheses.20.3.prg](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/020/valid_parentheses.20.3.prg)
A terceira solução adota uma estratégia diferente, utilizando expressões regulares para remover pares válidos de parênteses iterativamente:
- Define uma _pattern_ que casa os pares `()`, `[]` e `{}`.
- Em um laço `while`, a função utiliza `hb_regexReplace` para remover todas as ocorrências desses pares.
- O processo se repete até que não seja mais possível realizar substituições.
- Se, ao final, a _string_ se tornar vazia, então todos os pares foram corretamente identificados e removidos, e a _string_ é válida.
Essa abordagem é interessante por sua elegância e por demonstrar o poder das expressões regulares na simplificação de problemas que, à primeira vista, poderiam parecer complexos.
---
## Comparativo e Considerações
- **Complexidade e Legibilidade:**
A primeira e a segunda soluções seguem o padrão clássico de uso de pilha, que é bastante didático e fácil de entender para a maioria dos programadores. A segunda versão, entretanto, otimiza o processo ao interromper o loop imediatamente após identificar uma inconsistência.
- **Performance:**
Em termos de performance, ambas as soluções baseadas em pilha oferecem uma complexidade linear (O(n)). A versão com expressões regulares, embora elegante, pode ter um desempenho variável dependendo da implementação interna da função `hb_regexReplace` e do tamanho da _string_ de entrada.
- **Abordagens Alternativas:**
A terceira solução demonstra como o uso de expressões regulares pode simplificar a lógica do algoritmo. No entanto, é importante testar essa abordagem com diferentes conjuntos de dados, já que, para entradas maiores, o custo computacional de múltiplas substituições pode ser relevante.
---
## Conclusão
Cada uma das três soluções em Harbour para o desafio "Valid Parentheses" apresenta vantagens e sutilezas que podem ser exploradas conforme a necessidade do projeto. Se você busca clareza e desempenho imediato, as abordagens com pilha (soluções 1 e 2) são recomendadas. Por outro lado, se a elegância e a utilização de ferramentas poderosas como expressões regulares são prioridade, a terceira solução é uma excelente demonstração de como simplificar a lógica de validação.
Para mais detalhes e para conferir o código-fonte completo, acesse os links a seguir:
- **Solução 1:**
[Raw](https://raw.githubusercontent.com/naldodj/naldodj-xbase-leetcode-solutions/refs/heads/main/src/hb/020/valid_parentheses.20.1.prg) | [GitHub](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/020/valid_parentheses.20.1.prg)
- **Solução 2:**
[Raw](https://raw.githubusercontent.com/naldodj/naldodj-xbase-leetcode-solutions/refs/heads/main/src/hb/020/valid_parentheses.20.2.prg) | [GitHub](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/020/valid_parentheses.20.2.prg)
- **Solução 3:**
[Raw](https://raw.githubusercontent.com/naldodj/naldodj-xbase-leetcode-solutions/refs/heads/main/src/hb/020/valid_parentheses.20.3.prg) | [GitHub](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/020/valid_parentheses.20.3.prg)
---
## Hashtags
#Harbour, #LeetCode, #ValidParentheses, #Algoritmos, #Programação, #XBase, #Desenvolvimento, #ExpressaoRegular, #Stack, #Tecnologia
---
Esperamos que este artigo tenha esclarecido as diferentes abordagens para o desafio e oferecido insights valiosos para desenvolvedores que desejam aprimorar suas habilidades em Harbour e resolução de problemas algorítmicos. Bora codar!!!
---
Comentários
Postar um comentário