From 955781a864fabc33cc1e902881ddd3a7ad846a71 Mon Sep 17 00:00:00 2001 From: ivan Date: Sat, 28 Feb 2026 04:40:36 -0600 Subject: [PATCH] adding algo --- .../common_algos/two_sum_round_6.py | 24 +++++++ .../common_algos/valid_palindrome_round_6.py | 22 ++++++ .../ex_89_course_schedule_ii.py | 31 ++++++++ .../ex_89_course_schedule_ii.ts | 45 ++++++++++++ .../test_89_course_schedule_ii_round_22.py | 70 +++++++++++++++++++ 5 files changed, 192 insertions(+) create mode 100644 src/my_project/interviews/amazon_high_frequency_23/common_algos/two_sum_round_6.py create mode 100644 src/my_project/interviews/amazon_high_frequency_23/common_algos/valid_palindrome_round_6.py create mode 100644 src/my_project/interviews/top_150_questions_round_22/ex_89_course_schedule_ii.py create mode 100644 src/my_project/interviews_typescript/top_150_questions_round_1/ex_89_course_schedule_ii.ts create mode 100644 tests/test_150_questions_round_22/test_89_course_schedule_ii_round_22.py diff --git a/src/my_project/interviews/amazon_high_frequency_23/common_algos/two_sum_round_6.py b/src/my_project/interviews/amazon_high_frequency_23/common_algos/two_sum_round_6.py new file mode 100644 index 00000000..7cef88a4 --- /dev/null +++ b/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 [] + + + + + + + + diff --git a/src/my_project/interviews/amazon_high_frequency_23/common_algos/valid_palindrome_round_6.py b/src/my_project/interviews/amazon_high_frequency_23/common_algos/valid_palindrome_round_6.py new file mode 100644 index 00000000..67993077 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/src/my_project/interviews/top_150_questions_round_22/ex_89_course_schedule_ii.py b/src/my_project/interviews/top_150_questions_round_22/ex_89_course_schedule_ii.py new file mode 100644 index 00000000..330728fc --- /dev/null +++ b/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 [] \ No newline at end of file diff --git a/src/my_project/interviews_typescript/top_150_questions_round_1/ex_89_course_schedule_ii.ts b/src/my_project/interviews_typescript/top_150_questions_round_1/ex_89_course_schedule_ii.ts new file mode 100644 index 00000000..0e23ac5b --- /dev/null +++ b/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 = 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 : []; +} + + \ No newline at end of file diff --git a/tests/test_150_questions_round_22/test_89_course_schedule_ii_round_22.py b/tests/test_150_questions_round_22/test_89_course_schedule_ii_round_22.py new file mode 100644 index 00000000..cd28ffc9 --- /dev/null +++ b/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) +