Attempt 1 at assignment 2

Author: smodi23

02_activities/assignments/assignment_2.ipynb

@@ -27,17 +27,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2\n"
+     ]
+    }
+   ],
    "source": [
     "import hashlib\n",
     "\n",
     "def hash_to_range(input_string: str) -> int:\n",
     "     hash_object = hashlib.sha256(input_string.encode())\n",
     "     hash_int = int(hash_object.hexdigest(), 16)\n",
     "     return (hash_int % 3) + 1\n",
-    "input_string = \"your_first_name_here\"\n",
+    "input_string = \"sahil\"\n",
     "result = hash_to_range(input_string)\n",
     "print(result)\n"
    ]
@@ -141,13 +149,99 @@
    "outputs": [],
    "source": [
     "# Definition for a binary tree node.\n",
-    "# class TreeNode(object):\n",
-    "#     def __init__(self, val = 0, left = None, right = None):\n",
-    "#         self.val = val\n",
-    "#         self.left = left\n",
-    "#         self.right = right\n",
+    "from typing import List\n",
+    "\n",
+    "class TreeNode(object):\n",
+    "     def __init__(self, val = 0, left = None, right = None):\n",
+    "         self.val = val\n",
+    "         self.left = left\n",
+    "         self.right = right\n",
     "def bt_path(root: TreeNode) -> List[List[int]]:\n",
-    "  # TODO"
+    "    def dfs(node, path, result):\n",
+    "        if not node:\n",
+    "            return\n",
+    "        path.append(node.val)\n",
+    "        if not node.left and not node.right:  # If it's a leaf\n",
+    "            result.append(path[:])  # Copy the path\n",
+    "        else:\n",
+    "            dfs(node.left, path, result)\n",
+    "            dfs(node.right, path, result)\n",
+    "        path.pop()  # Backtrack\n",
+    "\n",
+    "    result = []\n",
+    "    dfs(root, [], result)\n",
+    "    return result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from collections import deque\n",
+    "\n",
+    "def build_tree(level_order):\n",
+    "    if not level_order:\n",
+    "        return None\n",
+    "    root = TreeNode(level_order[0])\n",
+    "    queue = deque([root])\n",
+    "    i = 1\n",
+    "    while queue and i < len(level_order):\n",
+    "        node = queue.popleft()\n",
+    "        if i < len(level_order):\n",
+    "            node.left = TreeNode(level_order[i])\n",
+    "            queue.append(node.left)\n",
+    "            i += 1\n",
+    "        if i < len(level_order):\n",
+    "            node.right = TreeNode(level_order[i])\n",
+    "            queue.append(node.right)\n",
+    "            i += 1\n",
+    "    return root"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[1, 2, 3], [1, 2, 5], [1, 2, 6], [1, 2, 7]]"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "root = build_tree([1, 2, 2, 3, 5, 6, 7])\n",
+    "paths = bt_path(root)\n",
+    "paths"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[10, 9, 8], [10, 7]]"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "root1 = build_tree([10, 9, 7, 8])\n",
+    "paths1 = bt_path(root1)\n",
+    "paths1"
    ]
   },
   {
@@ -227,7 +321,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your answer here"
+    "# Your answer here\n",
+    "# In the given list of integers, I need to move all the zeros to the end of the list while keeping the non-zero numbers in the original \n",
+    "# order which they appear in. "
    ]
   },
   {
@@ -244,7 +340,18 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your answer here"
+    "# Your answer here\n",
+    "# Example from me:\n",
+    "# Input: nums = [8, 6, 0, 2, 0, 0, 1]\n",
+    "# Output: [8, 6, 2, 1, 0, 0, 0]\n",
+    "\n",
+    "# Example from partner:\n",
+    "# Custom Test Case 1\n",
+    "# nums1 = [9, 0, 0, 3, 0, 2, 0]\n",
+    "# Expected: [9, 3, 2, 0, 0, 0, 0]\n",
+    "# The above example by my partner illustrates a list of numbers 9, 0, 0, 3, 0, 2, 0. Once put through the code, the expected output\n",
+    "# is correctly displayed as 9, 3, 2, 0, 0, 0, 0. The zeros have been moved to the end and the non-zero numbers are in the order they\n",
+    "# appear. \n"
    ]
   },
   {
@@ -257,11 +364,45 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[9, 3, 2, 0, 0, 0, 0]\n",
+      "[3, 0, 0, 0, 0]\n"
+     ]
+    }
+   ],
    "source": [
-    "# Your answer here"
+    "# Your answer here\n",
+    "from typing import List\n",
+    "\n",
+    "def move_zeros_to_end(nums: List[int]) -> List[int]:\n",
+    "    insert_pos = 0\n",
+    "\n",
+    "    for num in nums:\n",
+    "        if num != 0:\n",
+    "            nums[insert_pos] = num\n",
+    "            insert_pos += 1\n",
+    "\n",
+    "    while insert_pos < len(nums):\n",
+    "        nums[insert_pos] = 0\n",
+    "        insert_pos += 1\n",
+    "\n",
+    "    return nums\n",
+    "\n",
+    "# Validation\n",
+    "\n",
+    "# Custom Test Case 1\n",
+    "nums1 = [9, 0, 0, 3, 0, 2, 0]\n",
+    "print(move_zeros_to_end(nums1))  # Expected: [9, 3, 2, 0, 0, 0, 0]\n",
+    "\n",
+    "# Custom Test Case 2\n",
+    "nums2 = [0, 0, 0, 3, 0]\n",
+    "print(move_zeros_to_end(nums2))  # Expected: [3, 0, 0, 0, 0]"
    ]
   },
   {
@@ -278,7 +419,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your answer here"
+    "# Your answer here\n",
+    "# The solution works because the code loops through the list and everytime there is a non-zero number, it is moved ahead to the next\n",
+    "# available position. Once all non-zero numbers are moved forward, the remaining spaces are filled with the zeros. "
    ]
   },
   {
@@ -295,7 +438,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your answer here"
+    "# Your answer here\n",
+    "# The time complexity for this problem is O(n). It passes through the list 2 times. First to move all non-zero numbers and second to\n",
+    "# fill in the zeros. \n",
+    "# The space complexity for this problem is O(1). It modifies the list in place. "
    ]
   },
   {
@@ -312,7 +458,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your answer here"
+    "# Your answer here\n",
+    "# Overall the code is correct, clean, and efficient. The explainations are all correct as well. Only minor tweak could be to change the \n",
+    "# unnecessary overwrite when all the numbers are in the correct order for example [5, 9, 1, 2, 0, 0, 0]. "
    ]
   },
   {
@@ -338,7 +486,19 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your answer here"
+    "# Your answer here\n",
+    "# Working through the \"Valid Bracket Sequence\" problem helped me to deepen my understanding of how to use a stack data structure. \n",
+    "# Executing the code required deliberation of matching bracket pairs and the order in which they appear. I chose a stack data structure \n",
+    "# to track opening brackets and ensured each closing bracket had a valid corresponding opener. This exercise improved my analytical skills \n",
+    "# and highlighted the importance of testing, such as empty strings or strings with only one type of bracket.\n",
+    "\n",
+    "# Examining my partners \"Move All Zeros to End\" problem was a valuable learning experience in peer code reviews as done in industry. \n",
+    "# The logic behind using a two-pointer approach to preserve the relative order of non-zero elements while pushing zeros to the end was \n",
+    "# efficient. I analyzed its time and space complexity, recognizing that the in-place nature of the solution made it optimal. \n",
+    "# Critiquing the solution helped me understand subtle improvements and why certain decisions were made.\n",
+    "\n",
+    "# Overall, the process of writing and reviewing code strengthened my problem-solving skills, reinforced algorithmic thinking, and \n",
+    "# emphasized the value of reading someone else’s code.\n"
    ]
   },
   {
@@ -396,7 +556,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "dsi_participant",
    "language": "python",
    "name": "python3"
   },
@@ -410,7 +570,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.9.15"
   }
  },
  "nbformat": 4,