Merge pull request #34 from franciscoerramuspe/leetcode-problems

Leetcode problems

Author: conanbatt

profile-specific-challenges/backend/guess_hint/guess_hint.py

@@ -0,0 +1,62 @@
+"""
+Problem Statement
+You are implementing a word-guessing game where players try to guess a secret four-letter word. After each guess, the game provides hints about which letters are correct and/or present in the secret word.
+
+Write a function that takes two strings (the secret word and the guess) and returns a string containing hints in the form of 'W' and 'R' characters, where:
+- 'W' means the letter is correct and in the correct position
+- 'R' means the letter is present in the secret word but in the wrong position
+- The hint string should always show 'W's before 'R's
+
+The function must process the hints in two passes:
+1. First pass: Mark all exact matches (same letter, same position) with 'W'
+2. Second pass: For remaining unmatched letters, mark with 'R' if they appear somewhere else in the secret word
+
+Definition
+    
+Class: GuessHint
+Method: getHint
+Parameters: str, str
+Returns: str
+Method signature: def getHint(secret: str, guess: str) -> str
+
+Constraints
+- Both secret and guess will be exactly 4 characters long
+- All characters will be uppercase letters from 'A' to 'Z'
+- The same letter can appear multiple times in either string
+
+Examples
+0)
+    
+Input: secret = "ABCD", guess = "ABCD"
+Returns: "WWWW"
+All letters match exactly.
+
+1)
+
+Input: secret = "ABCD", guess = "DCBA"
+Returns: "RRRR"
+All letters exist but in wrong positions.
+
+2)
+
+Input: secret = "ABAA", guess = "BAAA"
+Returns: "WWRR"
+Two exact matches (positions 2,3) give "WW", then remaining unmatched letters (A,B) exist in wrong positions giving "RR".
+
+3)
+
+Input: secret = "ABCD", guess = "AAAA"
+Returns: "W"
+Only first A matches exactly. Other A's don't count since A was already matched.
+
+4)
+
+Input: secret = "ABCD", guess = "EFGH"
+Returns: ""
+No letters match or exist in the secret word.
+
+Notes:
+- Each letter in the secret word can only be matched once
+- Priority goes to exact matches (W) before wrong position matches (R)
+- The result string must always have W's before R's
+""" 

profile-specific-challenges/backend/guess_hint/test_guess_hint.py

@@ -0,0 +1,43 @@
+import pytest
+
+from guess_hint import GuessHint
+
+def test_1():
+    solution = GuessHint()
+    assert "WWWW" == solution.getHint("ABCD", "ABCD")
+
+def test_2():
+    solution = GuessHint()
+    assert "RRRR" == solution.getHint("ABCD", "DCBA")
+
+def test_3():
+    solution = GuessHint()
+    assert "WWRR" == solution.getHint("ABAA", "BAAA")
+
+def test_4():
+    solution = GuessHint()
+    assert "W" == solution.getHint("ABCD", "AAAA")
+
+def test_5():
+    solution = GuessHint()
+    assert "" == solution.getHint("ABCD", "EFGH")
+
+def test_6():
+    solution = GuessHint()
+    assert "WWR" == solution.getHint("AABB", "AAAB")
+
+def test_7():
+    solution = GuessHint()
+    assert "WR" == solution.getHint("ABCD", "ACAA")
+
+def test_8():
+    solution = GuessHint()
+    assert "WWRR" == solution.getHint("AAAA", "ABBA")
+
+def test_9():
+    solution = GuessHint()
+    assert "RR" == solution.getHint("ABCD", "CDAA")
+
+def test_10():
+    solution = GuessHint()
+    assert "WRR" == solution.getHint("ABCD", "ADBC") 

profile-specific-challenges/backend/on_call_schedule/on_call_schedule.py

