BlackTDN :: LetCode 26 :: Remove Duplicates from Sorted Array

_Créditos das imagens: ChatGPT/Sora
# 🧠 Removendo Duplicatas de Arrays Ordenados em xBase: Duas Abordagens, Um Desafio

O problema "Remove Duplicates from Sorted Array" do LeetCode é um clássico que testa a habilidade de manipular arrays de forma eficiente. A proposta é simples: dado um array ordenado, remover os elementos duplicados in-place, mantendo a ordem e retornando a quantidade de elementos únicos. 

Neste artigo, exploramos duas implementações distintas em xBase (Harbour), disponíveis no repositório [naldodj-xbase-leetcode-solutions](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/026/README.md). Ambas resolvem o mesmo problema, mas adotam estratégias diferentes.

---

## 🧩 Entendendo o Problema

O desafio consiste em modificar o array original para que os primeiros `k` elementos sejam únicos, mantendo a ordem original. Os elementos após `k` não são relevantes. 

- **Entrada:** `[0,0,1,1,1,2,2,3,3,4]`
- **Saída esperada:** `[0,1,2,3,4,_,_,_,_,_]` com `k = 5`

---

## 🧪 Implementação 1: Abordagem com XOR e Otimização para Arrays Ordenados

📄 Código-fonte: [remove_duplicates_from_sorted_array.26.1.prg](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/026/remove_duplicates_from_sorted_array.26.1.prg)

Esta versão utiliza uma função chamada `RemoveDuplicates` que recebe parâmetros adicionais:

- `lIsOrdered`: indica se o array está ordenado.
- `lForceTheIncreasingOrder`: força a ordenação crescente se necessário.
- `lUseXor`: utiliza a operação XOR para comparação de elementos. 

A lógica principal percorre o array, comparando elementos adjacentes e removendo duplicatas. Se o array não for ordenado e `lForceTheIncreasingOrder` for verdadeiro, o array é ordenado após a remoção das duplicatas. 

**Pontos-chave:**

- Utiliza `hb_bitXor` para comparar elementos, o que pode ser eficiente em determinados contextos.
- Adiciona "_" nas posições excedentes após a remoção.
- Flexível para arrays não ordenados, com opção de forçar ordenação.

---

## 🔁 Implementação 2: Abordagem Simples com Índices

📄 Código-fonte: [remove_duplicates_from_sorted_array.26.2.prg](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/026/remove_duplicates_from_sorted_array.26.2.prg)

Esta versão adota uma abordagem mais direta:

- Inicializa um índice `j` para rastrear a posição do próximo elemento único.
- Percorre o array com índice `i`, verificando se o elemento atual já existe entre os elementos únicos identificados.
- Se for único, incrementa `j` e atualiza a posição correspondente.
- Após o processamento, preenche as posições restantes com "_".

**Pontos-chave:**

- Mais simples e direta, facilitando a leitura e manutenção.
- Menos parâmetros e lógica mais enxuta.
- Adequada para arrays ordenados, conforme a premissa do problema. 

---

## ⚖️ Comparativo entre as Implementações

| Aspecto                     | Implementação 1                                     | Implementação 2                         |
|-----------------------------|-----------------------------------------------------|-----------------------------------------|
| Complexidade                | Alta (uso de XOR e múltiplos parâmetros)            | Baixa (lógica simples com índices)      |
| Flexibilidade               | Alta (suporta arrays não ordenados)                 | Média (focada em arrays ordenados)      |
| Legibilidade                | Média (lógica mais complexa)                        | Alta (código mais limpo e direto)       |
| Eficiência                  | Potencialmente maior em cenários específicos        | Suficiente para a maioria dos casos     | 

---

## 🧠 Conclusão

Ambas as implementações resolvem o problema proposto, cada uma com suas particularidades. A escolha entre elas depende do contexto e dos requisitos específicos:

- Se busca flexibilidade e suporte a arrays não ordenados, a **Implementação 1** é mais adequada.
- Se prioriza simplicidade e legibilidade, especialmente para arrays ordenados, a **Implementação 2** é recomendada. 

Explorar diferentes abordagens para um mesmo problema é uma excelente forma de aprimorar habilidades de programação e entender as nuances de desempenho e legibilidade.

---

## 🔗 Links Úteis

- 📝 [README.md](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/026/README.md)
- 💻 [Implementação 1](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/026/remove_duplicates_from_sorted_array.26.1.prg)
- 💻 [Implementação 2](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/026/remove_duplicates_from_sorted_array.26.2.prg)

---

## 🏷️ Hashtags

#xBase #HarbourLang #LeetCode #Algoritmos #Programação #Desenvolvimento #Arrays #RemoçãoDeDuplicatas #CódigoLimpo #EficiênciaComputacional

--- 

Comentários

Postagens mais visitadas