feat: add First Bad Version

Author: wislertt

.templates/leetcode/json/first_bad_version.json

@@ -0,0 +1,56 @@
+{
+    "problem_name": "first_bad_version",
+    "solution_class_name": "Solution",
+    "problem_number": "278",
+    "problem_title": "First Bad Version",
+    "difficulty": "Easy",
+    "topics": "Binary Search, Interactive",
+    "tags": ["grind-75"],
+    "readme_description": "You are a product manager and currently leading a team to develop a new product. Unfortunately, the latest version of your product fails the quality check. Since each version is developed based on the previous version, all the versions after a bad version are also bad.\n\nSuppose you have `n` versions `[1, 2, ..., n]` and you want to find out the first bad one, which causes all the following ones to be bad.\n\nYou are given an API `bool isBadVersion(version)` which returns whether `version` is bad. Implement a function to find the first bad version. You should minimize the number of calls to the API.",
+    "readme_examples": [
+        {
+            "content": "```\nInput: n = 5, bad = 4\nOutput: 4\n```\n**Explanation:**\n```\ncall isBadVersion(3) -> false\ncall isBadVersion(5) -> true\ncall isBadVersion(4) -> true\n```\nThen 4 is the first bad version."
+        },
+        { "content": "```\nInput: n = 1, bad = 1\nOutput: 1\n```" }
+    ],
+    "readme_constraints": "- 1 <= bad <= n <= 2^31 - 1",
+    "readme_additional": "**Note:** The `isBadVersion` API is already defined for you.",
+    "solution_imports": "",
+    "solution_methods": [
+        {
+            "name": "is_bad_version",
+            "parameters": "version: int",
+            "return_type": "bool",
+            "dummy_return": "False"
+        },
+        {
+            "name": "first_bad_version",
+            "parameters": "n: int",
+            "return_type": "int",
+            "dummy_return": "1"
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .solution import Solution",
+    "test_class_name": "FirstBadVersion",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" },
+        {
+            "name": "is_bad_version",
+            "parameters": "version: int, bad: int",
+            "body": "return version >= bad"
+        }
+    ],
+    "test_methods": [
+        {
+            "name": "test_first_bad_version",
+            "parametrize": "n, bad, expected",
+            "parametrize_typed": "n: int, bad: int, expected: int",
+            "test_cases": "[(5, 4, 4), (1, 1, 1), (3, 1, 1), (10, 7, 7), (5, -1, 1)]",
+            "body": "solution = Solution()\n# Mock is_bad_version for this test\nsolution.is_bad_version = lambda version: self.is_bad_version(version, bad)\nresult = solution.first_bad_version(n)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\nn = 5\nbad = 4\nexpected = 4",
+    "playground_execution": "solution = Solution()\nsolution.is_bad_version = lambda version: version >= bad\nresult = solution.first_bad_version(n)\nresult",
+    "playground_assertion": "assert result == expected"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= ransom_note
+PROBLEM ?= first_bad_version
 FORCE ?= 0
 COMMA := ,
 

leetcode/first_bad_version/README.md

@@ -0,0 +1,47 @@
+# First Bad Version
+
+**Difficulty:** Easy
+**Topics:** Binary Search, Interactive
+**Tags:** grind-75
+
+**LeetCode:** [Problem 278](https://leetcode.com/problems/first-bad-version/description/)
+
+## Problem Description
+
+You are a product manager and currently leading a team to develop a new product. Unfortunately, the latest version of your product fails the quality check. Since each version is developed based on the previous version, all the versions after a bad version are also bad.
+
+Suppose you have `n` versions `[1, 2, ..., n]` and you want to find out the first bad one, which causes all the following ones to be bad.
+
+You are given an API `bool isBadVersion(version)` which returns whether `version` is bad. Implement a function to find the first bad version. You should minimize the number of calls to the API.
+
+## Examples
+
+### Example 1:
+
+```
+Input: n = 5, bad = 4
+Output: 4
+```
+
+**Explanation:**
+
+```
+call isBadVersion(3) -> false
+call isBadVersion(5) -> true
+call isBadVersion(4) -> true
+```
+
+Then 4 is the first bad version.
+
+### Example 2:
+
+```
+Input: n = 1, bad = 1
+Output: 1
+```
+
+## Constraints
+
+- 1 <= bad <= n <= 2^31 - 1
+
+**Note:** The `isBadVersion` API is already defined for you.

leetcode/first_bad_version/__init__.py

@@ -0,0 +1,81 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from solution import Solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example test case\n",
+    "n = 5\n",
+    "bad = 4\n",
+    "expected = 4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "solution = Solution(first_bad=bad)\n",
+    "result = solution.first_bad_version(n)\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert result == expected"
+   ]
+  }
+ ],
+ "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": "python3",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

leetcode/first_bad_version/playground.ipynb

@@ -0,0 +1,45 @@
+class Solution:
+    # TODO: template constraint
+    def __init__(self, first_bad):
+        self.is_bad_version = lambda version: version >= first_bad
+
+    # Time: O(log n)
+    # Space: O(1)
+    def first_bad_version(self, n: int) -> int:
+        left = 1
+        right = n
+
+        while left < right:
+            mid = (left + right) // 2
+            if self.is_bad_version(mid):
+                right = mid
+            else:
+                left = mid + 1
+
+        return right
+
+
+# BISECT PATTERNS - General Binary Search
+# Given: arr = [10,20,30,30,30,40,50], target = 30
+#               0  1  2  3  4  5  6
+#
+# bisect_left: Find FIRST occurrence (leftmost insertion point)
+#   while left < right:
+#       if arr[mid] >= target:  # >= keeps moving left
+#           right = mid
+#   Returns: 2 (index of first 30, value=30)
+#            [10,20,30,30,30,40,50]
+#             0  1  2  3  4  5  6
+#                   ↑ index 2
+#
+# bisect_right: Find position AFTER last occurrence
+#   while left < right:
+#       if arr[mid] > target:   # > allows equal values
+#           right = mid
+#   Returns: 5 (index after last 30, value=40)
+#            [10,20,30,30,30,40,50]
+#             0  1  2  3  4  5  6
+#                            ↑ index 5
+#
+# Key difference: >= vs > in the condition
+# This problem uses bisect_left pattern to find first bad version

leetcode/first_bad_version/solution.py

@@ -0,0 +1,17 @@
+import pytest
+
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution
+
+
+class TestFirstBadVersion:
+
+    @pytest.mark.parametrize(
+        "n, bad, expected", [(5, 4, 4), (1, 1, 1), (3, 1, 1), (10, 7, 7), (5, -1, 1)]
+    )
+    @logged_test
+    def test_first_bad_version(self, n: int, bad: int, expected: int):
+        solution = Solution(first_bad=bad)
+        result = solution.first_bad_version(n)
+        assert result == expected