adding algo

src/my_project/interviews/top_150_questions_round_22/ex_97_combinations.py

@@ -0,0 +1,22 @@
+from typing import List, Union, Collection, Mapping, Optional
+from abc import ABC, abstractmethod
+from collections import deque, defaultdict
+
+class Solution:
+    def combine(self, n: int, k: int) -> List[List[int]]:
+        result = []
+
+        def backtrack(start: int, current: List[int]) -> None:
+            # Base case: if we have k numbers, add to result
+            if len(current) == k:
+                result.append(current[:])
+                return
+
+            # Try all numbers from start to n
+            for i in range(start, n + 1):
+                current.append(i)
+                backtrack(i + 1, current)
+                current.pop()
+
+        backtrack(1, [])
+        return result

src/my_project/interviews_typescript/top_150_questions_round_1/ex_97_combinations.ts

@@ -0,0 +1,21 @@
+function combine(n: number, k: number): number[][] {
+    const result: number[][] = [];
+
+    function backtrack(start: number, current: number[]): void {
+        // Base case: if we have k numbers, add to result
+        if (current.length === k) {
+            result.push([...current]);
+            return;
+        }
+
+        // Try all numbers from start to n
+        for (let i = start; i <= n; i++) {
+            current.push(i);
+            backtrack(i + 1, current);
+            current.pop();
+        }
+    }
+
+    backtrack(1, []);
+    return result;
+};

tests/test_150_questions_round_22/test_97_combinations_round_22.py

@@ -0,0 +1,48 @@
+import unittest
+from typing import Optional, List
+from src.my_project.interviews.top_150_questions_round_22\
+.ex_97_combinations import Solution
+
+
+class CombinationsTestCase(unittest.TestCase):
+    def setUp(self):
+        self.solution = Solution()
+
+    def test_example_1(self):
+        # n = 4, k = 2
+        result = self.solution.combine(4, 2)
+        expected = [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]
+        self.assertEqual(sorted(result), sorted(expected))
+
+    def test_example_2(self):
+        # n = 1, k = 1
+        result = self.solution.combine(1, 1)
+        expected = [[1]]
+        self.assertEqual(result, expected)
+
+    def test_k_equals_n(self):
+        # When k equals n, there's only one combination
+        result = self.solution.combine(3, 3)
+        expected = [[1, 2, 3]]
+        self.assertEqual(result, expected)
+
+    def test_k_equals_1(self):
+        # When k = 1, each number is a combination
+        result = self.solution.combine(3, 1)
+        expected = [[1], [2], [3]]
+        self.assertEqual(result, expected)
+
+    def test_larger_case(self):
+        # n = 5, k = 3
+        result = self.solution.combine(5, 3)
+        # Should have 5C3 = 10 combinations
+        self.assertEqual(len(result), 10)
+        # Verify all combinations are unique
+        self.assertEqual(len(result), len(set(map(tuple, result))))
+        # Verify all elements are in correct range
+        for combo in result:
+            self.assertEqual(len(combo), 3)
+            for num in combo:
+                self.assertTrue(1 <= num <= 5)
+            # Verify combination is sorted (which it should be from our algorithm)
+            self.assertEqual(combo, sorted(combo))