BlackTDN :: LeetCode (18) :: Resolvendo o Desafio 4Sum do LeetCode em Harbour e TLPP

_Créditos das imagens: ChatGPT_

# Resolvendo o Desafio 4Sum do LeetCode em Harbour e TLPP

O desafio [**4Sum** do LeetCode](https://leetcode.com/problems/4sum/) é um problema clássico de algoritmos que envolve encontrar todas as quadruplas únicas em um array de números que somam a um valor alvo. Neste artigo, vamos explorar duas implementações desse desafio em **Harbour** e **TLPP (TOTVS Language Plus Plus)**, duas linguagens de programação baseadas em xBase.

---

## O Problema 4Sum

O problema consiste em:

- Dado um array de números inteiros `nums` e um valor alvo `target`, encontrar todas as quadruplas únicas `[nums[a], nums[b], nums[c], nums[d]]` tais que:
  - `0 <= a, b, c, d < n` (onde `n` é o tamanho do array).
  - `a`, `b`, `c` e `d` são índices distintos.
  - A soma dos elementos nas posições `a`, `b`, `c` e `d` é igual ao `target`.

### Exemplos

1. **Entrada**: `nums = [1, 0, -1, 0, -2, 2]`, `target = 0`  
   **Saída**: `[[-2, -1, 1, 2], [-2, 0, 0, 2], [-1, 0, 0, 1]]`

2. **Entrada**: `nums = [2, 2, 2, 2, 2]`, `target = 8`  
   **Saída**: `[[2, 2, 2, 2]]`

---

## Soluções Implementadas

Abaixo, descrevemos as soluções implementadas em **Harbour** e **TLPP**, com links para os códigos completos.

### Solução em Harbour

Harbour é uma linguagem de programação moderna e multiplataforma, compatível com Clipper e xBase. As soluções implementadas em Harbour seguem uma abordagem de **dois ponteiros** para otimizar a busca por quadruplas.

#### Implementação 1
- **Link**: [4Sum.18.1.prg](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/018/4sum.18.1.prg)
- **Descrição**: Esta solução utiliza loops aninhados e a técnica de dois ponteiros para encontrar as quadruplas. O array é ordenado para facilitar a busca e evitar duplicatas.

#### Implementação 2
- **Link**: [4Sum.18.2.prg](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/018/4sum.18.2.prg)
- **Descrição**: Uma variação da primeira implementação, com pequenas otimizações e ajustes para melhorar a legibilidade e eficiência.

### Solução em TLPP (TOTVS Language Plus Plus)

TLPP é uma linguagem de programação utilizada no desenvolvimento de sistemas corporativos, baseada em xBase e amplamente utilizada no ecossistema TOTVS. As soluções em TLPP seguem uma lógica semelhante às implementações em Harbour.

#### Implementação 1
- **Link**: [4Sum.18.1.tlpp](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/tlpp/018/4sum.18.1.tlpp)
- **Descrição**: Utiliza loops aninhados e a técnica de dois ponteiros, com a ordenação do array para garantir a eficiência e evitar duplicatas.

#### Implementação 2
- **Link**: [4Sum.18.2.tlpp](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/tlpp/018/4sum.18.2.tlpp)
- **Descrição**: Uma versão otimizada da primeira implementação, com foco em reduzir o número de operações e melhorar o desempenho.

---

## Estratégia Comum

Ambas as soluções (em Harbour e TLPP) seguem uma estratégia comum:

1. **Ordenação do Array**: O array é ordenado para facilitar a busca e evitar duplicatas.
2. **Loops Aninhados**: Dois loops externos são usados para fixar os dois primeiros números da quadrupla.
3. **Dois Ponteiros**: Dois ponteiros são usados para percorrer o restante do array e encontrar os dois números que completam a quadrupla.
4. **Evitar Duplicatas**: Após encontrar uma quadrupla válida, os ponteiros são ajustados para evitar duplicatas.

---

## Links dos Códigos Completos

- **Harbour**:
  - [4Sum.18.1.prg](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/018/4sum.18.1.prg)
  - [4Sum.18.2.prg](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/018/4sum.18.2.prg)

- **TLPP**:
  - [4Sum.18.1.tlpp](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/tlpp/018/4sum.18.1.tlpp)
  - [4Sum.18.2.tlpp](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/tlpp/018/4sum.18.2.tlpp)

---

## Conclusão

As implementações em Harbour e TLPP demonstram como resolver o problema **4Sum** de forma eficiente, utilizando técnicas como ordenação, loops aninhados e dois ponteiros. Essas soluções são adaptáveis e podem ser utilizadas como referência para resolver problemas semelhantes em outras linguagens de programação.

---

## Hashtags Relacionadas

#LeetCode, #4Sum, #Harbour, #TLPP, #TOTVS, #xBase, #Algoritmos, #Programação, #Desafios, #DoisPonteiros