feat: add maximum_profit_in_job_scheduling

Author: wislertt

.templates/leetcode/json/maximum_profit_in_job_scheduling.json

@@ -0,0 +1,50 @@
+{
+    "problem_name": "maximum_profit_in_job_scheduling",
+    "solution_class_name": "Solution",
+    "problem_number": "1235",
+    "problem_title": "Maximum Profit in Job Scheduling",
+    "difficulty": "Hard",
+    "topics": "Array, Binary Search, Dynamic Programming, Sorting",
+    "tags": ["grind-75"],
+    "readme_description": "We have `n` jobs, where every job is scheduled to be done from `startTime[i]` to `endTime[i]`, obtaining a profit of `profit[i]`.\n\nYou're given the `startTime`, `endTime` and `profit` arrays, return the maximum profit you can take such that there are no two jobs in the subset with overlapping time range.\n\nIf you choose a job that ends at time `X` you will be able to start another job that starts at time `X`.",
+    "readme_examples": [
+        {
+            "content": "![Example 1](https://assets.leetcode.com/uploads/2019/10/10/sample1_1584.png)\n\n```\nInput: startTime = [1,2,3,3], endTime = [3,4,5,6], profit = [50,10,40,70]\nOutput: 120\n```\n**Explanation:** The subset chosen is the first and fourth job. Time range [1-3]+[3-6] , we get profit of 120 = 50 + 70."
+        },
+        {
+            "content": "![Example 2](https://assets.leetcode.com/uploads/2019/10/10/sample22_1584.png)\n\n```\nInput: startTime = [1,2,3,4,6], endTime = [3,5,10,6,9], profit = [20,20,100,70,60]\nOutput: 150\n```\n**Explanation:** The subset chosen is the first, fourth and fifth job. Profit obtained 150 = 20 + 70 + 60."
+        },
+        {
+            "content": "![Example 3](https://assets.leetcode.com/uploads/2019/10/10/sample3_1584.png)\n\n```\nInput: startTime = [1,1,1], endTime = [2,3,4], profit = [5,6,4]\nOutput: 6\n```"
+        }
+    ],
+    "readme_constraints": "- `1 <= startTime.length == endTime.length == profit.length <= 5 * 10^4`\n- `1 <= startTime[i] < endTime[i] <= 10^9`\n- `1 <= profit[i] <= 10^4`",
+    "readme_additional": "",
+    "solution_imports": "",
+    "solution_methods": [
+        {
+            "name": "job_scheduling",
+            "parameters": "start_time: list[int], end_time: list[int], profit: list[int]",
+            "return_type": "int",
+            "dummy_return": "0"
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .solution import Solution",
+    "test_class_name": "MaximumProfitInJobScheduling",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_job_scheduling",
+            "parametrize": "start_time, end_time, profit, expected",
+            "parametrize_typed": "start_time: list[int], end_time: list[int], profit: list[int], expected: int",
+            "test_cases": "[([1, 2, 3, 3], [3, 4, 5, 6], [50, 10, 40, 70], 120), ([1, 2, 3, 4, 6], [3, 5, 10, 6, 9], [20, 20, 100, 70, 60], 150), ([1, 1, 1], [2, 3, 4], [5, 6, 4], 6)]",
+            "body": "result = self.solution.job_scheduling(start_time, end_time, profit)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\nstart_time = [1, 2, 3, 3]\nend_time = [3, 4, 5, 6]\nprofit = [50, 10, 40, 70]\nexpected = 120",
+    "playground_execution": "result = Solution().job_scheduling(start_time, end_time, profit)\nresult",
+    "playground_assertion": "assert result == expected"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= trapping_rain_water
+PROBLEM ?= maximum_profit_in_job_scheduling
 FORCE ?= 0
 COMMA := ,
 

leetcode/k_closest_points_to_origin/playground.ipynb

@@ -6,31 +6,43 @@
    "id": "imports",
    "metadata": {},
    "outputs": [],
-   "source": ["from solution import Solution"]
+   "source": [
+    "from solution import Solution"
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "id": "setup",
    "metadata": {},
    "outputs": [],
-   "source": ["# Example test case\npoints = [[1, 3], [-2, 2]]\nk = 1\nexpected = [[-2, 2]]"]
+   "source": [
+    "# Example test case\n",
+    "points = [[1, 3], [-2, 2]]\n",
+    "k = 1\n",
+    "expected = [[-2, 2]]"
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "id": "execute",
    "metadata": {},
    "outputs": [],
-   "source": ["result = Solution().k_closest(points, k)\nresult"]
+   "source": [
+    "result = Solution().k_closest(points, k)\n",
+    "result"
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "id": "test",
    "metadata": {},
    "outputs": [],
-   "source": ["assert sorted(result) == sorted(expected)"]
+   "source": [
+    "assert sorted(result) == sorted(expected)"
+   ]
   }
  ],
  "metadata": {

leetcode/longest_palindrome/playground.ipynb

@@ -29,7 +29,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "result = Solution().longest_palindrome(s)\nresult"
+    "result = Solution().longest_palindrome(s)\n",
+    "result"
    ]
   },
   {

leetcode/maximum_profit_in_job_scheduling/README.md

@@ -0,0 +1,54 @@
+# Maximum Profit in Job Scheduling
+
+**Difficulty:** Hard
+**Topics:** Array, Binary Search, Dynamic Programming, Sorting
+**Tags:** grind-75
+
+**LeetCode:** [Problem 1235](https://leetcode.com/problems/maximum-profit-in-job-scheduling/description/)
+
+## Problem Description
+
+We have `n` jobs, where every job is scheduled to be done from `startTime[i]` to `endTime[i]`, obtaining a profit of `profit[i]`.
+
+You're given the `startTime`, `endTime` and `profit` arrays, return the maximum profit you can take such that there are no two jobs in the subset with overlapping time range.
+
+If you choose a job that ends at time `X` you will be able to start another job that starts at time `X`.
+
+## Examples
+
+### Example 1:
+
+![Example 1](https://assets.leetcode.com/uploads/2019/10/10/sample1_1584.png)
+
+```
+Input: startTime = [1,2,3,3], endTime = [3,4,5,6], profit = [50,10,40,70]
+Output: 120
+```
+
+**Explanation:** The subset chosen is the first and fourth job. Time range [1-3]+[3-6] , we get profit of 120 = 50 + 70.
+
+### Example 2:
+
+![Example 2](https://assets.leetcode.com/uploads/2019/10/10/sample22_1584.png)
+
+```
+Input: startTime = [1,2,3,4,6], endTime = [3,5,10,6,9], profit = [20,20,100,70,60]
+Output: 150
+```
+
+**Explanation:** The subset chosen is the first, fourth and fifth job. Profit obtained 150 = 20 + 70 + 60.
+
+### Example 3:
+
+![Example 3](https://assets.leetcode.com/uploads/2019/10/10/sample3_1584.png)
+
+```
+Input: startTime = [1,1,1], endTime = [2,3,4], profit = [5,6,4]
+Output: 6
+```
+
+## Constraints
+
+- `1 <= startTime.length == endTime.length == profit.length <= 5 * 10^4`
+- `1 <= startTime[i] < endTime[i] <= 10^9`
+- `1 <= profit[i] <= 10^4`

leetcode/maximum_profit_in_job_scheduling/__init__.py

@@ -0,0 +1,174 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import bisect\n",
+    "\n",
+    "from solution import Solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example test case\n",
+    "start_time = [1, 2, 3, 3]\n",
+    "end_time = [3, 4, 5, 6]\n",
+    "profit = [50, 10, 40, 70]\n",
+    "expected = 120"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "120"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result = Solution().job_scheduling(start_time, end_time, profit)\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert result == expected"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dd4ebe51",
+   "metadata": {},
+   "source": [
+    "# Bisect"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "3596ff83",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Original array: [1, 3, 3, 5, 7]\n",
+      "Indices:        [0, 1, 2, 3, 4]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Demo array\n",
+    "arr = [1, 3, 3, 5, 7]\n",
+    "print(f\"Original array: {arr}\")\n",
+    "print(f\"Indices:        {list(range(len(arr)))}\")\n",
+    "print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "508a52e9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "=== bisect_left vs bisect_right ===\n",
+      "x=0: left=0, right=0\n",
+      "x=3: left=1, right=3\n",
+      "x=4: left=3, right=3\n",
+      "x=8: left=5, right=5\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# bisect_left vs bisect_right\n",
+    "print(\"=== bisect_left vs bisect_right ===\")\n",
+    "for x in [0, 3, 4, 8]:\n",
+    "    left = bisect.bisect_left(arr, x)\n",
+    "    right = bisect.bisect_right(arr, x)\n",
+    "    print(f\"x={x}: left={left}, right={right}\")\n",
+    "print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b5dfa28a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "=== insort demonstration ===\n",
+      "Before: [1, 3, 5]\n",
+      "After insort(4): [1, 3, 4, 5]\n",
+      "After insort(3): [1, 3, 3, 4, 5]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# insort demonstration\n",
+    "print(\"=== insort demonstration ===\")\n",
+    "test_arr = [1, 3, 5]\n",
+    "print(f\"Before: {test_arr}\")\n",
+    "bisect.insort(test_arr, 4)\n",
+    "print(f\"After insort(4): {test_arr}\")\n",
+    "bisect.insort(test_arr, 3)\n",
+    "print(f\"After insort(3): {test_arr}\")\n",
+    "print()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "leetcode-py-py3.13",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

leetcode/maximum_profit_in_job_scheduling/playground.ipynb

@@ -0,0 +1,51 @@
+import bisect
+
+
+class Solution:
+    # Time: O(n log n)
+    # Space: O(n)
+    def job_scheduling(self, start_time: list[int], end_time: list[int], profit: list[int]) -> int:
+
+        jobs = sorted(zip(end_time, start_time, profit))
+        dp = [0] * len(jobs)
+
+        for i, (end, start, p) in enumerate(jobs):
+            # Binary search for latest non-overlapping job
+            j = bisect.bisect_right([job[0] for job in jobs[:i]], start) - 1
+
+            # Take current job + best profit from non-overlapping jobs
+            take = p + (dp[j] if j >= 0 else 0)
+            # Skip current job
+            skip = dp[i - 1] if i > 0 else 0
+
+            dp[i] = max(take, skip)
+
+        return dp[-1] if jobs else 0
+
+
+# bisect and insort Explanation:
+#
+# Etymology: "bisect" = bi (two) + sect (cut) = cut into two parts
+# Bisection method = binary search algorithm that repeatedly cuts search space in half
+#
+# bisect module provides binary search for SORTED lists (O(log n)):
+# - bisect_left(arr, x): leftmost insertion position
+# - bisect_right(arr, x): rightmost insertion position (default)
+# - bisect(arr, x): alias for bisect_right
+#
+# insort module maintains sorted order while inserting:
+# - insort_left(arr, x): insert at leftmost position
+# - insort_right(arr, x): insert at rightmost position (default)
+# - insort(arr, x): alias for insort_right
+#
+# Examples:
+# arr = [1, 3, 3, 5]
+# bisect_left(arr, 3) → 1   (before existing 3s)
+# bisect_right(arr, 3) → 3  (after existing 3s)
+# bisect_right(arr, 4) → 3  (between 3 and 5)
+#
+# insort(arr, 4) → arr becomes [1, 3, 3, 4, 5]
+#
+# In our solution:
+# bisect_right([2,4,6], 5) = 2 (insertion position)
+# j = 2 - 1 = 1 (index of latest job ending ≤ start_time)