From cd0bb8d030f59c278bfea80f585366626f964c72 Mon Sep 17 00:00:00 2001 From: bumpsoo Date: Sat, 7 Jun 2025 05:12:50 +0000 Subject: [PATCH 01/10] https://leetcode.com/problems/lexicographically-minimum-string-after-removing-stars --- ...cally_minimum_string_after_removing_stars.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 medium/lexicographically_minimum_string_after_removing_stars.py diff --git a/medium/lexicographically_minimum_string_after_removing_stars.py b/medium/lexicographically_minimum_string_after_removing_stars.py new file mode 100644 index 0000000..7dd490f --- /dev/null +++ b/medium/lexicographically_minimum_string_after_removing_stars.py @@ -0,0 +1,17 @@ +# https://leetcode.com/problems/lexicographically-minimum-string-after-removing-stars + +import heapq + +class Solution: + def clearStars(self, s: str) -> str: + result = list(s) + h = [] + for i in range(len(s)): + if s[i] == '*': + (_, _, origin) = heapq.heappop(h) + result[origin] = '' + result[i] = '' + else: + heapq.heappush(h, (s[i], -i, i)) + return ''.join(result) + From 2cfc402fddffaf42b9f30a3d277d164a2f2e94b8 Mon Sep 17 00:00:00 2001 From: bumpsoo Date: Sun, 8 Jun 2025 08:34:17 +0000 Subject: [PATCH 02/10] https://leetcode.com/problems/lexicographical-numbers --- medium/lexicographical_numbers.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 medium/lexicographical_numbers.py diff --git a/medium/lexicographical_numbers.py b/medium/lexicographical_numbers.py new file mode 100644 index 0000000..ccb29bb --- /dev/null +++ b/medium/lexicographical_numbers.py @@ -0,0 +1,20 @@ +# https://leetcode.com/problems/lexicographical-numbers + +from typing import List + +class Solution: + def lexicalOrder(self, n: int) -> List[int]: + result: List[int] = [] + s: List[int] = [int(x) for x in list(str(n))] + def iterate(curr: int, length: int, curr_index: int): + if curr_index >= len(s): + return + for num in range(1 if curr_index == 0 else 0, 10): + new_curr = (curr * 10) + num + if new_curr > n: + break + result.append(new_curr) + iterate(new_curr, length + 1, curr_index + 1) + + iterate(0, 0, 0) + return result From 9d128a5f1676861cfda21ba6d63ee789c5a28cce Mon Sep 17 00:00:00 2001 From: bumpsoo Date: Sun, 8 Jun 2025 08:44:38 +0000 Subject: [PATCH 03/10] https://leetcode.com/problems/binary-tree-right-side-view --- medium/binary_tree_right_side_view.py | 33 +++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 medium/binary_tree_right_side_view.py diff --git a/medium/binary_tree_right_side_view.py b/medium/binary_tree_right_side_view.py new file mode 100644 index 0000000..c3c1e34 --- /dev/null +++ b/medium/binary_tree_right_side_view.py @@ -0,0 +1,33 @@ +# https://leetcode.com/problems/binary-tree-right-side-view + +from collections import deque +from typing import Deque, List, Optional, Set, Tuple + +class TreeNode: + def __init__(self, val=0, left=None, right=None): + self.val = val + self.left = left + self.right = right + +class Solution: + def rightSideView(self, root: Optional[TreeNode]) -> List[int]: + result: List[int] = [] + q: Deque[Tuple[TreeNode, int]] = deque() + levels: Set[int] = set() + + if root is None: + return result + + q.append((root, 0)) + while len(q) > 0: + (curr, curr_level) = q.popleft() + if curr_level not in levels: + levels.add(curr_level) + result.append(curr.val) + if curr.right is not None: + q.append((curr.right, curr_level + 1)) + if curr.left is not None: + q.append((curr.left, curr_level + 1)) + + return result + From b96b438b8a43a851fdffca36252a484360e7f7f9 Mon Sep 17 00:00:00 2001 From: bumpsoo Date: Mon, 9 Jun 2025 13:58:01 +0000 Subject: [PATCH 04/10] https://leetcode.com/problems/k-th-smallest-in-lexicographical-order --- .../k_th_smallest_in_lexicographical_order.py | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 hard/k_th_smallest_in_lexicographical_order.py diff --git a/hard/k_th_smallest_in_lexicographical_order.py b/hard/k_th_smallest_in_lexicographical_order.py new file mode 100644 index 0000000..1f73dcc --- /dev/null +++ b/hard/k_th_smallest_in_lexicographical_order.py @@ -0,0 +1,24 @@ +# https://leetcode.com/problems/k-th-smallest-in-lexicographical-order + +class Solution: + def findKthNumber(self, n: int, k: int) -> int: + def max_step(curr: int) -> int: + step = 0 + first, last = curr, curr + while first <= n: + step += min(n, last) - first + 1 + first *= 10 + last = last * 10 + 9 + return step + curr = 1 + k -= 1 + while k > 0: + step = max_step(curr) + if step <= k: + k -= step + curr += 1 + else: + k -= 1 + curr *= 10 + return curr + From 74ea899d2cb4d0cfb174786265f55ed8712796c3 Mon Sep 17 00:00:00 2001 From: bumpsoo Date: Mon, 9 Jun 2025 14:53:03 +0000 Subject: [PATCH 05/10] https://leetcode.com/problems/linked-list-cycle --- easy/linked_list_cycle.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 easy/linked_list_cycle.py diff --git a/easy/linked_list_cycle.py b/easy/linked_list_cycle.py new file mode 100644 index 0000000..7dd4325 --- /dev/null +++ b/easy/linked_list_cycle.py @@ -0,0 +1,23 @@ +# https://leetcode.com/problems/linked-list-cycle + +from typing import Optional + +class ListNode: + val: int + next: Optional["ListNode"] + +class Solution: + def hasCycle(self, head: Optional[ListNode]) -> bool: + first: Optional[ListNode] = head + second: Optional[ListNode] = head + + while first is not None and \ + first.next is not None and \ + second is not None: + + first = first.next.next + second = second.next + if first == second: + return True + return False + From e9aef2c95dbbbedd8cb648a73185c9f80f3b6086 Mon Sep 17 00:00:00 2001 From: bumpsoo Date: Tue, 10 Jun 2025 14:23:33 +0000 Subject: [PATCH 06/10] https://leetcode.com/problems/maximum-difference-between-even-and-odd-frequency-i --- ...ifference_between_even_and_odd_frequency_i.py | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 easy/maximum_difference_between_even_and_odd_frequency_i.py diff --git a/easy/maximum_difference_between_even_and_odd_frequency_i.py b/easy/maximum_difference_between_even_and_odd_frequency_i.py new file mode 100644 index 0000000..f3b9aaf --- /dev/null +++ b/easy/maximum_difference_between_even_and_odd_frequency_i.py @@ -0,0 +1,16 @@ +# https://leetcode.com/problems/maximum-difference-between-even-and-odd-frequency-i + +from typing import Counter + +class Solution: + def maxDifference(self, s: str) -> int: + c = Counter(s) + max_odd = float("-inf") + min_even = float("inf") + for k in c: + if c[k] % 2 == 1: + max_odd = max(max_odd, c[k]) + else: + min_even = min(min_even, c[k]) + return int(max_odd - min_even) + From 47ddfc37e5f15fdd250d8dd63bd6b70220b0f5ef Mon Sep 17 00:00:00 2001 From: bumpsoo Date: Thu, 12 Jun 2025 12:20:16 +0000 Subject: [PATCH 07/10] https://leetcode.com/problems/maximum-difference-between-adjacent-elements-in-a-circular-array --- ...e_between_adjacent_elements_in_a_circular_array.py | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 easy/maximum_difference_between_adjacent_elements_in_a_circular_array.py diff --git a/easy/maximum_difference_between_adjacent_elements_in_a_circular_array.py b/easy/maximum_difference_between_adjacent_elements_in_a_circular_array.py new file mode 100644 index 0000000..f65f1b1 --- /dev/null +++ b/easy/maximum_difference_between_adjacent_elements_in_a_circular_array.py @@ -0,0 +1,11 @@ +# https://leetcode.com/problems/maximum-difference-between-adjacent-elements-in-a-circular-array + +from typing import List + +class Solution: + def maxAdjacentDistance(self, nums: List[int]) -> int: + result = 0 + for i in range(len(nums)): + result = max(abs(nums[i] - nums[i - 1]), result) + return result + From f981ba7f45ab598dcca15ceb45217a07a797c962 Mon Sep 17 00:00:00 2001 From: bumpsoo Date: Sat, 14 Jun 2025 10:01:34 +0000 Subject: [PATCH 08/10] https://leetcode.com/problems/maximum-difference-by-remapping-a-digit --- ...maximum_difference_by_remapping_a_digit.py | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 easy/maximum_difference_by_remapping_a_digit.py diff --git a/easy/maximum_difference_by_remapping_a_digit.py b/easy/maximum_difference_by_remapping_a_digit.py new file mode 100644 index 0000000..de7cc57 --- /dev/null +++ b/easy/maximum_difference_by_remapping_a_digit.py @@ -0,0 +1,24 @@ +# https://leetcode.com/problems/maximum-difference-by-remapping-a-digit + +from typing import List, Optional + +class Solution: + def minMaxDifference(self, num: int) -> int: + n: List[str] = list(str(num)) + max_num: List[str] = [] + min_num: List[str] = [] + max_target: Optional[str] = None + min_target: str = n[0] + for i in range(len(n)): + if n[i] == min_target: + min_num.append('0') + else: + min_num.append(n[i]) + if max_target is None and n[i] != '9': + max_target = n[i] + if max_target == n[i]: + max_num.append('9') + else: + max_num.append(n[i]) + return int(''.join(max_num)) - int(''.join(min_num)) + From 839160479e2e91befacc409ede9b48b01160d407 Mon Sep 17 00:00:00 2001 From: bumpsoo Date: Sun, 15 Jun 2025 05:55:09 +0000 Subject: [PATCH 09/10] https://leetcode.com/problems/max-difference-you-can-get-from-changing-an-integer --- ...ce_you_can_get_from_changing_an_integer.py | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 medium/max_difference_you_can_get_from_changing_an_integer.py diff --git a/medium/max_difference_you_can_get_from_changing_an_integer.py b/medium/max_difference_you_can_get_from_changing_an_integer.py new file mode 100644 index 0000000..9290f79 --- /dev/null +++ b/medium/max_difference_you_can_get_from_changing_an_integer.py @@ -0,0 +1,20 @@ +# https://leetcode.com/problems/max-difference-you-can-get-from-changing-an-integer + +class Solution: + def maxDiff(self, num: int) -> int: + n = str(num) + max_num: str = n + min_num: str = n + for digit in max_num: + if digit != '9': + max_num = max_num.replace(digit, '9') + break + for i in range(len(min_num)): + if i == 0 and min_num[i] != '1': + min_num = min_num.replace(min_num[i], '1') + break + if i != 0 and min_num[i] != '0' and min_num[i] != min_num[0]: + min_num = min_num.replace(min_num[i], '0') + break + return int(max_num) - int(min_num) + From e522ef06bdb4f06859dc77087c831b0a6fe472ab Mon Sep 17 00:00:00 2001 From: bumpsoo Date: Mon, 16 Jun 2025 10:48:31 +0000 Subject: [PATCH 10/10] https://leetcode.com/problems/maximum-difference-between-increasing-elements --- ...ximum_difference_between_increasing_elements.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 easy/maximum_difference_between_increasing_elements.py diff --git a/easy/maximum_difference_between_increasing_elements.py b/easy/maximum_difference_between_increasing_elements.py new file mode 100644 index 0000000..8a4aa7e --- /dev/null +++ b/easy/maximum_difference_between_increasing_elements.py @@ -0,0 +1,14 @@ +# https://leetcode.com/problems/maximum-difference-between-increasing-elements + +from typing import List + +class Solution: + def maximumDifference(self, nums: List[int]) -> int: + result = -1 + curr_min = nums[0] + for i in range(1, len(nums)): + if nums[i] > curr_min: + result = max(result, nums[i] - curr_min) + curr_min = min(curr_min, nums[i]) + return result +