feat: add Largest Rectangle in Histogram

Author: wislertt

.templates/leetcode/json/coin_change.json

@@ -5,7 +5,7 @@
     "problem_title": "Coin Change",
     "difficulty": "Medium",
     "topics": "Array, Dynamic Programming, Breadth-First Search",
-    "tags": [],
+    "tags": ["grind-75"],
     "readme_description": "You are given an integer array `coins` representing coins of different denominations and an integer `amount` representing a total amount of money.\n\nReturn the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return `-1`.\n\nYou may assume that you have an infinite number of each kind of coin.",
     "readme_examples": [
         {

.templates/leetcode/json/largest_rectangle_in_histogram.json

@@ -0,0 +1,47 @@
+{
+    "problem_name": "largest_rectangle_in_histogram",
+    "solution_class_name": "Solution",
+    "problem_number": "84",
+    "problem_title": "Largest Rectangle in Histogram",
+    "difficulty": "Hard",
+    "topics": "Array, Stack, Monotonic Stack",
+    "tags": ["grind-75"],
+    "readme_description": "Given an array of integers `heights` representing the histogram's bar height where the width of each bar is `1`, return the area of the largest rectangle in the histogram.",
+    "readme_examples": [
+        {
+            "content": "![Example 1](https://assets.leetcode.com/uploads/2021/01/04/histogram.jpg)\n\n```\nInput: heights = [2,1,5,6,2,3]\nOutput: 10\n```\n**Explanation:** The above is a histogram where width of each bar is 1. The largest rectangle is shown in the red area, which has an area = 10 units."
+        },
+        {
+            "content": "![Example 2](https://assets.leetcode.com/uploads/2021/01/04/histogram-1.jpg)\n\n```\nInput: heights = [2,4]\nOutput: 4\n```"
+        }
+    ],
+    "readme_constraints": "- `1 <= heights.length <= 10^5`\n- `0 <= heights[i] <= 10^4`",
+    "readme_additional": "",
+    "solution_imports": "",
+    "solution_methods": [
+        {
+            "name": "largest_rectangle_area",
+            "parameters": "heights: 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": "LargestRectangleInHistogram",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_largest_rectangle_area",
+            "parametrize": "heights, expected",
+            "parametrize_typed": "heights: list[int], expected: int",
+            "test_cases": "[([2, 1, 5, 6, 2, 3], 10), ([2, 4], 4), ([1], 1), ([0], 0), ([1, 1], 2), ([0, 0, 0], 0), ([1, 2, 3, 4, 5], 9), ([5, 4, 3, 2, 1], 9), ([3, 3, 3, 3], 12), ([2, 1, 2], 3), ([1, 3, 1], 3), ([6, 7, 5, 2, 4, 5, 9, 3], 16), ([4, 2, 0, 3, 2, 5], 6), ([1, 2, 2, 1], 4), ([0, 9], 9), ([9, 0], 9), ([2, 1, 5, 6, 2, 3, 1, 5, 6, 2], 10), ([1, 8, 6, 2, 5, 4, 8, 3, 7], 16)]",
+            "body": "result = self.solution.largest_rectangle_area(heights)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\nheights = [2, 1, 5, 6, 2, 3]\nexpected = 10",
+    "playground_execution": "result = Solution().largest_rectangle_area(heights)\nresult",
+    "playground_assertion": "assert result == expected"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= coin_change
+PROBLEM ?= largest_rectangle_in_histogram
 FORCE ?= 0
 COMMA := ,
 

leetcode/coin_change/README.md

@@ -2,7 +2,7 @@
 
 **Difficulty:** Medium
 **Topics:** Array, Dynamic Programming, Breadth-First Search
-**Tags:**
+**Tags:** grind-75
 
 **LeetCode:** [Problem 322](https://leetcode.com/problems/coin-change/description/)
 

leetcode/largest_rectangle_in_histogram/README.md

@@ -0,0 +1,38 @@
+# Largest Rectangle in Histogram
+
+**Difficulty:** Hard
+**Topics:** Array, Stack, Monotonic Stack
+**Tags:** grind-75
+
+**LeetCode:** [Problem 84](https://leetcode.com/problems/largest-rectangle-in-histogram/description/)
+
+## Problem Description
+
+Given an array of integers `heights` representing the histogram's bar height where the width of each bar is `1`, return the area of the largest rectangle in the histogram.
+
+## Examples
+
+### Example 1:
+
+![Example 1](https://assets.leetcode.com/uploads/2021/01/04/histogram.jpg)
+
+```
+Input: heights = [2,1,5,6,2,3]
+Output: 10
+```
+
+**Explanation:** The above is a histogram where width of each bar is 1. The largest rectangle is shown in the red area, which has an area = 10 units.
+
+### Example 2:
+
+![Example 2](https://assets.leetcode.com/uploads/2021/01/04/histogram-1.jpg)
+
+```
+Input: heights = [2,4]
+Output: 4
+```
+
+## Constraints
+
+- `1 <= heights.length <= 10^5`
+- `0 <= heights[i] <= 10^4`

leetcode/largest_rectangle_in_histogram/__init__.py

@@ -0,0 +1,79 @@
+{
+ "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",
+    "heights = [2, 1, 5, 6, 2, 3]\n",
+    "expected = 10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result = Solution().largest_rectangle_area(heights)\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": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

leetcode/largest_rectangle_in_histogram/playground.ipynb

@@ -0,0 +1,29 @@
+class Solution:
+    # Time: O(n)
+    # Space: O(n)
+    def largest_rectangle_area(self, heights: list[int]) -> int:
+        # Monotonic stack approach
+        # Stack stores indices of bars in increasing height order
+        # When we find a shorter bar, we calculate area using previous bars
+
+        stack: list[int] = []  # Stack of indices
+        max_area = 0
+
+        for i, height in enumerate(heights):
+            # While current height is less than stack top height
+            # Pop from stack and calculate area with popped height as smallest
+            while stack and heights[stack[-1]] > height:
+                max_area = max(max_area, self.calculate_area(heights, stack, i))
+
+            stack.append(i)
+
+        while stack:
+            max_area = max(max_area, self.calculate_area(heights, stack, len(heights)))
+
+        return max_area
+
+    @staticmethod
+    def calculate_area(heights: list[int], stack: list[int], right_bound: int) -> int:
+        h = heights[stack.pop()]
+        w = right_bound if not stack else right_bound - stack[-1] - 1
+        return h * w

leetcode/largest_rectangle_in_histogram/solution.py

@@ -0,0 +1,46 @@
+import pytest
+
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution
+
+
+class TestLargestRectangleInHistogram:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @pytest.mark.parametrize(
+        "heights, expected",
+        [
+            # Basic examples
+            ([2, 1, 5, 6, 2, 3], 10),
+            ([2, 4], 4),
+            # Edge cases
+            ([1], 1),
+            ([0], 0),
+            ([1, 1], 2),
+            ([0, 0, 0], 0),
+            # Patterns
+            ([1, 2, 3, 4, 5], 9),
+            ([5, 4, 3, 2, 1], 9),
+            ([3, 3, 3, 3], 12),
+            ([2, 1, 2], 3),
+            ([1, 3, 1], 3),
+            # Complex cases
+            ([6, 7, 5, 2, 4, 5, 9, 3], 16),
+            ([4, 2, 0, 3, 2, 5], 6),
+            ([1, 2, 2, 1], 4),
+            ([0, 9], 9),
+            ([9, 0], 9),
+            # Large rectangles
+            ([2, 1, 5, 6, 2, 3, 1, 5, 6, 2], 10),
+            ([1, 8, 6, 2, 5, 4, 8, 3, 7], 16),
+            ([50, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 50),
+            ([1, 1, 1, 1, 1, 50, 1, 1, 1, 1, 1], 50),
+            ([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 50], 50),
+        ],
+    )
+    @logged_test
+    def test_largest_rectangle_area(self, heights: list[int], expected: int):
+        result = self.solution.largest_rectangle_area(heights)
+        assert result == expected