adding algo

src/my_project/interviews/amazon_high_frequency_23/common_algos/two_sum_round_4.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_4.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_88_course_schedule.py

@@ -0,0 +1,32 @@
+from typing import List, Union, Collection, Mapping, Optional
+from abc import ABC, abstractmethod
+from collections import deque, defaultdict
+
+class Solution:
+    def canFinish(self, numCourses: int, 
+                        prerequisites: List[List[int]]) -> bool:
+        # 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
+
+        # Add all courses with no prerequisites to queue
+        queue = deque([i for i in range(numCourses) if in_degree[i] == 0])
+        courses_taken = 0
+
+        # Process courses
+        while queue:
+            course = queue.popleft()
+            courses_taken += 1
+
+            # 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 took all courses, no cycle exists
+        return courses_taken == numCourses

src/my_project/interviews_typescript/top_150_questions_round_1/ex_88_course_schedule.ts

@@ -0,0 +1,44 @@
+function canFinish(numCourses: number, prerequisites: number[][]): boolean {
+    // 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 graph and calculate in-degrees
+    for (const [course, prereq] of prerequisites) {
+        graph.get(prereq)!.push(course);
+        inDegree[course]++;
+    }
+
+    // Add all courses with no prerequisites to queue
+    const queue: number[] = [];
+    for (let i = 0; i < numCourses; i++) {
+        if (inDegree[i] === 0) {
+            queue.push(i);
+        }
+    }
+
+    let coursesTaken = 0;
+
+    // Process courses using BFS (Kahn's algorithm)
+    while (queue.length > 0) {
+        const course = queue.shift()!;
+        coursesTaken++;
+
+        // Reduce in-degree for dependent courses
+        for (const nextCourse of graph.get(course)!) {
+            inDegree[nextCourse]--;
+            if (inDegree[nextCourse] === 0) {
+                queue.push(nextCourse);
+            }
+        }
+    }
+
+    // If we took all courses, no cycle exists
+    return coursesTaken === numCourses;
+}
+

tests/test_150_questions_round_22/test_88_course_schedule_round_22.py

@@ -0,0 +1,41 @@
+import unittest
+from src.my_project.interviews.top_150_questions_round_22\
+    .ex_88_course_schedule import Solution
+from typing import Optional, List
+
+
+class CourseScheduleTestCase(unittest.TestCase):
+
+    def test_example_1(self):
+        """
+        Example 1:
+        Input: numCourses = 2, prerequisites = [[1,0]]
+        Output: true
+        Explanation: There are a total of 2 courses to take. 
+        To take course 1 you should have finished course 0. So it is possible.
+        """
+        solution = Solution()
+        numCourses = 2
+        prerequisites = [[1, 0]]
+        expected = True
+
+        result = solution.canFinish(numCourses, prerequisites)
+        self.assertEqual(result, expected)
+
+    def test_example_2(self):
+        """
+        Example 2:
+        Input: numCourses = 2, prerequisites = [[1,0],[0,1]]
+        Output: false
+        Explanation: There are a total of 2 courses to take. 
+        To take course 1 you should have finished course 0, and to take course 0 
+        you should also have finished course 1. So it is impossible.
+        """
+        solution = Solution()
+        numCourses = 2
+        prerequisites = [[1, 0], [0, 1]]
+        expected = False
+
+        result = solution.canFinish(numCourses, prerequisites)
+        self.assertEqual(result, expected)
+