feat: add atoi problem

Author: wislertt

.templates/leetcode/json/string_to_integer_atoi.json

@@ -0,0 +1,51 @@
+{
+    "problem_name": "string_to_integer_atoi",
+    "solution_class_name": "Solution",
+    "problem_number": "8",
+    "problem_title": "String to Integer (atoi)",
+    "difficulty": "Medium",
+    "topics": "String",
+    "tags": ["grind-75"],
+    "readme_description": "Implement the `my_atoi(string s)` function, which converts a string to a 32-bit signed integer.\n\nThe algorithm for `my_atoi(string s)` is as follows:\n\n1. **Whitespace**: Ignore any leading whitespace (` `).\n2. **Signedness**: Determine the sign by checking if the next character is `-` or `+`, assuming positivity if neither present.\n3. **Conversion**: Read the integer by skipping leading zeros until a non-digit character is encountered or the end of the string is reached. If no digits were read, then the result is 0.\n4. **Rounding**: If the integer is out of the 32-bit signed integer range `[-2^31, 2^31 - 1]`, then round the integer to remain in the range. Specifically, integers less than `-2^31` should be rounded to `-2^31`, and integers greater than `2^31 - 1` should be rounded to `2^31 - 1`.\n\nReturn the integer as the final result.",
+    "readme_examples": [
+        {
+            "content": "```\nInput: s = \"42\"\nOutput: 42\n```\n**Explanation:**\n```\nThe underlined characters are what is read in and the caret is the current reader position.\nStep 1: \"42\" (no characters read because there is no leading whitespace)\n         ^\nStep 2: \"42\" (no characters read because there is neither a '-' nor '+')\n         ^\nStep 3: \"42\" (\"42\" is read in)\n           ^\n```"
+        },
+        {
+            "content": "```\nInput: s = \"   -042\"\nOutput: -42\n```\n**Explanation:**\n```\nStep 1: \"   -042\" (leading whitespace is read and ignored)\n            ^\nStep 2: \"   -042\" ('-' is read, so the result should be negative)\n             ^\nStep 3: \"   -042\" (\"042\" is read in, leading zeros ignored in the result)\n               ^\n```"
+        },
+        {
+            "content": "```\nInput: s = \"1337c0d3\"\nOutput: 1337\n```\n**Explanation:**\n```\nStep 1: \"1337c0d3\" (no characters read because there is no leading whitespace)\n         ^\nStep 2: \"1337c0d3\" (no characters read because there is neither a '-' nor '+')\n         ^\nStep 3: \"1337c0d3\" (\"1337\" is read in; reading stops because the next character is a non-digit)\n             ^\n```"
+        },
+        {
+            "content": "```\nInput: s = \"0-1\"\nOutput: 0\n```\n**Explanation:**\n```\nStep 1: \"0-1\" (no characters read because there is no leading whitespace)\n         ^\nStep 2: \"0-1\" (no characters read because there is neither a '-' nor '+')\n         ^\nStep 3: \"0-1\" (\"0\" is read in; reading stops because the next character is a non-digit)\n          ^\n```"
+        },
+        {
+            "content": "```\nInput: s = \"words and 987\"\nOutput: 0\n```\n**Explanation:** Reading stops at the first non-digit character 'w'."
+        }
+    ],
+    "readme_constraints": "- `0 <= s.length <= 200`\n- `s` consists of English letters (lower-case and upper-case), digits (0-9), ` `, `+`, `-`, and `.`.",
+    "readme_additional": "",
+    "solution_imports": "",
+    "solution_methods": [
+        { "name": "my_atoi", "parameters": "s: str", "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": "StringToIntegerAtoi",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_my_atoi",
+            "parametrize": "s, expected",
+            "parametrize_typed": "s: str, expected: int",
+            "test_cases": "[('42', 42), ('   -042', -42), ('1337c0d3', 1337), ('0-1', 0), ('words and 987', 0), ('', 0), ('   ', 0), ('+1', 1), ('-1', -1), ('2147483647', 2147483647), ('-2147483648', -2147483648), ('2147483648', 2147483647), ('-2147483649', -2147483648)]",
+            "body": "result = self.solution.my_atoi(s)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\ns = '42'\nexpected = 42",
+    "playground_execution": "result = Solution().my_atoi(s)\nresult",
+    "playground_assertion": "assert result == expected"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= implement_trie_prefix_tree
+PROBLEM ?= string_to_integer_atoi
 FORCE ?= 0
 COMMA := ,
 

leetcode/string_to_integer_atoi/README.md

@@ -0,0 +1,109 @@
+# String to Integer (atoi)
+
+**Difficulty:** Medium
+**Topics:** String
+**Tags:** grind-75
+
+**LeetCode:** [Problem 8](https://leetcode.com/problems/string-to-integer-atoi/description/)
+
+## Problem Description
+
+Implement the `my_atoi(string s)` function, which converts a string to a 32-bit signed integer.
+
+The algorithm for `my_atoi(string s)` is as follows:
+
+1. **Whitespace**: Ignore any leading whitespace (` `).
+2. **Signedness**: Determine the sign by checking if the next character is `-` or `+`, assuming positivity if neither present.
+3. **Conversion**: Read the integer by skipping leading zeros until a non-digit character is encountered or the end of the string is reached. If no digits were read, then the result is 0.
+4. **Rounding**: If the integer is out of the 32-bit signed integer range `[-2^31, 2^31 - 1]`, then round the integer to remain in the range. Specifically, integers less than `-2^31` should be rounded to `-2^31`, and integers greater than `2^31 - 1` should be rounded to `2^31 - 1`.
+
+Return the integer as the final result.
+
+## Examples
+
+### Example 1:
+
+```
+Input: s = "42"
+Output: 42
+```
+
+**Explanation:**
+
+```
+The underlined characters are what is read in and the caret is the current reader position.
+Step 1: "42" (no characters read because there is no leading whitespace)
+         ^
+Step 2: "42" (no characters read because there is neither a '-' nor '+')
+         ^
+Step 3: "42" ("42" is read in)
+           ^
+```
+
+### Example 2:
+
+```
+Input: s = "   -042"
+Output: -42
+```
+
+**Explanation:**
+
+```
+Step 1: "   -042" (leading whitespace is read and ignored)
+            ^
+Step 2: "   -042" ('-' is read, so the result should be negative)
+             ^
+Step 3: "   -042" ("042" is read in, leading zeros ignored in the result)
+               ^
+```
+
+### Example 3:
+
+```
+Input: s = "1337c0d3"
+Output: 1337
+```
+
+**Explanation:**
+
+```
+Step 1: "1337c0d3" (no characters read because there is no leading whitespace)
+         ^
+Step 2: "1337c0d3" (no characters read because there is neither a '-' nor '+')
+         ^
+Step 3: "1337c0d3" ("1337" is read in; reading stops because the next character is a non-digit)
+             ^
+```
+
+### Example 4:
+
+```
+Input: s = "0-1"
+Output: 0
+```
+
+**Explanation:**
+
+```
+Step 1: "0-1" (no characters read because there is no leading whitespace)
+         ^
+Step 2: "0-1" (no characters read because there is neither a '-' nor '+')
+         ^
+Step 3: "0-1" ("0" is read in; reading stops because the next character is a non-digit)
+          ^
+```
+
+### Example 5:
+
+```
+Input: s = "words and 987"
+Output: 0
+```
+
+**Explanation:** Reading stops at the first non-digit character 'w'.
+
+## Constraints
+
+- `0 <= s.length <= 200`
+- `s` consists of English letters (lower-case and upper-case), digits (0-9), ` `, `+`, `-`, and `.`.

leetcode/string_to_integer_atoi/__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",
+    "s = \"42\"\n",
+    "expected = 42"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "42"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result = Solution().my_atoi(s)\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/string_to_integer_atoi/playground.ipynb

@@ -0,0 +1,30 @@
+class Solution:
+    # Time: O(n)
+    # Space: O(1)
+    def my_atoi(self, s: str) -> int:
+        i = 0
+        n = len(s)
+
+        # Skip whitespace
+        while i < n and s[i] == " ":
+            i += 1
+
+        if i == n:
+            return 0
+
+        # Check sign
+        sign = 1
+        if s[i] in {"+", "-"}:
+            sign = -1 if s[i] == "-" else 1
+            i += 1
+
+        # Convert digits
+        result = 0
+        while i < n and s[i].isdigit():
+            result = result * 10 + int(s[i])
+            i += 1
+
+        result *= sign
+
+        # Clamp to 32-bit range
+        return max(-(2**31), min(2**31 - 1, result))

leetcode/string_to_integer_atoi/solution.py

@@ -0,0 +1,49 @@
+import pytest
+
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution
+
+
+class TestStringToIntegerAtoi:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @pytest.mark.parametrize(
+        "s, expected",
+        [
+            ("42", 42),
+            ("   -042", -42),
+            ("1337c0d3", 1337),
+            ("0-1", 0),
+            ("words and 987", 0),
+            ("", 0),
+            ("   ", 0),
+            ("+1", 1),
+            ("-1", -1),
+            ("2147483647", 2147483647),
+            ("-2147483648", -2147483648),
+            ("2147483648", 2147483647),
+            ("-2147483649", -2147483648),
+            # Edge cases
+            ("+-12", 0),
+            ("-+12", 0),
+            ("++1", 0),
+            ("--1", 0),
+            ("   +0 123", 0),
+            ("0000000000012345678", 12345678),
+            ("-000000000000001", -1),
+            ("   +000", 0),
+            ("123-", 123),
+            ("   13  5", 13),
+            (".1", 0),
+            ("1a33", 1),
+            ("  -0012a42", -12),
+            ("21474836460", 2147483647),
+            ("-21474836480", -2147483648),
+        ],
+    )
+    @logged_test
+    def test_my_atoi(self, s: str, expected: int):
+        result = self.solution.my_atoi(s)
+        assert result == expected