Setup

Pipfile

@@ -6,6 +6,8 @@ name = "pypi"
 [packages]
 pytest = "*"
 pytest-django = "*"
+numpy = "*"
+qiskit = "*"
 
 [dev-packages]
 flake8 = "*"

algorithms_project/algorithms/arrays/exponential_search.py → algorithms_project/algorithms/binary_search/exponential_search.py

@@ -10,6 +10,7 @@
   muito grande caso o índice acessado esteja fora do limite.
 """
 
+
 # Simula o ArrayReader do LeetCode
 class ArrayReader:
     def __init__(self, arr):
@@ -105,3 +106,4 @@ def search(self, reader: ArrayReader, target: int) -> int:
 
         # Target não encontrado
         return -1
+

algorithms_project/algorithms/hashing/first_uni_char.py

@@ -0,0 +1,35 @@
+class Solution:
+    # Define uma classe chamada Solution (estrutura comum usada no LeetCode)
+    def firstUniqChar(self, s: str) -> int:
+        # Método que recebe uma string 's' e retorna o índice do primeiro caractere único
+        # (que aparece apenas uma vez). Se não houver, retorna -1.
+
+        d = {}
+        # Cria um dicionário vazio 'd' que vai armazenar cada caractere da string
+        # como chave, e como valor uma lista [índice, contagem].
+
+        for idx, ch in enumerate(s):
+            # Percorre cada caractere 'ch' da string 's', junto com seu índice 'idx'.
+
+            if not d.get(ch):
+                # Se o caractere ainda não existe no dicionário...
+
+                d[ch] = [idx, 1]
+                # Adiciona o caractere no dicionário com:
+                # [índice da primeira ocorrência, contagem inicial 1].
+
+            else:
+                d[ch][1] += 1
+                # Caso o caractere já esteja no dicionário, incrementa a contagem em +1.
+
+        for ch, val in d.items():
+            # Percorre os pares (caractere, [índice, contagem]) armazenados no dicionário.
+
+            if val[1] == 1:
+                # Se a contagem (val[1]) for igual a 1, significa que o caractere é único.
+
+                return val[0]
+                # Retorna o índice (val[0]) da primeira ocorrência desse caractere único.
+
+        return -1
+        # Se não encontrar nenhum caractere único, retorna -1.

algorithms_project/algorithms/sliding_window/contains_duplicate.py

@@ -1,23 +1,34 @@
 class Numsolution(object):
     def containnumsNearbyDuplicate(self, nums, k):
         """
+        Verifica se existe algum par de elementos duplicados na lista 'nums'
+        tal que os índices desses elementos estejam a no máximo 'k' posições de distância.
+
         :type nums: List[int]
         :type k: int
         :rtype: bool
         """
 
+        # Começamos com o primeiro índice da lista
         i = 0
 
+        # Loop externo percorre cada elemento da lista como possível "primeiro duplicado"
         while i < len(nums):
+            # 'j' começa logo após 'i' e vai até 'i + k' ou até o final da lista
             j = i + 1
             while j <= i + k and j < len(nums):
+                # Imprime quais elementos estão sendo comparados (útil para depuração)
                 print(f'Comparando nums[{i}] = {nums[i]} com nums[{j}] = {nums[j]}')
+
+                # Se encontrar duplicata dentro da janela de tamanho k, retorna True
                 if nums[i] == nums[j]:
                     return True
+
+                # Avança o segundo índice
                 j += 1
+
+            # Avança o primeiro índice
             i += 1
+
+        # Se percorreu toda a lista e não encontrou duplicatas próximas, retorna False
         return False
-
-
-numsolution = Numsolution()
-print(numsolution.containnumsNearbyDuplicate([1, 2, 3, 1], 3))

algorithms_project/tests/test_arrays/test_exponential_search.py

@@ -1,5 +1,5 @@
 import pytest
-from algorithms_project.algorithms.arrays.exponential_search import Solution, ArrayReader
+from algorithms_project.algorithms.binary_search.exponential_search import Solution, ArrayReader
 
 
 @pytest.mark.parametrize("array,target,expected", [

algorithms_project/tests/test_binary_search/test_binarysearch.py

@@ -1,5 +1,5 @@
 import pytest
-from algorithms.arrays.binary_search import Binary
+from algorithms_project.algorithms.binary_search.binary_search import Binary
 
 
 @pytest.mark.parametrize("array,target,expected", [

algorithms_project/tests/test_hashing/test_contains_duplicated.py

@@ -0,0 +1,13 @@
+import pytest
+from algorithms_project.algorithms.sliding_window.contains_duplicate import Numsolution
+
+
+array = [1, 2, 3, 1]
+k = 3
+result = Numsolution().containnumsNearbyDuplicate(array,k)
+
+@pytest.mark.parametrize("array,k,expected", [
+    (array,k,result),
+])
+def test_contains_duplicated(array, k, expected):
+    assert Numsolution().containnumsNearbyDuplicate(array,k) == expected

algorithms_project/tests/test_hashing/test_first_uni_char.py

@@ -0,0 +1,21 @@
+import pytest
+from algorithms_project.algorithms.hashing.first_uni_char import Solution
+
+
+st = "leetcode"
+ex = Solution().firstUniqChar("leetcode")
+
+@pytest.mark.parametrize("string,expected", [
+    (st, ex),
+])
+def test_exponential_search(string, expected):
+    assert Solution().firstUniqChar(string) == expected
+
+st = "loveleetcode"
+ex = Solution().firstUniqChar("loveleetcode")
+
+@pytest.mark.parametrize("string,expected", [
+    (st, ex),
+])
+def test_exponential_search1(string, expected):
+    assert Solution().firstUniqChar(string) == expected