Pular para o conteúdo principal

Postagem em destaque

Postado por

BlackTDN :: Multiplicação Chinesa vs. Russa :: Técnicas Antigas e Implementação em xBase

_Créditos das imagens: Grok # Multiplicação Chinesa vs. Russa: Técnicas Antigas e Implementação em xBase A matemática sempre nos presenteia com métodos criativos para resolver problemas aparentemente simples. Duas técnicas fascinantes para a multiplicação de números – a **Multiplicação Chinesa** e a **Multiplicação Russa** – demonstram que, mesmo sem o uso das convenções modernas, é possível chegar a resultados corretos através de abordagens alternativas. Neste artigo, vamos comparar essas duas técnicas, ilustrar seus processos com exemplos gráficos e discutir como foram implementadas em xBase, ampliando os horizontes para o processamento de números muito grandes. A multiplicação é uma operação fundamental na matemática, e diferentes culturas desenvolveram métodos únicos para realizá-la. Neste artigo, exploraremos duas técnicas fascinantes: a **multiplicação chinesa** (baseada em grids/lattice) e a **multiplicação russa** (também conhecida como "multiplicação camponesa"),...
Postar um comentário
Leia mais
Marcadores
Postado por

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
Enviar esta postagem
Marcadores:

Comentários

Postar um comentário

Postagens mais visitadas