add Reverse 32-Bit Integer

Author: MarcoBasileDev

Cheatsheet/MathAndGeometry/reverse_32_bit_integer.ipynb

@@ -0,0 +1,136 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "6f0cd801",
+   "metadata": {},
+   "source": [
+    "# Reverse 32-Bit Integer\n",
+    "Reverse the digits of a signed 32-bit integer. If the reversed integer overflows (i.e., is outside the range [−2<sup>31</sup>, −2<sup>31</sup> -1]), return 0. Assume the environment only allows you to store integers within the signed 32-bit integer range."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58d6cb87",
+   "metadata": {},
+   "source": [
+    "## Intuition\n",
+    "\n",
+    "The main challenge in this problem lies in correctly handling edge cases, particularly integer overflow and underflow. Before addressing those, let's first focus on how to reverse an integer in a basic scenario.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "### Reversing Positive and Negative Numbers\n",
+    "\n",
+    "To reverse an integer `n`, follow these steps:\n",
+    "\n",
+    "1. Extract the last digit:  \n",
+    "   `digit = n % 10`\n",
+    "\n",
+    "2. Remove the last digit from `n`:  \n",
+    "   `n = n // 10`\n",
+    "\n",
+    "3. Append the digit to the reversed number:  \n",
+    "   `reversed_n = reversed_n * 10 + digit`\n",
+    "\n",
+    "This logic works for both positive and negative integers.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "### Detecting Integer Overflow\n",
+    "\n",
+    "If the reversed integer exceeds the maximum value representable by a 32-bit signed integer, i.e.,  \n",
+    "`INT_MAX = 2^31 - 1 = 2147483647`,  \n",
+    "then we must return `0` to indicate an overflow.\n",
+    "\n",
+    "We **cannot** check for overflow **after** appending the digit, because the multiplication and addition themselves may already cause an overflow.  \n",
+    "Instead, we perform a **preemptive check** before appending the digit.\n",
+    "\n",
+    "```python\n",
+    "if reversed_n > INT_MAX // 10:\n",
+    "    return 0\n",
+    "```\n",
+    "\n",
+    "---\n",
+    "\n",
+    "#### Why this works?\n",
+    "This condition checks whether `reversed_n` is already large enough that multiplying it by 10 would push it past `INT_MAX`.\n",
+    "- If `reversed_n > INT_MAX // 10`, then `reversed_n * 10` is guaranteed to exceed `INT_MAX`.\n",
+    "- Even if `reversed_n == INT_MAX // 10`, appending any digit > 7 would overflow (since `INT_MAX % 10 == 7`), so a stricter check may also compare the `digit`.\n",
+    "\n",
+    "But for simplicity and early exit, this inequality suffices to catch imminent overflows.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "### Detecting Integer Underflow\n",
+    "Similarly, for the minimum 32-bit signed integer value: `INT_MIN = -2^31 = -2147483648`.\n",
+    "We check before appending the digit:\n",
+    "\n",
+    "```python\n",
+    "if reversed_n < INT_MIN // 10:\n",
+    "    return 0\n",
+    "```\n",
+    "\n",
+    "This ensures that multiplying `reversed_n` by 10 won't cause it to drop below `INT_MIN`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "d08c74c9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math\n",
+    "\n",
+    "def reverse_32_bit_integer(n: int) -> int:\n",
+    "    INT_MAX = 2**31 - 1\n",
+    "    INT_MIN = -2**31\n",
+    "    reversed_n = 0\n",
+    "\n",
+    "    while n != 0:\n",
+    "        digit = int(math.fmod(n, 10))\n",
+    "        n = int(n / 10)\n",
+    "\n",
+    "        if (reversed_n > int(INT_MAX / 10) or reversed_n < int(INT_MIN // 10)):\n",
+    "            return 0\n",
+    "\n",
+    "        reversed_n = reversed_n * 10 + digit\n",
+    "    \n",
+    "    return reversed_n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d0f98617",
+   "metadata": {},
+   "source": [
+    "### Complexity Analysis\n",
+    "The time complexity is O(log(n)) because we loop through each digit of n, of which there are roughly log(n) digits. As this environment supports 32-bit integers, the time complexity can also be considered O(1).\n",
+    "\n",
+    "The space complexity is O(1)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}