adding algo

src/my_project/interviews/amazon_high_frequency_23/common_algos/two_sum_round_6.py

@@ -0,0 +1,24 @@
+from typing import List, Union, Collection, Mapping, Optional
+from abc import ABC, abstractmethod
+
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+
+        answer = dict()
+
+        for k, v in enumerate(nums):
+
+            if v in answer:
+                return [answer[v], k]
+            else: 
+                answer[target - v] = k
+
+        return []
+
+
+
+
+
+
+
+

src/my_project/interviews/amazon_high_frequency_23/common_algos/valid_palindrome_round_6.py

@@ -0,0 +1,22 @@
+from typing import List, Union, Collection, Mapping, Optional
+from abc import ABC, abstractmethod
+import re
+
+class Solution:
+    def isPalindrome(self, s: str) -> bool:
+
+        # To lowercase 
+        s = s.lower()
+
+        # Remove non-alphanumeric characters
+        s = re.sub(pattern=r'[^a-zA-Z0-9]', repl='', string=s)
+
+        # Determine if s is palindrome or not
+        len_s = len(s)
+
+        for i in range(len_s//2):
+
+            if s[i] != s[len_s - 1 - i]:
+                return False 
+
+        return True 

src/my_project/interviews/top_150_questions_round_22/ex_89_course_schedule_ii.py

@@ -0,0 +1,31 @@
+from typing import List, Union, Collection, Mapping, Optional
+from abc import ABC, abstractmethod
+from collections import deque, defaultdict
+
+class Solution:
+    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
+        # Build adjacency list and in-degree array
+        graph = defaultdict(list)
+        in_degree = [0] * numCourses
+
+        for course, prereq in prerequisites:
+            graph[prereq].append(course)
+            in_degree[course] += 1
+
+        # Initialize queue with courses that have no prerequisites
+        queue = deque([i for i in range(numCourses) if in_degree[i] == 0])
+        result = []
+
+        # Process courses in topological order
+        while queue:
+            course = queue.popleft()
+            result.append(course)
+
+            # Reduce in-degree for dependent courses
+            for next_course in graph[course]:
+                in_degree[next_course] -= 1
+                if in_degree[next_course] == 0:
+                    queue.append(next_course)
+
+        # If we processed all courses, return the order; otherwise return empty list
+        return result if len(result) == numCourses else []

src/my_project/interviews_typescript/top_150_questions_round_1/ex_89_course_schedule_ii.ts

@@ -0,0 +1,45 @@
+function findOrder(numCourses: number, prerequisites: number[][]): number[] {
+    // Build adjacency list and in-degree array
+    const graph: Map<number, number[]> = new Map();
+    const inDegree: number[] = new Array(numCourses).fill(0);
+
+    // Initialize graph
+    for (let i = 0; i < numCourses; i++) {
+        graph.set(i, []);
+    }
+
+    // Build the graph
+    for (const [course, prereq] of prerequisites) {
+        graph.get(prereq)!.push(course);
+        inDegree[course]++;
+    }
+
+    // Initialize queue with courses that have no prerequisites
+    const queue: number[] = [];
+    for (let i = 0; i < numCourses; i++) {
+        if (inDegree[i] === 0) {
+            queue.push(i);
+        }
+    }
+
+    const result: number[] = [];
+
+    // Process courses in topological order
+    while (queue.length > 0) {
+        const course = queue.shift()!;
+        result.push(course);
+
+        // Reduce in-degree for dependent courses
+        for (const nextCourse of graph.get(course)!) {
+            inDegree[nextCourse]--;
+            if (inDegree[nextCourse] === 0) {
+                queue.push(nextCourse);
+            }
+        }
+    }
+
+    // If we processed all courses, return the order; otherwise return empty array
+    return result.length === numCourses ? result : [];
+}
+
+

tests/test_150_questions_round_22/test_89_course_schedule_ii_round_22.py

@@ -0,0 +1,70 @@
+import unittest
+from src.my_project.interviews.top_150_questions_round_22\
+    .ex_89_course_schedule_ii import Solution
+from typing import Optional, List
+
+
+class CourseScheduleIITestCase(unittest.TestCase):
+
+    def is_valid_order(self, numCourses: int, prerequisites: List[List[int]], order: List[int]) -> bool:
+        """Helper function to validate if an order satisfies all prerequisites."""
+        if len(order) != numCourses:
+            return False
+
+        # Create position map
+        position = {course: i for i, course in enumerate(order)}
+
+        # Check if all prerequisites are satisfied
+        for course, prereq in prerequisites:
+            if position[prereq] >= position[course]:
+                return False
+
+        return True
+
+    def test_example_1(self):
+        """
+        Example 1:
+        Input: numCourses = 2, prerequisites = [[1,0]]
+        Output: [0,1]
+        Explanation: There are a total of 2 courses to take. 
+        To take course 1 you should have finished course 0. 
+        So the correct course order is [0,1].
+        """
+        solution = Solution()
+        numCourses = 2
+        prerequisites = [[1, 0]]
+
+        result = solution.findOrder(numCourses, prerequisites)
+        self.assertTrue(self.is_valid_order(numCourses, prerequisites, result))
+
+    def test_example_2(self):
+        """
+        Example 2:
+        Input: numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
+        Output: [0,2,1,3]
+        Explanation: There are a total of 4 courses to take. 
+        To take course 3 you should have finished both courses 1 and 2. 
+        Both courses 1 and 2 should be taken after you finished course 0.
+        So one correct course order is [0,1,2,3]. Another correct ordering is [0,2,1,3].
+        """
+        solution = Solution()
+        numCourses = 4
+        prerequisites = [[1, 0], [2, 0], [3, 1], [3, 2]]
+
+        result = solution.findOrder(numCourses, prerequisites)
+        self.assertTrue(self.is_valid_order(numCourses, prerequisites, result))
+
+    def test_example_3(self):
+        """
+        Example 3:
+        Input: numCourses = 1, prerequisites = []
+        Output: [0]
+        """
+        solution = Solution()
+        numCourses = 1
+        prerequisites = []
+        expected = [0]
+
+        result = solution.findOrder(numCourses, prerequisites)
+        self.assertEqual(result, expected)
+