@@ -0,0 +1,50 @@
+"""
+Problem Statement
+You are given a dictionary representing an on-call schedule where each key is a person's name and the value is a tuple of two integers representing their shift's start and end times in minutes.
+
+Write a function that processes this schedule and returns all distinct time segments with their corresponding on-call personnel. A new segment starts or ends whenever someone's shift begins or ends.
+
+For each segment in the schedule, determine all people who are on-call during that entire segment. The function should return a list of tuples, where each tuple contains:
+- The start time of the segment
+- The end time of the segment
+- A list of names of all people who are on-call during that segment
+
+Definition
+    
+Class: OnCallSchedule
+Method: createOnCallSchedule
+Parameters: dict
+Returns: list
+Method signature: def createOnCallSchedule(onCallDict)
+
+Constraints
+- The dictionary will contain between 1 and 100 entries
+- All times will be non-negative integers
+- For each person, start time will be strictly less than end time
+- All times will be between 0 and 1000000, inclusive
+
+Examples
+0)
+    
+Input: {"Anna": (10, 100), "Juan": (30, 80)}
+Returns: [(10, 30, ["Anna"]), (30, 80, ["Anna", "Juan"]), (80, 100, ["Anna"])]
+
+1)
+
+Input: {"Ben": (50, 70), "Carla": (60, 120), "David": (150, 300)}
+Returns: [(50, 60, ["Ben"]), (60, 70, ["Ben", "Carla"]), (70, 120, ["Carla"]), (150, 300, ["David"])]
+
+2)
+
+Input: {"Alice": (0, 50), "Bob": (0, 50)}
+Returns: [(0, 50, ["Alice", "Bob"])]
+
+Notes:
+- A person is considered on-call for their entire interval, including start and end times
+- The output should only include segments where at least one person is on-call
+- The segments should be in chronological order
+- Each segment's personnel list should be sorted alphabetically
+"""
+class Solution:
+    def createOnCallSchedule(self, onCallDict):
+        return []

profile-specific-challenges/backend/on_call_schedule/test_on_call_schedule.py

@@ -0,0 +1,58 @@
+import pytest
+
+from on_call_schedule import Solution
+
+def test1():
+    solution = Solution()
+    assert [(10, 30, ["Anna"]), 
+            (30, 80, ["Anna", "Juan"]), 
+            (80, 100, ["Anna"])] == solution.createOnCallSchedule({
+                "Anna": (10, 100),
+                "Juan": (30, 80)
+            })
+
+def test2():
+    solution = Solution()
+    assert [(50, 60, ["Ben"]),
+            (60, 70, ["Ben", "Carla"]),
+            (70, 120, ["Carla"]),
+            (150, 300, ["David"])] == solution.createOnCallSchedule({
+                "Ben": (50, 70),
+                "Carla": (60, 120),
+                "David": (150, 300)
+            })
+
+def test3():
+    solution = Solution()
+    assert [(0, 50, ["Alice", "Bob"])] == solution.createOnCallSchedule({
+                "Alice": (0, 50),
+                "Bob": (0, 50)
+            })
+
+def test4():
+    solution = Solution()
+    assert [(10, 20, ["Alice"]),
+            (30, 40, ["Bob"]),
+            (50, 60, ["Charlie"])] == solution.createOnCallSchedule({
+                "Alice": (10, 20),
+                "Bob": (30, 40),
+                "Charlie": (50, 60)
+            })
+
+def test5():
+    solution = Solution()
+    assert [(0, 10, ["Alice"]),
+            (10, 20, ["Alice", "Bob"]),
+            (20, 30, ["Alice", "Bob", "Charlie"]),
+            (30, 40, ["Bob", "Charlie"]),
+            (40, 50, ["Charlie"])] == solution.createOnCallSchedule({
+                "Alice": (0, 30),
+                "Bob": (10, 40),
+                "Charlie": (20, 50)
+            })
+
+def test6():
+    solution = Solution()
+    assert [(100, 200, ["Alice"])] == solution.createOnCallSchedule({
+                "Alice": (100, 200)
+            })