17_leetcode_problems.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1. Two Sum (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution1:\n",
    "    def two_sum(self, nums: List[int], target: int) -> List[int]:\n",
    "        for i, num1 in enumerate(nums):\n",
    "            for j, num2 in enumerate(nums[i+1:]):\n",
    "                if num1 + num2 == target:\n",
    "                    return [i, j+i+1]\n",
    "\n",
    "Solution1().two_sum(nums=[3,3], target=6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 0]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution1_1:\n",
    "    def two_sum(self, nums: List[int], target: int) -> List[int]:\n",
    "        seen = {}\n",
    "        for i, num in enumerate(nums):\n",
    "            comp = target - num\n",
    "            if comp in seen:\n",
    "                return [i, seen[comp]]\n",
    "            seen[num] = i\n",
    "\n",
    "Solution1_1().two_sum(nums=[3,3], target=6)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 2. Add Two Numbers (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ListNode{val: 7, next: ListNode{val: 0, next: ListNode{val: 8, next: None}}}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "\n",
    "def linked_list_to_int(l1: Optional[ListNode]) -> Optional[int]:\n",
    "    l1_list = [l1.val]\n",
    "    l1 = l1.next\n",
    "    while l1 is not None:\n",
    "        l1_list.append(l1.val)\n",
    "        l1 = l1.next\n",
    "    return int(''.join([str(i) for i in l1_list[::-1]]))\n",
    "\n",
    "\n",
    "def int_to_linked_list(n: Optional[int]) -> Optional[ListNode]:\n",
    "    n_list = [int(i) for i in str(n)]\n",
    "    linked_list = ListNode(val=n_list[0], next=None)\n",
    "    for value in n_list[1:]:\n",
    "        linked_list = ListNode(val=value, next=linked_list)\n",
    "    return linked_list\n",
    "    \n",
    "\n",
    "class Solution2:\n",
    "    def add_two_numbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:\n",
    "        l1_int = linked_list_to_int(l1)\n",
    "        l2_int = linked_list_to_int(l2)\n",
    "        return int_to_linked_list(l1_int+l2_int)\n",
    "\n",
    "Solution2().add_two_numbers(\n",
    "    l1=ListNode(val=2,next=ListNode(val=4, next=ListNode(val=3, next=None))),\n",
    "    l2=ListNode(val=5,next=ListNode(val=6, next=ListNode(val=4, next=None)))\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ListNode{val: 7, next: ListNode{val: 0, next: ListNode{val: 8, next: None}}}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution2_1:\n",
    "    def add_two_numbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:\n",
    "        zero_node = ListNode(None)\n",
    "        prev = zero_node\n",
    "        carry = 0\n",
    "        while l1 or l2 or carry:\n",
    "            d1 = l1.val if l1 else 0\n",
    "            d2 = l2.val if l2 else 0\n",
    "            carry, d = divmod(d1 + d2 + carry, 10)\n",
    "            prev.next = ListNode(d)\n",
    "            prev = prev.next\n",
    "            l1 = l1.next if l1 else None\n",
    "            l2 = l2.next if l2 else None\n",
    "        return zero_node.next\n",
    "\n",
    "Solution2_1().add_two_numbers(\n",
    "    l1=ListNode(val=2,next=ListNode(val=4, next=ListNode(val=3, next=None))),\n",
    "    l2=ListNode(val=5,next=ListNode(val=6, next=ListNode(val=4, next=None)))\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 3. Longest Substring Without Repeating Characters (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution3:\n",
    "    def length_of_longest_substring(self, s: str) -> int:\n",
    "        longest_size = 0\n",
    "        for i, _ in enumerate(s):\n",
    "            j = i + 1\n",
    "            while len(set(s[i:j+1])) == len(s[i:j+1]) and j <= len(s):\n",
    "                j += 1\n",
    "            if (j - i) > longest_size:\n",
    "                longest_size = j - i\n",
    "        return longest_size\n",
    "\n",
    "Solution3().length_of_longest_substring(s='abstracefaaabc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution3_1:\n",
    "    def length_of_longest_substring(self, s: str) -> int:\n",
    "        d = {}\n",
    "        i = 0\n",
    "        ans = 0\n",
    "        for j, _ in enumerate(s):\n",
    "            if s[j] in d:\n",
    "                i = max(d[s[j]] + 1, i)\n",
    "            d[s[j]] = j\n",
    "            ans = max(ans, j - i + 1)\n",
    "        return ans\n",
    "\n",
    "Solution3_1().length_of_longest_substring(s='abstracefaaabc')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 4. Median of Two Sorted Arrays (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution4:\n",
    "    def find_median_sorted_arrays(self, nums1: List[int], nums2: List[int]) -> float:\n",
    "        m = len(nums1)\n",
    "        n = len(nums2)\n",
    "        m1 = 0\n",
    "        m2 = 0\n",
    "        i = 0\n",
    "        j = 0\n",
    "        for _ in range((m + n) // 2 + 1):\n",
    "            m2 = m1\n",
    "            if i != m and j != n:\n",
    "                if nums1[i] > nums2[j]:\n",
    "                    m1 = nums2[j]\n",
    "                    j += 1\n",
    "                else:\n",
    "                    m1 = nums1[i]\n",
    "                    i += 1\n",
    "            elif i < m:\n",
    "                m1 = nums1[i]\n",
    "                i += 1\n",
    "            else:\n",
    "                m1 = nums2[j]\n",
    "                j += 1\n",
    "        \n",
    "        if (m + n) % 2 == 1:\n",
    "            return float(m1)\n",
    "        else:\n",
    "            return (m1 + m2) / 2\n",
    "\n",
    "Solution4().find_median_sorted_arrays(nums1=[0, 0], nums2=[3, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution4_1:\n",
    "    def find_median_sorted_arrays(self, nums1: List[int], nums2: List[int]) -> float:\n",
    "        merged = []\n",
    "        i, j = 0, 0\n",
    "        while i < len(nums1) and j < len(nums2):\n",
    "            if nums1[i] < nums2[j]:\n",
    "                merged.append(nums1[i])\n",
    "                i += 1\n",
    "            else:\n",
    "                merged.append(nums2[j])\n",
    "                j += 1\n",
    "        while i < len(nums1):\n",
    "            merged.append(nums1[i])\n",
    "            i += 1\n",
    "        while j < len(nums2):\n",
    "            merged.append(nums2[j])\n",
    "            j += 1\n",
    "        mid = len(merged) // 2\n",
    "        if len(merged) % 2 == 0:\n",
    "            return (merged[mid-1] + merged[mid]) / 2\n",
    "        else:\n",
    "            return merged[mid]\n",
    "\n",
    "Solution4_1().find_median_sorted_arrays(nums1=[0, 0], nums2=[3, 4])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 5. Longest Palindromic Substring (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'dabad'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution5:\n",
    "    def longest_palindrome(self, s: str) -> str:\n",
    "        longest_palindrome = ''\n",
    "        for i, _ in enumerate(s):\n",
    "            for j, _ in enumerate(s[i:]):\n",
    "                current_substring = s[i:j+i+1]\n",
    "                if current_substring == current_substring[::-1] and len(current_substring) > len(longest_palindrome):\n",
    "                    longest_palindrome = current_substring\n",
    "        return longest_palindrome\n",
    "\n",
    "Solution5().longest_palindrome(s='dabadc')\n",
    "# превышен лимит времени на тестовом примере сайта"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bb'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution5_1:\n",
    "    def longest_palindrome(self, s: str) -> str:\n",
    "        ans = ''\n",
    "        def helper_with_pointers(ans, left, right):\n",
    "            while left >= 0 and right < len(s):\n",
    "                if s[left] != s[right]:\n",
    "                    break\n",
    "                if right - left + 1 > len(ans):\n",
    "                    ans = s[left:right+1]\n",
    "                left -= 1\n",
    "                right += 1\n",
    "            return ans\n",
    "        for i, _ in enumerate(s):\n",
    "            ans = helper_with_pointers(ans, i, i)\n",
    "            ans = helper_with_pointers(ans, i, i+1)\n",
    "        return ans\n",
    "\n",
    "Solution5_1().longest_palindrome(s='cbbd')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 6. Zigzag Conversion (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['PIN', 'ALSIG', 'YAHR', 'PI']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'PINALSIGYAHRPI'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution6:\n",
    "    def convert(self, s: str, num_rows: int) -> str:\n",
    "        if num_rows == 1:\n",
    "            return s\n",
    "        ans = ['' for i in range(num_rows)]\n",
    "        cur_row = 0\n",
    "        regime_flag = True\n",
    "        for i, _ in enumerate(s):\n",
    "            if regime_flag and cur_row == num_rows:\n",
    "                regime_flag = False\n",
    "                cur_row -= 1\n",
    "            if not regime_flag and cur_row == 0:\n",
    "                regime_flag = True\n",
    "                cur_row += 1\n",
    "            if regime_flag:\n",
    "                ans[cur_row] += s[i]\n",
    "                cur_row += 1\n",
    "            else:\n",
    "                cur_row -= 1\n",
    "                ans[cur_row] += s[i]\n",
    "        s_ans = ''\n",
    "        print(ans)\n",
    "        for s_row in ans:\n",
    "            s_ans += s_row\n",
    "        return s_ans\n",
    "\n",
    "Solution6().convert(s=\"PAYPALISHIRING\", num_rows=4)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 7. Reverse Integer (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution7:\n",
    "    def reverse(self, x: int) -> int:\n",
    "        if x < 0:\n",
    "            x = -x\n",
    "            x_str = str(x)[::-1]\n",
    "            if len(x_str) < 10:\n",
    "                return int('-' + x_str)\n",
    "            else:\n",
    "                if len(x_str) == 10 and x_str <= '2147483648':\n",
    "                    return int('-' + x_str)\n",
    "                else:\n",
    "                    return 0\n",
    "        else:\n",
    "            x_str = str(x)[::-1]\n",
    "            if len(x_str) < 10:\n",
    "                return int(x_str)\n",
    "            else:\n",
    "                if len(x_str) == 10 and x_str <= '2147483647':\n",
    "                    return int(x_str)\n",
    "                else:\n",
    "                    return 0\n",
    "\n",
    "Solution7().reverse(x=120)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 9. Palindrome Number (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution9:\n",
    "    def is_palindrome(self, x: int) -> bool:\n",
    "        if str(x)[::-1] == str(x):\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "Solution9().is_palindrome(x=10101)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution9_1:\n",
    "    def is_palindrome(self, x: int) -> bool:\n",
    "        if x < 0:\n",
    "            return False\n",
    "        new = 0\n",
    "        original_x = x\n",
    "        while x:\n",
    "            x, d = divmod(x, 10)\n",
    "            new = new * 10 + d\n",
    "        return new == original_x\n",
    "\n",
    "Solution9_1().is_palindrome(x=10101)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 10. Regular Expression Matching (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution10:\n",
    "    def is_match(self, s: str, p: str) -> bool:\n",
    "        memo = {}\n",
    "        def dp(i: int, j: int) -> bool:\n",
    "            if (i, j) in memo:\n",
    "                return memo[(i, j)]\n",
    "            if j == len(p):\n",
    "                return i == len(s)\n",
    "            first_match = i < len(s) and (p[j] == s[i] or p[j] == '.')\n",
    "            if j + 1 < len(p) and p[j + 1] == '*':\n",
    "                ans = dp(i, j + 2) or (first_match and dp(i + 1, j))\n",
    "            else:\n",
    "                ans = first_match and dp(i + 1, j + 1)\n",
    "            memo[(i, j)] = ans\n",
    "            return ans\n",
    "        return dp(0, 0)\n",
    "\n",
    "Solution10().is_match(s='aa', p='a')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 11. Container With Most Water (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "49"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution11:\n",
    "    def max_area(self, height: List[int]) -> int:\n",
    "        left, right = 0, len(height) - 1\n",
    "        ans = 0\n",
    "        while left <= right:\n",
    "            ans = max(ans, (right - left) * min(height[left], height[right]))\n",
    "            if height[left] < height[right]:\n",
    "                left += 1\n",
    "            else:\n",
    "                right -= 1\n",
    "        return ans\n",
    "\n",
    "Solution11().max_area(height=[1, 8, 6, 2, 5, 4, 8, 3, 7])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 12. Integer to Roman (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'LVIII'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution12:\n",
    "    def int_to_roman(self, num: int) -> str:\n",
    "        int_to_roman_map = {1: 'I', 4: 'IV',\n",
    "                            5: 'V', 9: 'IX',\n",
    "                            10: 'X', 40: 'XL',\n",
    "                            50: 'L', 90: 'XC',\n",
    "                            100: 'C', 400: 'CD',\n",
    "                            500: 'D', 900: 'CM',\n",
    "                            1000: 'M'}\n",
    "        ans = ''\n",
    "        for k, v in reversed(int_to_roman_map.items()):\n",
    "            while k <= num:\n",
    "                ans += v\n",
    "                num -= k\n",
    "        return ans\n",
    "\n",
    "Solution12().int_to_roman(num=58)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'LVIII'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution12_1:\n",
    "    def int_to_roman(self, num: int) -> str:\n",
    "        int_to_roman_map = {1: 'I', 4: 'IV',\n",
    "                            5: 'V', 9: 'IX',\n",
    "                            10: 'X', 40: 'XL',\n",
    "                            50: 'L', 90: 'XC',\n",
    "                            100: 'C', 400: 'CD',\n",
    "                            500: 'D', 900: 'CM',\n",
    "                            1000: 'M'}\n",
    "        ans = ''\n",
    "        for k in sorted(list(int_to_roman_map.keys()),reverse=True):\n",
    "            while k <= num:\n",
    "                ans += int_to_roman_map[k]\n",
    "                num -= k\n",
    "        return ans\n",
    "\n",
    "Solution12_1().int_to_roman(num=58)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 13. Roman to Integer (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1994"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution13:\n",
    "    def roman_to_int(self, s: str) -> int:\n",
    "        symbols_dict = {\n",
    "            'I': 1,\n",
    "            'V': 5,\n",
    "            'X': 10,\n",
    "            'L': 50,\n",
    "            'C': 100,\n",
    "            'D': 500,\n",
    "            'M': 1000\n",
    "        }\n",
    "        s_int = 0\n",
    "        last_symbol = s[0]\n",
    "        for symbol in s:\n",
    "            if symbols_dict[symbol] > symbols_dict[last_symbol]:\n",
    "                s_int += symbols_dict[symbol]\n",
    "                s_int -= 2 * symbols_dict[last_symbol]\n",
    "            else:\n",
    "                s_int += symbols_dict[symbol]\n",
    "            last_symbol = symbol\n",
    "        \n",
    "        return s_int\n",
    "\n",
    "Solution13().roman_to_int(s='MCMXCIV')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1994"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution13_1:\n",
    "    def roman_to_int(self, s: str) -> int:\n",
    "        symbols_dict = {\n",
    "            'I': 1,\n",
    "            'V': 5,\n",
    "            'X': 10,\n",
    "            'L': 50,\n",
    "            'C': 100,\n",
    "            'D': 500,\n",
    "            'M': 1000\n",
    "        }\n",
    "        ans = 0\n",
    "        i = 0\n",
    "        while i < len(s):\n",
    "            if i < len(s) - 1 and symbols_dict[s[i]] < symbols_dict[s[i+1]]:\n",
    "                ans += symbols_dict[s[i+1]] - symbols_dict[s[i]]\n",
    "                i += 2\n",
    "            else:\n",
    "                ans += symbols_dict[s[i]]\n",
    "                i += 1\n",
    "        return ans\n",
    "\n",
    "Solution13_1().roman_to_int(s='MCMXCIV')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 14. Longest Common Prefix (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'geo'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution14:\n",
    "    def longest_common_prefix(self, strs: List[str]) -> str:\n",
    "        common_prefix = ''\n",
    "        words_lengths = [len(word) for word in strs]\n",
    "        min_index = words_lengths.index(min(words_lengths))\n",
    "        for i, s in enumerate(strs[min_index]):\n",
    "            if [word[i] == s for word in strs] == [1]*len(strs):\n",
    "                common_prefix += s\n",
    "            else:\n",
    "                break\n",
    "        return common_prefix\n",
    "\n",
    "Solution14().longest_common_prefix(strs=['geology','geomechanics', 'geometry'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'c'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution14_1:\n",
    "    def longest_common_prefix(self, strs: List[str]) -> str:\n",
    "        first = strs[0]\n",
    "        ans = ''\n",
    "        i = 0\n",
    "        for i, _ in enumerate(first):\n",
    "            for word in strs[1:]:\n",
    "                if i > len(word) - 1 or first[i] != word[i]:\n",
    "                    return ans\n",
    "            ans += first[i]\n",
    "        return ans\n",
    "\n",
    "Solution14_1().longest_common_prefix(strs=['cir', 'car'])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 15. 3Sum (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(-3, -1, 4),\n",
       " (-1, 0, 1),\n",
       " (-4, 1, 3),\n",
       " (-1, -1, 2),\n",
       " (-3, 1, 2),\n",
       " (-3, 0, 3),\n",
       " (-4, 0, 4),\n",
       " (-2, -1, 3),\n",
       " (-2, 0, 2)]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution15:\n",
    "    def three_sum(self, nums: List[int]) -> List[List[int]]:\n",
    "        def two_sum(ind):\n",
    "            target = -nums[ind]\n",
    "            seen = set()\n",
    "            for j, _ in enumerate(nums):\n",
    "                if j != ind:\n",
    "                    comp = target - nums[j]\n",
    "                    if comp in seen:\n",
    "                        ans.add(tuple(sorted([nums[ind], nums[j], comp])))\n",
    "                    seen.add(nums[j])\n",
    "        ans = set()\n",
    "\n",
    "        already_seen = set()\n",
    "        for i, _ in enumerate(nums):\n",
    "            if nums[i] not in already_seen:\n",
    "                already_seen.add(nums[i])\n",
    "                two_sum(i)\n",
    "        \n",
    "        return list(ans)\n",
    "\n",
    "Solution15().three_sum(nums=[-1,0,1,2,-1,-4,-2,-3,3,0,4])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 17. Letter Combinations of a Phone Number (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ad', 'ae', 'af', 'bd', 'be', 'bf', 'cd', 'ce', 'cf']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution17:\n",
    "    def letter_combinations(self, digits: str) -> List[str]:\n",
    "\n",
    "        if len(digits) == 0:\n",
    "            return ''\n",
    "        \n",
    "        buttons_dict = {'2': 'abc',\n",
    "                        '3': 'def',\n",
    "                        '4': 'ghi',\n",
    "                        '5': 'jkl',\n",
    "                        '6': 'mno',\n",
    "                        '7': 'prqs',\n",
    "                        '8': 'tuv',\n",
    "                        '9': 'wxyz'}\n",
    "        ans = []\n",
    "        def dfs(digits, comb):\n",
    "            if len(digits) == 0:\n",
    "                ans.append(comb)\n",
    "                return\n",
    "            for l in buttons_dict[digits[0]]:\n",
    "                dfs(digits[1:], comb + l)\n",
    "        dfs(digits, '')\n",
    "        return ans\n",
    "\n",
    "Solution17().letter_combinations(digits='23')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 19. Remove Nth Node From End of List (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ListNode{val: 1, next: ListNode{val: 2, next: ListNode{val: 3, next: ListNode{val: 5, next: None}}}}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution19:\n",
    "    def remove_nth_from_end(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:\n",
    "        zero_node = ListNode(None)\n",
    "        zero_node.next = head\n",
    "        pointer1 = zero_node\n",
    "        pointer2 = zero_node\n",
    "        cnt = 0\n",
    "        while pointer1:\n",
    "            pointer1 = pointer1.next\n",
    "            if cnt >= n + 1:\n",
    "                pointer2 = pointer2.next\n",
    "            cnt += 1\n",
    "        pointer2.next = pointer2.next.next\n",
    "        return zero_node.next\n",
    "\n",
    "Solution19().remove_nth_from_end(head=ListNode(1,ListNode(2,ListNode(3,ListNode(4,ListNode(5,None))))), n=2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 20. Valid Parentheses (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution20:\n",
    "    def is_valid(self, s: str) -> bool:\n",
    "        braces_list = ['{}', '[]', '()']\n",
    "        while [braces in s for braces in braces_list] != [0, 0, 0]:\n",
    "            for braces in braces_list:\n",
    "                s = s.replace(braces, '')\n",
    "        if len(s):\n",
    "            return False\n",
    "        else:\n",
    "            return True\n",
    "\n",
    "Solution20().is_valid(s='([)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution20_1:\n",
    "    def is_valid(self, s: str) -> bool:\n",
    "        stack = []\n",
    "        parentheses_dict = {')':'(', ']':'[', '}':'{'}\n",
    "        for ch in s:\n",
    "            if ch not in parentheses_dict.keys():\n",
    "                stack.append(ch)\n",
    "            else:\n",
    "                if stack and stack[-1] == parentheses_dict[ch]:\n",
    "                    stack.pop()\n",
    "                else:\n",
    "                    return False\n",
    "        return len(stack) == 0\n",
    "\n",
    "Solution20_1().is_valid(s='()')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# следующий код немного лучше отрабатывает по времени и по памяти\n",
    "class Solution20_2:\n",
    "    def is_valid(self, s: str) -> bool:\n",
    "        while '{}' in s or '[]' in s or '()' in s:\n",
    "            s = s.replace('{}', '').replace('[]', '').replace('()', '')\n",
    "        return True if s == '' else False\n",
    "\n",
    "Solution20_2().is_valid(s='([])')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 21. Merge Two Sorted Lists (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ListNode{val: 1, next: ListNode{val: 1, next: ListNode{val: 2, next: ListNode{val: 3, next: ListNode{val: 4, next: ListNode{val: 4, next: None}}}}}}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution21:\n",
    "    def merge_two_lists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:\n",
    "        zero_node = ListNode(None)\n",
    "        prev = zero_node\n",
    "        while list1 and list2:\n",
    "            if list1.val > list2.val:\n",
    "                prev.next = list2\n",
    "                list2 = list2.next\n",
    "            else:\n",
    "                prev.next = list1\n",
    "                list1 = list1.next\n",
    "            prev = prev.next\n",
    "        if list1:\n",
    "            prev.next = list1\n",
    "        if list2:\n",
    "            prev.next = list2\n",
    "        return zero_node.next\n",
    "\n",
    "Solution21().merge_two_lists(list1=ListNode(val=1, next=ListNode(val=2, next=ListNode(val=4, next=None))),\n",
    "                             list2=ListNode(val=1, next=ListNode(val=3, next=ListNode(val=4, next=None))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 22. Generate Parantheses (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['((()))', '(()())', '(())()', '()(())', '()()()']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution22:\n",
    "    def generate_parenthesis(self, n: int) -> List[str]:\n",
    "        def dfs(left, right, s):\n",
    "            if len(s) == n * 2:\n",
    "                ans.append(s)\n",
    "                return\n",
    "            if left < n:\n",
    "                dfs(left + 1, right, s + '(')\n",
    "            if right < left:\n",
    "                dfs(left, right + 1, s + ')')\n",
    "        ans = []\n",
    "        dfs(0, 0, '')\n",
    "        return ans\n",
    "\n",
    "Solution22().generate_parenthesis(n=3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 23. Merge k Sorted Lists (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ListNode{val: 1, next: ListNode{val: 1, next: ListNode{val: 2, next: ListNode{val: 3, next: ListNode{val: 4, next: ListNode{val: 4, next: ListNode{val: 5, next: ListNode{val: 6, next: None}}}}}}}}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution23:\n",
    "    def merge_k_lists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:\n",
    "\n",
    "        if not lists:\n",
    "            return None\n",
    "        \n",
    "        def merge_two_lists(list1, list2):\n",
    "            zero_node = ListNode(None)\n",
    "            prev = zero_node\n",
    "            while list1 and list2:\n",
    "                if list1.val > list2.val:\n",
    "                    prev.next = list2\n",
    "                    list2 = list2.next\n",
    "                else:\n",
    "                    prev.next = list1\n",
    "                    list1 = list1.next\n",
    "                prev = prev.next\n",
    "            if list1:\n",
    "                prev.next = list1\n",
    "            if list2:\n",
    "                prev.next = list2\n",
    "            return zero_node.next\n",
    "        \n",
    "        ans = lists[0]\n",
    "        for lst in lists[1:]:\n",
    "            ans = merge_two_lists(ans, lst)\n",
    "        return ans\n",
    "\n",
    "Solution23().merge_k_lists(lists=[ListNode(val=1, next=ListNode(val=4, next=ListNode(val=5, next=None))),\n",
    "                                  ListNode(val=1, next=ListNode(val=3, next=ListNode(val=4, next=None))),\n",
    "                                  ListNode(val=2, next=ListNode(val=6, next=None))])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 24. Swap Nodes in Pairs (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ListNode{val: 2, next: ListNode{val: 1, next: ListNode{val: 4, next: ListNode{val: 3, next: None}}}}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution24:\n",
    "    def swap_pairs(self, head: Optional[ListNode]) -> Optional[ListNode]:\n",
    "        zero_node = ListNode(None)\n",
    "        zero_node.next = head\n",
    "        prev = zero_node\n",
    "        cur = head\n",
    "        while cur and cur.next:\n",
    "            nxt = cur.next\n",
    "            prev.next = nxt\n",
    "            cur.next = nxt.next\n",
    "            nxt.next = cur\n",
    "            prev = cur\n",
    "            cur = cur.next\n",
    "        return zero_node.next\n",
    "\n",
    "Solution24().swap_pairs(head=ListNode(val=1,\n",
    "                                      next=ListNode(val=2, next=ListNode(val=3, next=ListNode(val=4, next=None)))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 26. Remove Duplicates from Sorted Array (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, [0, 1, 2, 3, 4, '_', '_', '_', '_', '_'])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution26:\n",
    "    def remove_duplicates(self, nums: List[int]) -> int:\n",
    "        i = 0\n",
    "        del_count = 0\n",
    "        while i != len(nums) - 1 and nums[i] != '_':\n",
    "            if nums[i] == nums[i+1]:\n",
    "                del nums[i]\n",
    "                del_count += 1\n",
    "                nums.append('_')\n",
    "            else:\n",
    "                i += 1\n",
    "            \n",
    "        return len(nums) - del_count, nums\n",
    "\n",
    "Solution26().remove_duplicates(nums=[0,0,1,1,1,2,2,3,3,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 0, 2, 1, 3, 1]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution26_1:\n",
    "    def remove_duplicates(self, nums: List[int]) -> int:\n",
    "        j = 0\n",
    "        for i, _ in enumerate(nums):\n",
    "            if nums[i] != nums[j]:\n",
    "                j += 1\n",
    "                nums[j], nums[i] = nums[i], nums[j]\n",
    "        print(nums)\n",
    "        return j + 1\n",
    "\n",
    "Solution26_1().remove_duplicates(nums=[0,0,1,1,1,2,2,3,3,4])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 27. Remove Element (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 0, 3, -1, -1, -1]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution27:\n",
    "    def remove_element(self, nums: List[int], val: int) -> int:\n",
    "        i, j = 0, len(nums) - 1\n",
    "        count = 0\n",
    "        while i < len(nums) and nums[i] != -1:\n",
    "            if nums[i] == val:\n",
    "                nums[i] = -1\n",
    "                nums[i], nums[j] = nums[j], nums[i]\n",
    "                j -= 1\n",
    "                count += 1\n",
    "            else:\n",
    "                i += 1\n",
    "        print(nums)\n",
    "        return len(nums) - count\n",
    "\n",
    "Solution27().remove_element(nums=[0, 1, 2, 2, 3, 0, 4, 2], val=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution27_1:\n",
    "    def remove_element(self, nums: List[int], val: int) -> int:\n",
    "        i = 0\n",
    "        for j, _ in enumerate(nums):\n",
    "            if nums[j] != val:\n",
    "                nums[i] = nums[j]\n",
    "                i += 1\n",
    "        return i\n",
    "\n",
    "Solution27_1().remove_element(nums=[0, 1, 2, 2, 3, 0, 4, 2], val=2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 28. Find the Index of the First Occurrence in a String (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution28:\n",
    "    def str_str(self, haystack: str, needle: str) -> int:\n",
    "        if needle in haystack:\n",
    "            return haystack.find(needle)\n",
    "        else:\n",
    "            return -1\n",
    "\n",
    "Solution28().str_str(haystack='newtonew', needle='new')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution28_1:\n",
    "    def str_str(self, haystack: str, needle: str) -> int:\n",
    "        haystack_len = len(haystack)\n",
    "        needle_len = len(needle)\n",
    "        for i in range(haystack_len - needle_len + 1):\n",
    "            if haystack[i:i+needle_len] == needle:\n",
    "                return i\n",
    "\n",
    "Solution28_1().str_str(haystack='hello', needle='ll')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 31. Next Permutation (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 3]\n"
     ]
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution31:\n",
    "    def next_permutation(self, nums: List[int]) -> None:\n",
    "        \"\"\"\n",
    "        Do not return anything, modify nums in-place instead.\n",
    "        \"\"\"\n",
    "        i = len(nums) - 1\n",
    "        while i > 0 and nums[i - 1] >= nums[i]:\n",
    "            i -= 1\n",
    "        if i == 0:\n",
    "            nums[:] = nums[::-1]\n",
    "        else:\n",
    "            j = len(nums) - 1\n",
    "            while nums[j] <= nums[i - 1]:\n",
    "                j -= 1\n",
    "            nums[i-1], nums[j] = nums[j], nums[i-1]\n",
    "            nums[i:] = nums[i:][::-1]\n",
    "        print(nums)\n",
    "\n",
    "Solution31().next_permutation(nums=[1,2,3,4])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 32. Longest Valid Parentheses (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution32:\n",
    "    def longest_valid_parentheses(self, s: str) -> int:\n",
    "        stack = []\n",
    "        stack.append(-1)\n",
    "        ans = 0\n",
    "        for i, ch in enumerate(s):\n",
    "            if ch == '(':\n",
    "                stack.append(i)\n",
    "            else:\n",
    "                stack.pop()\n",
    "                if len(stack) == 0:\n",
    "                    stack.append(i)\n",
    "                ans = max(ans, i - stack[-1])\n",
    "        return ans\n",
    "\n",
    "Solution32().longest_valid_parentheses(s='))()')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 33. Search in Rotated Sorted Array (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution33:\n",
    "    def search(self, nums: List[int], target: int) -> int:\n",
    "\n",
    "        left, right = 0, len(nums) - 1\n",
    "        if nums[left] > nums[right]:\n",
    "            while left + 1 < right:\n",
    "                mid = (left + right) // 2\n",
    "                if nums[mid] > nums[right]:\n",
    "                    left = mid\n",
    "                if nums[mid] < nums[right]:\n",
    "                    right = mid\n",
    "        edge = right\n",
    "\n",
    "        def binary_search(l, r, target):\n",
    "            while l <= r:\n",
    "                mid = (l + r) // 2\n",
    "                if nums[mid] == target:\n",
    "                    return mid\n",
    "                if nums[mid] > target:\n",
    "                    r = mid - 1\n",
    "                else:\n",
    "                    l = mid + 1\n",
    "            return -1\n",
    "        \n",
    "        left_result = binary_search(0, edge - 1, target)\n",
    "        right_result = binary_search(edge, len(nums) - 1, target)\n",
    "        if right_result != -1:\n",
    "            return right_result\n",
    "        else:\n",
    "            return left_result\n",
    "\n",
    "Solution33().search(nums=[1,2,3,4,5,6,7], target=3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 34. Find First and Last Position of Element in Sorted Array (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution34:\n",
    "    def search_range(self, nums: List[int], target: int) -> List[int]:\n",
    "        if not nums:\n",
    "            return [-1,-1]\n",
    "        left, right = 0, len(nums) - 1\n",
    "        while left < right:\n",
    "            mid = (left + right) // 2\n",
    "            if nums[mid] > target:\n",
    "                right = mid - 1\n",
    "            elif nums[mid] == target:\n",
    "                right = mid\n",
    "            else:\n",
    "                left = mid + 1\n",
    "        if nums[left] != target:\n",
    "            return [-1, -1]\n",
    "        else:\n",
    "            start = end = left\n",
    "            right = len(nums) - 1\n",
    "            while left <= right:\n",
    "                mid = (left + right) // 2\n",
    "                if nums[mid] == target:\n",
    "                    left = mid + 1\n",
    "                else:\n",
    "                    right = mid - 1\n",
    "            end = right\n",
    "            return [start, end]\n",
    "\n",
    "Solution34().search_range(nums=[5,7,7,8,8,10], target=8)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 35. Search Insert Position (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution35:\n",
    "    def search_insert(self, nums: List[int], target: int) -> int:\n",
    "        left = 0\n",
    "        right = len(nums)\n",
    "        while (left + 1) != right:\n",
    "            \n",
    "            if nums[(right+left)//2] > target:\n",
    "                right = (right+left) // 2\n",
    "            elif nums[(right+left)//2] < target:\n",
    "                left = (right+left) // 2\n",
    "            else:\n",
    "                left_temp = left\n",
    "                left = (right+left_temp) // 2\n",
    "                right = (right+left_temp) // 2 + 1\n",
    "            #print(str(left) + ' , ' + str(right))\n",
    "        \n",
    "        if nums[left] >= target:\n",
    "            return left\n",
    "        else:\n",
    "            return left + 1\n",
    "        \n",
    "print(Solution35().search_insert(nums=[1,3,5,6], target=7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "from typing import List\n",
    "from bisect import bisect_left\n",
    "\n",
    "class Solution35_1:\n",
    "    def search_insert(self, nums: List[int], target: int) -> int:\n",
    "        return bisect_left(nums, target)\n",
    "\n",
    "print(Solution35_1().search_insert(nums=[1,3,5,6], target=7))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 36. Valid Sudoku (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution36:\n",
    "    def is_valid_sudoku(self, board: List[List[str]]) -> bool:\n",
    "        for i in range(9):\n",
    "            vertical = list(filter(lambda a: a != '.', board[:][i]))\n",
    "            horizontal = list(filter(lambda a: a != '.', list(zip(*board))[i]))\n",
    "\n",
    "            if len(set(vertical)) != len(vertical):\n",
    "                return False\n",
    "            \n",
    "            if len(set(horizontal)) != len(horizontal):\n",
    "                return False\n",
    "        \n",
    "        for i in [0, 3, 6]:\n",
    "            for j in [0, 3, 6]:\n",
    "                current_square = board[i][j:j+3] + board[i+1][j:j+3] + board[i+2][j:j+3]\n",
    "                current_square = list(filter(lambda a: a != '.', current_square))\n",
    "\n",
    "                if len(set(current_square)) != len(current_square):\n",
    "                    return False\n",
    "        \n",
    "        return True\n",
    "\n",
    "Solution36().is_valid_sudoku(\n",
    "    board = [['5', '3', '.', '.', '7', '.', '.', '.', '.'],\n",
    "             ['6', '.', '.', '1', '9', '5', '.', '.', '.'],\n",
    "             ['.', '9', '8', '.', '.', '.', '.', '6', '.'],\n",
    "             ['8', '.', '.', '.', '6', '.', '.', '.', '3'],\n",
    "             ['4', '.', '.', '8', '.', '3', '.', '.', '1'],\n",
    "             ['7', '.', '.', '.', '2', '.', '.', '.', '6'],\n",
    "             ['.', '6', '.', '.', '.', '.', '2', '8', '.'],\n",
    "             ['.', '.', '.', '4', '1', '9', '.', '.', '5'],\n",
    "             ['.', '.', '.', '.', '8', '.', '.', '7', '9']]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Solution36().is_valid_sudoku(\n",
    "    board = [['5', '3', '.', '.', '7', '.', '.', '.', '.'],\n",
    "             ['6', '.', '.', '1', '9', '5', '.', '.', '.'],\n",
    "             ['.', '9', '5', '.', '.', '.', '.', '6', '.'],\n",
    "             ['8', '.', '.', '.', '6', '.', '.', '.', '3'],\n",
    "             ['4', '.', '.', '8', '.', '3', '.', '.', '1'],\n",
    "             ['7', '.', '.', '.', '2', '.', '.', '.', '6'],\n",
    "             ['.', '6', '.', '.', '.', '.', '2', '8', '.'],\n",
    "             ['.', '.', '.', '4', '1', '9', '.', '.', '5'],\n",
    "             ['.', '.', '.', '.', '8', '.', '.', '7', '9']]\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 37. Sudoku Solver (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['5', '3', '4', '6', '7', '8', '9', '1', '2'], ['6', '7', '2', '1', '9', '5', '3', '4', '8'], ['1', '9', '8', '3', '4', '2', '5', '6', '7'], ['8', '5', '9', '7', '6', '1', '4', '2', '3'], ['4', '2', '6', '8', '5', '3', '7', '9', '1'], ['7', '1', '3', '9', '2', '4', '8', '5', '6'], ['9', '6', '1', '5', '3', '7', '2', '8', '4'], ['2', '8', '7', '4', '1', '9', '6', '3', '5'], ['3', '4', '5', '2', '8', '6', '1', '7', '9']]\n"
     ]
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "\n",
    "class Node:\n",
    "    def __init__(self, header_node=None):\n",
    "        self.value = None\n",
    "        self.up = self\n",
    "        self.down = self\n",
    "        self.left = self\n",
    "        self.right = self\n",
    "        self.column = header_node\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'Node: {}:{}'.format(self.column.value, self.value)\n",
    "\n",
    "\n",
    "class HeaderNode(Node):\n",
    "    def __init__(self, column_id):\n",
    "        super().__init__(header_node=self)\n",
    "        self.value = column_id\n",
    "        self.node_count = 0\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'HeaderNode: {}'.format(self.value)\n",
    "\n",
    "\n",
    "class RootNode(Node):\n",
    "    def __init__(self, value='root'):\n",
    "        super().__init__()\n",
    "        self.value = value\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'RootNode'\n",
    "\n",
    "\n",
    "def generate_exact_cover_board(grid_size):\n",
    "\n",
    "    exact_cover_board = [[0]*(4*grid_size**2) for _ in range(grid_size**3)]\n",
    "\n",
    "    for col in range(grid_size ** 2):\n",
    "        for row in range(grid_size):\n",
    "            exact_cover_board[row + col * grid_size][col] = 1\n",
    "\n",
    "    for col in range(grid_size ** 2, 2 * grid_size**2):\n",
    "        adjusted_col = col % grid_size**2\n",
    "        column_block = adjusted_col // grid_size\n",
    "        for row in range(grid_size):\n",
    "            x = row + (column_block * grid_size) + grid_size**2\n",
    "            y = adjusted_col * grid_size + row\n",
    "            exact_cover_board[y][x] = 1\n",
    "\n",
    "    for col in range(2 * grid_size**2, 3 * grid_size**2):\n",
    "        adjusted_col = col % grid_size**2\n",
    "        for row in range(grid_size):\n",
    "            x = (row + adjusted_col * grid_size) % grid_size**2 + 2 * grid_size**2\n",
    "            y = row + adjusted_col * grid_size\n",
    "            exact_cover_board[y][x] = 1\n",
    "\n",
    "    for col in range(3 * grid_size**2, 4 * grid_size**2):\n",
    "        adjusted_col = col % grid_size**2\n",
    "        box_size = int(grid_size**(1/2))\n",
    "        column_block = (adjusted_col // box_size) % box_size\n",
    "        for row in range(grid_size):\n",
    "            x = row + (column_block + (adjusted_col // (grid_size * box_size)) *\n",
    "                       box_size) * grid_size + 3 * grid_size**2\n",
    "            y = adjusted_col * grid_size + row\n",
    "            exact_cover_board[y][x] = 1\n",
    "\n",
    "    return exact_cover_board\n",
    "\n",
    "\n",
    "def create_sparse_matrix(matrix):\n",
    "    root = RootNode()\n",
    "\n",
    "    for i in range(len(matrix[0])):\n",
    "        new_node = HeaderNode(i)\n",
    "        last = root.left\n",
    "        new_node.right = root\n",
    "        root.left = new_node\n",
    "        new_node.left = last\n",
    "        last.right = new_node\n",
    "\n",
    "    for i in range(len(matrix)):\n",
    "        row_start = None\n",
    "        for j in range(len(matrix[0])):\n",
    "            if matrix[i][j]:\n",
    "                header = root.right\n",
    "                for _ in range(j):\n",
    "                    header = header.right\n",
    "                new_node = Node(header)\n",
    "                new_node.value = (int(i // len(matrix) ** (2 / 3)),\n",
    "                                  int(i // len(matrix) ** (1 / 3) % len(matrix) ** (1 / 3)),\n",
    "                                  int(i % len(matrix) ** (1 / 3)) + 1)\n",
    "                last = header.up\n",
    "                new_node.down = header\n",
    "                header.up = new_node\n",
    "                new_node.up = last\n",
    "                last.down = new_node\n",
    "                header.node_count += 1\n",
    "\n",
    "                if row_start:\n",
    "                    last = row_start.left\n",
    "                    new_node.right = row_start\n",
    "                    row_start.left = new_node\n",
    "                    new_node.left = last\n",
    "                    last.right = new_node\n",
    "                else:\n",
    "                    row_start = new_node\n",
    "    return root\n",
    "\n",
    "\n",
    "def print_sparse_matrix(root):\n",
    "    node = root\n",
    "    while node.right != root:\n",
    "        node = node.right\n",
    "        column = node\n",
    "        print(node, 'node_count:', node.node_count)\n",
    "        while node.down != column:\n",
    "            node = node.down\n",
    "            print('\\t {} Right{} Left{}'.format(node, node.right, node.left))\n",
    "        node = node.down\n",
    "\n",
    "\n",
    "def choose_least_column(root):\n",
    "    node = root.right\n",
    "    least_column = node\n",
    "    while node.right != root:\n",
    "        node = node.right\n",
    "        if node.node_count < least_column.node_count:\n",
    "            least_column = node\n",
    "    return least_column\n",
    "\n",
    "\n",
    "def cover(node):\n",
    "    column = node.column\n",
    "    column.right.left = column.left\n",
    "    column.left.right = column.right\n",
    "\n",
    "    row = column.down\n",
    "    while row != column:\n",
    "        right_node = row.right\n",
    "        while right_node != row:\n",
    "            right_node.up.down = right_node.down\n",
    "            right_node.down.up = right_node.up\n",
    "            right_node.column.node_count -= 1\n",
    "            right_node = right_node.right\n",
    "        row = row.down\n",
    "\n",
    "\n",
    "def uncover(node):\n",
    "    column = node.column\n",
    "\n",
    "    row = column.up\n",
    "    while row != column:\n",
    "        left_node = row.left\n",
    "        while left_node != row:\n",
    "            left_node.up.down = left_node\n",
    "            left_node.down.up = left_node\n",
    "            left_node.column.node_count += 1\n",
    "            left_node = left_node.left\n",
    "        row = row.up\n",
    "\n",
    "    column.right.left = column\n",
    "    column.left.right = column\n",
    "\n",
    "\n",
    "def cover_values(root, values, size):\n",
    "    for value in values:\n",
    "        column_id = value[0] * size + value[1]\n",
    "\n",
    "        column = root.right\n",
    "        while column != root:\n",
    "            if column.value == column_id:\n",
    "                break\n",
    "            column = column.right\n",
    "\n",
    "        cover(column)\n",
    "\n",
    "        row_node = column.down\n",
    "        while row_node != column:\n",
    "            if row_node.value == value:\n",
    "                break\n",
    "            row_node = row_node.down\n",
    "\n",
    "        right_node = row_node.right\n",
    "        while right_node != row_node:\n",
    "            cover(right_node)\n",
    "            right_node = right_node.right\n",
    "\n",
    "\n",
    "def solve(root, solution):\n",
    "    if root.right == root:\n",
    "        return solution, True\n",
    "\n",
    "    column = choose_least_column(root)\n",
    "    cover(column)\n",
    "\n",
    "    row_node = column.down\n",
    "    while row_node != column:\n",
    "        solution.append(row_node)\n",
    "\n",
    "        right_node = row_node.right\n",
    "        while right_node != row_node:\n",
    "            cover(right_node)\n",
    "            right_node = right_node.right\n",
    "\n",
    "        solution, found = solve(root, solution)\n",
    "        if found:\n",
    "            return solution, True\n",
    "\n",
    "        solution.pop()\n",
    "\n",
    "        column = row_node.column\n",
    "        left_node = row_node.left\n",
    "        while left_node != row_node:\n",
    "            if left_node != root:\n",
    "                uncover(left_node)\n",
    "            left_node = left_node.left\n",
    "        row_node = row_node.down\n",
    "    uncover(column)\n",
    "\n",
    "    return solution, False\n",
    "\n",
    "\n",
    "class Solution37:\n",
    "    def solve_sudoku(self, board: List[List[str]]) -> None:\n",
    "        sudoku_size = len(board)\n",
    "        exact_cover = generate_exact_cover_board(sudoku_size)\n",
    "        root = create_sparse_matrix(exact_cover)\n",
    "        values = []\n",
    "        for row in range(len(board)):\n",
    "            for col in range(len(board[0])):\n",
    "                if board[row][col] != '.':\n",
    "                    values.append((row, col, int(board[row][col])))\n",
    "        try:\n",
    "            cover_values(root, values, sudoku_size)\n",
    "        except AttributeError:\n",
    "            return 'Given Sudoku field violate game rules'\n",
    "        \n",
    "        solution, found = solve(root, [])\n",
    "        if found:\n",
    "            for element in solution:\n",
    "                sol_value = element.value\n",
    "                board[sol_value[0]][sol_value[1]] = str(sol_value[2])\n",
    "        else:\n",
    "            return 'No solution to given Sudoku field'\n",
    "        print(board)\n",
    "\n",
    "Solution37().solve_sudoku(board=[[\"5\",\"3\",\".\",\".\",\"7\",\".\",\".\",\".\",\".\"],\n",
    "                                 [\"6\",\".\",\".\",\"1\",\"9\",\"5\",\".\",\".\",\".\"],\n",
    "                                 [\".\",\"9\",\"8\",\".\",\".\",\".\",\".\",\"6\",\".\"],\n",
    "                                 [\"8\",\".\",\".\",\".\",\"6\",\".\",\".\",\".\",\"3\"],\n",
    "                                 [\"4\",\".\",\".\",\"8\",\".\",\"3\",\".\",\".\",\"1\"],\n",
    "                                 [\"7\",\".\",\".\",\".\",\"2\",\".\",\".\",\".\",\"6\"],\n",
    "                                 [\".\",\"6\",\".\",\".\",\".\",\".\",\"2\",\"8\",\".\"],\n",
    "                                 [\".\",\".\",\".\",\"4\",\"1\",\"9\",\".\",\".\",\"5\"],\n",
    "                                 [\".\",\".\",\".\",\".\",\"8\",\".\",\".\",\"7\",\"9\"]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 39. Combination Sum (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2, 2, 3], [7]]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution39:\n",
    "    def combination_sum(self, candidates: List[int], target: int) -> List[List[int]]:\n",
    "        ans = []\n",
    "        def dfs(i, summ, comb):\n",
    "            if summ == 0:\n",
    "                ans.append(comb)\n",
    "                return\n",
    "            if summ < 0:\n",
    "                return\n",
    "            \n",
    "            for j in range(i, len(candidates)):\n",
    "                dfs(j, summ - candidates[j], comb + [candidates[j]])\n",
    "        \n",
    "        dfs(0, target, [])\n",
    "\n",
    "        return ans\n",
    "\n",
    "Solution39().combination_sum(candidates=[2,3,6,7], target=7)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 41. First Missing Positive (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution41:\n",
    "    def first_missing_positive(self, nums: List[int]) -> int:\n",
    "        nums_set = set(nums)\n",
    "        missing_positive_integer = 1\n",
    "        while True:\n",
    "            if missing_positive_integer not in nums_set:\n",
    "                break\n",
    "            missing_positive_integer += 1\n",
    "        return missing_positive_integer\n",
    "\n",
    "Solution41().first_missing_positive(nums=[1,2,0])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 42. Trapping Rain Water (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution42:\n",
    "    def trap(self, height: List[int]) -> int:\n",
    "        left, right = 0, len(height) - 1\n",
    "        left_max, right_max = height[left], height[right]\n",
    "        ans = 0\n",
    "        while left < right:\n",
    "            if left_max < right_max:\n",
    "                left += 1\n",
    "                left_max = max(left_max, height[left])\n",
    "                ans += left_max - height[left]\n",
    "            else:\n",
    "                right -= 1\n",
    "                right_max = max(right_max, height[right])\n",
    "                ans += right_max - height[right]\n",
    "        return ans\n",
    "\n",
    "Solution42().trap(height=[0,1,0,2,1,0,1,3,2,1,2,1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 43. Multiply Strings (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'6'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution43:\n",
    "    def multiply(self, num1: str, num2: str) -> str:\n",
    "        m, n = len(num1), len(num2)\n",
    "        products = [0] * (m + n)\n",
    "        for i in range(m-1, -1, -1):\n",
    "            for j in range(n-1, -1, -1):\n",
    "                digit1 = ord(num1[i]) - ord('0')\n",
    "                digit2 = ord(num2[j]) - ord('0')\n",
    "                product = digit1 * digit2\n",
    "                pos1, pos2 = i+j, i+j+1\n",
    "                carry, value = divmod(product + products[pos2], 10)\n",
    "                products[pos1] += carry\n",
    "                products[pos2] = value\n",
    "        ans = ''\n",
    "        flag = False\n",
    "        for digit in products:\n",
    "            if digit != 0:\n",
    "                flag = True\n",
    "            if flag:\n",
    "                ans += chr(48 + digit)\n",
    "        return ans if flag else '0'\n",
    "\n",
    "Solution43().multiply(num1='2', num2='3')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 44. Wildcard Matching (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution44:\n",
    "    def is_match(self, s: str, p: str) -> bool:\n",
    "        m, n = len(s), len(p)\n",
    "        dp = [[False] * (n + 1) for _ in range(m + 1)]\n",
    "\n",
    "        dp[0][0] = True\n",
    "        for j in range(1, n + 1):\n",
    "            if p[j - 1] == '*':\n",
    "                dp[0][j] = dp[0][j - 1]\n",
    "        \n",
    "        for i in range(1, m + 1):\n",
    "            for j in range(1, n + 1):\n",
    "                if p[j - 1] == '?' or s[i - 1] == p[j - 1]:\n",
    "                    dp[i][j] = dp[i - 1][j - 1]\n",
    "                elif p[j - 1] == '*':\n",
    "                    dp[i][j] = dp[i][j - 1] or dp[i - 1][j]\n",
    "        \n",
    "        return dp[m][n]\n",
    "\n",
    "Solution44().is_match(s='aa', p='*')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 45. Jump Game II (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from functools import lru_cache\n",
    "\n",
    "class Solution45:\n",
    "    def jump(self, nums: List[int]) -> int:\n",
    "\n",
    "        # DFS\n",
    "        @lru_cache(None)\n",
    "        def helper(i):\n",
    "            if i >= len(nums) - 1:\n",
    "                return 0\n",
    "            ans = float('inf')\n",
    "            for j in range(1, nums[i] + 1):\n",
    "                ans = min(ans, 1 + helper(i + j))\n",
    "            return ans\n",
    "        \n",
    "        return helper(0)\n",
    "\n",
    "Solution45().jump(nums=[2,3,1,1,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution45:\n",
    "    def jump(self, nums: List[int]) -> int:\n",
    "        farthest = 0\n",
    "        cur_pos = 0\n",
    "        jumps = 0\n",
    "        for i, _ in enumerate(nums[:-1]):\n",
    "            farthest = max(farthest, i+nums[i])\n",
    "            if i == cur_pos:\n",
    "                jumps += 1\n",
    "                cur_pos = farthest\n",
    "        return jumps\n",
    "\n",
    "Solution45().jump(nums=[2,3,1,1,4])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 46. Permutations (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution46:\n",
    "    def permute(self, nums: List[int]) -> List[List[int]]:\n",
    "        if len(nums) == 1:\n",
    "            return [nums]\n",
    "        ans = []\n",
    "        for i, _ in enumerate(nums):\n",
    "            for remain in self.permute(nums[:i] + nums[i+1:]):\n",
    "                ans.append([nums[i]] + remain)\n",
    "        return ans\n",
    "\n",
    "Solution46().permute(nums=[1,2,3])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 47. Permutations II (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 1, 2, 2],\n",
       " [1, 2, 1, 2],\n",
       " [1, 2, 2, 1],\n",
       " [2, 1, 1, 2],\n",
       " [2, 1, 2, 1],\n",
       " [2, 2, 1, 1]]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution47:\n",
    "    def permute_unique(self, nums: List[int]) -> List[List[int]]:\n",
    "        def dfs(nums, cur):\n",
    "            if not nums:\n",
    "                ans.append(cur)\n",
    "            for num in set(nums):\n",
    "                remain = nums.copy()\n",
    "                remain.remove(num)\n",
    "                dfs(remain, cur + [num])\n",
    "        ans = []\n",
    "        dfs(nums, [])\n",
    "        return ans\n",
    "\n",
    "Solution47().permute_unique(nums=[1,1,2,2])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 48. Rotate Image (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7, 4, 1], [8, 5, 2], [9, 6, 3]]\n"
     ]
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution48:\n",
    "    def rotate(self, matrix: List[List[int]]) -> None:\n",
    "        n = len(matrix)\n",
    "        left, right = 0, n - 1\n",
    "        while left <= right:\n",
    "            matrix[left], matrix[right] = matrix[right], matrix[left]\n",
    "            left += 1\n",
    "            right -= 1\n",
    "        for row in range(n):\n",
    "            for col in range(row, n):\n",
    "                matrix[row][col], matrix[col][row] = matrix[col][row], matrix[row][col]\n",
    "        print(matrix)\n",
    "\n",
    "Solution48().rotate(matrix=[[1, 2, 3], [4, 5, 6], [7, 8, 9]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 49. Group Anagrams (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import defaultdict\n",
    "\n",
    "class Solution49:\n",
    "    def group_anagrams(self, strs: List[str]) -> List[List[str]]:\n",
    "        strs_dict = defaultdict(list)\n",
    "        for s in strs:\n",
    "            key = tuple(sorted(s))\n",
    "            strs_dict[key].append(s)\n",
    "        return list(strs_dict.values())\n",
    "\n",
    "Solution49().group_anagrams(strs=['eat', 'tea', 'tan', 'ate', 'nat', 'bat'])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 53. Maximum Subarray (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution53:\n",
    "    def max_subarray(self, nums: List[int]) -> int:\n",
    "        dp = [0] * len(nums)\n",
    "        dp[0] = nums[0]\n",
    "        for i, num in enumerate(nums[1:], start=1):\n",
    "            dp[i] = max(dp[i-1] + num, num)\n",
    "        return max(dp)\n",
    "\n",
    "Solution53().max_subarray(nums=[-2,1,-3,4,-1,2,1,-5,4])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 54. Spiral Matrix (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 6, 9, 8, 7, 4, 5]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution54:\n",
    "    def spiral_order(self, matrix: List[List[int]]) -> List[int]:\n",
    "        d = {(0,1): (1,0),\n",
    "             (1,0): (0,-1),\n",
    "             (0,-1): (-1,0),\n",
    "             (-1,0): (0,1)}\n",
    "        m, n = len(matrix), len(matrix[0])\n",
    "        ans = []\n",
    "        row, col = 0, 0\n",
    "        dirr = (0, 1)\n",
    "        for _ in range(m * n):\n",
    "            ans.append(matrix[row][col])\n",
    "            matrix[row][col] = '#'\n",
    "\n",
    "            rs, cs = dirr\n",
    "\n",
    "            nr, nc = row + rs, col + cs\n",
    "\n",
    "            if 0 <= nr < m and 0 <= nc < n and matrix[nr][nc] != '#':\n",
    "                row, col = nr, nc\n",
    "            else:\n",
    "                dirr = d[dirr]\n",
    "                rs, cs = dirr\n",
    "                row, col = row + rs, col + cs\n",
    "        return ans\n",
    "\n",
    "Solution54().spiral_order(matrix=[[1,2,3],[4,5,6],[7,8,9]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 55. Jump Game (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution55:\n",
    "    def can_jump(self, nums: List[int]) -> bool:\n",
    "        dp = [False] * len(nums)\n",
    "        dp[-1] = True\n",
    "        for i in range(len(nums) - 2, -1, -1):\n",
    "            for j in range(1, nums[i]+1):\n",
    "                if i + j < len(dp):\n",
    "                    dp[i] = max(dp[i], dp[i + j])\n",
    "        return dp[0]\n",
    "\n",
    "Solution55().can_jump(nums=[2,3,1,1,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from functools import lru_cache\n",
    "\n",
    "class Solution55_1:\n",
    "    def can_jump(self, nums: List[int]) -> bool:\n",
    "        @lru_cache(None)\n",
    "        def helper(i):\n",
    "            if i >= len(nums) - 1:\n",
    "                return True\n",
    "            for j in range(1, nums[i] + 1):\n",
    "                if helper(i + j):\n",
    "                    return True\n",
    "        return helper(0)\n",
    "\n",
    "Solution55_1().can_jump(nums=[2,3,1,1,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution55_2:\n",
    "    def can_jump(self, nums: List[int]) -> bool:\n",
    "        dp = [False] * len(nums)\n",
    "        dp[-1] = True\n",
    "        for i in range(len(nums) - 2, -1, -1):\n",
    "            av = dp[i+1:i+nums[i]+1]\n",
    "            if av:\n",
    "                dp[i] = max(av)\n",
    "            #dp[i] = any(dp[i+1:i+nums[i]+1])\n",
    "        return dp[0]\n",
    "\n",
    "Solution55_2().can_jump(nums=[2,3,1,1,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution55_3:\n",
    "    def can_jump(self, nums: List[int]) -> bool:\n",
    "        last_pos = len(nums) - 1\n",
    "        for i in range(len(nums) - 2, -1, -1):\n",
    "            if i + nums[i] >= last_pos:\n",
    "                last_pos = i\n",
    "        return last_pos == 0\n",
    "\n",
    "Solution55_3().can_jump(nums=[2,3,1,1,4])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 56. Merge Intervals (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 6], [8, 10], [15, 18]]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution56:\n",
    "    def merge(self, intervals: List[List[int]]) -> List[List[int]]:\n",
    "        ans = []\n",
    "        intervals = sorted(intervals, key=lambda x: x[0])\n",
    "        for i, _ in enumerate(intervals[:-1]):\n",
    "            if intervals[i][1] >= intervals[i+1][0]:\n",
    "                intervals[i+1][0] = intervals[i][0]\n",
    "                intervals[i+1][1] = max(intervals[i+1][1], intervals[i][1])\n",
    "                intervals[i] = '_'\n",
    "        for interval in intervals:\n",
    "            if interval != '_':\n",
    "                ans.append(interval)\n",
    "        return ans\n",
    "\n",
    "Solution56().merge(intervals=[[1,3],[2,6],[8,10],[15,18],[16,17]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 57. Insert Interval (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 5], [6, 9]]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution57:\n",
    "    def insert(self, intervals: List[List[int]], new_interval: List[int]) -> List[List[int]]:\n",
    "        ans = []\n",
    "        intervals = sorted(intervals+[new_interval], key=lambda x: x[0])\n",
    "        for i, _ in enumerate(intervals[:-1]):\n",
    "            if intervals[i][1] >= intervals[i+1][0]:\n",
    "                intervals[i+1][0] = intervals[i][0]\n",
    "                intervals[i+1][1] = max(intervals[i+1][1], intervals[i][1])\n",
    "                intervals[i] = '_'\n",
    "        for interval in intervals:\n",
    "            if interval != '_':\n",
    "                ans.append(interval)\n",
    "        return ans\n",
    "\n",
    "Solution57().insert(intervals=[[1,3],[6,9]], new_interval=[2,5])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 58. Length of Last Word (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution58:\n",
    "    def length_of_last_word(self, s: str) -> int:\n",
    "\n",
    "        if s == ' ':\n",
    "            return 0\n",
    "        \n",
    "        if len(s) == 1:\n",
    "            return 1\n",
    "        \n",
    "        s = ' ' + s\n",
    "        \n",
    "        word_detected = 0\n",
    "        for j in range(len(s)-1,-1,-1):\n",
    "            if s[j] != ' ' and word_detected == 0:\n",
    "                word_detected = j\n",
    "            else:\n",
    "                if word_detected and s[j] == ' ':\n",
    "                    return word_detected - j\n",
    "                if word_detected and j == 0:\n",
    "                    return word_detected + 1\n",
    "\n",
    "Solution58().length_of_last_word(s=\" av  \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution58_1:\n",
    "    def length_of_last_word(self, s: str) -> int:\n",
    "        cur = 0\n",
    "        prev = None\n",
    "        for ch in s:\n",
    "            if ch == ' ':\n",
    "                if prev != ' ':\n",
    "                    last = cur\n",
    "                    cur = 0\n",
    "            else:\n",
    "                cur += 1   \n",
    "            prev = ch\n",
    "        return last if not cur else cur\n",
    "\n",
    "Solution58_1().length_of_last_word(s=\"   fly me   to   the moon  \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution58_2:\n",
    "    def length_of_last_word(self, s: str) -> int:\n",
    "        word = ''\n",
    "        for i in range(len(s)-1, -1, -1):\n",
    "            if s[i] == ' ':\n",
    "                if word:\n",
    "                    return len(word)\n",
    "            else:\n",
    "                word += s[i]\n",
    "        return len(word)\n",
    "\n",
    "Solution58_2().length_of_last_word(s=\"luffy is still joyboy\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 61. Rotate List (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ListNode{val: 2, next: ListNode{val: 0, next: ListNode{val: 1, next: None}}}"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution61:\n",
    "    def rotate_right(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:\n",
    "        if not head or not head.next:\n",
    "            return head\n",
    "        n = 0\n",
    "        prev = None\n",
    "        cur = head\n",
    "        while cur:\n",
    "            prev = cur\n",
    "            cur = cur.next\n",
    "            n += 1\n",
    "        tail = prev\n",
    "        cur = head\n",
    "        for _ in range(k%n+1):\n",
    "            cur = cur.next\n",
    "        slow = head\n",
    "        fast = cur\n",
    "        while fast:\n",
    "            slow = slow.next\n",
    "            fast = fast.next\n",
    "        new_head = slow.next\n",
    "        slow.next = None\n",
    "\n",
    "        tail.next = head\n",
    "\n",
    "        return new_head\n",
    "\n",
    "Solution61().rotate_right(head=ListNode(val=0, next=ListNode(val=1, next=ListNode(val=2, next=None))), k = 4)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 62. Unique Paths (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import lru_cache\n",
    "\n",
    "class Solution62:\n",
    "    @lru_cache(None)\n",
    "    def unique_paths(self, m: int, n: int) -> int:\n",
    "        if m == 1 or n == 1:\n",
    "            return 1\n",
    "        return self.unique_paths(m - 1, n) + self.unique_paths(m, n - 1)\n",
    "\n",
    "Solution62().unique_paths(m = 3, n = 7)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 63. Unique Paths II (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import lru_cache\n",
    "from typing import List\n",
    "\n",
    "class Solution63:\n",
    "    def unique_paths(self, obstacle_grid: List[List[int]]) -> int:\n",
    "        m, n = len(obstacle_grid) - 1, len(obstacle_grid[0]) - 1\n",
    "        flag = 0\n",
    "        for i, _ in enumerate(obstacle_grid):\n",
    "            if obstacle_grid[i][0] == 1:\n",
    "                flag = 1\n",
    "            obstacle_grid[i][0] = flag\n",
    "        flag = 0\n",
    "        for j, _ in enumerate(obstacle_grid[0]):\n",
    "            if obstacle_grid[0][j] == 1:\n",
    "                flag = 1\n",
    "            obstacle_grid[0][j] = flag\n",
    "        @lru_cache(None)\n",
    "        def helper(i, j):\n",
    "            if i == 0 or j == 0:\n",
    "                return 1 - obstacle_grid[i][j]\n",
    "            if obstacle_grid[i][j] == 1:\n",
    "                return 0\n",
    "            return helper(i - 1, j) + helper(i, j - 1)\n",
    "        return helper(m, n)\n",
    "\n",
    "Solution63().unique_paths(obstacle_grid=[[1, 0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution63_1:\n",
    "    def unique_paths(self, obstacle_grid: List[List[int]]) -> int:\n",
    "        dp = [[0] * len(obstacle_grid[0]) for _ in enumerate(obstacle_grid)]\n",
    "        flag = 1\n",
    "        for i, _ in enumerate(dp):\n",
    "            if obstacle_grid[i][0] == 1:\n",
    "                flag = 0\n",
    "            dp[i][0] = flag\n",
    "        flag = 1\n",
    "        for j, _ in enumerate(dp[0]):\n",
    "            if obstacle_grid[0][j] == 1:\n",
    "                flag = 0\n",
    "            dp[0][j] = flag\n",
    "        for i, _ in enumerate(dp[1:], start=1):\n",
    "            for j, _ in enumerate(dp[0][1:], start=1):\n",
    "                if obstacle_grid[i][j] == 1:\n",
    "                    dp[i][j] = 0\n",
    "                else:\n",
    "                    dp[i][j] = dp[i-1][j] + dp[i][j-1]\n",
    "        return dp[-1][-1]\n",
    "\n",
    "Solution63_1().unique_paths(obstacle_grid=[[0, 0, 0],[0, 1, 0],[0, 0, 0]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 66. Plus One (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 0, 0, 0]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution66:\n",
    "    def plus_one(self, digits: List[int]) -> List[int]:\n",
    "        carry = 1\n",
    "        for i, d in enumerate(digits[::-1]):\n",
    "            carry, digits[len(digits)-i-1] = divmod(d + carry, 10)\n",
    "        return digits if not carry else [carry] + digits\n",
    "\n",
    "Solution66().plus_one(digits=[9,9,9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 0, 0, 0]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution66_1:\n",
    "    def plus_one(self, digits: List[int]) -> List[int]:\n",
    "        return [int(y) for y in list(str(int(''.join(str(x) for x in digits))+1))]\n",
    "\n",
    "Solution66_1().plus_one(digits=[9,9,9])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 67. Add Binary (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'100'"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution67:\n",
    "    def add_binary(self, a: str, b: str) -> str:\n",
    "        carry = 0\n",
    "        total = 0\n",
    "        ans = ''\n",
    "        i, j = len(a) - 1, len(b) - 1\n",
    "        while i >= 0 or j >= 0 or carry:\n",
    "            total = carry\n",
    "            if i >= 0:\n",
    "                total += int(a[i])\n",
    "                i -= 1\n",
    "            if j >= 0:\n",
    "                total += int(b[j])\n",
    "                j -= 1\n",
    "            ans = str(total % 2) + ans\n",
    "            carry = total // 2\n",
    "        return ans\n",
    "\n",
    "Solution67().add_binary(a='11', b='1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'100'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution67_1:\n",
    "    def add_binary(self, a: str, b: str) -> str:\n",
    "        len_a, len_b = len(a), len(b)\n",
    "        if len_a > len_b:\n",
    "            b = '0' * (len_a - len_b) + b\n",
    "        else:\n",
    "            a = '0' * (len_b - len_a) + a\n",
    "        carry = 0\n",
    "        ans = ''\n",
    "        for i in range(len(b)-1, -1, -1):\n",
    "            d1 = int(a[i])\n",
    "            d2 = int(b[i])\n",
    "            carry, d = divmod(d1 + d2 + carry, 2)\n",
    "            ans += str(d)\n",
    "        if carry:\n",
    "            ans += str(carry)\n",
    "        return ans[::-1]\n",
    "\n",
    "Solution67_1().add_binary(a='11', b='1')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 68. Text Justification (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['This    is    an', 'example  of text', 'justification.  ']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution68:\n",
    "    def full_justify(self, words: List[str], max_width: int) -> List[str]:\n",
    "        ans, cur_list, num_of_letters = [], [], 0\n",
    "        for word in words:\n",
    "            if num_of_letters + len(word) + len(cur_list) > max_width:\n",
    "                size = max(1, len(cur_list) - 1)\n",
    "                for i in range(max_width - num_of_letters):\n",
    "                    ind = i % size\n",
    "                    cur_list[ind] += ' '\n",
    "                ans.append(''.join(cur_list))\n",
    "                cur_list, num_of_letters = [], 0\n",
    "            cur_list.append(word)\n",
    "            num_of_letters += len(word)\n",
    "        ans.append(' '.join(cur_list).ljust(max_width))\n",
    "        return ans\n",
    "\n",
    "Solution68().full_justify(words=[\"This\", \"is\", \"an\", \"example\", \"of\", \"text\", \"justification.\"],\n",
    "                          max_width=16)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 69. Sqrt(x) (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution69:\n",
    "    def my_sqrt(self, x: int) -> int:\n",
    "        x_sqrt = 1\n",
    "        while True:\n",
    "            x_last = x_sqrt\n",
    "            x_sqrt = (x_sqrt * x_sqrt + x) / (2 * x_sqrt)\n",
    "            if (x_sqrt - x_last) ** 2 < 0.1:\n",
    "                break\n",
    "        return int(x_sqrt)\n",
    "\n",
    "Solution69().my_sqrt(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution69_1:\n",
    "    def my_sqrt(self, x: int) -> int:\n",
    "\n",
    "        if x < 2:\n",
    "            return x\n",
    "        \n",
    "        left, right = 1, x // 2\n",
    "        while left <= right:\n",
    "            mid = (left + right) // 2\n",
    "            sq = mid * mid\n",
    "            if sq > x:\n",
    "                right = mid - 1\n",
    "            else:\n",
    "                left = mid + 1\n",
    "        return right\n",
    "\n",
    "Solution69_1().my_sqrt(x=65)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 70. Climbing Stairs (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution70:\n",
    "    def climb_stairs(self, n: int) -> int:\n",
    "        dp = [1, 2]\n",
    "        for i in range(2, n):\n",
    "            dp.append(dp[i - 2] + dp[i - 1])\n",
    "        return dp[n-1]\n",
    "\n",
    "Solution70().climb_stairs(n=5)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 71. Simplify Path (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/home'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution71:\n",
    "    def simplify_path(self, path: str) -> str:\n",
    "        ans = ''\n",
    "        stack = []\n",
    "        for ch in path + '/':\n",
    "            if ch == '/':\n",
    "                if ans == '..':\n",
    "                    stack.pop() if stack else None\n",
    "                elif ans != '' and ans != '.':\n",
    "                    stack.append(ans)\n",
    "                ans = ''\n",
    "            else:\n",
    "                ans += ch\n",
    "        return '/' + '/'.join(stack)\n",
    "\n",
    "Solution71().simplify_path(path='/home/')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 72. Edit Distance (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution72:\n",
    "    def min_distance(self, word1: str, word2: str) -> int:\n",
    "        m, n = len(word1), len(word2)\n",
    "        prev = [0] * (n + 1)\n",
    "        cur = [0] * (n + 1)\n",
    "        for j in range(n + 1):\n",
    "            prev[j] = j\n",
    "        for i in range(1, m + 1):\n",
    "            cur[0] = i\n",
    "            for j in range(1, n + 1):\n",
    "                if word1[i-1] == word2[j-1]:\n",
    "                    cur[j] = prev[j-1]\n",
    "                else:\n",
    "                    cur[j] = 1 + min(prev[j-1], prev[j], cur[j-1])\n",
    "            prev = cur[:]\n",
    "        return prev[n]\n",
    "\n",
    "Solution72().min_distance(word1='intention', word2='execution')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 73. Set Matrix Zeroes (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 0, 1], [0, 0, 0], [1, 0, 1]]\n"
     ]
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution73:\n",
    "    def set_zeroes(self, matrix: List[List[int]]) -> None:\n",
    "        zero_col = False\n",
    "        m, n = len(matrix), len(matrix[0])\n",
    "        for row in range(m):\n",
    "            if matrix[row][0] == 0:\n",
    "                zero_col = True\n",
    "            for col in range(1, n):\n",
    "                if matrix[row][col] == 0:\n",
    "                    matrix[0][col] = 0\n",
    "                    matrix[row][0] = 0\n",
    "        for row in range(1, m):\n",
    "            for col in range(1, n):\n",
    "                if matrix[0][col] == 0 or matrix[row][0] == 0:\n",
    "                    matrix[row][col] = 0\n",
    "        if matrix[0][0] == 0:\n",
    "            for col in range(n):\n",
    "                matrix[0][col] = 0\n",
    "        if zero_col:\n",
    "            for row in range(m):\n",
    "                matrix[row][0] = 0\n",
    "        print(matrix)\n",
    "\n",
    "Solution73().set_zeroes(matrix=[[1,1,1],[1,0,1],[1,1,1]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 74. Search a 2D Matrix (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution74:\n",
    "    def search_matrix(self, matrix: List[List[int]], target: int) -> bool:\n",
    "        m, n = len(matrix), len(matrix[0])\n",
    "        left, right = 0, m * n - 1\n",
    "        while left <= right:\n",
    "            mid = (left + right) // 2\n",
    "            if matrix[mid // n][mid % n] == target:\n",
    "                return True\n",
    "            if matrix[mid // n][mid % n] > target:\n",
    "                right = mid - 1\n",
    "            else:\n",
    "                left = mid + 1\n",
    "        return False\n",
    "\n",
    "Solution74().search_matrix(matrix=[[1]], target=1)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 78. Subsets (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3]]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution78:\n",
    "    def subsets(self, nums: List[int]) -> List[List[int]]:\n",
    "        ans = []\n",
    "        def dfs(i, subset):\n",
    "            ans.append(subset)\n",
    "            if i < len(nums):\n",
    "                for j, _ in enumerate(nums[i:], start=i):\n",
    "                    dfs(j + 1, subset + [nums[j]])\n",
    "        dfs(0, [])\n",
    "        return ans\n",
    "\n",
    "Solution78().subsets(nums=[1,2,3])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 79. Word Search (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution79:\n",
    "    def exist(self, board: List[List[str]], word: str) -> bool:\n",
    "        m, n = len(board), len(board[0])\n",
    "        visited = set()\n",
    "\n",
    "        def dfs(row, col, idx):\n",
    "            if idx == len(word):\n",
    "                return True\n",
    "            if row < 0 or row >= m or col < 0 or col >= n or word[idx] != board[row][col] or (row, col) in visited:\n",
    "                return False\n",
    "            visited.add((row, col))\n",
    "            ans = dfs(row+1, col, idx+1) or dfs(row-1, col, idx+1) or dfs(row, col+1, idx+1) or dfs(row, col-1, idx+1)\n",
    "            visited.remove((row, col))\n",
    "            return ans\n",
    "        \n",
    "        for i in range(m):\n",
    "            for j in range(n):\n",
    "                if dfs(i, j, 0):\n",
    "                    return True\n",
    "        return False\n",
    "\n",
    "Solution79().exist(board=[[\"A\",\"B\",\"C\",\"E\"],[\"S\",\"F\",\"C\",\"S\"],[\"A\",\"D\",\"E\",\"E\"]], word = \"ABCCEDA\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 81. Search in Rotated Sorted Array II (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution81:\n",
    "    def search(self, nums: List[int], target: int) -> int:\n",
    "\n",
    "        memo = set()\n",
    "        nums_without_duplicates = []\n",
    "        for num in nums:\n",
    "            if num not in memo:\n",
    "                nums_without_duplicates.append(num)\n",
    "            memo.add(num)\n",
    "        nums = nums_without_duplicates\n",
    "\n",
    "        left, right = 0, len(nums) - 1\n",
    "        if nums[left] > nums[right]:\n",
    "            while left + 1 < right:\n",
    "                mid = (left + right) // 2\n",
    "                if nums[mid] > nums[right]:\n",
    "                    left = mid\n",
    "                if nums[mid] < nums[right]:\n",
    "                    right = mid\n",
    "        edge = right\n",
    "\n",
    "        def binary_search(l, r, target):\n",
    "            while l <= r:\n",
    "                mid = (l + r) // 2\n",
    "                if nums[mid] == target:\n",
    "                    return mid\n",
    "                if nums[mid] > target:\n",
    "                    r = mid - 1\n",
    "                else:\n",
    "                    l = mid + 1\n",
    "            return -1\n",
    "        \n",
    "        left_result = binary_search(0, edge - 1, target)\n",
    "        right_result = binary_search(edge, len(nums) - 1, target)\n",
    "        if right_result != -1 or left_result != -1:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "Solution81().search(nums=[1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1], target=2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 83. Remove Duplicates from Sorted List (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ListNode{val: 1, next: None}"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution83:\n",
    "    def delete_duplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n",
    "        zero_node = ListNode(None, next=head)\n",
    "        prev = zero_node\n",
    "        while head:\n",
    "            if head.val == prev.val:\n",
    "                prev.next = head.next\n",
    "            else:\n",
    "                prev = head\n",
    "            head = head.next\n",
    "        return zero_node.next\n",
    "\n",
    "Solution83().delete_duplicates(head=ListNode(val=1, next=ListNode(val=1, next=ListNode(val=1, next=None))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 86. Partition List (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ListNode{val: 1, next: ListNode{val: 2, next: ListNode{val: 2, next: ListNode{val: 4, next: ListNode{val: 3, next: ListNode{val: 5, next: None}}}}}}"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution86:\n",
    "    def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:\n",
    "        part1, part2 = ListNode(None), ListNode(None)\n",
    "        pointer_part1, pointer_part2 = part1, part2\n",
    "        while head:\n",
    "            if head.val < x:\n",
    "                pointer_part1.next, pointer_part1 = head, head\n",
    "            else:\n",
    "                pointer_part2.next, pointer_part2 = head, head\n",
    "            head = head.next\n",
    "        pointer_part2.next = None\n",
    "        pointer_part1.next = part2.next\n",
    "        return part1.next\n",
    "\n",
    "Solution86().partition(head=ListNode(1, ListNode(4, ListNode(3, ListNode(2, ListNode(5, ListNode(2, None)))))), x=3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 88. Merge Sorted Array (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 2, 3, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution88:\n",
    "    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n",
    "        writing_pointer = m + n - 1\n",
    "        while writing_pointer >= 0:\n",
    "            if n < 1 or (m > 0 and nums1[m - 1] > nums2[n - 1]):\n",
    "                nums1[writing_pointer] = nums1[m - 1]\n",
    "                m -= 1\n",
    "            else:\n",
    "                nums1[writing_pointer] = nums2[n - 1]\n",
    "                n -= 1\n",
    "            writing_pointer -= 1\n",
    "        print(nums1)\n",
    "\n",
    "Solution88().merge(nums1=[1,2,3,0,0,0], m=3, nums2=[2,5,6], n = 3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 91. Decode Ways (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution91:\n",
    "    def num_decodings(self, s: str) -> int:\n",
    "        dp = [0] * (len(s) + 1)\n",
    "        dp[-1] = 1\n",
    "        for i in range(len(s)-1, -1, -1):\n",
    "            if s[i] != '0':\n",
    "                dp[i] += dp[i+1]\n",
    "                if i < len(s) - 1 and int(s[i:i+2]) <= 26:\n",
    "                    dp[i] += dp[i+2]\n",
    "        return dp[0]\n",
    "\n",
    "Solution91().num_decodings(s='226')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 92. Reverse Linked List II (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ListNode{val: 1, next: ListNode{val: 4, next: ListNode{val: 3, next: ListNode{val: 2, next: ListNode{val: 5, next: None}}}}}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution92:\n",
    "    def reverse_between(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:\n",
    "        if left == right:\n",
    "            return head\n",
    "        zero_node = ListNode(0)\n",
    "        zero_node.next = head\n",
    "        prev = zero_node\n",
    "        for _ in range(left - 1):\n",
    "            prev = prev.next\n",
    "        reverse = None\n",
    "        cur = prev.next\n",
    "        for _ in range(right - left + 1):\n",
    "            nxt = cur.next\n",
    "            cur.next = reverse\n",
    "            reverse = cur\n",
    "            cur = nxt\n",
    "        prev.next.next = cur\n",
    "        prev.next = reverse\n",
    "\n",
    "        return zero_node.next\n",
    "\n",
    "Solution92().reverse_between(head=ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5, None))))),\n",
    "                             left=2, right=4)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 94. Binary Tree Inorder Traversal (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 2]"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional, List\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution94:\n",
    "    def inorder_traversal(self, root: Optional[TreeNode]) -> List[int]:\n",
    "        ans = []\n",
    "        def helper(node):\n",
    "            if node:\n",
    "                helper(node.left)\n",
    "                ans.append(node.val)\n",
    "                helper(node.right)\n",
    "        helper(root)\n",
    "        return ans\n",
    "\n",
    "Solution94().inorder_traversal(TreeNode(val=1,\n",
    "                                        left=None,\n",
    "                                        right=TreeNode(val=2,\n",
    "                                                       left=TreeNode(val=3, left=None, right=None),\n",
    "                                                       right=None)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 2]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional, List\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution94_1:\n",
    "    def inorder_traversal(self, root: Optional[TreeNode]) -> List[int]:\n",
    "        ans = []\n",
    "        stack = []\n",
    "        cur = root\n",
    "        while stack or cur:\n",
    "            while cur:\n",
    "                stack.append(cur)\n",
    "                cur = cur.left\n",
    "            cur = stack.pop()\n",
    "            ans.append(cur.val)\n",
    "            cur = cur.right\n",
    "        return ans\n",
    "\n",
    "Solution94_1().inorder_traversal(TreeNode(val=1,\n",
    "                                        left=None,\n",
    "                                        right=TreeNode(val=2,\n",
    "                                                       left=TreeNode(val=3, left=None, right=None),\n",
    "                                                       right=None)))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 97. Interleaving String (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution97:\n",
    "    def is_interleave(self, s1: str, s2: str, s3: str) -> bool:\n",
    "        m, n, q = len(s1), len(s2), len(s3)\n",
    "        if m + n != q:\n",
    "            return False\n",
    "        dp = [False] * (n + 1)\n",
    "        dp[0] = True\n",
    "\n",
    "        for j in range(1, n + 1):\n",
    "            dp[j] = dp[j - 1] and s2[j - 1] == s3[j - 1]\n",
    "        \n",
    "        for i in range(1, m + 1):\n",
    "            dp[0] = dp[0] and s1[i - 1] == s3[i - 1]\n",
    "            for j in range(1, n + 1):\n",
    "                dp[j] = (dp[j] and s1[i - 1] == s3[i + j - 1]) or (dp[j - 1] and s2[j - 1] == s3[i + j - 1])\n",
    "        \n",
    "        return dp[n]\n",
    "\n",
    "Solution97().is_interleave(s1='aabcc', s2='dbbca', s3='aadbbcbcac')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 98. Validate Binary Search Tree (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution98:\n",
    "    def is_valid_bst(self, root: Optional[TreeNode]) -> bool:\n",
    "        def helper(root, lower, upper):\n",
    "            if not root:\n",
    "                return True\n",
    "            if not lower < root.val < upper:\n",
    "                return False\n",
    "            left = helper(root.left, lower, root.val)\n",
    "            right = helper(root.right, root.val, upper)\n",
    "            return left and right\n",
    "        return helper(root, float('-inf'), float('inf'))\n",
    "\n",
    "Solution98().is_valid_bst(root=TreeNode(val=5,\n",
    "                                        left=TreeNode(val=1, left=None, right=None),\n",
    "                                        right=TreeNode(val=4,\n",
    "                                                       left=TreeNode(val=3, left=None, right=None),\n",
    "                                                       right=TreeNode(val=6, left=None, right=None))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 100. Same Tree (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional, List\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution100:\n",
    "    def is_same_tree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:\n",
    "        if not p and not q:\n",
    "            return True\n",
    "        if not p or not q:\n",
    "            return False\n",
    "        return p.val == q.val and self.is_same_tree(p=p.left, q=q.left) and self.is_same_tree(p=p.right, q=q.right)\n",
    "\n",
    "Solution100().is_same_tree(p=TreeNode(val=3, left=None, right=None),\n",
    "                           q=TreeNode(val=3, left=None, right=None))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 101. Symmetric Tree (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "from collections import deque\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution101:\n",
    "    def is_symmetric(self, root: Optional[TreeNode]) -> bool:\n",
    "        q = deque([root])\n",
    "        # levels = []\n",
    "        while q:\n",
    "            level = []\n",
    "            for _ in range(len(q)):\n",
    "                cur = q.popleft()\n",
    "                level.append(cur.val if cur else 'Empty')\n",
    "                if cur:\n",
    "                    q.append(cur.left)\n",
    "                    q.append(cur.right)\n",
    "            if len(level) > 1:\n",
    "                level_len = len(level)\n",
    "                if level[:level_len//2] != level[level_len//2:][::-1]:\n",
    "                    return False  \n",
    "            # levels.append(level)\n",
    "        # print(levels)\n",
    "        return True\n",
    "\n",
    "Solution101().is_symmetric(root=TreeNode(val=1,\n",
    "                                         left=TreeNode(val=2,\n",
    "                                                       left=TreeNode(val=3, left=None, right=None),\n",
    "                                                       right=TreeNode(val=4, left=None, right=None)),\n",
    "                                         right=TreeNode(val=2,\n",
    "                                                       left=TreeNode(val=4, left=None, right=None),\n",
    "                                                       right=TreeNode(val=3, left=None, right=None))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Solution101().is_symmetric(root=TreeNode(val=1,\n",
    "                                         left=TreeNode(val=2,\n",
    "                                                       left=None,\n",
    "                                                       right=TreeNode(val=3, left=None, right=None)),\n",
    "                                         right=TreeNode(val=2,\n",
    "                                                       left=None,\n",
    "                                                       right=TreeNode(val=3, left=None, right=None))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 103. Binary Tree Zigzag Level Order Traversal (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[3], [20, 9], [15, 7]]"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional, List\n",
    "from collections import deque\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution103:\n",
    "    def zigzag_level_order(self, root: Optional[TreeNode]) -> List[List[int]]:\n",
    "        if not root:\n",
    "            return []\n",
    "        q = deque([root])\n",
    "        ans = []\n",
    "        rev_flag = False\n",
    "\n",
    "        while q:\n",
    "            level = []\n",
    "            for _ in range(len(q)):\n",
    "                cur = q.popleft()\n",
    "                level.append(cur.val)\n",
    "                if cur.left:\n",
    "                    q.append(cur.left)\n",
    "                if cur.right:\n",
    "                    q.append(cur.right)\n",
    "            if rev_flag:\n",
    "                level = level[::-1]\n",
    "            rev_flag = not rev_flag\n",
    "            ans.append(level)\n",
    "        return ans\n",
    "\n",
    "Solution103().zigzag_level_order(root=TreeNode(val=3,\n",
    "                                               left=TreeNode(val=9, left=None, right=None),\n",
    "                                               right=TreeNode(val=20,\n",
    "                                                              left=TreeNode(val=15, left=None, right=None),\n",
    "                                                              right=TreeNode(val=7, left=None, right=None))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[3], [20, 9], [15, 7]]"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional, List\n",
    "from collections import deque\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution103_1:\n",
    "    def zigzag_level_order(self, root: Optional[TreeNode]) -> List[List[int]]:\n",
    "        if not root:\n",
    "            return []\n",
    "        q = [root]\n",
    "        ans = []\n",
    "        rev_flag = False\n",
    "\n",
    "        while q:\n",
    "            level = []\n",
    "            # здесь ещё раз проверить enumerate() вместо range(len())\n",
    "            for _ in range(len(q)):\n",
    "                cur = q.pop(0)\n",
    "                level.append(cur.val)\n",
    "                if cur.left:\n",
    "                    q.append(cur.left)\n",
    "                if cur.right:\n",
    "                    q.append(cur.right)\n",
    "            if rev_flag:\n",
    "                level = level[::-1]\n",
    "            rev_flag = not rev_flag\n",
    "            ans.append(level)\n",
    "        return ans\n",
    "\n",
    "Solution103_1().zigzag_level_order(root=TreeNode(val=3,\n",
    "                                               left=TreeNode(val=9, left=None, right=None),\n",
    "                                               right=TreeNode(val=20,\n",
    "                                                              left=TreeNode(val=15, left=None, right=None),\n",
    "                                                              right=TreeNode(val=7, left=None, right=None))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 104. Maximum Depth of Binary Tree (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution104:\n",
    "    def max_depth(self, root: Optional[TreeNode]) -> int:\n",
    "        if not root:\n",
    "            return 0\n",
    "        left = self.max_depth(root.left)\n",
    "        right = self.max_depth(root.right)\n",
    "        return max(left, right) + 1\n",
    "\n",
    "Solution104().max_depth(root=TreeNode(val=3,\n",
    "                                      left=TreeNode(val=9, left=None, right=None),\n",
    "                                      right=TreeNode(val=20,\n",
    "                                                     left=TreeNode(val=15, left=None, right=None),\n",
    "                                                     right=TreeNode(val=7, left=None, right=None))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 108. Convert Sorted Array to Binary Search Tree (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TreeNode{val: 0, left: TreeNode{val: -10, left: None, right: TreeNode{val: -3, left: None, right: None}}, right: TreeNode{val: 5, left: None, right: TreeNode{val: 9, left: None, right: None}}}"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution108:\n",
    "    def sorted_array_to_bst(self, nums: List[int]) -> Optional[TreeNode]:\n",
    "        def helper(left, right):\n",
    "            if left <= right:\n",
    "                mid = (left + right) // 2\n",
    "                root = TreeNode(nums[mid])\n",
    "                root.left = helper(left, mid - 1)\n",
    "                root.right = helper(mid + 1, right)\n",
    "                return root\n",
    "        return helper(0, len(nums) - 1)\n",
    "\n",
    "Solution108().sorted_array_to_bst(nums=[-10, -3, 0, 5, 9])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 110. Balanced Binary Tree (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "    \n",
    "class Solution110:\n",
    "    def is_balanced(self, root: Optional[TreeNode]) -> bool:\n",
    "\n",
    "        def helper(root):\n",
    "            if not root:\n",
    "                return True, 0\n",
    "            left_balanced, left_height = helper(root.left)\n",
    "            right_balanced, right_height = helper(root.right)\n",
    "            if not left_balanced or not right_balanced:\n",
    "                return False, -1\n",
    "            return abs(right_height - left_height) < 2, 1 + max(left_height, right_height)\n",
    "        \n",
    "        return helper(root)[0]\n",
    "\n",
    "Solution110().is_balanced(root=TreeNode(val=3,\n",
    "                                        left=TreeNode(val=9, left=None, right=None),\n",
    "                                        right=TreeNode(val=20,\n",
    "                                                       left=TreeNode(val=15, left=None, right=None),\n",
    "                                                       right=TreeNode(val=7, left=None, right=None))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "    \n",
    "class Solution110_1:\n",
    "    def is_balanced(self, root: Optional[TreeNode]) -> bool:\n",
    "        if not root:\n",
    "            return True\n",
    "        def height(root):\n",
    "            if not root:\n",
    "                return 0\n",
    "            return max(height(root.left), height(root.right)) + 1\n",
    "        stack = [root]\n",
    "        while stack:\n",
    "            cur = stack.pop()\n",
    "            left = height(cur.left)\n",
    "            right = height(cur.right)\n",
    "            if abs(left - right) > 1:\n",
    "                return False\n",
    "            if cur.left:\n",
    "                stack.append(cur.left)\n",
    "            if cur.right:\n",
    "                stack.append(cur.right)\n",
    "        return True\n",
    "\n",
    "Solution110_1().is_balanced(root=TreeNode(val=3,\n",
    "                                          left=TreeNode(val=9, left=None, right=None),\n",
    "                                          right=TreeNode(val=20,\n",
    "                                                         left=TreeNode(val=15, left=None, right=None),\n",
    "                                                         right=TreeNode(val=7, left=None, right=None))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 111. Minimum Depth of Binary Tree (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "from collections import deque\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution111:\n",
    "    def min_depth(self, root: Optional[TreeNode]) -> int:\n",
    "\n",
    "        if not root:\n",
    "            return 0\n",
    "\n",
    "        q = deque([(root, 1)])\n",
    "        while q:\n",
    "            cur, depth = q.popleft()\n",
    "            if not cur.left and not cur.right:\n",
    "                return depth\n",
    "            if cur.left:\n",
    "                q.append((cur.left, depth+1))\n",
    "            if cur.right:\n",
    "                q.append((cur.right, depth+1))\n",
    "\n",
    "Solution111().min_depth(root=TreeNode(val=3,\n",
    "                                      left=TreeNode(val=9, left=None, right=None),\n",
    "                                      right=TreeNode(val=20,\n",
    "                                                     left=TreeNode(val=15, left=None, right=None),\n",
    "                                                     right=TreeNode(val=7, left=None, right=None))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 118. Pascal's Triangle (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1], [1, 1], [1, 2, 1], [1, 3, 3, 1]]"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "def factorial(num: int):\n",
    "    itog = 1\n",
    "    for i in range(num):\n",
    "        itog *= (i+1)\n",
    "    return itog\n",
    "\n",
    "\n",
    "def combinations(k: int, n: int):\n",
    "    return int(factorial(n) / (factorial(k) * factorial(n-k)))\n",
    "\n",
    "\n",
    "class Solution118:\n",
    "    def generate(self, num_rows: int) -> List[List[int]]:\n",
    "        triangle_rows = []\n",
    "        for i in range(num_rows):\n",
    "            triangle_rows.append([combinations(j, i) for j in range(i+1)])\n",
    "        return triangle_rows\n",
    "\n",
    "\n",
    "Solution118().generate(num_rows=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1], [1, 1], [1, 2, 1], [1, 3, 3, 1]]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution118_1:\n",
    "    def generate(self, num_rows: int) -> List[List[int]]:\n",
    "        dp = [[1], [1, 1]]\n",
    "        if num_rows < 3:\n",
    "            return dp[:num_rows]\n",
    "        for _ in range(num_rows-2):\n",
    "            next_row = [1]\n",
    "            for i, _ in enumerate(dp[-1][:-1]):\n",
    "                next_row.append(dp[-1][i] + dp[-1][i+1])\n",
    "            next_row += [1]\n",
    "            dp.append(next_row)\n",
    "        return dp\n",
    "\n",
    "Solution118_1().generate(num_rows=4)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 119. Pascal's Triangle 2 (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 3, 1]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "def factorial(num: int):\n",
    "    itog = 1\n",
    "    for i in range(num):\n",
    "        itog *= (i+1)\n",
    "    return itog\n",
    "\n",
    "def combinations(k: int, n: int):\n",
    "    return int(factorial(n) / (factorial(k) * factorial(n-k)))\n",
    "\n",
    "\n",
    "class Solution119:\n",
    "    def getRow(self, rowIndex: int) -> List[int]:\n",
    "        return [combinations(j, rowIndex) for j in range(rowIndex+1)]\n",
    "\n",
    "Solution119().getRow(rowIndex=3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 120. Triangle (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution120:\n",
    "    def minimum_total(self, triangle: List[List[int]]) -> int:\n",
    "        n = len(triangle)\n",
    "        for i in range(1, n):\n",
    "            m = len(triangle[i])\n",
    "            triangle[i][0] += triangle[i-1][0]\n",
    "            triangle[i][m-1] += triangle[i-1][m-2]\n",
    "            for j in range(1, m-1):\n",
    "                triangle[i][j] += min(triangle[i-1][j-1], triangle[i-1][j])\n",
    "        return min(triangle[-1])\n",
    "\n",
    "Solution120().minimum_total(triangle=[[2],[3,4],[6,5,7],[4,1,8,3]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 121. Best Time to Buy and Sell Stock (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution121:\n",
    "    def max_profit(self, prices: List[int]) -> int:\n",
    "        if len(prices) == 1:\n",
    "            return 0\n",
    "        profits = []\n",
    "        for i, _ in enumerate(prices):\n",
    "            profits.append([j-k for j,k in zip(prices[i:], prices[:-i])])\n",
    "        profits_flatten = [item for sublist in profits for item in sublist]\n",
    "        max_profit = max(profits_flatten)\n",
    "        \n",
    "        return max_profit if max_profit > 0 else 0\n",
    "\n",
    "Solution121().max_profit(prices=[7,1,5,3,6,4])\n",
    "# превышен лимит времени на тестовом примере сайта"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution121_1:\n",
    "    def max_profit(self, prices: List[int]) -> int:\n",
    "        min_price = 2e4\n",
    "        max_profit = 0\n",
    "        for i, _ in enumerate(prices):\n",
    "            if prices[i] < min_price:\n",
    "                min_price = prices[i]\n",
    "            else:\n",
    "                current_difference = prices[i] - min_price\n",
    "                if current_difference > max_profit:\n",
    "                    max_profit = current_difference\n",
    "        return max_profit\n",
    "\n",
    "Solution121_1().max_profit(prices=[7,1,5,3,6,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution121_2:\n",
    "    def max_profit(self, prices: List[int]) -> int:\n",
    "        min_price = float('inf')\n",
    "        max_profit = 0\n",
    "        for price in prices:\n",
    "            min_price = min(min_price, price)\n",
    "            max_profit = max(max_profit, price - min_price)\n",
    "        return max_profit\n",
    "\n",
    "Solution121_2().max_profit(prices=[7,1,5,3,6,4])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 122. Best Time to Buy and Sell Stock 2 (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution122:\n",
    "    def max_profit(self, prices: List[int]) -> int:\n",
    "        max_profit = 0\n",
    "        for i, _ in enumerate(prices[:-1]):\n",
    "            prices_difference = prices[i+1] - prices[i]\n",
    "            if prices_difference > 0:\n",
    "                max_profit += prices_difference\n",
    "        return max_profit\n",
    "\n",
    "Solution122().max_profit(prices=[7,1,5,3,6,4])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 125. Valid Palindrome (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution125:\n",
    "    def is_palindrome(self, s: str) -> bool:\n",
    "        left, right = 0, len(s) - 1\n",
    "        while left <= right:\n",
    "            if not s[left].isalnum():\n",
    "                left += 1\n",
    "                continue\n",
    "            if not s[right].isalnum():\n",
    "                right -= 1\n",
    "                continue\n",
    "            if s[left].lower() != s[right].lower():\n",
    "                return False\n",
    "            left += 1\n",
    "            right -= 1\n",
    "        return True\n",
    "\n",
    "Solution125().is_palindrome(s='A man, a plan, a canal: Panama')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 134. Gas Station (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution134:\n",
    "    def can_complete_circuit(self, gas: List[int], cost: List[int]) -> int:\n",
    "        net_gas = [g - c for g, c in zip(gas, cost)]\n",
    "        if sum(net_gas) < 0:\n",
    "            return -1\n",
    "        tank = 0\n",
    "        start = 0\n",
    "        for i, g in enumerate(net_gas):\n",
    "            tank += g\n",
    "            if tank < 0:\n",
    "                tank = 0\n",
    "                start = i + 1\n",
    "        return start\n",
    "\n",
    "Solution134().can_complete_circuit(gas=[1,2,3,4,5], cost=[3,4,5,1,2])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 135. Candy (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution135:\n",
    "    def candy(self, ratings: List[int]) -> int:\n",
    "        n = len(ratings)\n",
    "        ans = [1] * n\n",
    "        for i in range(n-1):\n",
    "            if ratings[i] < ratings[i+1]:\n",
    "                ans[i+1] = max(1 + ans[i], ans[i+1])\n",
    "        for i in range(n-2, -1, -1):\n",
    "            if ratings[i+1] < ratings[i]:\n",
    "                ans[i] = max(1 + ans[i+1], ans[i])\n",
    "        return sum(ans)\n",
    "\n",
    "Solution135().candy(ratings=[1,0,2])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 136. Single Number (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution136:\n",
    "    def single_number(self, nums: List[int]) -> int:\n",
    "        alone_num = 0\n",
    "        for num in nums:\n",
    "            alone_num ^= num\n",
    "        return alone_num\n",
    "\n",
    "Solution136().single_number(nums=[4,1,2,1,2])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 138. Copy List with Random Pointer (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "    def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):\n",
    "        self.val = int(x)\n",
    "        self.next = next\n",
    "        self.random = random\n",
    "\n",
    "class Solution138:\n",
    "    def copy_random_list(self, head: 'Optional[Node]') -> 'Optional[Node]':\n",
    "        d = {}\n",
    "        zero_node = Node(0)\n",
    "        prev = zero_node\n",
    "\n",
    "        cur = head\n",
    "\n",
    "        while prev:\n",
    "            new = Node(cur.val)\n",
    "            d[cur] = new\n",
    "            prev.next = new\n",
    "            prev = prev.next\n",
    "            cur = cur.next\n",
    "        \n",
    "        cur_old = head\n",
    "        cur_new = zero_node.next\n",
    "\n",
    "        while cur_old:\n",
    "            cur_new.random = d[cur_old.random] if cur_old.random else None\n",
    "            cur_old = cur_old.next\n",
    "            cur_new = cur_new.next\n",
    "        \n",
    "        return zero_node.next\n",
    "\n",
    "#Solution138().copy_random_list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "    def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):\n",
    "        self.val = int(x)\n",
    "        self.next = next\n",
    "        self.random = random\n",
    "\n",
    "class Solution138_1:\n",
    "    def copy_random_list(self, head: 'Optional[Node]') -> 'Optional[Node]':\n",
    "        if head is None:\n",
    "            return None\n",
    "        pointers = {}\n",
    "        cur = head\n",
    "        while cur:\n",
    "            pointers[cur] = Node(cur.val, None, None)\n",
    "            cur = cur.next\n",
    "        cur = head\n",
    "        while cur:\n",
    "            if cur.next:\n",
    "                pointers[cur].next = pointers[cur.next]\n",
    "            if cur.random:\n",
    "                pointers[cur].random = pointers[cur.random]\n",
    "            cur = cur.next\n",
    "        return pointers[head]\n",
    "\n",
    "#Solution138_1().copy_random_list()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 139. Word Break (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Time Limit Exceeded\n",
    "from typing import List\n",
    "\n",
    "class Solution139:\n",
    "    def word_break(self, s: str, word_dict: List[str]) -> bool:\n",
    "        s_len = len(s)\n",
    "        if s_len == 0:\n",
    "            return True\n",
    "        for i in range(1, s_len+1):\n",
    "            if s[0:i] in word_dict and self.word_break(s[i:s_len], word_dict):\n",
    "                return True\n",
    "        return False\n",
    "\n",
    "Solution139().word_break(s='leetcode', word_dict=['leet', 'code'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution139_1:\n",
    "    def word_break(self, s: str, word_dict: List[str]) -> bool:\n",
    "        s_len = len(s)\n",
    "        \n",
    "        dp = [False] * (s_len + 1)\n",
    "\n",
    "        for i in range(1, s_len + 1):\n",
    "\n",
    "            if dp[i] or s[0:i] in word_dict:\n",
    "                dp[i] = True\n",
    "\n",
    "                if dp[i] and i == s_len:\n",
    "                    return True\n",
    "                \n",
    "                for j in range(i + 1, s_len + 1):\n",
    "                    if s[i:j] in word_dict:\n",
    "                        dp[j] = True\n",
    "                    if dp[j] and j == s_len:\n",
    "                        return True\n",
    "        return False\n",
    "\n",
    "Solution139_1().word_break(s=\"aebbbbs\", word_dict=[\"a\",\"aeb\",\"ebbbb\",\"s\",\"eb\"])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 141. Linked List Cycle (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution141:\n",
    "    def has_cycle(self, head: Optional[ListNode]) -> bool:\n",
    "        seen = set()\n",
    "        while head:\n",
    "            if head in seen:\n",
    "                return True\n",
    "            seen.add(head)\n",
    "            head = head.next\n",
    "        return False\n",
    "\n",
    "Solution141().has_cycle(head=ListNode(val=4, next=None))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution141_1:\n",
    "    def has_cycle(self, head: Optional[ListNode]) -> bool:\n",
    "        slow = head\n",
    "        fast = head\n",
    "        while fast and fast.next:\n",
    "            slow = slow.next\n",
    "            fast = fast.next.next\n",
    "            if slow == fast:\n",
    "                return True\n",
    "        return False\n",
    "\n",
    "Solution141_1().has_cycle(head=ListNode(val=4, next=None))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 144. Binary Tree Preorder Traversal (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional, List\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution144:\n",
    "    def preorder_traversal(self, root: Optional[TreeNode]) -> List[int]:\n",
    "        return [root.val] + self.preorder_traversal(root.left) + self.preorder_traversal(root.right) if root else []\n",
    "\n",
    "Solution144().preorder_traversal(TreeNode(val=1,\n",
    "                                          left=None,\n",
    "                                          right=TreeNode(val=2,\n",
    "                                                         left=TreeNode(val=3, left=None, right=None),\n",
    "                                                         right=None)))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 145. Binary Tree Postorder Traversal (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 4]"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional, List\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution145:\n",
    "    def postorder_traversal(self, root: Optional[TreeNode]) -> List[int]:\n",
    "        ans = []\n",
    "        def helper(node):\n",
    "            if node:\n",
    "                helper(node.left)\n",
    "                helper(node.right)\n",
    "                ans.append(node.val)\n",
    "        helper(root)\n",
    "        return ans\n",
    "\n",
    "Solution145().postorder_traversal(TreeNode(val=4, left=None, right=TreeNode(val=5, left=None, right=None)))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 153. Find Minimum in Rotated Sorted Array (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution153:\n",
    "    def find_min(self, nums: List[int]) -> int:\n",
    "        left, right = 0, len(nums) - 1\n",
    "        if nums[left] <= nums[right]:\n",
    "            return nums[left]\n",
    "        while left <= right:\n",
    "            mid = (left + right) // 2\n",
    "            if nums[mid] > nums[mid + 1]:\n",
    "                return nums[mid + 1]\n",
    "            if nums[mid] > nums[right]:\n",
    "                left = mid + 1\n",
    "            else:\n",
    "                right = mid\n",
    "\n",
    "Solution153().find_min(nums=[4,5,1,2,3])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 155. Min Stack (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3; 0; -2\n"
     ]
    }
   ],
   "source": [
    "class MinStack:\n",
    "\n",
    "    def __init__(self):\n",
    "        self.values = []\n",
    "\n",
    "    def push(self, val: int) -> None:\n",
    "        self.values.append(val)\n",
    "\n",
    "    def pop(self) -> None:\n",
    "        self.values.pop()\n",
    "\n",
    "    def top(self) -> int:\n",
    "        return self.values[-1]\n",
    "\n",
    "    def get_min(self) -> int:\n",
    "        return min(self.values)\n",
    "\n",
    "\n",
    "# Your MinStack object will be instantiated and called as such:\n",
    "obj = MinStack()\n",
    "obj.push(-2)\n",
    "obj.push(0)\n",
    "obj.push(-3)\n",
    "param_4 = obj.get_min()\n",
    "obj.pop()\n",
    "param_6 = obj.top()\n",
    "param_7 = obj.get_min()\n",
    "print(f'{param_4}; {param_6}; {param_7}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3; 0; -2\n"
     ]
    }
   ],
   "source": [
    "class MinStack2:\n",
    "\n",
    "    def __init__(self):\n",
    "        self.stack = []\n",
    "        self.minstack = []\n",
    "\n",
    "    def push(self, val: int) -> None:\n",
    "        self.stack.append(val)\n",
    "        if not self.minstack:\n",
    "            self.minstack.append(val)\n",
    "        else:\n",
    "            self.minstack.append(min(val, self.minstack[-1]))\n",
    "\n",
    "    def pop(self) -> None:\n",
    "        self.stack.pop()\n",
    "        self.minstack.pop()\n",
    "\n",
    "    def top(self) -> int:\n",
    "        return self.stack[-1]\n",
    "\n",
    "    def get_min(self) -> int:\n",
    "        return self.minstack[-1]\n",
    "\n",
    "\n",
    "# Your MinStack2 object will be instantiated and called as such:\n",
    "obj = MinStack2()\n",
    "obj.push(-2)\n",
    "obj.push(0)\n",
    "obj.push(-3)\n",
    "param_4 = obj.get_min()\n",
    "obj.pop()\n",
    "param_6 = obj.top()\n",
    "param_7 = obj.get_min()\n",
    "print(f'{param_4}; {param_6}; {param_7}')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 160. Intersection of Two Linked Lists (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution160:\n",
    "    def get_intersection_node(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:\n",
    "        l1 = 0\n",
    "        cur1 = headA\n",
    "        while cur1:\n",
    "            l1 += 1\n",
    "            cur1 = cur1.next\n",
    "        l2 = 0\n",
    "        cur2 = headB\n",
    "        while cur2:\n",
    "            l2 += 1\n",
    "            cur2 = cur2.next\n",
    "        if l1 > l2:\n",
    "            n = l1 - l2\n",
    "            cur_long = headA\n",
    "            cur_short = headB\n",
    "        else:\n",
    "            n = l2 - l1\n",
    "            cur_long = headB\n",
    "            cur_short = headA\n",
    "        while n:\n",
    "            cur_long = cur_long.next\n",
    "            n -= 1\n",
    "        while cur_long:\n",
    "            if cur_long == cur_short:\n",
    "                return cur_long\n",
    "            cur_short = cur_short.next\n",
    "            cur_long = cur_long.next\n",
    "\n",
    "#Solution160().get_intersection_node()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 162. Find Peak Element (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution162:\n",
    "    def find_peak_element(self, nums: List[int]) -> int:\n",
    "        if len(nums) == 1:\n",
    "            return 0\n",
    "        if nums[1] < nums[0]:\n",
    "            return 0\n",
    "        if nums[len(nums) - 2] < nums[len(nums) - 1]:\n",
    "            return len(nums) - 1\n",
    "        left = 1\n",
    "        right = len(nums) - 2\n",
    "        while left <= right:\n",
    "            mid = (left + right) // 2\n",
    "            if nums[mid - 1] < nums[mid] > nums[mid + 1]:\n",
    "                return mid\n",
    "            elif nums[mid - 1] < nums[mid]:\n",
    "                left = mid + 1\n",
    "            else:\n",
    "                right = mid - 1\n",
    "        return None\n",
    "\n",
    "Solution162().find_peak_element(nums=[1,2,3,1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 167. Two Sum II - Input Array Is Sorted (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution167:\n",
    "    def two_sum(self, numbers: List[int], target: int) -> List[int]:\n",
    "        left, right = 0, len(numbers) - 1\n",
    "        while left <= right:\n",
    "            cur_sum = numbers[left] + numbers[right]\n",
    "            if cur_sum == target:\n",
    "                return [left + 1, right + 1]\n",
    "            if cur_sum > target:\n",
    "                right -= 1\n",
    "            if cur_sum < target:\n",
    "                left += 1\n",
    "\n",
    "Solution167().two_sum(numbers=[2, 7, 11, 15], target=9)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 168. Excel Sheet Column Title (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AB'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution168:\n",
    "    def convert_to_title(self, column_number: int) -> str:\n",
    "        ans = []\n",
    "        while column_number > 0:\n",
    "            column_number -= 1\n",
    "            cur = column_number % 26\n",
    "            column_number = int(column_number / 26)\n",
    "            ans.append(chr(cur + ord('A')))\n",
    "        return ''.join(ans[::-1])\n",
    "\n",
    "Solution168().convert_to_title(column_number=28)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 169. Majority Element (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import Counter\n",
    "\n",
    "class Solution169:\n",
    "    def majority_element(self, nums: List[int]) -> int:\n",
    "        return Counter(nums).most_common()[0][0]\n",
    "\n",
    "Solution169().majority_element(nums=[3, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution169_1:\n",
    "    def majority_element(self, nums: List[int]) -> int:\n",
    "        count = 0\n",
    "        candidate = None\n",
    "        for num in nums:\n",
    "            if count == 0:\n",
    "                candidate = num\n",
    "            count += (1 if num == candidate else -1)\n",
    "        return candidate\n",
    "\n",
    "Solution169_1().majority_element(nums=[3, 2, 3])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 189. Rotate Array (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 6, 7, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "class Solution189:\n",
    "    def rotate(self, nums: List[int], k: int) -> None:\n",
    "\n",
    "        def reverse(left, right):\n",
    "            while left <= right:\n",
    "                nums[left], nums[right] = nums[right], nums[left]\n",
    "                left += 1\n",
    "                right -= 1\n",
    "        \n",
    "        n = len(nums)\n",
    "\n",
    "        reverse(0, n - 1)\n",
    "        reverse(0, k % n - 1)\n",
    "        reverse(k % n, n - 1)\n",
    "        print(nums)\n",
    "        return None\n",
    "\n",
    "Solution189().rotate(nums=[1, 2, 3, 4, 5, 6, 7], k=3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 191. Number of 1 Bits (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution191:\n",
    "    def hamming_weight(self, n: int) -> int:\n",
    "        ans = 0\n",
    "        while n:\n",
    "            ans += n & 1\n",
    "            n >>= 1\n",
    "        return ans\n",
    "\n",
    "Solution191().hamming_weight(n=int('10001110100110', 2))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 202. Happy Number (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution202:\n",
    "    def is_happy(self, n: int) -> bool:\n",
    "        cache = []\n",
    "        while n != 1:\n",
    "            sum = 0\n",
    "            for i in str(n):\n",
    "                sum += int(i)**2\n",
    "            n = sum\n",
    "            if n in cache:\n",
    "                return False\n",
    "            else:\n",
    "                cache.append(n)\n",
    "        return True\n",
    "\n",
    "Solution202().is_happy(n=19)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 203. Remove Linked List Elements (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ListNode{val: 4, next: None}"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution203:\n",
    "    def remove_elements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:\n",
    "        zero_node = ListNode(None, next=head)\n",
    "        cur = head\n",
    "        prev = zero_node\n",
    "        while cur:\n",
    "            if cur.val == val:\n",
    "                prev.next = cur.next\n",
    "            else:\n",
    "                prev = cur\n",
    "            cur = cur.next\n",
    "        return zero_node.next\n",
    "\n",
    "Solution203().remove_elements(head=ListNode(val=3,next=ListNode(val=4,next=None)), val=3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 204. Count Primes (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution204:\n",
    "    def count_primes(self, n: int) -> int:\n",
    "        arr = [True] * n\n",
    "        if n == 0 or n == 1:\n",
    "            return 0\n",
    "        arr[0], arr[1] = False, False\n",
    "        for i in range(2, int(n ** 0.5) + 1):\n",
    "            if arr[i]:\n",
    "                for j in range(i * i, n, i):\n",
    "                    arr[j] = False\n",
    "        return sum(arr)\n",
    "\n",
    "Solution204().count_primes(n=10)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 205. Isomorphic Strings (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution205:\n",
    "    def is_isomorphic(self, s: str, t: str) -> bool:\n",
    "\n",
    "        d1 = {}\n",
    "        d2 = {}\n",
    "\n",
    "        for i, _ in enumerate(s):\n",
    "            if s[i] in d1:\n",
    "                if d1[s[i]] != t[i]:\n",
    "                    return False\n",
    "            else:\n",
    "                if t[i] in d2 and d2[t[i]] != s[i]:\n",
    "                    return False\n",
    "                else:\n",
    "                    d1[s[i]] = t[i]\n",
    "                    d2[t[i]] = s[i]\n",
    "        \n",
    "        return True\n",
    "\n",
    "Solution205().is_isomorphic(s='egg', t='add')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 206. Reverse Linked List (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution206:\n",
    "    def reverse_list(self, head: Optional[ListNode]) -> Optional[ListNode]:\n",
    "        prev = None\n",
    "        cur = head\n",
    "        while cur:\n",
    "            temp = cur.next\n",
    "            cur.next = prev\n",
    "            prev = cur\n",
    "            cur = temp\n",
    "            #cur.next, prev, cur = prev, cur, cur.next\n",
    "        return prev"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 207. Course Schedule (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution207:\n",
    "    def can_finish(self, num_courses: int, prerequisites: List[List[int]]) -> bool:\n",
    "        graph = [[] for _ in range(num_courses)]\n",
    "        for course, prereq in prerequisites:\n",
    "            graph[course].append(prereq)\n",
    "        \n",
    "        def dfs(i):\n",
    "            if not graph[i]:\n",
    "                return False\n",
    "            if i in visited:\n",
    "                return True\n",
    "            visited.add(i)\n",
    "            for j in graph[i]:\n",
    "                if dfs(j):\n",
    "                    return True\n",
    "            visited.remove(i)\n",
    "            return False\n",
    "        for i in range(num_courses):\n",
    "            visited = set()\n",
    "            if dfs(i):\n",
    "                return False\n",
    "            graph[i] =[]\n",
    "        return True\n",
    "\n",
    "Solution207().can_finish(num_courses=2, prerequisites=[[1,0], [0,1]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 215. Kth Largest Element in an Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3] -- test\n",
      "[2, 3] -- test\n",
      "[1, 3, 2] -- test\n",
      "[2, 3]\n",
      "[2, 3, 5] -- test\n",
      "[3, 5]\n",
      "[3, 5, 6] -- test\n",
      "[5, 6]\n",
      "[4, 6, 5] -- test\n",
      "[5, 6]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import heapq\n",
    "from typing import List\n",
    "\n",
    "class Solution215:\n",
    "    def findKthLargest(self, nums: List[int], k: int) -> int:\n",
    "        min_heap = []\n",
    "        for num in nums:\n",
    "            heapq.heappush(min_heap, num)\n",
    "            print(f'{min_heap} -- test')\n",
    "            if len(min_heap) > k:\n",
    "                heapq.heappop(min_heap)\n",
    "                print(min_heap)\n",
    "        return min_heap[0]\n",
    "\n",
    "Solution215().findKthLargest(nums=[3,2,1,5,6,4], k=2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 217. Contains Duplicate (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution217:\n",
    "    def contains_duplicate(self, nums: List[int]) -> bool:\n",
    "        return len(nums) != len(set(nums))\n",
    "\n",
    "Solution217().contains_duplicate(nums=[1,2,3,1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 219. Contains Duplicate II (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution219:\n",
    "    def contains_nearby_duplicate(self, nums: List[int], k: int) -> bool:\n",
    "        \n",
    "        d = {}\n",
    "\n",
    "        for i, num in enumerate(nums):\n",
    "            if num in d and i - d[num] <= k:\n",
    "                return True\n",
    "            d[num] = i\n",
    "        \n",
    "        return False\n",
    "\n",
    "Solution219().contains_nearby_duplicate(nums=[1, 2, 3, 1], k = 3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 224. Basic Calculator (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution224:\n",
    "    def calculate(self, s: str) -> int:\n",
    "        output, cur, sgn, stack = 0, 0, 1, []\n",
    "        for ch in s:\n",
    "            if ch.isdigit():\n",
    "                cur = (cur * 10) + int(ch)\n",
    "            elif ch in '+-':\n",
    "                output += cur * sgn\n",
    "                cur = 0\n",
    "                sgn = 1 if ch == '+' else -1\n",
    "            elif ch == '(':\n",
    "                stack.append(output)\n",
    "                stack.append(sgn)\n",
    "                sgn = 1\n",
    "                output = 0\n",
    "            elif ch == ')':\n",
    "                output += cur * sgn\n",
    "                output *= stack.pop()\n",
    "                output += stack.pop()\n",
    "                cur = 0\n",
    "        return output + (cur * sgn)\n",
    "\n",
    "Solution224().calculate(s='(1+(4+5+2)-3)+(6+8)')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 225. Implement Stack using Queues (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "None\n",
      "2\n",
      "2\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "from collections import deque\n",
    "\n",
    "class MyStack:\n",
    "\n",
    "    def __init__(self):\n",
    "        self._queue = deque()\n",
    "\n",
    "    def push(self, x: int) -> None:\n",
    "        q = self._queue\n",
    "        q.append(x)\n",
    "        for _ in range(len(q) - 1):\n",
    "            q.append(q.popleft())\n",
    "\n",
    "    def pop(self) -> int:\n",
    "        return self._queue.popleft()\n",
    "\n",
    "    def top(self) -> int:\n",
    "        return self._queue[0]\n",
    "\n",
    "    def empty(self) -> bool:\n",
    "        return not len(self._queue)\n",
    "\n",
    "obj = MyStack()\n",
    "print(obj.push(1),\n",
    "      obj.push(2),\n",
    "      obj.top(),\n",
    "      obj.pop(),\n",
    "      obj.empty(),\n",
    "      sep='\\n')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 226. Invert Binary Tree (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TreeNode{val: 4, left: TreeNode{val: 7, left: TreeNode{val: 9, left: None, right: None}, right: TreeNode{val: 6, left: None, right: None}}, right: TreeNode{val: 2, left: TreeNode{val: 3, left: None, right: None}, right: TreeNode{val: 1, left: None, right: None}}}"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution226:\n",
    "    def invert_tree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:\n",
    "        if not root:\n",
    "            return None\n",
    "        root.left, root.right = self.invert_tree(root.right), self.invert_tree(root.left)\n",
    "        return root\n",
    "\n",
    "Solution226().invert_tree(root=TreeNode(val=4,\n",
    "                                        left=TreeNode(val=2,\n",
    "                                                      left=TreeNode(val=1, left=None, right=None),\n",
    "                                                      right=TreeNode(val=3, left=None, right=None)),\n",
    "                                        right=TreeNode(val=7,\n",
    "                                                       left=TreeNode(val=6, left=None, right=None),\n",
    "                                                       right=TreeNode(val=9, left=None, right=None))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 228. Summary Ranges (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['0->2', '4->5', '7']"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution228:\n",
    "    def summary_ranges(self, nums: List[int]) -> List[str]:\n",
    "        if not nums:\n",
    "            return nums\n",
    "        s = nums[0]\n",
    "        nums.append(-1)\n",
    "        ans = []\n",
    "        for i in range(1, len(nums)):\n",
    "            if nums[i] - nums[i - 1] != 1:\n",
    "                e = nums[i - 1]\n",
    "                if s != e:\n",
    "                    ans.append(f'{s}->{e}')\n",
    "                else:\n",
    "                    ans.append(f'{s}')\n",
    "                s = nums[i]\n",
    "        return ans\n",
    "\n",
    "Solution228().summary_ranges(nums=[0, 1, 2, 4, 5, 7])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 229. Majority Element II (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution229:\n",
    "    def majority_element(self, nums: List[int]) -> List[int]:\n",
    "        if not nums:\n",
    "            return []\n",
    "        cand1, cand2, cnt1, cnt2 = 0, 1, 0, 0\n",
    "        for num in nums:\n",
    "            if num == cand1:\n",
    "                cnt1 += 1\n",
    "            elif num == cand2:\n",
    "                cnt2 += 1\n",
    "            elif cnt1 == 0:\n",
    "                cand1, cnt1 = num, 1\n",
    "            elif cnt2 == 0:\n",
    "                cand2, cnt2 = num, 1\n",
    "            else:\n",
    "                cnt1 -= 1\n",
    "                cnt2 -= 1\n",
    "        return [num for num in (cand1, cand2) if nums.count(num) > len(nums) // 3]\n",
    "\n",
    "Solution229().majority_element(nums=[3,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import Counter\n",
    "\n",
    "class Solution229_1:\n",
    "    def majority_element(self, nums: List[int]) -> List[int]:\n",
    "        el_count = Counter(nums)\n",
    "        maj_els = []\n",
    "        threshold = len(nums) // 3\n",
    "        for el, cnt in el_count.items():\n",
    "            if cnt > threshold:\n",
    "                maj_els.append(el)\n",
    "        return maj_els\n",
    "\n",
    "Solution229_1().majority_element(nums=[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import Counter\n",
    "\n",
    "class Solution229_2:\n",
    "    def majority_element(self, nums: List[int]) -> List[int]:\n",
    "        return [num for num, cnt in Counter(nums).items() if cnt > len(nums) // 3]\n",
    "\n",
    "Solution229_2().majority_element(nums=[1,2])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 231. Power of Two (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution231:\n",
    "    def is_power_of_two(self, n: int) -> bool:\n",
    "        if n == 1:\n",
    "            return True\n",
    "        if n < 1:\n",
    "            return False\n",
    "        return self.is_power_of_two(n / 2)\n",
    "\n",
    "Solution231().is_power_of_two(n=16)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 234. Palindrome Linked List (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution234:\n",
    "    def is_palindrome(self, head: Optional[ListNode]) -> bool:\n",
    "\n",
    "        slow = head\n",
    "        fast = head\n",
    "        while fast and fast.next and fast.next.next:\n",
    "            slow = slow.next\n",
    "            fast = fast.next.next\n",
    "        \n",
    "        #first_tail = slow\n",
    "        second_head = slow.next\n",
    "\n",
    "        prev = None\n",
    "        cur = second_head\n",
    "        while cur:\n",
    "            nxt = cur.next\n",
    "            cur.next = prev\n",
    "            prev = cur\n",
    "            cur = nxt\n",
    "        \n",
    "        head_1 = head\n",
    "        head_2 = prev\n",
    "        while head_2:\n",
    "            if head_1.val != head_2.val:\n",
    "                return False\n",
    "            head_1 = head_1.next\n",
    "            head_2 = head_2.next\n",
    "        return True\n",
    "\n",
    "Solution234().is_palindrome(head=ListNode(val=1,\n",
    "                                          next=ListNode(val=2, next=ListNode(val=2, next=ListNode(val=1, next=None)))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 236. Lowest Common Ancestor of a Binary Tree (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nSolution236().lowest_common_ancestor(root=TreeNode(val=3,\\n                                                   left=TreeNode(val=5,\\n                                                                   left=TreeNode(val=6, left=None, right=None),\\n                                                                   right=TreeNode(val=2,\\n                                                                                  left=TreeNode(val=7,\\n                                                                                                left=None,\\n                                                                                                right=None),\\n                                                                                  right=TreeNode(val=4,\\n                                                                                                 left=None,\\n                                                                                                 right=None))),\\n                                                   right=TreeNode(val=1,\\n                                                                  left=TreeNode(val=0, left=None, right=None),\\n                                                                  right=TreeNode(val=8, left=None, right=None))),\\n                                     p=TreeNode(5), q=TreeNode(4))\\n'"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution236:\n",
    "    def lowest_common_ancestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':\n",
    "        ancestors = {}\n",
    "        parent = None\n",
    "        stack = [(root, parent)]\n",
    "        while stack:\n",
    "            cur, parent = stack.pop()\n",
    "            ancestors[cur] = parent\n",
    "            if cur.left:\n",
    "                stack.append((cur.left, cur))\n",
    "            if cur.right:\n",
    "                stack.append((cur.right, cur))\n",
    "        p_ancestors = set()\n",
    "        print(ancestors)\n",
    "        while p:\n",
    "            p_ancestors.add(p)\n",
    "            p = ancestors[p]\n",
    "        while q not in p_ancestors:\n",
    "            q = ancestors[q]\n",
    "        return q\n",
    "\"\"\"\n",
    "Solution236().lowest_common_ancestor(root=TreeNode(val=3,\n",
    "                                                   left=TreeNode(val=5,\n",
    "                                                                   left=TreeNode(val=6, left=None, right=None),\n",
    "                                                                   right=TreeNode(val=2,\n",
    "                                                                                  left=TreeNode(val=7,\n",
    "                                                                                                left=None,\n",
    "                                                                                                right=None),\n",
    "                                                                                  right=TreeNode(val=4,\n",
    "                                                                                                 left=None,\n",
    "                                                                                                 right=None))),\n",
    "                                                   right=TreeNode(val=1,\n",
    "                                                                  left=TreeNode(val=0, left=None, right=None),\n",
    "                                                                  right=TreeNode(val=8, left=None, right=None))),\n",
    "                                     p=TreeNode(5), q=TreeNode(4))\n",
    "\"\"\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 237. Delete Node in a Linked List (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ListNode{val: 4, next: ListNode{val: 5, next: None}}\n"
     ]
    }
   ],
   "source": [
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution237:\n",
    "    def delete_node(self, node: ListNode):\n",
    "        node.val = node.next.val\n",
    "        node.next = node.next.next\n",
    "        print(node)\n",
    "    \n",
    "Solution237().delete_node(node=ListNode(val=3, next=ListNode(val=4, next=ListNode(val=5, next=None))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 238. Product of Array Except Self (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[24, 12, 8, 6]"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution238:\n",
    "    def product_except_self(self, nums: List[int]) -> List[int]:\n",
    "        ans = [1]\n",
    "        for i, _ in enumerate(nums[1:], start=1):\n",
    "            ans.append(ans[-1] * nums[i - 1])\n",
    "        cur = 1\n",
    "        for j in range(len(nums)-2, -1, -1):\n",
    "            cur *= nums[j + 1]\n",
    "            ans[j] *= cur\n",
    "        return ans\n",
    "\n",
    "Solution238().product_except_self(nums=[1,2,3,4])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 239. Sliding Window Maximum (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 3, 5, 5, 6, 7]"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import deque\n",
    "\n",
    "class Solution239:\n",
    "    def max_sliding_window(self, nums: List[int], k: int) -> List[int]:\n",
    "        ans = []\n",
    "        window = deque()\n",
    "\n",
    "        for i, num in enumerate(nums):\n",
    "            while window and window[0] < i - k + 1:\n",
    "                window.popleft()\n",
    "            while window and nums[window[-1]] < num:\n",
    "                window.pop()\n",
    "            window.append(i)\n",
    "            if i >= k - 1:\n",
    "                ans.append(nums[window[0]])\n",
    "        return ans\n",
    "\n",
    "Solution239().max_sliding_window(nums=[1,3,-1,-3,5,3,6,7], k=3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 242. Valid Anagram (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "class Solution242:\n",
    "    def is_anagram(self, s: str, t: str) -> bool:\n",
    "        return Counter(s) == Counter(t)\n",
    "\n",
    "Solution242().is_anagram(s='anagram', t='nagaram')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 252. Meeting Rooms (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution252:\n",
    "    def can_attend_meetings(self, intervals: List[List[int]]) -> bool:\n",
    "        intervals.sort()\n",
    "        for i in range(1, len(intervals)):\n",
    "            if intervals[i][0] < intervals[i-1][1]:\n",
    "                return False\n",
    "        return True\n",
    "\n",
    "Solution252().can_attend_meetings(intervals=[[0, 30], [5, 10], [15, 20]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution252_1:\n",
    "    def can_attend_meetings(self, intervals: List[List[int]]) -> bool:\n",
    "        intervals.sort()\n",
    "        for prev, next in zip(intervals, intervals[1:]):\n",
    "            if prev[-1] > next[0]:\n",
    "                return False\n",
    "        return True\n",
    "\n",
    "Solution252_1().can_attend_meetings(intervals=[[0, 30], [5, 10], [15, 20]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 257. Binary Tree Paths (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1->2->5', '1->3']"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional, List\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution257:\n",
    "    def binary_tree_paths(self, root: Optional[TreeNode]) -> List[str]:\n",
    "\n",
    "        ans = []\n",
    "\n",
    "        def dfs(node, path):\n",
    "            path += str(node.val) + '->'\n",
    "            if not node.left and not node.right:\n",
    "                ans.append(path[:-2])\n",
    "                return\n",
    "            if node.left:\n",
    "                dfs(node.left, path)\n",
    "            if node.right:\n",
    "                dfs(node.right, path)\n",
    "        \n",
    "        dfs(root, '')\n",
    "\n",
    "        return ans\n",
    "\n",
    "Solution257().binary_tree_paths(root=TreeNode(val=1,\n",
    "                                              left=TreeNode(val=2,\n",
    "                                                            left=None,\n",
    "                                                            right=TreeNode(val=5, left=None, right=None)),\n",
    "                                                            right=TreeNode(val=3, left=None, right=None)))\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 258. Add Digits (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution258:\n",
    "    def add_digits(self, num: int) -> int:\n",
    "        if num == 0:\n",
    "            return 0\n",
    "        else:\n",
    "            return 1 + ((num - 1) % 9)\n",
    "\n",
    "Solution258().add_digits(num=38)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 260. Single Number III (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 5]"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution260:\n",
    "    def single_number(self, nums: List[int]) -> List[int]:\n",
    "        xor = 0\n",
    "        for num in nums:\n",
    "            xor ^= num\n",
    "        xor = xor & (-xor)\n",
    "        xor1, xor2 = 0, 0\n",
    "        for num in nums:\n",
    "            if not num & xor:\n",
    "                xor2 ^= num\n",
    "            else:\n",
    "                xor1 ^= num\n",
    "        return [xor1, xor2]\n",
    "\n",
    "Solution260().single_number(nums=[1,2,1,3,2,5])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 263. Ugly Number (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution263:\n",
    "    def is_ugly(self, n: int) -> bool:\n",
    "        if n == 0:\n",
    "            return False\n",
    "        while n % 2 == 0:\n",
    "            n /= 2\n",
    "        while n % 3 == 0:\n",
    "            n /= 3\n",
    "        while n % 5 == 0:\n",
    "            n /= 5\n",
    "        return True if n == 1 else False\n",
    "\n",
    "Solution263().is_ugly(n=7)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 264. Ugly Number II (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution264:\n",
    "    def nth_ugly_number(self, n: int) -> int:\n",
    "        ans = [1]\n",
    "        i = j = k = 0\n",
    "        cnt = 1\n",
    "        while cnt < n:\n",
    "            v = min(ans[i]*2, min(ans[j]*3, ans[k]*5))\n",
    "            if v == ans[i]*2:\n",
    "                i += 1\n",
    "            elif v == ans[j]*3:\n",
    "                j += 1\n",
    "            else:\n",
    "                k += 1\n",
    "            if v not in ans:\n",
    "                ans.append(v)\n",
    "                cnt += 1\n",
    "        return ans[-1]\n",
    "\n",
    "Solution264().nth_ugly_number(n=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution264_1:\n",
    "    def nth_ugly_number(self, n: int) -> int:\n",
    "        ans = [0] * n\n",
    "        ans[0] = 1\n",
    "        i = j = k = 0\n",
    "        for num_ind in range(1,n):\n",
    "            ans[num_ind] = min(ans[i] * 2, min(ans[j] * 3, ans[k] * 5))\n",
    "            if ans[num_ind] == ans[i] * 2:\n",
    "                i += 1\n",
    "            if ans[num_ind] == ans[j] * 3:\n",
    "                j += 1\n",
    "            if ans[num_ind] == ans[k] * 5:\n",
    "                k += 1\n",
    "        return ans[-1]\n",
    "\n",
    "Solution264_1().nth_ugly_number(n=10)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 268. Missing Number (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution268:\n",
    "    def missing_number(self, nums: List[int]) -> int:\n",
    "        n = max(nums)\n",
    "        mis = n * (n + 1) // 2 - sum(nums)\n",
    "        if mis == 0 and 0 in nums:\n",
    "            return n + 1\n",
    "        if not 0 in nums:\n",
    "            return 0\n",
    "        return mis\n",
    "\n",
    "Solution268().missing_number(nums=[3, 0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution268_1:\n",
    "    def missing_number(self, nums: List[int]) -> int:\n",
    "        return list(set(range(len(nums)+1)) - set(nums))[0]\n",
    "\n",
    "Solution268_1().missing_number(nums=[3, 0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution268_2:\n",
    "    def missing_number(self, nums: List[int]) -> int:\n",
    "        n = len(nums)\n",
    "        return n * (n + 1) // 2 - sum(nums)\n",
    "\n",
    "Solution268_2().missing_number(nums=[3, 0, 1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 270. Closest Binary Search Tree Value (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution270:\n",
    "    def closest_value(self, root: Optional[TreeNode], target: float) -> int:\n",
    "        def dfs(node, cur, target):\n",
    "            if not node:\n",
    "                return cur\n",
    "            if cur == target:\n",
    "                return cur\n",
    "            if abs(node.val - target) < abs(cur - target):\n",
    "                cur = node.val\n",
    "            if target > node.val:\n",
    "                kid = dfs(node.right, cur, target)\n",
    "            else:\n",
    "                kid = dfs(node.left, cur, target)\n",
    "            return kid\n",
    "        return dfs(root, float('inf'), target)\n",
    "\n",
    "Solution270().closest_value(root=TreeNode(val=4,\n",
    "                                          left=TreeNode(val=2,\n",
    "                                                        left=TreeNode(val=1, left=None, right=None),\n",
    "                                                        right=TreeNode(val=3, left=None, right=None)),\n",
    "                                          right=TreeNode(val=5, left=None, right=None)),\n",
    "                            target=3.714286)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 274. H-Index (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution274:\n",
    "    def h_index(self, citations: List[int]) -> int:\n",
    "        citations.sort()\n",
    "        n = len(citations)\n",
    "        for i in range(n):\n",
    "            if citations[i] >= n - i:\n",
    "                return n - i\n",
    "        return 0\n",
    "\n",
    "Solution274().h_index(citations=[3,0,6,1,5])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 275. H-Index II (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution275:\n",
    "    def h_index(self, citations: List[int]) -> int:\n",
    "        n = len(citations)\n",
    "        left, right = 0, n\n",
    "        while left <= right:\n",
    "            mid = (left + right) // 2\n",
    "            if citations[mid] >= n - mid:\n",
    "                right = mid - 1\n",
    "            else:\n",
    "                left = mid + 1\n",
    "            if left == n:\n",
    "                return min(1, citations[left-1])\n",
    "        return n - left\n",
    "\n",
    "Solution275().h_index(citations=[1,2,100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution275_1:\n",
    "    def h_index(self, citations: List[int]) -> int:\n",
    "        n = len(citations)\n",
    "        left, right = 0, n - 1\n",
    "        while left <= right:\n",
    "            mid = (left + right) // 2\n",
    "            if citations[mid] >= n - mid:\n",
    "                right = mid - 1\n",
    "            else:\n",
    "                left = mid + 1\n",
    "        return n - left\n",
    "\n",
    "Solution275_1().h_index(citations=[1,2,100])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 278. First Bad Version (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def is_bad_version(version: int) -> bool:\n",
    "    if version >= 4:\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "class Solution278:\n",
    "    def first_bad_version(self, n: int) -> int:\n",
    "        left, right = 0, n\n",
    "        while left <= right:\n",
    "            mid = (left + right) // 2\n",
    "            if is_bad_version(mid):\n",
    "                right = mid - 1\n",
    "            else:\n",
    "                left = mid + 1\n",
    "        return left\n",
    "\n",
    "Solution278().first_bad_version(n=5)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 279. Perfect Squares (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import lru_cache\n",
    "\n",
    "class Solution279:\n",
    "    @lru_cache(None)\n",
    "    def num_squares(self, n: int) -> int:\n",
    "        if n == 0:\n",
    "            return 0\n",
    "        if n < 0:\n",
    "            return float('inf')\n",
    "        min_square_nums = n\n",
    "        i = 1\n",
    "        while i * i <= n:\n",
    "            min_square_nums = min(min_square_nums, self.num_squares(n - (i * i)))\n",
    "            i += 1\n",
    "        return min_square_nums + 1\n",
    "\n",
    "Solution279().num_squares(n=12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution279_1:\n",
    "    def num_squares(self, n: int) -> int:\n",
    "        dp = [i for i in range(n+1)]\n",
    "        for i in range(n+1):\n",
    "            j = 1\n",
    "            while j * j <= i:\n",
    "                dp[i] = min(dp[i], dp[i-(j*j)]+1)\n",
    "                j += 1\n",
    "        return dp[-1]\n",
    "\n",
    "Solution279_1().num_squares(n=12)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 283. Move Zeroes (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 12, 3, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "class Solution283:\n",
    "    def move_zeroes(self, nums: List[int]) -> None:\n",
    "        j = 0\n",
    "        for i, _ in enumerate(nums):\n",
    "            if nums[i] != 0:\n",
    "                nums[i], nums[j] = nums[j], nums[i]\n",
    "                j += 1\n",
    "        print(nums)\n",
    "\n",
    "Solution283().move_zeroes(nums=[0,1,0,12,3])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 287. Find the Duplicate Number (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution287:\n",
    "    def find_duplicate(self, nums: List[int]) -> int:\n",
    "        nums.sort()\n",
    "        for i, num in enumerate(nums[1:], start=1):\n",
    "            if nums[i-1] == num:\n",
    "                return num\n",
    "        return 0\n",
    "\n",
    "Solution287().find_duplicate(nums=[1,3,4,2,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution287_1:\n",
    "    def find_duplicate(self, nums: List[int]) -> int:\n",
    "        slow = 0\n",
    "        fast = 0\n",
    "        while not slow or slow != fast:\n",
    "            slow = nums[slow]\n",
    "            fast = nums[nums[fast]]\n",
    "        slow = 0\n",
    "        while slow != fast:\n",
    "            slow = nums[slow]\n",
    "            fast = nums[fast]\n",
    "        return slow\n",
    "\n",
    "Solution287_1().find_duplicate(nums=[1,3,4,2,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution287_2:\n",
    "    def find_duplicate(self, nums: List[int]) -> int:\n",
    "        slow = nums[nums[0]]\n",
    "        fast = nums[nums[nums[0]]]\n",
    "        while slow != fast:\n",
    "            slow = nums[slow]\n",
    "            fast = nums[nums[fast]]\n",
    "        slow = nums[0]\n",
    "        while slow != fast:\n",
    "            slow = nums[slow]\n",
    "            fast = nums[fast]\n",
    "        return slow\n",
    "\n",
    "Solution287_2().find_duplicate(nums=[1,3,4,2,2])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 289. Game of Life (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, 0, 0], [1, 0, 1], [0, 1, 1], [0, 1, 0]]\n"
     ]
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution289:\n",
    "    def game_of_life(self, board: List[List[int]]) -> None:\n",
    "        \"\"\"\n",
    "        Do not return anything, modify board in-place instead.\n",
    "        \"\"\"\n",
    "        rows, cols = len(board), len(board[0])\n",
    "        for r in range(rows):\n",
    "            for c in range(cols):\n",
    "                count = sum(board[nr][nc] & 1 for nr in range(r-1, r+2) if 0 <= nr < rows\n",
    "                                              for nc in range(c-1, c+2) if 0 <= nc < cols and (nr, nc) != (r, c))\n",
    "                if 2 <= count <= 3:\n",
    "                    board[r][c] |= (board[r][c] | count & 1) << 1\n",
    "        for r in range(rows):\n",
    "            for c in range(cols):\n",
    "                board[r][c] >>= 1\n",
    "        print(board)\n",
    "\n",
    "Solution289().game_of_life(board=[[0,1,0],[0,0,1],[1,1,1],[0,0,0]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 316. Remove Duplicate Letters (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution316:\n",
    "    def remove_duplicate_letters(self, s: str) -> str:\n",
    "        stack = []\n",
    "        seen = set()\n",
    "        last_occ = {ch: i for i, ch in enumerate(s)}\n",
    "        for i, ch in enumerate(s):\n",
    "            if ch not in seen:\n",
    "                while stack and ch < stack[-1] and i < last_occ[stack[-1]]:\n",
    "                    seen.discard(stack.pop())\n",
    "                seen.add(ch)\n",
    "                stack.append(ch)\n",
    "        return ''.join(stack)\n",
    "\n",
    "Solution316().remove_duplicate_letters(s='bcabc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'acdb'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "class Solution316_1:\n",
    "    def remove_duplicate_letters(self, s: str) -> str:\n",
    "        count = Counter(s)\n",
    "        ans = []\n",
    "        visited = set()\n",
    "        for ch in s:\n",
    "            count[ch] -= 1\n",
    "            if ch in visited:\n",
    "                continue\n",
    "            while ans and ch < ans[-1] and count[ans[-1]] > 0:\n",
    "                visited.remove(ans.pop())\n",
    "            visited.add(ch)\n",
    "            ans.append(ch)\n",
    "        return ''.join(ans)\n",
    "\n",
    "Solution316_1().remove_duplicate_letters(s='cbacdcbc')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 322. Coin Change (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution322:\n",
    "    def coin_change(self, coins: List[int], amount: int) -> int:\n",
    "        memo = {}\n",
    "        def helper(amount):\n",
    "            if amount == 0:\n",
    "                return 0\n",
    "            if amount < 0:\n",
    "                return float('inf')\n",
    "            if amount in memo:\n",
    "                return memo[amount]\n",
    "            ret = float('inf')\n",
    "            for coin in coins:\n",
    "                ret = min(ret, 1 + helper(amount - coin))\n",
    "            memo[amount] = ret\n",
    "            return ret\n",
    "        ans = helper(amount)\n",
    "        return ans if ans != float('inf') else -1\n",
    "\n",
    "Solution322().coin_change(coins=[1,2,5], amount=11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from functools import lru_cache\n",
    "\n",
    "class Solution322_1:\n",
    "    def coin_change(self, coins: List[int], amount: int) -> int:\n",
    "        @lru_cache(None)\n",
    "        def helper(amount):\n",
    "            if amount == 0:\n",
    "                return 0\n",
    "            if amount < 0:\n",
    "                return float('inf')\n",
    "            ret = float('inf')\n",
    "            for coin in coins:\n",
    "                ret = min(ret, 1 + helper(amount - coin))\n",
    "            return ret\n",
    "        ans = helper(amount)\n",
    "        return ans if ans != float('inf') else -1\n",
    "\n",
    "Solution322_1().coin_change(coins=[1,2,5], amount=11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution322_2:\n",
    "    def coin_change(self, coins: List[int], amount: int) -> int:\n",
    "        dp = [float('inf')] * (amount + 1)\n",
    "        dp[0] = 0\n",
    "        for i, _ in enumerate(dp[1:], start=1):\n",
    "            for coin in coins:\n",
    "                if coin <= i:\n",
    "                    dp[i] = min(dp[i], 1 + dp[i - coin])\n",
    "        return dp[-1] if dp[-1] != float('inf') else -1\n",
    "\n",
    "Solution322_2().coin_change(coins=[1,2,5], amount=11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import deque\n",
    "\n",
    "class Solution322_3:\n",
    "    def coin_change(self, coins: List[int], amount: int) -> int:\n",
    "        q = deque([(amount, 0)])\n",
    "        visited = set()\n",
    "        while q:\n",
    "            cur, n_coins = q.popleft()\n",
    "            if cur == 0:\n",
    "                return n_coins\n",
    "            for c in coins:\n",
    "                new_cur = cur - c\n",
    "                if new_cur in visited or new_cur < 0:\n",
    "                    continue\n",
    "                q.append((new_cur, n_coins+1))\n",
    "                visited.add(new_cur)\n",
    "        return -1\n",
    "\n",
    "Solution322_3().coin_change(coins=[1,2,5], amount=11)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 332. Reconstruct Itinerary (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['JFK', 'MUC', 'LHR', 'SFO', 'SJC']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import defaultdict\n",
    "\n",
    "class Solution332:\n",
    "    def find_itinerary(self, tickets: List[List[str]]) -> List[str]:\n",
    "        graph = defaultdict(list)\n",
    "        for dep, dest in sorted(tickets, reverse=True):\n",
    "            graph[dep].append(dest)\n",
    "        stack = ['JFK']\n",
    "        itinerary = []\n",
    "        while stack:\n",
    "            while graph[stack[-1]]:\n",
    "                stack.append(graph[stack[-1]].pop())\n",
    "            itinerary.append(stack.pop())\n",
    "        return itinerary[::-1]\n",
    "\n",
    "Solution332().find_itinerary(tickets=[[\"MUC\",\"LHR\"],[\"JFK\",\"MUC\"],[\"SFO\",\"SJC\"],[\"LHR\",\"SFO\"]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['JFK', 'ATL', 'JFK', 'SFO', 'ATL', 'SFO']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import defaultdict\n",
    "\n",
    "class Solution332_1:\n",
    "    def find_itinerary(self, tickets: List[List[str]]) -> List[str]:\n",
    "        graph = defaultdict(list)\n",
    "        for dep, dest in sorted(tickets, reverse=True):\n",
    "            graph[dep].append(dest)\n",
    "        itinerary = []\n",
    "        def dfs(tag):\n",
    "            while graph[tag]:\n",
    "                dfs(graph[tag].pop())\n",
    "            itinerary.append(tag)\n",
    "        dfs('JFK')\n",
    "        return itinerary[::-1]\n",
    "\n",
    "Solution332_1().find_itinerary(tickets=[[\"JFK\",\"SFO\"],[\"JFK\",\"ATL\"],[\"SFO\",\"ATL\"],[\"ATL\",\"JFK\"],[\"ATL\",\"SFO\"]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 338. Counting Bits (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1]"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution338:\n",
    "    def count_bits(self, n: int) -> List[int]:\n",
    "        ans = []\n",
    "        for i in range(n+1):\n",
    "            cur = 0\n",
    "            while i:\n",
    "                cur += i & 1\n",
    "                i >>= 1\n",
    "            ans.append(cur)\n",
    "        return ans\n",
    "\n",
    "Solution338().count_bits(n=2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 342. Power of Four (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution342:\n",
    "    def is_power_of_four(self, n: int) -> bool:\n",
    "        if n == 1:\n",
    "            return True\n",
    "        if n < 1:\n",
    "            return False\n",
    "        return self.is_power_of_four(n / 4)\n",
    "\n",
    "Solution342().is_power_of_four(n=16)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 343. Integer Break (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution343:\n",
    "    def integer_break(self, n: int) -> int:\n",
    "        dp = [0] * (n + 1)\n",
    "        dp[1] = 1\n",
    "        for i in range(2, n + 1):\n",
    "            dp[i] = -float('inf')\n",
    "            for j in range(1, i):\n",
    "                dp[i] = max(dp[i], j * (i - j), j * dp[i - j])\n",
    "        return dp[n]\n",
    "\n",
    "Solution343().integer_break(n=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "36"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution343_1:\n",
    "    def integer_break(self, n: int) -> int:\n",
    "        memo = [-1] * (n + 1)\n",
    "        def max_product(k):\n",
    "            if memo[k] != -1:\n",
    "                return memo[k]\n",
    "            if k == 1:\n",
    "                return 1\n",
    "            ans = -float('inf')\n",
    "            for i in range(1, k):\n",
    "                ans = max(ans, i * max_product(k - i), i * (k - i))\n",
    "            memo[k] = ans\n",
    "            return ans\n",
    "        return max_product(n)\n",
    "\n",
    "Solution343_1().integer_break(n=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "54"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution343_2:\n",
    "    def integer_break(self, n: int) -> int:\n",
    "        if n == 2:\n",
    "            return 1\n",
    "        if n == 3:\n",
    "            return 2\n",
    "        ans = 1\n",
    "        while n > 4:\n",
    "            ans *= 3\n",
    "            n -= 3\n",
    "        return ans * n\n",
    "\n",
    "Solution343_2().integer_break(n=11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "81"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution343_3:\n",
    "    def integer_break(self, n: int) -> int:\n",
    "        if n == 2:\n",
    "            return 1\n",
    "        if n == 3:\n",
    "            return 2\n",
    "        q = n // 3\n",
    "        r = n % 3\n",
    "        if r == 0:\n",
    "            return 3 ** q\n",
    "        elif r == 1:\n",
    "            return (3 ** (q - 1)) * 4\n",
    "        else:\n",
    "            return (3 ** q) * 2\n",
    "\n",
    "Solution343_3().integer_break(n=12)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 344. Reverse String (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['o', 'l', 'l', 'e', 'h']\n"
     ]
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution344:\n",
    "    def reverse_string(self, s: List[str]) -> None:\n",
    "        left, right = 0, len(s) - 1\n",
    "        while left < right:\n",
    "            s[left], s[right] = s[right], s[left]\n",
    "            left += 1\n",
    "            right -= 1\n",
    "        print(s)\n",
    "\n",
    "Solution344().reverse_string(s=['h', 'e', 'l', 'l', 'o'])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 345. Reverse Vowels of a String (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'holle'"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution345:\n",
    "    def reverse_vowels(self, s: str) -> str:\n",
    "        vowels = {'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'}\n",
    "        s = list(s)\n",
    "        left, right = 0, len(s) - 1\n",
    "        while left <= right:\n",
    "            if not s[left] in vowels:\n",
    "                left += 1\n",
    "                continue\n",
    "            if not s[right] in vowels:\n",
    "                right -= 1\n",
    "                continue\n",
    "            s[left], s[right] = s[right], s[left]\n",
    "            left += 1\n",
    "            right -= 1\n",
    "        return ''.join(s)\n",
    "\n",
    "Solution345().reverse_vowels(s='hello')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 349. Intersection of Two Arrays (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2]"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import Counter\n",
    "\n",
    "class Solution349:\n",
    "    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:\n",
    "        cnt1, cnt2 = Counter(nums1), Counter(nums2)\n",
    "        return list(cnt1 & cnt2)\n",
    "\n",
    "Solution349().intersection(nums1=[1,2,2,3], nums2=[4,5,2,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2]"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution349_1:\n",
    "    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:\n",
    "        return list(set(nums1) & set(nums2))\n",
    "\n",
    "Solution349_1().intersection(nums1=[1,2,2,3], nums2=[4,5,2,2])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 349. Intersection of Two Arrays II (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 2]"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import Counter\n",
    "\n",
    "class Solution349:\n",
    "    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:\n",
    "        cnt1, cnt2 = Counter(nums1), Counter(nums2)\n",
    "        ans = []\n",
    "        for k, v in (cnt1 & cnt2).items():\n",
    "            ans += [k] * v\n",
    "        return ans\n",
    "\n",
    "Solution349().intersection(nums1=[1,2,2,3], nums2=[4,5,2,2])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 367. Valid Perfect Square (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution367:\n",
    "    def is_perfect_square(self, num: int) -> bool:\n",
    "\n",
    "        if num == 1:\n",
    "            return True\n",
    "\n",
    "        left, right = 1, num // 2\n",
    "        while left <= right:\n",
    "            mid = (left + right) // 2\n",
    "            mid_square = mid * mid\n",
    "            if mid_square == num:\n",
    "                return True\n",
    "            if mid_square > num:\n",
    "                right = mid - 1\n",
    "            else:\n",
    "                left = mid + 1\n",
    "        return False\n",
    "\n",
    "Solution367().is_perfect_square(num=25)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 374. Guess Number Higher or Lower (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def guess(num: int) -> int:\n",
    "    if num > 7:\n",
    "        return -1\n",
    "    elif num < 7:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "class Solution374:\n",
    "    def guess_number(self, n: int) -> int:\n",
    "        left, right = 1, n\n",
    "        while left <= right:\n",
    "            mid = (left + right) // 2\n",
    "            check = guess(mid)\n",
    "            if check == 0:\n",
    "                return mid\n",
    "            if check < 0:\n",
    "                right = mid - 1\n",
    "            else:\n",
    "                left = mid + 1\n",
    "\n",
    "Solution374().guess_number(n=10)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 377. Combination Sum IV (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import defaultdict\n",
    "\n",
    "class Solution377:\n",
    "    def combination_sum_4(self, nums: List[int], target: int) -> int:\n",
    "        nums.sort()\n",
    "        memo = defaultdict()\n",
    "        def helper(n):\n",
    "            if n in memo:\n",
    "                return memo[n]\n",
    "            if n == 0:\n",
    "                return 1\n",
    "            if n < nums[0]:\n",
    "                return 0\n",
    "            cnt = 0\n",
    "            for num in nums:\n",
    "                if n - num < 0:\n",
    "                    break\n",
    "                cnt += helper(n - num)\n",
    "            memo[n] = cnt\n",
    "            return cnt\n",
    "        return helper(target)\n",
    "\n",
    "Solution377().combination_sum_4(nums=[1,2,3], target=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution377_1:\n",
    "    def combination_sum_4(self, nums: List[int], target: int) -> int:\n",
    "        dp = [0] * (target + 1)\n",
    "        dp[0] = 1\n",
    "        for i in range(1, target + 1):\n",
    "            for num in nums:\n",
    "                if i - num >= 0:\n",
    "                    dp[i] += dp[i - num]\n",
    "        return dp[target]\n",
    "\n",
    "Solution377_1().combination_sum_4(nums=[1,2,3], target=4)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 383. Ransom Note (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "class Solution383:\n",
    "    def can_construct(self, ransome_note: str, magazine: str) -> bool:\n",
    "        ransome_note_cnt = Counter(ransome_note)\n",
    "        magazine_cnt = Counter(magazine)\n",
    "        for k, v in ransome_note_cnt.items():\n",
    "            if magazine_cnt[k] < v:\n",
    "                return False\n",
    "        return True\n",
    "\n",
    "Solution383().can_construct(ransome_note='a', magazine='b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "class Solution383_1:\n",
    "    def can_construct(self, ransome_note: str, magazine: str) -> bool:\n",
    "        return (Counter(ransome_note) & Counter(magazine)) == Counter(ransome_note)\n",
    "\n",
    "Solution383_1().can_construct(ransome_note='a', magazine='b')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 387. First Unique Character in a String (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "class Solution387:\n",
    "    def first_uniq_char(self, s: str) -> int:\n",
    "        cnt = Counter(s)\n",
    "        for i, ch in enumerate(s):\n",
    "            if cnt[ch] == 1:\n",
    "                return i\n",
    "        return -1\n",
    "\n",
    "Solution387().first_uniq_char(s='loveleetcode')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 389. Find the Difference (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'e'"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "class Solution389:\n",
    "    def find_the_difference(self, s: str, t: str) -> str:\n",
    "        #return list((Counter(t) - Counter(s)).elements())[0]\n",
    "        return list((Counter(t) - Counter(s)).keys())[0]\n",
    "\n",
    "Solution389().find_the_difference(s='abcd', t='abcde')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'e'"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution389_1:\n",
    "    def find_the_difference(self, s: str, t: str) -> str:\n",
    "        t_counter = Counter(t)\n",
    "        for ch in s:\n",
    "            t_counter[ch] -= 1\n",
    "        return list(t_counter.keys())[list(t_counter.values()).index(1)]\n",
    "\n",
    "Solution389_1().find_the_difference(s='abcd', t='abcde')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 392. Is Subsequence (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution392:\n",
    "    def is_subsequence(self, s: str, t: str) -> bool:\n",
    "        stack = list(s)\n",
    "        for c in t[::-1]:\n",
    "            if stack and stack[-1] == c:\n",
    "                stack.pop()\n",
    "        return len(stack) == 0\n",
    "\n",
    "Solution392().is_subsequence(s='abc', t='ahbgdc')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 394. Decode String (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'aaabcbc'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution394:\n",
    "    def decode_string(self, s: str) -> str:\n",
    "        stack = []\n",
    "        cur_str = ''\n",
    "        cur_num = 0\n",
    "        for ch in s:\n",
    "            if ch.isdigit():\n",
    "                cur_num = cur_num * 10 + int(ch)\n",
    "            elif ch == '[':\n",
    "                stack.append(cur_num)\n",
    "                stack.append(cur_str)\n",
    "                cur_num = 0\n",
    "                cur_str = ''\n",
    "            elif ch == ']':\n",
    "                prev_str = stack.pop()\n",
    "                prev_num = stack.pop()\n",
    "                cur_str = prev_str + cur_str * prev_num\n",
    "            else:\n",
    "                cur_str += ch\n",
    "        while stack:\n",
    "            cur_str = stack.pop() + cur_str\n",
    "        return cur_str\n",
    "\n",
    "Solution394().decode_string(s='3[a]2[bc]')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 396. Rotate Function (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution396:\n",
    "    def max_rotate_function(self, nums: List[int]) -> int:\n",
    "        sum_nums = sum(nums)\n",
    "        f_value = sum(i * n for i, n in enumerate(nums))\n",
    "        f_max = f_value\n",
    "        for _, num in enumerate(nums):\n",
    "            f_value += len(nums) * num - sum_nums\n",
    "            if f_value > f_max:\n",
    "                f_max = f_value\n",
    "        return f_max\n",
    "\n",
    "Solution396().max_rotate_function(nums=[4,3,2,6])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 397. Integer Replacement (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import lru_cache\n",
    "\n",
    "class Solution397:\n",
    "    @lru_cache(None)\n",
    "    def integer_replacement(self, n: int) -> int:\n",
    "        #if n < 1:\n",
    "        #    return float('inf')\n",
    "        if n == 1:\n",
    "            return 0\n",
    "        if n % 2 == 0:\n",
    "            return self.integer_replacement(n / 2) + 1\n",
    "        else:\n",
    "            a = self.integer_replacement(n + 1) + 1\n",
    "            b = self.integer_replacement(n - 1) + 1\n",
    "            return min(a, b)\n",
    "\n",
    "Solution397().integer_replacement(n=8)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 400. Nth Digit (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution400:\n",
    "    def find_nth_digit(self, n: int) -> int:\n",
    "        digit = base = 1\n",
    "        while n > 9 * base * digit:\n",
    "            n -= 9 * base * digit\n",
    "            digit += 1\n",
    "            base *= 10\n",
    "        q, r = divmod(n-1, digit)\n",
    "        return int(str(base + q)[r])\n",
    "\n",
    "Solution400().find_nth_digit(n=11)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 403. Frog Jump (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution403:\n",
    "    def can_cross(self, stones: List[int]) -> bool:\n",
    "        if stones[1] - stones[0] != 1:\n",
    "            return False\n",
    "        s = set(stones)\n",
    "        stack = [(stones[1], 1)]\n",
    "        visited = set(stack)\n",
    "        while stack:\n",
    "            x, n = stack.pop()\n",
    "            if x == stones[-1]:\n",
    "                return True\n",
    "            for dn in (-1, 0, 1):\n",
    "                if x + n + dn in s and not (x + n + dn, n + dn) in visited:\n",
    "                    visited.add((x + n + dn, n + dn))\n",
    "                    stack.append((x + n + dn, n + dn))\n",
    "        return False\n",
    "\n",
    "Solution403().can_cross(stones=[0,1,3,5,6,8,12,17])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution403_1:\n",
    "    def can_cross(self, stones: List[int]) -> bool:\n",
    "        m = len(stones)\n",
    "        dp = [{} for i in range(m)]\n",
    "        dp[0][0] = True\n",
    "        for i in range(1, m):\n",
    "            for j in range(i):\n",
    "                delta = stones[i] - stones[j]\n",
    "                if delta in dp[j] or delta - 1 in dp[j] or delta + 1 in dp[j]:\n",
    "                    dp[i][delta] = True\n",
    "        return bool(dp[m - 1])\n",
    "\n",
    "Solution403_1().can_cross(stones=[0,1,2,3,4,8,9,11])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 404. Sum of Left Leaves (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution404:\n",
    "    def sum_of_left_leaves(self, root: Optional[TreeNode]) -> int:\n",
    "        ans = 0\n",
    "        stack = [(root, None)]\n",
    "        while stack:\n",
    "            cur, is_left = stack.pop()\n",
    "            if not cur.left and not cur.right and is_left:\n",
    "                ans += cur.val\n",
    "            if cur.left:\n",
    "                stack.append((cur.left, 1))\n",
    "            if cur.right:\n",
    "                stack.append((cur.right, 0))\n",
    "        return ans\n",
    "\n",
    "Solution404().sum_of_left_leaves(root=TreeNode(val=3,\n",
    "                                               left=TreeNode(val=9, left=None, right=None),\n",
    "                                               right=TreeNode(val=20,\n",
    "                                                              left=TreeNode(val=15, left=None, right=None),\n",
    "                                                              right=TreeNode(val=7, left=None, right=None))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution404_1:\n",
    "    def sum_of_left_leaves(self, root: Optional[TreeNode]) -> int:\n",
    "\n",
    "        def dfs_helper(node, left):\n",
    "            if not node:\n",
    "                return 0\n",
    "            if not node.left and not node.right and left:\n",
    "                return node.val\n",
    "            left = dfs_helper(node.left, True)\n",
    "            right = dfs_helper(node.right, False)\n",
    "            return left + right\n",
    "        \n",
    "        return dfs_helper(root, False)\n",
    "\n",
    "Solution404_1().sum_of_left_leaves(root=TreeNode(val=3,\n",
    "                                                 left=TreeNode(val=9, left=None, right=None),\n",
    "                                                 right=TreeNode(val=20,\n",
    "                                                                left=TreeNode(val=15, left=None, right=None),\n",
    "                                                                right=TreeNode(val=7, left=None, right=None))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 409. Longest Palindrome (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "class Solution409:\n",
    "    def longest_palindrome(self, s: str) -> int:\n",
    "        cnt = Counter(s)\n",
    "        ans = 0\n",
    "        for _, c in cnt.items():\n",
    "            ans += c // 2 * 2\n",
    "        return ans + 1 if ans != len(s) else ans\n",
    "\n",
    "Solution409().longest_palindrome(s='abccccdd')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "class Solution409_1:\n",
    "    def longest_palindrome(self, s: str) -> int:\n",
    "        cnt = Counter(s)\n",
    "        ans = 0\n",
    "        for l, c in cnt.items():\n",
    "            cur = c - (c % 2)\n",
    "            ans += cur\n",
    "            cnt[l] -= cur\n",
    "        return ans if not sum(cnt.values()) else ans + 1\n",
    "\n",
    "Solution409_1().longest_palindrome(s='abccccdd')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 412. Fizz Buzz (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '2', 'Fizz']"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution412:\n",
    "    def fizz_buzz(self, n: int) -> List[str]:\n",
    "        ans = []\n",
    "        for i in range(1, n+1):\n",
    "            if i % 3 == 0 and i % 5 == 0:\n",
    "                ans.append('FizzBuzz')\n",
    "            elif i % 3 == 0:\n",
    "                ans.append('Fizz')\n",
    "            elif i % 5 == 0:\n",
    "                ans.append('Buzz')\n",
    "            else:\n",
    "                ans.append(str(i))\n",
    "        return ans\n",
    "\n",
    "Solution412().fizz_buzz(n=3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 448. Find All Numbers Disappeared in an Array (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6]"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution448:\n",
    "    def find_disappeared_numbers(self, nums: List[int]) -> List[int]:\n",
    "        return list(set(range(1, len(nums)+1)) - set(nums))\n",
    "\n",
    "Solution448().find_disappeared_numbers(nums=[4, 3, 2, 7, 8, 2, 3, 1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 455. Assign Cookies (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution455:\n",
    "    def find_content_children(self, g: List[int], s: List[int]) -> int:\n",
    "        g.sort()\n",
    "        s.sort()\n",
    "        child_pointer = 0\n",
    "        for cookie in s:\n",
    "            if cookie >= g[child_pointer]:\n",
    "                child_pointer += 1\n",
    "            if child_pointer == len(g):\n",
    "                break\n",
    "        return child_pointer\n",
    "\n",
    "Solution455().find_content_children(g=[1,2,3], s=[1,1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 456. 132 Pattern (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution456:\n",
    "    def find_132_pattern(self, nums: List[int]) -> bool:\n",
    "        if len(nums) < 3:\n",
    "            return False\n",
    "        num_2 = float('-inf')\n",
    "        stack = []\n",
    "        for i in range(len(nums) - 1, -1, -1):\n",
    "            if nums[i] < num_2:\n",
    "                return True\n",
    "            while stack and stack[-1] < nums[i]:\n",
    "                num_2 = stack.pop()\n",
    "            stack.append(nums[i])\n",
    "        return False\n",
    "\n",
    "Solution456().find_132_pattern(nums=[1,2,3,4])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 459. Repeated Substring Pattern (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Time Limit Exceeded (120/129 testcases passed)\n",
    "class Solution459:\n",
    "    def repeated_substring_pattern(self, s: str) -> bool:\n",
    "        window = 1\n",
    "        flag = False\n",
    "        while window <= len(s) // 2:\n",
    "            for i in range(0, len(s)-window, window):\n",
    "                for j in range(0, window):\n",
    "                    if i+j < len(s) and i+window+j < len(s) and s[i+j] != s[i+window+j]:\n",
    "                        flag = True\n",
    "                        break\n",
    "                    if i == len(s)-2*window and j == window - 1:\n",
    "\n",
    "                        return True\n",
    "                if flag:\n",
    "                    flag = False\n",
    "                    break\n",
    "            window += 1\n",
    "        return False\n",
    "\n",
    "Solution459().repeated_substring_pattern(s='ababab')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution459_1:\n",
    "    def repeated_substring_pattern(self, s: str) -> bool:\n",
    "        return s in s[1:] + s[:len(s)-1]\n",
    "\n",
    "Solution459_1().repeated_substring_pattern(s='ababab')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 461. Hamming Distance (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution461:\n",
    "    def hamming_distance(self, x: int, y: int) -> int:\n",
    "        dist = 0\n",
    "        while x or y:\n",
    "            dist += (x & 1) != (y & 1)\n",
    "            x >>= 1\n",
    "            y >>= 1\n",
    "        return dist\n",
    "\n",
    "Solution461().hamming_distance(x=1, y=4)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 463. Island Perimeter (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution463:\n",
    "    def island_perimeter(self, grid: List[List[int]]) -> int:\n",
    "        perimeter = 0\n",
    "        for i, _ in enumerate(grid):\n",
    "            for j, _ in enumerate(grid[0]):\n",
    "                if grid[i][j] == 1:\n",
    "                    perimeter += 4\n",
    "                    if i > 0 and grid[i-1][j] == 1:\n",
    "                        perimeter -= 2\n",
    "                    if j > 0 and grid[i][j-1] == 1:\n",
    "                        perimeter -= 2\n",
    "        return perimeter\n",
    "\n",
    "Solution463().island_perimeter(grid=[[0,1,0,0],[1,1,1,0],[0,1,0,0],[1,1,0,0]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 474. Ones and Zeroes (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution474:\n",
    "    def find_max_form(self, strs: List[str], m: int, n: int) -> int:\n",
    "        dp = [[0] * (n + 1) for _ in range(m + 1)]\n",
    "        for s in strs:\n",
    "            zeroes_count, ones_count = s.count('0'), s.count('1')\n",
    "            for i in range(m, zeroes_count - 1, -1):\n",
    "                for j in range(n, ones_count - 1, -1):\n",
    "                    dp[i][j] = max(1 + dp[i-zeroes_count][j-ones_count], dp[i][j])\n",
    "        return dp[-1][-1]\n",
    "\n",
    "Solution474().find_max_form(strs=[\"10\",\"0001\",\"111001\",\"1\",\"0\"], m=5, n=3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 475. Heaters (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution475:\n",
    "    def find_radius(self, houses: List[int], heaters: List[int]) -> int:\n",
    "        max_radius = 0\n",
    "        heaters.sort()\n",
    "        for i, _ in enumerate(houses):\n",
    "            left, right = 0, len(heaters) - 1\n",
    "            radius_req = float('inf')\n",
    "            while left <= right:\n",
    "                mid = (left + right) // 2\n",
    "                if heaters[mid] == houses[i]:\n",
    "                    radius_req = 0\n",
    "                    break\n",
    "                elif heaters[mid] < houses[i]:\n",
    "                    radius_req = min(radius_req, abs(heaters[mid] - houses[i]))\n",
    "                    left = mid + 1\n",
    "                else:\n",
    "                    radius_req = min(radius_req, abs(heaters[mid] - houses[i]))\n",
    "                    right = mid - 1\n",
    "            radius_req = min(radius_req, abs(heaters[left-1] - houses[i]))\n",
    "            max_radius = max(max_radius, radius_req)\n",
    "        return max_radius\n",
    "\n",
    "Solution475().find_radius(houses=[1,2,3], heaters=[2])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 477. Total Hamming Distance (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution477:\n",
    "    def total_hamming_distance(self, nums: List[int]) -> int:\n",
    "        ans = 0\n",
    "        nums_max = max(nums)\n",
    "        while nums_max > 0:\n",
    "            odd_count = 0\n",
    "            even_count = 0\n",
    "            for i, num in enumerate(nums):\n",
    "                if num % 2 == 0:\n",
    "                    even_count += 1\n",
    "                else:\n",
    "                    odd_count += 1\n",
    "                nums[i] = num >> 1\n",
    "            ans += odd_count * even_count\n",
    "            nums_max >>= 1\n",
    "        return ans\n",
    "\n",
    "Solution477().total_hamming_distance(nums=[4,14,2])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 482. License Key Formatting (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'5-F3Z2-E9WR'"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution482:\n",
    "    def license_key_formatting(self, s: str, k: int) -> int:\n",
    "        s = s.replace('-', '').upper()\n",
    "        first_len = len(s) % k\n",
    "        ans = ''\n",
    "        if first_len != 0:\n",
    "            ans = s[:first_len] + '-'\n",
    "        for i in range(first_len, len(s), k):\n",
    "            ans += s[i:i+k] + '-'\n",
    "        return ans[:-1]\n",
    "\n",
    "Solution482().license_key_formatting(s='5F3Z-2e-9-wr', k=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'5F3-Z2E9W-RT123'"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution482_1:\n",
    "    def license_key_formatting(self, s: str, k: int) -> int:\n",
    "        s = s.replace('-', '').upper()\n",
    "        ans = ''\n",
    "        helper_count = 0\n",
    "        for i in range(len(s)-1, -1, -1):\n",
    "            ans += s[i]\n",
    "            if not (len(ans)-helper_count) % k:\n",
    "                ans += '-'\n",
    "                helper_count += 1\n",
    "        reversed_ans = ans[::-1]\n",
    "        return reversed_ans if reversed_ans[0] != '-' else reversed_ans[1:]\n",
    "\n",
    "Solution482_1().license_key_formatting(s='5F3Z-2e-9-wr--t12-3', k=5)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 485. Max Consecutive Ones (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution485:\n",
    "    def find_max_consecutive_ones(self, nums: List[int]) -> int:\n",
    "        dp = [0] * (len(nums) + 1)\n",
    "        for i, _ in enumerate(nums):\n",
    "            if nums[i]:\n",
    "                dp[i + 1] = dp[i] + 1\n",
    "            else:\n",
    "                dp[i + 1] = 0\n",
    "        return max(dp)\n",
    "\n",
    "Solution485().find_max_consecutive_ones(nums=[1, 1, 0, 1, 1, 1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 509. Fibonacci Number (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import lru_cache\n",
    "\n",
    "class Solution509:\n",
    "\n",
    "    @lru_cache(None)\n",
    "    def fib(self, n: int) -> int:\n",
    "        if n < 2:\n",
    "            return n\n",
    "        return self.fib(n-1) + self.fib(n-2)\n",
    "\n",
    "Solution509().fib(n=10)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 518. Coin Change II (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution518:\n",
    "    def change(self, amount: int, coins: List[int]) -> int:\n",
    "        dp = [0] * (amount + 1)\n",
    "        dp[0] = 1\n",
    "        for i, _ in enumerate(coins):\n",
    "            for j in range(coins[i], amount+1):\n",
    "                dp[j] += dp[j - coins[i]]\n",
    "        return dp[amount]\n",
    "\n",
    "Solution518().change(amount=5, coins=[1,2,5])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 520. Detect Capital (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution520:\n",
    "    def detect_capital_use(self, word: str) -> bool:\n",
    "        return word.lower() == word or word.upper() == word or word.istitle()\n",
    "\n",
    "Solution520().detect_capital_use(word='FlaG')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 542. 01 Matrix (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 0, 0], [0, 1, 0], [1, 2, 1]]"
      ]
     },
     "execution_count": 202,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import deque\n",
    "\n",
    "class Solution542:\n",
    "    def update_matrix(self, mat: List[List[int]]) -> List[List[int]]:\n",
    "        if not mat or not mat[0]:\n",
    "            return []\n",
    "        m, n = len(mat), len(mat[0])\n",
    "        queue = deque()\n",
    "        max_value = m * n\n",
    "\n",
    "        for i in range(m):\n",
    "            for j in range(n):\n",
    "                if mat[i][j] == 0:\n",
    "                    queue.append((i, j))\n",
    "                else:\n",
    "                    mat[i][j] = max_value\n",
    "        \n",
    "        directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]\n",
    "\n",
    "        while queue:\n",
    "            row, col = queue.popleft()\n",
    "            for dr, dc in directions:\n",
    "                r, c = row + dr, col + dc\n",
    "                if 0 <= r < m and 0 <= c < n and mat[r][c] > mat[row][col] + 1:\n",
    "                    queue.append((r, c))\n",
    "                    mat[r][c] = mat[row][col] + 1\n",
    "        \n",
    "        return mat\n",
    "\n",
    "Solution542().update_matrix(mat=[[0,0,0],[0,1,0],[1,1,1]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 543. Diameter of Binary Tree (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution543:\n",
    "    def diameter_of_binary_tree(self, root: Optional[TreeNode]) -> int:\n",
    "        self.ans = float('-inf')\n",
    "        def helper(root):\n",
    "            if not root:\n",
    "                return 0\n",
    "            left = helper(root.left)\n",
    "            right = helper(root.right)\n",
    "            self.ans = max(self.ans, left + right)\n",
    "            return 1 + max(left, right)\n",
    "        helper(root)\n",
    "        return self.ans\n",
    "\n",
    "Solution543().diameter_of_binary_tree(root=TreeNode(val=1,\n",
    "                                                    left=TreeNode(val=2,\n",
    "                                                                  left=TreeNode(val=4, left=None, right=None),\n",
    "                                                                  right=TreeNode(val=5, left=None, right=None)),\n",
    "                                                    right=TreeNode(val=3, left=None, right=None)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution543_1:\n",
    "    def diameter_of_binary_tree(self, root: Optional[TreeNode]) -> int:\n",
    "        def helper(root):\n",
    "            if not root:\n",
    "                return 0, 0\n",
    "            left_diam, left_height = helper(root.left)\n",
    "            right_diam, right_height = helper(root.right)\n",
    "            return max(left_diam, right_diam, left_height + right_height), 1 + max(left_height, right_height)\n",
    "        return helper(root)[0]\n",
    "\n",
    "Solution543_1().diameter_of_binary_tree(root=TreeNode(val=1,\n",
    "                                                    left=TreeNode(val=2,\n",
    "                                                                  left=TreeNode(val=4, left=None, right=None),\n",
    "                                                                  right=TreeNode(val=5, left=None, right=None)),\n",
    "                                                    right=TreeNode(val=3, left=None, right=None)))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 551. Student Attendance Record I (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution551:\n",
    "    def check_record(self, s: str) -> bool:\n",
    "        late_count = 0\n",
    "        absent_count = 0\n",
    "        for c in s:\n",
    "            if c == 'A':\n",
    "                absent_count += 1\n",
    "                if absent_count == 2:\n",
    "                    return False\n",
    "            if c == 'L':\n",
    "                late_count += 1\n",
    "                if late_count > 2:\n",
    "                    return False\n",
    "            else:\n",
    "                late_count = 0\n",
    "        return True\n",
    "\n",
    "Solution551().check_record(s='PPALLP')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution551_1:\n",
    "    def check_record(self, s: str) -> bool:\n",
    "        return s.count('A') < 2 and s.count('LLL') == 0\n",
    "\n",
    "Solution551_1().check_record(s='PPALLP')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 554. Brick Wall (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import defaultdict\n",
    "\n",
    "class Solution554:\n",
    "    def least_bricks(self, wall: List[List[int]]) -> int:\n",
    "        n = len(wall)\n",
    "        m = sum(wall[0])\n",
    "        col0 = defaultdict(int)\n",
    "        for i in range(n):\n",
    "            prev = 0\n",
    "            for j in range(len(wall[i])):\n",
    "                col0[prev + wall[i][j]] += 1\n",
    "                prev += wall[i][j]\n",
    "        col0[m] = 0\n",
    "        tangents = max(v for v in col0.values())\n",
    "        return n - tangents\n",
    "\n",
    "Solution554().least_bricks(wall=[[1,2,2,1],[3,1,2],[1,3,2],[2,4],[3,1,2],[1,3,1,1]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 557. Reverse Words in a String (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"s'teL ekat edoCteeL tsetnoc\""
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution557:\n",
    "    def reverse_words(self, s: str) -> str:\n",
    "        words = s.split(' ')\n",
    "        for i, _ in enumerate(words):\n",
    "            j, k = 0, len(words[i]) - 1\n",
    "            word_lst = list(words[i])\n",
    "            while j <= k:\n",
    "                word_lst[j], word_lst[k] = word_lst[k], word_lst[j]\n",
    "                j += 1\n",
    "                k -= 1\n",
    "            words[i] = ''.join(word_lst)\n",
    "        return ' '.join(words)\n",
    "\n",
    "Solution557().reverse_words(s=\"Let's take LeetCode contest\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"s'teL ekat edoCteeL tsetnoc\""
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution557_1:\n",
    "    def reverse_words(self, s: str) -> str:\n",
    "        words = s.split(' ')\n",
    "        for i, _ in enumerate(words):\n",
    "            words[i] = words[i][::-1]\n",
    "        return ' '.join(words)\n",
    "\n",
    "Solution557_1().reverse_words(s=\"Let's take LeetCode contest\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 605. Can Place Flowers (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# первая попытка (не проходит тесты)\n",
    "from typing import List\n",
    "\n",
    "class Solution605:\n",
    "    def can_place_flowers(self, flowerbed: List[int], n: int) -> bool:\n",
    "        flowerbed_len = len(flowerbed)\n",
    "        flower_ind = 0\n",
    "        available = 0\n",
    "        while flower_ind != flowerbed_len:\n",
    "            if flowerbed[flower_ind] == 1:\n",
    "                if flower_ind != 0:\n",
    "                    flowerbed[flower_ind - 1] = 1\n",
    "                if flower_ind != flowerbed_len - 1:\n",
    "                    flowerbed[flower_ind + 1] = 1\n",
    "                    flower_ind += 1\n",
    "            flower_ind += 1\n",
    "        for flower in flowerbed:\n",
    "            if flower == 0:\n",
    "                available += 1\n",
    "        return available >= n\n",
    "\n",
    "Solution605().can_place_flowers(flowerbed=[1,0,0,0,1], n=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution605_1:\n",
    "    def can_place_flowers(self, flowerbed: List[int], n: int) -> bool:\n",
    "        flowerbed = [0] + flowerbed + [0]\n",
    "        for i in range(1, len(flowerbed)-1):\n",
    "            if flowerbed[i-1] == 0 and flowerbed[i] == 0 and flowerbed[i+1] == 0:\n",
    "                flowerbed[i] = 1\n",
    "                n -= 1\n",
    "        return n <= 0\n",
    "\n",
    "Solution605_1().can_place_flowers(flowerbed=[1,0,0,0,0,1], n=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution605_2:\n",
    "    def can_place_flowers(self, flowerbed: List[int], n: int) -> bool:\n",
    "        flowerbed = [0] + flowerbed + [0]\n",
    "        for i, _ in enumerate(flowerbed[1:-1]):\n",
    "            if flowerbed[i] == 0 and flowerbed[i+1] == 0 and flowerbed[i+2] == 0:\n",
    "                flowerbed[i+1] = 1\n",
    "                n -= 1\n",
    "        return n <= 0\n",
    "\n",
    "Solution605_2().can_place_flowers(flowerbed=[1,0,0,0,0,1], n=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 212,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution605_3:\n",
    "    def can_place_flowers(self, flowerbed: List[int], n: int) -> bool:\n",
    "        flowerbed = [0] + flowerbed + [0]\n",
    "        for i in range(1, len(flowerbed)-1):\n",
    "            if not sum(flowerbed[i-1:i+2]):\n",
    "                flowerbed[i] = 1\n",
    "                n -= 1\n",
    "        return n <= 0\n",
    "\n",
    "Solution605_3().can_place_flowers(flowerbed=[1,0,0,0,0,1], n=2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 617. Merge Two Binary Trees (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TreeNode{val: 3, left: TreeNode{val: 4, left: TreeNode{val: 5, left: None, right: None}, right: TreeNode{val: 4, left: None, right: None}}, right: TreeNode{val: 5, left: None, right: TreeNode{val: 7, left: None, right: None}}}"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution617:\n",
    "    def merge_trees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:\n",
    "        if not root1 and not root2:\n",
    "            return None\n",
    "        if not root1:\n",
    "            return root2\n",
    "        if not root2:\n",
    "            return root1\n",
    "        new_root = TreeNode(root1.val+root2.val)\n",
    "        new_root.left = self.merge_trees(root1.left, root2.left)\n",
    "        new_root.right = self.merge_trees(root1.right, root2.right)\n",
    "        return new_root\n",
    "\n",
    "Solution617().merge_trees(root1=TreeNode(val=1,\n",
    "                                         left=TreeNode(val=3,\n",
    "                                                       left=TreeNode(val=5, left=None, right=None),\n",
    "                                                       right=None),\n",
    "                                         right=TreeNode(val=2, left=None, right=None)),\n",
    "                          root2=TreeNode(val=2,\n",
    "                                         left=TreeNode(val=1,\n",
    "                                                       left=None,\n",
    "                                                       right=TreeNode(val=4, left=None, right=None)),\n",
    "                                         right=TreeNode(val=3,\n",
    "                                                        left=None,\n",
    "                                                        right=TreeNode(val=7, left=None, right=None))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 621. Task Scheduler (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import Counter\n",
    "\n",
    "class Solution621:\n",
    "    def least_interval(self, tasks: List[str], n: int) -> int:\n",
    "        freq = Counter(tasks)\n",
    "        max_freq = max(freq.values())\n",
    "        freq = list(freq.values())\n",
    "        max_count = freq.count(max_freq)\n",
    "        possible_ans = (max_freq - 1) * (n + 1) + max_count\n",
    "        return max(len(tasks), possible_ans)\n",
    "\n",
    "Solution621().least_interval(tasks=[\"A\",\"A\",\"A\",\"B\",\"B\",\"B\"], n=2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 637. Average of Levels in Binary Tree (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3.0, 14.5, 11.0]"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "from collections import deque\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution637:\n",
    "    def average_of_levels(self, root: Optional[TreeNode]) -> List[float]:\n",
    "        ans = []\n",
    "        q = deque([root])\n",
    "        while q:\n",
    "            cur_sum = 0\n",
    "            cnt = 0\n",
    "            for _ in range(len(q)):\n",
    "                cur = q.popleft()\n",
    "                cur_sum += cur.val\n",
    "                cnt += 1\n",
    "                if cur.left:\n",
    "                    q.append(cur.left)\n",
    "                if cur.right:\n",
    "                    q.append(cur.right)\n",
    "            ans.append(cur_sum / cnt)\n",
    "        return ans\n",
    "\n",
    "Solution637().average_of_levels(root=TreeNode(val=3,\n",
    "                                              left=TreeNode(val=9, left=None, right=None),\n",
    "                                              right=TreeNode(val=20,\n",
    "                                                             left=TreeNode(val=15, left=None, right=None),\n",
    "                                                             right=TreeNode(val=7, left=None, right=None))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 643. Maximum Average Subarray (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.75"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution643:\n",
    "    def find_max_average(self, nums: List[int], k: int) -> float:\n",
    "        count = 0\n",
    "        current_sum = 0\n",
    "        ans = float('-inf')\n",
    "        for _, v in enumerate(nums):\n",
    "            current_sum += v\n",
    "            count += 1\n",
    "            if count >= k:\n",
    "                ans = max(ans, current_sum / k)\n",
    "                current_sum -= nums[count-k]\n",
    "        return ans\n",
    "\n",
    "Solution643().find_max_average(nums=[1,12,-5,-6,50,3], k=4)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 646. Maximum Length of Pair Chain (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution646:\n",
    "    def find_longest_chain(self, pairs: List[List[int]]) -> int:\n",
    "        n = len(pairs)\n",
    "        pairs.sort(key = lambda x: x[1])\n",
    "        ans = 0\n",
    "        cur = float('-inf')\n",
    "        for start, end in pairs:\n",
    "            if start > cur:\n",
    "                cur = end\n",
    "                ans += 1\n",
    "        return ans\n",
    "\n",
    "Solution646().find_longest_chain(pairs=[[1,2],[2,3],[3,4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution646_1:\n",
    "    def find_longest_chain(self, pairs: List[List[int]]) -> int:\n",
    "        n = len(pairs)\n",
    "        pairs.sort(key = lambda x: x[0])\n",
    "        dp = [1] * n\n",
    "        for i in range(n):\n",
    "            for j in range(i):\n",
    "                if pairs[i][0] > pairs[j][1]:\n",
    "                    dp[i] = max(dp[i], 1 + dp[j])\n",
    "        return max(dp)\n",
    "\n",
    "Solution646_1().find_longest_chain(pairs=[[1,2],[7,8],[4,5]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 653. Two Sum IV - Input is a BST (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution653:\n",
    "    def find_target(self, root: Optional[TreeNode], k: int) -> bool:\n",
    "        seen = set()\n",
    "        stack = [root]\n",
    "        while stack:\n",
    "            cur = stack.pop()\n",
    "            if k - cur.val in seen:\n",
    "                return True\n",
    "            seen.add(cur.val)\n",
    "            if cur.left:\n",
    "                stack.append(cur.left)\n",
    "            if cur.right:\n",
    "                stack.append(cur.right)\n",
    "        return False\n",
    "\n",
    "Solution653().find_target(root=TreeNode(val=5,\n",
    "                                        left=TreeNode(val=3,\n",
    "                                                      left=TreeNode(val=2, left=None, right=None),\n",
    "                                                      right=TreeNode(val=4, left=None, right=None)),\n",
    "                                        right=TreeNode(val=6,\n",
    "                                                       left=None,\n",
    "                                                       right=TreeNode(val=7, left=None, right=None))),\n",
    "                          k=9)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 674. Longest Continuous Increasing Subsequence (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 217,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution674:\n",
    "    def find_length_of_lcis(self, nums: List[int]) -> int:\n",
    "        dp = [1] * len(nums)\n",
    "        for i, _ in enumerate(nums[1:],start=1):\n",
    "            if nums[i] > nums[i - 1]:\n",
    "                dp[i] = dp[i - 1] + 1\n",
    "        \n",
    "        return max(dp)\n",
    "\n",
    "Solution674().find_length_of_lcis(nums=[1,2,3,3,4,5])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 700. Search in a Binary Search Tree (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TreeNode{val: 2, left: TreeNode{val: 1, left: None, right: None}, right: TreeNode{val: 3, left: None, right: None}}"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution700:\n",
    "    def search_bst(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:\n",
    "        if not root:\n",
    "            return None\n",
    "        if root.val == val:\n",
    "            return root\n",
    "        if val < root.val:\n",
    "            return self.search_bst(root.left, val)\n",
    "        else:\n",
    "            return self.search_bst(root.right, val)\n",
    "\n",
    "Solution700().search_bst(root=TreeNode(val=4,\n",
    "                                       left=TreeNode(val=2,\n",
    "                                                     left=TreeNode(val=1, left=None, right=None),\n",
    "                                                     right=TreeNode(val=3, left=None, right=None)),\n",
    "                                       right=TreeNode(val=7, left=None, right=None)),\n",
    "                         val=2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 704. Binary Search (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution704:\n",
    "    def search(self, nums: List[int], target: int) -> int:\n",
    "        left, right = 0, len(nums) - 1\n",
    "        while left <= right:\n",
    "            mid = (left + right) // 2\n",
    "            if nums[mid] == target:\n",
    "                return mid\n",
    "            if nums[mid] > target:\n",
    "                right = mid - 1\n",
    "            else:\n",
    "                left = mid + 1\n",
    "        return -1\n",
    "\n",
    "Solution704().search(nums=[1,4,5,6,7,12,42,100], target=42)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 706. Design HashMap (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None None 1 -1 None 1 None -1\n"
     ]
    }
   ],
   "source": [
    "class ListNode:\n",
    "    def __init__(self, key, value):\n",
    "        self.key = key\n",
    "        self.value = value\n",
    "        self.next = None\n",
    "\n",
    "\n",
    "class MyHashMap:\n",
    "\n",
    "    def __init__(self):\n",
    "        self.size = 1000\n",
    "        self.table = [None] * self.size\n",
    "    \n",
    "    def _index(self, key: int) -> int:\n",
    "        return key % self.size\n",
    "\n",
    "    def put(self, key: int, value: int) -> None:\n",
    "        idx = self._index(key)\n",
    "        if not self.table[idx]:\n",
    "            self.table[idx] = ListNode(key, value)\n",
    "            return\n",
    "        cur = self.table[idx]\n",
    "        while cur:\n",
    "            if cur.key == key:\n",
    "                cur.value = value\n",
    "                return\n",
    "            if not cur.next:\n",
    "                cur.next = ListNode(key, value)\n",
    "                return\n",
    "            cur = cur.next\n",
    "\n",
    "    def get(self, key: int) -> int:\n",
    "        idx = self._index(key)\n",
    "        cur = self.table[idx]\n",
    "        while cur:\n",
    "            if cur.key == key:\n",
    "                return cur.value\n",
    "            cur = cur.next\n",
    "        return -1\n",
    "\n",
    "    def remove(self, key: int) -> None:\n",
    "        idx = self._index(key)\n",
    "        cur = self.table[idx]\n",
    "        if not cur:\n",
    "            return\n",
    "        if cur.key == key:\n",
    "            self.table[idx] = cur.next\n",
    "            return\n",
    "        while cur.next:\n",
    "            if cur.next.key == key:\n",
    "                cur.next = cur.next.next\n",
    "                return\n",
    "            cur = cur.next\n",
    "\n",
    "\n",
    "obj = MyHashMap()\n",
    "print(obj.put(1, 1),\n",
    "      obj.put(2, 2),\n",
    "      obj.get(1),\n",
    "      obj.get(3),\n",
    "      obj.put(2, 1),\n",
    "      obj.get(2),\n",
    "      obj.remove(2),\n",
    "      obj.get(2))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 725. Split Linked List in Parts (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ListNode{val: 1, next: None},\n",
       " ListNode{val: 2, next: None},\n",
       " ListNode{val: 3, next: None},\n",
       " None,\n",
       " None]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional, List\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution725:\n",
    "    def split_list_to_parts(self, head: Optional[ListNode], k: int) -> List[Optional[ListNode]]:\n",
    "        cur, length = head, 0\n",
    "        while cur:\n",
    "            cur, length = cur.next, length + 1\n",
    "        chunk_size, longer_chunks = length // k, length % k\n",
    "        res = [chunk_size + 1] * longer_chunks + [chunk_size] * (k - longer_chunks)\n",
    "        prev, cur = None, head\n",
    "        for ind, num in enumerate(res):\n",
    "            if prev:\n",
    "                prev.next = None\n",
    "            res[ind] = cur\n",
    "            for _ in range(num):\n",
    "                prev, cur = cur, cur.next\n",
    "        return res\n",
    "\n",
    "Solution725().split_list_to_parts(head=ListNode(1, ListNode(2, ListNode(3, None))), k=5)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 767. Reorganize String (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'aba'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import heapq\n",
    "from collections import Counter\n",
    "\n",
    "class Solution767:\n",
    "    def reorganize_string(self, s: str) -> str:\n",
    "        ans, c = [], Counter(s)\n",
    "        pq = [(-value, key) for key, value in c.items()]\n",
    "        heapq.heapify(pq)\n",
    "        p_a, p_b = 0, ''\n",
    "        while pq:\n",
    "            a, b = heapq.heappop(pq)\n",
    "            ans += [b]\n",
    "            if p_a < 0:\n",
    "                heapq.heappush(pq, (p_a, p_b))\n",
    "            a += 1\n",
    "            p_a, p_b = a, b\n",
    "        ans = ''.join(ans)\n",
    "        if len(ans) != len(s):\n",
    "            return ''\n",
    "        return ans\n",
    "\n",
    "Solution767().reorganize_string(s='aab')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 771. Jewels and Stones (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution771:\n",
    "    def num_jewels_in_stones(self, jewels: str, stones: str) -> int:\n",
    "        jewels = set(jewels)\n",
    "        ans = 0\n",
    "        for s in stones:\n",
    "            if s in jewels:\n",
    "                ans += 1\n",
    "        return ans\n",
    "\n",
    "Solution771().num_jewels_in_stones(jewels='aA', stones='aAAbbbbbb')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 781. Rabbits in Forest (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution781:\n",
    "    def num_rabbits(self, answers: List[int]) -> int:\n",
    "        d = {}\n",
    "        count = 0\n",
    "        for i in answers:\n",
    "            if i == 0:\n",
    "                count += 1\n",
    "            else:\n",
    "                if i not in d or i == d[i]:\n",
    "                    d[i] = 0\n",
    "                    count += i + 1\n",
    "                else:\n",
    "                    d[i] += 1\n",
    "        return count\n",
    "\n",
    "Solution781().num_rabbits(answers=[1,1,2])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 799. Champagne Tower (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution799:\n",
    "    def champagne_tower(self, poured: int, query_row: int, query_glass: int) -> float:\n",
    "        tower = [[0] * (i + 1) for i in range(query_row + 1)]\n",
    "        tower[0][0] = poured\n",
    "        for row in range(query_row):\n",
    "            for glass in range(min(len(tower[row]), query_glass + 1)):\n",
    "                excess = (tower[row][glass] - 1) / 2.0\n",
    "                if excess > 0:\n",
    "                    tower[row + 1][glass] += excess\n",
    "                    tower[row + 1][glass + 1] += excess\n",
    "        return min(1.0, tower[query_row][query_glass])\n",
    "\n",
    "Solution799().champagne_tower(poured=1, query_row=1, query_glass=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution799_1:\n",
    "    def champagne_tower(self, poured: int, query_row: int, query_glass: int) -> float:\n",
    "        cur_level = [poured]\n",
    "        for row in range(query_row):\n",
    "            next_level = [0.0] * (row + 2)\n",
    "            for glass, _ in enumerate(cur_level):\n",
    "                overflow = (cur_level[glass] - 1.0) / 2.0\n",
    "                if overflow > 0.0:\n",
    "                    next_level[glass] += overflow\n",
    "                    next_level[glass + 1] += overflow\n",
    "            cur_level = next_level\n",
    "        return min(1.0, cur_level[query_glass])\n",
    "\n",
    "Solution799_1().champagne_tower(poured=2, query_row=1, query_glass=0)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 832. Flipping an Image (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 0, 0], [0, 1, 0], [1, 1, 1]]"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution832:\n",
    "    def flip_and_invert_image(self, image: List[List[int]]) -> List[List[int]]:\n",
    "        for row in image:\n",
    "            left, right = 0, len(row) - 1\n",
    "            while left <= right:\n",
    "                row[left], row[right] = row[right], row[left]\n",
    "                row[left] = 0 if row[left] else 1\n",
    "                if left != right:\n",
    "                    row[right] = 0 if row[right] else 1\n",
    "                left += 1\n",
    "                right -= 1\n",
    "        return image\n",
    "\n",
    "Solution832().flip_and_invert_image(image=[[1, 1, 0], [1, 0, 1], [0, 0, 0]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 841. Keys and Rooms (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution841:\n",
    "    def can_visit_all_rooms(self, rooms: List[List[int]]) -> bool:\n",
    "        def dfs(source, rooms, seen):\n",
    "            seen.add(source)\n",
    "            for node in rooms[source]:\n",
    "                if node not in seen:\n",
    "                    dfs(node, rooms, seen)\n",
    "        seen = set()\n",
    "        dfs(0, rooms, seen)\n",
    "        return len(seen) == len(rooms)\n",
    "\n",
    "Solution841().can_visit_all_rooms(rooms=[[1],[2],[3],[]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 844. Backspace String Compare (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution844:\n",
    "    def backspace_compare(self, s: str, t: str) -> bool:\n",
    "        def typing(s_commands):\n",
    "            stack = []\n",
    "            for ch in s_commands:\n",
    "                if ch == '#':\n",
    "                    if stack:\n",
    "                        stack.pop()\n",
    "                else:\n",
    "                    stack.append(ch)\n",
    "            return ''.join(stack)\n",
    "        return typing(s) == typing(t)\n",
    "\n",
    "Solution844().backspace_compare(s='ab#c', t='ad#c')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 847. Shortest Path Visiting All Nodes (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import deque\n",
    "\n",
    "class Solution847:\n",
    "    def shortest_path_length(self, graph: List[List[int]]) -> int:\n",
    "        n = len(graph)\n",
    "        q = deque([(1 << i, i, 0) for i in range(n)])\n",
    "        visited = set((1 << i, i) for i in range(n))\n",
    "        while q:\n",
    "            mask, node, dist = q.popleft()\n",
    "            if mask == (1 << n) - 1:\n",
    "                return dist\n",
    "            for neighbor in graph[node]:\n",
    "                new_mask = mask | (1 << neighbor)\n",
    "                if (new_mask, neighbor) not in visited:\n",
    "                    visited.add((new_mask, neighbor))\n",
    "                    q.append((new_mask, neighbor, dist + 1))\n",
    "\n",
    "Solution847().shortest_path_length(graph=[[1],[0,2,4],[1,3,4],[2],[1,2]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 852. Peak Index in a Mountain Array (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution852:\n",
    "    def peak_index_in_mountain_array(self, arr: List[int]) -> int:\n",
    "        left, right = 0, len(arr) - 1\n",
    "        while left <= right:\n",
    "            mid = (left + right) // 2\n",
    "            if arr[mid - 1] < arr[mid] > arr[mid + 1]:\n",
    "                return mid\n",
    "            if arr[mid] < arr[mid + 1]:\n",
    "                left = mid + 1\n",
    "            else:\n",
    "                right = mid - 1\n",
    "\n",
    "Solution852().peak_index_in_mountain_array(arr=[2,10,7,4,1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 876. Middle of the Linked List (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ListNode{val: 4, next: ListNode{val: 5, next: None}}"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution876:\n",
    "    def middle_node(self, head: Optional[ListNode]) -> Optional[ListNode]:\n",
    "        slow = head\n",
    "        fast = head\n",
    "        while fast and fast.next:\n",
    "            slow = slow.next\n",
    "            fast = fast.next.next\n",
    "        return slow\n",
    "\n",
    "Solution876().middle_node(head=ListNode(val=3, next=ListNode(val=4, next=ListNode(val=5, next=None))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 880. Decoded String at Index (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'o'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution880:\n",
    "    def decode_at_index(self, s: str, k: int) -> str:\n",
    "        decoded_len = 0\n",
    "        for ch in s:\n",
    "            if ch.isdigit():\n",
    "                decoded_len *= int(ch)\n",
    "            else:\n",
    "                decoded_len += 1\n",
    "        for i in range(len(s) - 1, -1, -1):\n",
    "            cur_ch = s[i]\n",
    "            if cur_ch.isdigit():\n",
    "                decoded_len //= int(cur_ch)\n",
    "                k %= decoded_len\n",
    "            else:\n",
    "                if k == 0 or decoded_len == k:\n",
    "                    return cur_ch\n",
    "                decoded_len -= 1\n",
    "        return ''\n",
    "\n",
    "Solution880().decode_at_index(s='leet2code3', k=10)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 896. Monotonic Array (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution896:\n",
    "    def is_monotonic(self, nums: List[int]) -> bool:\n",
    "        increase, decrease = True, True\n",
    "        for i, _ in enumerate(nums[1:], start=1):\n",
    "            if nums[i] > nums[i - 1]:\n",
    "                decrease = False\n",
    "            if nums[i] < nums[i - 1]:\n",
    "                increase = False\n",
    "        return increase or decrease\n",
    "\n",
    "Solution896().is_monotonic(nums=[1, 2, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution896_1:\n",
    "    def is_monotonic(self, nums: List[int]) -> bool:\n",
    "        increase = False\n",
    "        decrease = False\n",
    "        for i, num in enumerate(nums[:-1]):\n",
    "            if nums[i+1] > num:\n",
    "                increase = True\n",
    "            if nums[i+1] < num:\n",
    "                decrease = True\n",
    "            if increase and decrease:\n",
    "                return False\n",
    "        return True\n",
    "\n",
    "Solution896_1().is_monotonic(nums=[6,5,4,4])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 905. Sort Array By Parity (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[32, 2, 8, 90, 1, 7, 3, 87, 85, 67, 31, 1]"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution905:\n",
    "    def sort_array_by_parity(self, nums: List[int]) -> List[int]:\n",
    "        i, j = 0, len(nums) - 1\n",
    "        while i < j:\n",
    "            if nums[i] % 2 != 0 and nums[j] % 2 == 0:\n",
    "                nums[i], nums[j] = nums[j], nums[i]\n",
    "                i += 1\n",
    "                j -= 1\n",
    "            if nums[i] % 2 == 0:\n",
    "                i += 1\n",
    "            if not nums[j] % 2 == 0:\n",
    "                j -= 1\n",
    "        return nums\n",
    "\n",
    "Solution905().sort_array_by_parity(nums=[1,2,8,3,1,7,90,87,85,67,31,32])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 8, 90, 32, 1, 7, 1, 87, 85, 67, 31, 3]"
      ]
     },
     "execution_count": 227,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution905_1:\n",
    "    def sort_array_by_parity(self, nums: List[int]) -> List[int]:\n",
    "        j = 0\n",
    "        for i, _ in enumerate(nums):\n",
    "            if nums[i] % 2 == 0:\n",
    "                nums[j], nums[i] = nums[i], nums[j]\n",
    "                j += 1\n",
    "        return nums\n",
    "\n",
    "Solution905_1().sort_array_by_parity(nums=[1,2,8,3,1,7,90,87,85,67,31,32])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 912. Sort an Array (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5]"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "def merge(nums: List[int], p: int, q: int, r: int):\n",
    "    left = nums[p:q+1]\n",
    "    right = nums[q+1:r+1]\n",
    "    i = 0\n",
    "    j = 0\n",
    "    k = p\n",
    "    while i < len(left) and j < len(right):\n",
    "        if left[i] < right[j]:\n",
    "            nums[k] = left[i]\n",
    "            i += 1\n",
    "        else:\n",
    "            nums[k] = right[j]\n",
    "            j += 1\n",
    "        k += 1\n",
    "        \n",
    "    while i < len(left):\n",
    "        nums[k] = left[i]\n",
    "        i += 1\n",
    "        k += 1\n",
    "        \n",
    "    while j < len(right):\n",
    "        nums[k] = right[j]\n",
    "        j += 1\n",
    "        k += 1\n",
    "        \n",
    "def merge_sort(nums: List[int], p: int, r:int):\n",
    "    if p < r:\n",
    "        mid = (p + r) // 2\n",
    "        merge_sort(nums, p, mid)\n",
    "        merge_sort(nums, mid+1, r)\n",
    "        merge(nums, p, mid, r)\n",
    "    return nums\n",
    "\n",
    "class Solution912:\n",
    "\n",
    "    def sort_array(self, nums: List[int]) -> List[int]:\n",
    "        return merge_sort(nums, 0, len(nums)-1)\n",
    "\n",
    "Solution912().sort_array(nums=[5, 2, 3, 1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 929. Unique Email Addresses (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution929:\n",
    "    def num_unique_emails(self, emails: List[str]) -> int:\n",
    "        unique_emails = set()\n",
    "        for e in emails:\n",
    "            name, dom = e.split('@')\n",
    "            name = name.split('+')[0].replace('.', '')\n",
    "            unique_emails.add(f'{name}@{dom}')\n",
    "        return len(unique_emails)\n",
    "\n",
    "Solution929().num_unique_emails(emails=[\"test.email+alex@leetcode.com\",\n",
    "                                      \"test.e.mail+bob.cathy@leetcode.com\",\n",
    "                                      \"testemail+david@lee.tcode.com\"])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 938. Range Sum of BST (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class TreeNode:\n",
    "    def __init__(self, val=0, left=None, right=None):\n",
    "        self.val = val\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "    def __repr__(self):\n",
    "        return f'TreeNode{{val: {self.val}, left: {self.left}, right: {self.right}}}'\n",
    "\n",
    "class Solution938:\n",
    "    def range_sum_bst(self, root: Optional[TreeNode], low: int, high: int) -> int:\n",
    "        if not root:\n",
    "            return 0\n",
    "        left, right = 0, 0\n",
    "        if root.val < high:\n",
    "            right = self.range_sum_bst(root.right, low, high)\n",
    "        if root.val > low:\n",
    "            left = self.range_sum_bst(root.left, low, high)\n",
    "        cur = root.val if low <= root.val <= high else 0\n",
    "        return left + right + cur\n",
    "\n",
    "Solution938().range_sum_bst(root=TreeNode(val=10,\n",
    "                                          left=TreeNode(val=5,\n",
    "                                                        left=TreeNode(val=3, left=None, right=None),\n",
    "                                                        right=TreeNode(val=7, left=None, right=None)),\n",
    "                                          right=TreeNode(val=15,\n",
    "                                                         left=None,\n",
    "                                                         right=TreeNode(val=18, left=None, right=None))),\n",
    "                            low=7, high=15)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 941. Valid Mountain Array (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution941:\n",
    "    def valid_mountain_array(self, arr: List[int]) -> bool:\n",
    "\n",
    "        if len(arr) < 3:\n",
    "            return False\n",
    "        \n",
    "        i = 0\n",
    "        while arr[i] < arr[i + 1]:\n",
    "            i += 1\n",
    "            if i >= len(arr) - 1:\n",
    "                break\n",
    "        \n",
    "        j = len(arr) - 1\n",
    "        while arr[j - 1] > arr[j]:\n",
    "            j -= 1\n",
    "            if j <= 0:\n",
    "                break\n",
    "        \n",
    "        return i == j and 0 < i < len(arr) - 1\n",
    "\n",
    "Solution941().valid_mountain_array(arr=[0,1,2,3])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 953. Verifying an Alien Dictionary (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 232,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution953:\n",
    "    def is_alien_sorted(self, words: List[str], order: str) -> bool:\n",
    "        if len(words) < 2:\n",
    "            return True\n",
    "        d = {c:i for i,c in enumerate(order)}\n",
    "        for i in range(1, len(words)):\n",
    "            word_1 = words[i-1]\n",
    "            word_2 = words[i]\n",
    "            len_1, len_2 = len(word_1), len(word_2)\n",
    "            j = 0\n",
    "            while j < len_1 and j < len_2:\n",
    "                ord_1, ord_2 = d[word_1[j]], d[word_2[j]]\n",
    "                if ord_1 < ord_2:\n",
    "                    break\n",
    "                if ord_1 > ord_2:\n",
    "                    return False\n",
    "                j += 1\n",
    "            if len_1 > len_2 and (j == len_1 or j == len_2):\n",
    "                return False\n",
    "        return True\n",
    "\n",
    "Solution953().is_alien_sorted(words=[\"kuvp\",\"q\"], order=\"ngxlkthsjuoqcpavbfdermiywz\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 977. Squares of a Sorted Array (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 9, 16, 100]"
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution977:\n",
    "    def sorted_squares(self, nums: List[int]) -> List[int]:\n",
    "        left, right = 0, len(nums) - 1\n",
    "        ans = []\n",
    "        while left <= right:\n",
    "            if abs(nums[right]) > abs(nums[left]):\n",
    "                ans.append(nums[right] * nums[right])\n",
    "                right -= 1\n",
    "            else:\n",
    "                ans.append(nums[left] * nums[left])\n",
    "                left += 1\n",
    "        return ans[::-1]\n",
    "\n",
    "Solution977().sorted_squares(nums=[-4, -1, 0, 3, 10])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 994. Rotting Oranges (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import deque\n",
    "\n",
    "class Solution994:\n",
    "    def oranges_rotting(self, grid: List[List[int]]) -> int:\n",
    "        fresh, rotting = set(), deque()\n",
    "        for i, _ in enumerate(grid):\n",
    "            for j, _ in enumerate(grid[0]):\n",
    "                if grid[i][j] == 1:\n",
    "                    fresh.add((i, j))\n",
    "                elif grid[i][j] == 2:\n",
    "                    rotting.append((i, j))\n",
    "        ans = 0\n",
    "        while fresh and rotting:\n",
    "            for _ in range(len(rotting)):\n",
    "                i, j = rotting.popleft()\n",
    "                for coord in ((i-1, j), (i+1, j), (i, j-1), (i, j+1)):\n",
    "                    if coord in fresh:\n",
    "                        fresh.remove(coord)\n",
    "                        rotting.append(coord)\n",
    "            ans += 1\n",
    "        return -1 if fresh else ans\n",
    "\n",
    "Solution994().oranges_rotting(grid=[[2,1,1],[1,1,0],[0,1,1]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1047. Remove All Adjacent Duplicates In String (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ca'"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution1047:\n",
    "    def remove_duplicates(self, s: str) -> str:\n",
    "        stack = []\n",
    "        for ch in s:\n",
    "            if stack and stack[-1] == ch:\n",
    "                stack.pop()\n",
    "            else:\n",
    "                stack.append(ch)\n",
    "        return ''.join(stack)\n",
    "\n",
    "Solution1047().remove_duplicates(s='abbaca')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1048. Longest String Chain (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution1048:\n",
    "    def longest_str_chain(self, words: List[str]) -> int:\n",
    "        words.sort(key=len)\n",
    "        dp = {}\n",
    "        max_chain = 0\n",
    "        for word in words:\n",
    "            dp[word] = 1\n",
    "            for i, _ in enumerate(word):\n",
    "                prev_word = word[:i] + word[i+1:]\n",
    "                if prev_word in dp:\n",
    "                    dp[word] = max(dp[word], dp[prev_word] + 1)\n",
    "            max_chain = max(max_chain, dp[word])\n",
    "        return max_chain\n",
    "\n",
    "Solution1048().longest_str_chain(words=[\"a\",\"b\",\"ba\",\"bca\",\"bda\",\"bdca\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution1048_1:\n",
    "    def longest_str_chain(self, words: List[str]) -> int:\n",
    "        words_set = set(words)\n",
    "        memo = {}\n",
    "\n",
    "        def dfs(word):\n",
    "            if word not in words_set:\n",
    "                return 0\n",
    "            if word in memo:\n",
    "                return memo[word]\n",
    "            max_chain = 1\n",
    "            for i, _ in enumerate(word):\n",
    "                next_word = word[:i] + word[i+1:]\n",
    "                max_chain = max(max_chain, 1 + dfs(next_word))\n",
    "            memo[word] = max_chain\n",
    "            return max_chain\n",
    "        \n",
    "        return max(dfs(word) for word in words)\n",
    "\n",
    "Solution1048_1().longest_str_chain(words=[\"xbc\",\"pcxbcf\",\"xb\",\"cxbc\",\"pcxbc\"])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1081. Smallest Subsequence of Distinct Characters (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "class Solution1081:\n",
    "    def smallest_subsequence(self, s: str) -> str:\n",
    "        count = Counter(s)\n",
    "        ans = []\n",
    "        visited = set()\n",
    "        for ch in s:\n",
    "            count[ch] -= 1\n",
    "            if ch in visited:\n",
    "                continue\n",
    "            while ans and ch < ans[-1] and count[ans[-1]] > 0:\n",
    "                visited.remove(ans.pop())\n",
    "            visited.add(ch)\n",
    "            ans.append(ch)\n",
    "        return ''.join(ans)\n",
    "\n",
    "Solution1081().smallest_subsequence(s='bcabc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'acdb'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution1081_1:\n",
    "    def remove_duplicate_letters(self, s: str) -> str:\n",
    "        stack = []\n",
    "        seen = set()\n",
    "        last_occ = {ch: i for i, ch in enumerate(s)}\n",
    "        for i, ch in enumerate(s):\n",
    "            if ch not in seen:\n",
    "                while stack and ch < stack[-1] and i < last_occ[stack[-1]]:\n",
    "                    seen.discard(stack.pop())\n",
    "                seen.add(ch)\n",
    "                stack.append(ch)\n",
    "        return ''.join(stack)\n",
    "\n",
    "Solution1081_1().remove_duplicate_letters(s='cbacdcbc')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1137. N-th Tribonacci Number (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1389537"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution1137:\n",
    "    def tribonacci(self, n: int) -> int:\n",
    "        dp = [0, 1, 1]\n",
    "        if n < 3:\n",
    "            return dp[n]\n",
    "        for i in range(3, n+1):\n",
    "            dp.append(dp[i-3] + dp[i-2] + dp[i-1])\n",
    "        return dp[-1]\n",
    "\n",
    "Solution1137().tribonacci(n=25)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1203. Sort Items by Groups Respecting Dependencies (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 5, 2, 6, 3, 4, 7, 1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import deque, defaultdict\n",
    "\n",
    "class Solution1203:\n",
    "    def sort_items(self, n: int, m: int, group: List[int], before_items: List[List[int]]) -> List[int]:\n",
    "        def topological_sort(nodes, pred, success):\n",
    "            order, no_pred = [], deque(node for node in nodes if not pred[node])\n",
    "            while no_pred:\n",
    "                node = no_pred.popleft()\n",
    "                order.append(node)\n",
    "                for s in success[node]:\n",
    "                    pred[s].discard(node)\n",
    "                    if not pred[s]:\n",
    "                        no_pred.append(s)\n",
    "            return order if len(order) == len(nodes) else []\n",
    "        \n",
    "        group_to_items, new_group = defaultdict(set), m\n",
    "        for item in range(n):\n",
    "            if group[item] == -1:\n",
    "                group[item] = new_group\n",
    "                new_group += 1\n",
    "            group_to_items[group[item]].add(item)\n",
    "        \n",
    "        intra_pred, intra_success = defaultdict(set), defaultdict(set)\n",
    "        inter_pred, inter_success = defaultdict(set), defaultdict(set)\n",
    "        for item in range(n):\n",
    "            for before in before_items[item]:\n",
    "                if group[item] == group[before]:\n",
    "                    intra_pred[item].add(before)\n",
    "                    intra_success[before].add(item)\n",
    "                else:\n",
    "                    inter_pred[group[item]].add(group[before])\n",
    "                    inter_success[group[before]].add(group[item])\n",
    "        groups_order = topological_sort(list(group_to_items.keys()), inter_pred, inter_success)\n",
    "        if not groups_order:\n",
    "            return []\n",
    "        items_order = []\n",
    "        for grp in groups_order:\n",
    "            order = topological_sort(group_to_items[grp], intra_pred, intra_success)\n",
    "            if not order:\n",
    "                return []\n",
    "            items_order.extend(order)\n",
    "        return items_order\n",
    "\n",
    "Solution1203().sort_items(n=8, m=2, group=[-1,-1,1,0,0,1,0,-1], before_items=[[],[6],[5],[6],[3,6],[],[],[]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1282. Group the People Given the Group Size They Belong To (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 1, 2], [5], [3, 4, 6]]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution1282:\n",
    "    def group_the_people(self, group_sizes: List[int]) -> List[List[int]]:\n",
    "        groups = {}\n",
    "        ans = []\n",
    "        for i, size in enumerate(group_sizes):\n",
    "            if size not in groups:\n",
    "                groups[size] = []\n",
    "            groups[size].append(i)\n",
    "            if len(groups[size]) == size:\n",
    "                ans.append(groups[size])\n",
    "                groups[size] = []\n",
    "        return ans\n",
    "\n",
    "Solution1282().group_the_people(group_sizes=[3,3,3,3,3,1,3])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1290. Convert Binary Number in a Linked List to Integer (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional\n",
    "\n",
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "    def __repr__(self):\n",
    "        return f'ListNode{{val: {self.val}, next: {self.next}}}'\n",
    "\n",
    "class Solution1290:\n",
    "    def get_decimal_value(self, head: ListNode) -> int:\n",
    "        ans = 0\n",
    "        while head:\n",
    "            ans = ans * 2 + head.val\n",
    "            head = head.next\n",
    "        return ans\n",
    "\n",
    "Solution1290().get_decimal_value(head=ListNode(val=1, next=ListNode(val=0, next=ListNode(val=1, next=None))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1295. Find Numbers with Even Number of Digits (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 237,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution1295:\n",
    "    def find_numbers(self, nums: List[int]) -> int:\n",
    "        def digits_counter(num):\n",
    "            count = 0\n",
    "            while num:\n",
    "                num //= 10\n",
    "                count += 1\n",
    "            return count\n",
    "        required_nums_count = 0\n",
    "        for num in nums:\n",
    "            required_nums_count += 0 if digits_counter(num) % 2 else 1\n",
    "        return required_nums_count\n",
    "\n",
    "Solution1295().find_numbers(nums=[12, 345, 2, 6, 7896])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1326. Minimum Number of Taps to Open to Water a Garden (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(-4, 6), (0, 0), (0, 6), (1, 7), (2, 2), (2, 8), (3, 11), (5, 7), (5, 13), (8, 8)]\n"
     ]
    }
   ],
   "source": [
    "# Доработать\n",
    "from typing import List\n",
    "\n",
    "class Solution1326:\n",
    "    def min_taps(self, n: int, ranges: List[int]) -> int:\n",
    "        intervals = [(0, 0)] * len(ranges) \n",
    "        for i, val in enumerate(ranges):\n",
    "            intervals[i] = (i - val, i + val)\n",
    "        intervals.sort(key=lambda x:x[0])\n",
    "        print(intervals)\n",
    "\n",
    "Solution1326().min_taps(n=9, ranges=[0,5,0,3,3,3,1,4,0,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution1326_1:\n",
    "    def min_taps(self, n: int, ranges: List[int]) -> int:\n",
    "        dp = [float('inf')] * (n + 1)\n",
    "        dp[0] = 0\n",
    "        for i, val in enumerate(ranges):\n",
    "            start, end = max(0, i - val), min(n, i + val)\n",
    "            for j in range(start + 1, end + 1):\n",
    "                dp[j] = min(dp[j], dp[start] + 1)\n",
    "        return dp[-1] if dp[-1] != float('inf') else -1\n",
    "\n",
    "Solution1326_1().min_taps(n=9, ranges=[0,5,0,3,3,3,1,4,0,4])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1329. Sort the Matrix Diagonally (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[5, 17, 4, 1, 52, 7],\n",
       " [11, 11, 25, 45, 8, 69],\n",
       " [14, 23, 25, 44, 58, 15],\n",
       " [22, 27, 31, 36, 50, 66],\n",
       " [84, 28, 75, 33, 55, 68]]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import defaultdict\n",
    "\n",
    "class Solution1329:\n",
    "    def diagonal_sort(self, mat: List[List[int]]) -> List[List[int]]:\n",
    "        d = defaultdict(list)\n",
    "        for i, _ in enumerate(mat):\n",
    "            for j, _ in enumerate(mat[0]):\n",
    "                d[i - j].append(mat[i][j])\n",
    "        for diag in d.values():\n",
    "            diag.sort(reverse=True)\n",
    "        for i, _ in enumerate(mat):\n",
    "            for j, _ in enumerate(mat[0]):\n",
    "                val = d[i - j].pop()\n",
    "                mat[i][j] = val\n",
    "        return mat\n",
    "\n",
    "Solution1329().diagonal_sort(mat=[[11,25,66,1,69,7],\n",
    "                                  [23,55,17,45,15,52],\n",
    "                                  [75,31,36,44,58,8],\n",
    "                                  [22,27,33,25,68,4],\n",
    "                                  [84,28,14,11,5,50]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1337. The K Weakest Rows in a Matrix (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 0, 3]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution1337:\n",
    "    def k_weakest_rows(self, mat: List[List[int]], k: int) -> List[int]:\n",
    "        rows_ranks = [(sum(row), i) for i, row in enumerate(mat)]\n",
    "        rows_ranks.sort(key=lambda x: (x[0], x[1]))\n",
    "        return [row[1] for row in rows_ranks[:k]]\n",
    "\n",
    "Solution1337().k_weakest_rows(mat=[[1,1,0,0,0],\n",
    "                                   [1,1,1,1,0],\n",
    "                                   [1,0,0,0,0],\n",
    "                                   [1,1,0,0,0],\n",
    "                                   [1,1,1,1,1]], k=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from heapq import heappush, heappop\n",
    "\n",
    "class Solution1337_1:\n",
    "    def k_weakest_rows(self, mat: List[List[int]], k: int) -> List[int]:\n",
    "        heap = []\n",
    "        for i, row in enumerate(mat):\n",
    "            rank = sum(row)\n",
    "            heappush(heap, (-rank, -i))\n",
    "            if len(heap) > k:\n",
    "                heappop(heap)\n",
    "        return [-i for _, i in sorted(heap, reverse=True)]\n",
    "\n",
    "Solution1337_1().k_weakest_rows(mat=[[1,0,0,0],\n",
    "                                     [1,1,1,1],\n",
    "                                     [1,0,0,0],\n",
    "                                     [1,0,0,0]], k=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 0, 3]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from heapq import heapify, nsmallest\n",
    "\n",
    "class Solution1337_2:\n",
    "    def k_weakest_rows(self, mat: List[List[int]], k: int) -> List[int]:\n",
    "        def binary_search(arr):\n",
    "            left, right = 0, len(arr) - 1\n",
    "            while left <= right:\n",
    "                mid = (left + right) // 2\n",
    "                if arr[mid] == 1:\n",
    "                    left = mid + 1\n",
    "                else:\n",
    "                    right = mid - 1\n",
    "            return right\n",
    "        queue = [(binary_search(row), i) for i, row in enumerate(mat)]\n",
    "        heapify(queue)\n",
    "        return [i for _, i in nsmallest(k, queue)]\n",
    "\n",
    "Solution1337_2().k_weakest_rows(mat=[[1,1,0,0,0],\n",
    "                                     [1,1,1,1,0],\n",
    "                                     [1,0,0,0,0],\n",
    "                                     [1,1,0,0,0],\n",
    "                                     [1,1,1,1,1]], k=3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1346. Check If N and Its Double Exist (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution1346:\n",
    "    def check_if_exist(self, arr: List[int]) -> bool:\n",
    "        seen = set()\n",
    "        for num in arr:\n",
    "            if num * 2 in seen or num / 2 in seen:\n",
    "                return True\n",
    "            seen.add(num)\n",
    "        return False\n",
    "\n",
    "Solution1346().check_if_exist(arr=[6,1,12,4])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1359. Count All Valid Pickup and Delivery Options (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution1359:\n",
    "    memo = {}\n",
    "    def count_orders(self, n: int) -> int:\n",
    "        if n == 1:\n",
    "            return 1\n",
    "        if n in self.memo:\n",
    "            return self.memo[n]\n",
    "        cnt = (self.countOrders(n - 1) * (2 * n - 1) * n) % (10**9 + 7)\n",
    "        self.memo[n] = cnt\n",
    "        return cnt\n",
    "\n",
    "Solution1359().count_orders(n=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution1359_1:\n",
    "    def count_orders(self, n: int) -> int:\n",
    "        cnt = 1\n",
    "        for i in range(2, n + 1):\n",
    "            cnt = (cnt * (2 * i - 1) * i) % (10**9 + 7)\n",
    "        return cnt\n",
    "\n",
    "Solution1359_1().count_orders(n=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "90"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import factorial\n",
    "\n",
    "MOD = 10**9 + 7\n",
    "class Solution1359_2:\n",
    "    def count_orders(self, n: int) -> int:\n",
    "        two_n_factorial = factorial(2 * n) % MOD\n",
    "        two_pow_n = pow(2, n, MOD)\n",
    "        return (two_n_factorial * pow(two_pow_n, -1, MOD)) % MOD\n",
    "\n",
    "Solution1359_2().count_orders(n=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2520"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "from operator import mul\n",
    "\n",
    "class Solution1359_3:\n",
    "    def count_orders(self, n: int) -> int:\n",
    "        return reduce(mul, (*range(1, n+1), *range(1,2*n,2)), 1) % (10**9+7)\n",
    "\n",
    "Solution1359_3().count_orders(n=4)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1431. Kids With the Greatest Number of Candies (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, True, True, False, True]"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution1431:\n",
    "    def kids_with_candies(self, candies: List[int], extra_candies: int) -> List[bool]:\n",
    "        candies_max = max(candies)\n",
    "        result = []\n",
    "        for candy in candies:\n",
    "            if candy + extra_candies >= candies_max:\n",
    "                result.append(True)\n",
    "            else:\n",
    "                result.append(False)\n",
    "        return result\n",
    "\n",
    "Solution1431().kids_with_candies(candies=[2, 3, 5, 1, 3], extra_candies=3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1480. Running Sum of 1d Array (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 6, 10, 15]"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution1480:\n",
    "    def running_sum(self, nums: List[int]) -> List[int]:\n",
    "        for i, _ in enumerate(nums[1:], start=1):\n",
    "            nums[i] += nums[i-1]\n",
    "        return nums\n",
    "\n",
    "Solution1480().running_sum(nums=[1, 2, 3, 4, 5])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1489. Find Critical and Pseudo-Critical Edges in Minimum Spanning Tree (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[], [0, 1, 2, 3]]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution1489:\n",
    "    def find_critical_and_pseudo_critical_edges(self, n: int, edges: List[List[int]]) -> List[List[int]]:\n",
    "        edges = [(a, b, c, i) for i, (a, b, c) in enumerate(edges)]\n",
    "        edges.sort(key = lambda x: x[2])\n",
    "        max_cost = 1000 * 100\n",
    "        def get_mst_cost(e_p, v_p, c_p):\n",
    "            if len(v_p) == n:\n",
    "                return c_p\n",
    "            else:\n",
    "                for a, b, c, i in edges:\n",
    "                    if i not in e_p and (a in v_p and b not in v_p or a not in v_p and b in v_p):\n",
    "                        return get_mst_cost(e_p | set([i]), v_p | set([a, b]), c_p + c)\n",
    "            return max_cost\n",
    "        c_p = get_mst_cost(set(), set([0]), 0)\n",
    "        crit, pseudo_crit = [], []\n",
    "        for a, b, c, i in edges:\n",
    "            if get_mst_cost(set([i]), set([0]), 0) > c_p:\n",
    "                crit += [i]\n",
    "            elif get_mst_cost(set([i]), set([a, b]), c) == c_p:\n",
    "                pseudo_crit += [i]\n",
    "        return [crit, pseudo_crit]\n",
    "\n",
    "Solution1489().find_critical_and_pseudo_critical_edges(n=4, edges = [[0,1,1],[1,2,1],[2,3,1],[0,3,1]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1512. Number of Good Pairs (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution1512:\n",
    "    def num_identical_pairs(self, nums: List[int]) -> int:\n",
    "        count = {}\n",
    "        ans = 0\n",
    "        for num in nums:\n",
    "            if num in count:\n",
    "                ans += count[num]\n",
    "                count[num] += 1\n",
    "            else:\n",
    "                count[num] = 1\n",
    "        return ans\n",
    "\n",
    "Solution1512().num_identical_pairs(nums=[1,2,3,1,1,3])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1518. Water Bottles (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 241,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution1518:\n",
    "    def num_water_bottles(self, numBottles: int, numExchange: int) -> int:\n",
    "        drunk_bottles = 0\n",
    "        full_bottles = numBottles\n",
    "        empty_bottles = 0\n",
    "        while full_bottles >= 1:\n",
    "            drunk_bottles += full_bottles\n",
    "            full_bottles_new = (full_bottles + empty_bottles) // numExchange\n",
    "            empty_bottles = (full_bottles + empty_bottles) % numExchange\n",
    "            full_bottles = full_bottles_new\n",
    "        \n",
    "        return drunk_bottles\n",
    "\n",
    "Solution1518().num_water_bottles(numBottles=10, numExchange=6)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1539. Kth Missing Positive Number (Easy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution1539:\n",
    "    def find_kth_positive(self, arr: List[int], k: int) -> int:\n",
    "        current_missed_count = 0\n",
    "        n = 1\n",
    "        i = 0\n",
    "        while True:\n",
    "            if i < len(arr) and arr[i] != n:\n",
    "                current_missed_count += 1\n",
    "            elif i >= len(arr):\n",
    "                current_missed_count += 1\n",
    "            else:\n",
    "                i += 1\n",
    "            if current_missed_count == k:\n",
    "                return n\n",
    "            n += 1\n",
    "\n",
    "Solution1539().find_kth_positive(arr=[2,3,4,7,11], k=6)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1584. Min Cost to Connect All Points (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from heapq import heappush, heappop\n",
    "\n",
    "class Solution1584:\n",
    "    def min_cost_connect_points(self, points: List[List[int]]) -> int:\n",
    "        n = len(points)\n",
    "        visited = [False] * n\n",
    "        heap_dict = {0: 0}\n",
    "        min_heap = [(0, 0)]\n",
    "        all_cost = 0\n",
    "        while min_heap:\n",
    "            cost, u = heappop(min_heap)\n",
    "            if visited[u] or heap_dict.get(u, float('inf')) < cost:\n",
    "                continue\n",
    "            visited[u] = True\n",
    "            all_cost += cost\n",
    "            for v in range(n):\n",
    "                if not visited[v]:\n",
    "                    new_dist = abs(points[u][0] - points[v][0]) + abs(points[u][1] - points[v][1])\n",
    "                    if new_dist < heap_dict.get(v, float('inf')):\n",
    "                        heap_dict[v] = new_dist\n",
    "                        heappush(min_heap, (new_dist, v))\n",
    "        return all_cost\n",
    "\n",
    "Solution1584().min_cost_connect_points(points=[[0,0],[2,2],[3,10],[5,2],[7,0]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1615. Maximal Network Rank (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 243,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from collections import defaultdict\n",
    "\n",
    "class Solution1615:\n",
    "    def maximal_network_rank(self, n: int, roads: List[List[int]]) -> int:\n",
    "        connected = defaultdict(set)\n",
    "        for a, b in roads:\n",
    "            connected[a].add(b)\n",
    "            connected[b].add(a)\n",
    "        m = 0\n",
    "        for i in range(n):\n",
    "            for j in range(i+1, n):\n",
    "                m = max(m, len(connected[i]) + len(connected[j]) - (i in connected[j]))\n",
    "        return m\n",
    "\n",
    "Solution1615().maximal_network_rank(n=4, roads=[[0,1],[0,3],[1,2],[1,3]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1631. Path With Minimum Effort (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "from heapq import heappush, heappop\n",
    "\n",
    "class Solution1631:\n",
    "    def minimum_effort_path(self, heights: List[List[int]]) -> int:\n",
    "        r, c = len(heights), len(heights[0])\n",
    "        dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)]\n",
    "        dist = [[float('inf') for _ in range(c)] for _ in range(r)]\n",
    "        dist[0][0] = 0\n",
    "        min_heap = [(0, 0, 0)]\n",
    "        while min_heap:\n",
    "            effort, x, y = heappop(min_heap)\n",
    "            if x == r - 1 and y == c - 1:\n",
    "                return effort\n",
    "            for dx, dy in dirs:\n",
    "                nx, ny = x + dx, y + dy\n",
    "                if 0 <= nx < r and 0 <= ny < c:\n",
    "                    new_effort = max(effort, abs(heights[x][y] - heights[nx][ny]))\n",
    "                    if new_effort < dist[nx][ny]:\n",
    "                        dist[nx][ny] = new_effort\n",
    "                        heappush(min_heap, (new_effort, nx, ny))\n",
    "\n",
    "Solution1631().minimum_effort_path(heights=[[1,2,1,1,1],[1,2,1,2,1],[1,2,1,2,1],[1,2,1,2,1],[1,1,1,2,1]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1647. Minimum Deletions to Make Character Frequencies Unique (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "class Solution1647:\n",
    "    def min_deletions(self, s: str) -> int:\n",
    "        cnt = Counter(s)\n",
    "        dels = 0\n",
    "        used_freqs = set()\n",
    "        for _, freq in cnt.items():\n",
    "            while freq > 0 and freq in used_freqs:\n",
    "                freq -= 1\n",
    "                dels += 1\n",
    "            used_freqs.add(freq)\n",
    "        return dels\n",
    "\n",
    "Solution1647().min_deletions(s='aaabbbcc')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1658. Minimum Operations to Reduce X to Zero (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution1658:\n",
    "    def min_operations(self, nums: List[int], x: int) -> int:\n",
    "        target, n = sum(nums) - x, len(nums)\n",
    "        if target == 0:\n",
    "            return n\n",
    "        max_len = cur_sum = left = 0\n",
    "        for right, val in enumerate(nums):\n",
    "            cur_sum += val\n",
    "            while left <= right and cur_sum > target:\n",
    "                cur_sum -= nums[left]\n",
    "                left += 1\n",
    "            if cur_sum == target:\n",
    "                max_len = max(max_len, right - left + 1)\n",
    "        return n - max_len if max_len else -1\n",
    "\n",
    "Solution1658().min_operations(nums=[1,1,4,2,3], x=5)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 2038. Remove Colored Pieces if Both Neighbors are the Same Color (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "class Solution2038:\n",
    "    def winner_of_game(self, colors: str) -> bool:\n",
    "        alice_plays = sum(len(match.group()) - 2 for match in re.finditer(r'A{3,}', colors))\n",
    "        bob_plays = sum(len(match.group()) - 2 for match in re.finditer(r'B{3,}', colors))\n",
    "        return alice_plays > bob_plays\n",
    "\n",
    "Solution2038().winner_of_game(colors='AAABABB')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution2038_1:\n",
    "    def winner_of_game(self, colors: str) -> bool:\n",
    "        alice_plays, bob_plays = 0, 0\n",
    "        count = 1\n",
    "        for i, _ in enumerate(colors[1:], start=1):\n",
    "            if colors[i] == colors[i-1]:\n",
    "                count += 1\n",
    "            else:\n",
    "                if colors[i-1] == 'A':\n",
    "                    alice_plays += max(0, count - 2)\n",
    "                else:\n",
    "                    bob_plays += max(0, count - 2)\n",
    "                count = 1\n",
    "        if colors[-1] == 'A':\n",
    "            alice_plays += max(0, count - 2)\n",
    "        else:\n",
    "            bob_plays += max(0, count - 2)\n",
    "        return alice_plays > bob_plays\n",
    "\n",
    "Solution2038_1().winner_of_game(colors='ABBBBBBBAAA')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 2366. Minimum Replacements to Sort the Array (Hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution2366:\n",
    "    def minimum_replacement(self, nums: List[int]) -> int:\n",
    "        n = len(nums)\n",
    "        ops = 0\n",
    "        prev_val = nums[n-1]\n",
    "        for i in range(n - 2, -1, -1):\n",
    "            if nums[i] > prev_val:\n",
    "                k = (nums[i] + prev_val - 1) // prev_val\n",
    "                ops += k - 1\n",
    "                prev_val = nums[i] // k\n",
    "            else:\n",
    "                prev_val = nums[i]\n",
    "        return ops\n",
    "\n",
    "Solution2366().minimum_replacement(nums=[3,9,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution2366_1:\n",
    "    def minimum_replacement(self, nums: List[int]) -> int:\n",
    "        ops = 0\n",
    "        prev_val = nums[-1]\n",
    "        for i in range(len(nums) - 2, -1, -1):\n",
    "            k = (nums[i] + prev_val - 1) // prev_val\n",
    "            ops += k - 1\n",
    "            prev_val = nums[i] // k\n",
    "        return ops\n",
    "\n",
    "Solution2366_1().minimum_replacement(nums=[3,9,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution2366_2:\n",
    "    def minimum_replacement(self, nums: List[int]) -> int:\n",
    "        ops = 0\n",
    "        prev_val = nums[-1]\n",
    "        for i in range(len(nums) - 2, -1, -1):\n",
    "            if nums[i] <= prev_val:\n",
    "                prev_val = nums[i]\n",
    "                continue\n",
    "            if nums[i] % prev_val:\n",
    "                k = nums[i] // prev_val + 1\n",
    "                prev_val = nums[i] // k\n",
    "            else:\n",
    "                k = nums[i] // prev_val\n",
    "            ops += k - 1\n",
    "        return ops\n",
    "\n",
    "Solution2366_2().minimum_replacement(nums=[3,9,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution2366_3:\n",
    "    def minimum_replacement(self, nums: List[int]) -> int:\n",
    "        prev_val = nums.pop()\n",
    "        ops = 0\n",
    "        while nums:\n",
    "            num = nums.pop()\n",
    "            k = (num + prev_val - 1) // prev_val\n",
    "            ops += k - 1\n",
    "            prev_val = num // k\n",
    "        return ops\n",
    "\n",
    "Solution2366_3().minimum_replacement(nums=[3,9,3])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 2369. Check if There is a Valid Partition For The Array (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 244,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution2369:\n",
    "    def valid_partition(self, nums: List[int]) -> bool:\n",
    "        n = len(nums)\n",
    "        if n == 1:\n",
    "            return False\n",
    "        dp = [True, False, nums[0] == nums[1] if n > 1 else False]\n",
    "        for i in range(2, n):\n",
    "            cur = False\n",
    "            if nums[i] == nums[i-1] and dp[1]:\n",
    "                cur = True\n",
    "            elif nums[i] == nums[i-1] == nums[i-2] and dp[0]:\n",
    "                cur = True\n",
    "            elif nums[i] - nums[i-1] == 1 and nums[i-1] - nums[i-2] == 1 and dp[0]:\n",
    "                cur = True\n",
    "            dp[0], dp[1], dp[2] = dp[1], dp[2], cur\n",
    "        return dp[2]\n",
    "\n",
    "Solution2369().valid_partition(nums=[4,4,4,5,6])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 2483. Minimum Penalty for a Shop (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Time Limit Exceeded\n",
    "class Solution2483:\n",
    "    def best_closing_time(self, customers: str) -> int:\n",
    "        customers += '_'\n",
    "        n = len(customers)\n",
    "        penalty_min = float('inf')\n",
    "        penalty_min_idx = 0\n",
    "        for i, _ in enumerate(customers):\n",
    "            penalty = 0\n",
    "            for j in range(i):\n",
    "                if customers[j] == 'N':\n",
    "                    penalty += 1\n",
    "            for j in range(i, n):\n",
    "                if customers[j] == 'Y':\n",
    "                    penalty += 1\n",
    "            if penalty < penalty_min:\n",
    "                penalty_min = penalty\n",
    "                penalty_min_idx = i\n",
    "        return penalty_min_idx\n",
    "\n",
    "Solution2483().best_closing_time(customers='YYNY')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution2483_1:\n",
    "    def best_closing_time(self, customers: str) -> int:\n",
    "\n",
    "        customers = '_' + customers\n",
    "        n = len(customers)\n",
    "        prefix_penalty = [0] * n\n",
    "        cur_penalty = 0\n",
    "        penalty_min = float('inf')\n",
    "        penalty_min_idx = n - 1\n",
    "\n",
    "        for i, ch in enumerate(customers):\n",
    "            if ch == 'N':\n",
    "                cur_penalty += 1\n",
    "            prefix_penalty[i] = cur_penalty\n",
    "        customers = customers[1:] + '_'\n",
    "        cur_penalty = 0\n",
    "\n",
    "        for j in range(n-1, -1, -1):\n",
    "            if customers[j] == 'Y':\n",
    "                cur_penalty += 1\n",
    "            sum_penalty = cur_penalty + prefix_penalty[j]\n",
    "            if sum_penalty <= penalty_min:\n",
    "                penalty_min = sum_penalty\n",
    "                penalty_min_idx = j\n",
    "        \n",
    "        return penalty_min_idx\n",
    "\n",
    "Solution2483_1().best_closing_time(customers='YN')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution2483_2:\n",
    "    def best_closing_time(self, customers: str) -> int:\n",
    "\n",
    "        n = len(customers)\n",
    "        cnt = 0\n",
    "        prefix_penalty = [0] * (n + 1)\n",
    "        suffix_penalty = [0] * (n + 1)\n",
    "\n",
    "        for i, ch in enumerate(customers):\n",
    "            cnt += (ch == 'N')\n",
    "            prefix_penalty[i + 1] = cnt\n",
    "        \n",
    "        cnt = 0\n",
    "        for i, ch in enumerate(reversed(customers)):\n",
    "            cnt += (ch == 'Y')\n",
    "            suffix_penalty[i + 1] = cnt\n",
    "        \n",
    "        suffix_penalty.reverse()\n",
    "\n",
    "        best_hour, _ = min(enumerate(a + b for a, b in zip(prefix_penalty, suffix_penalty)), key=lambda x: x[1])\n",
    "\n",
    "        return best_hour\n",
    "\n",
    "Solution2483_2().best_closing_time(customers='YYNY')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Solution2483_3:\n",
    "    def best_closing_time(self, customers: str) -> int:\n",
    "        max_score = score = 0\n",
    "        best_hour = -1\n",
    "\n",
    "        for i, ch in enumerate(customers):\n",
    "            score += 1 if ch == 'Y' else -1\n",
    "            if score > max_score:\n",
    "                max_score, best_hour = score, i\n",
    "        \n",
    "        return best_hour + 1\n",
    "\n",
    "Solution2483_3().best_closing_time(customers='YYNY')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 2616. Minimize the Maximum Difference of Pairs (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 245,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution2616:\n",
    "    def minimize_max(self, nums: List[int], p: int) -> int:\n",
    "        nums.sort()\n",
    "        left, right = 0, nums[len(nums) - 1] - nums[0]\n",
    "        while left <= right:\n",
    "            mid = (left + right) // 2\n",
    "            pairs_count, i = 0, 1\n",
    "            while i < len(nums):\n",
    "                if nums[i] - nums[i - 1] <= mid:\n",
    "                    pairs_count += 1\n",
    "                    i += 1\n",
    "                i += 1\n",
    "            if pairs_count >= p:\n",
    "                right = mid - 1\n",
    "            else:\n",
    "                left = mid + 1\n",
    "        return left\n",
    "\n",
    "Solution2616().minimize_max(nums=[10,1,2,7,1,3], p=2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 2707. Extra Characters in a String (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution2707:\n",
    "    def min_extra_char(self, s: str, dictionary: List[str]) -> int:\n",
    "        n = len(s) + 1\n",
    "        dp = [0] * n\n",
    "        dict_set = set(dictionary)\n",
    "        for i in range(1, n):\n",
    "            dp[i] = dp[i - 1] + 1\n",
    "            for j in range(1, i + 1):\n",
    "                if s[i-j:i] in dict_set:\n",
    "                    dp[i] = min(dp[i], dp[i-j])\n",
    "        return dp[-1]\n",
    "\n",
    "Solution2707().min_extra_char(s='sayhelloworld', dictionary=['hello', 'world'])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 2865. Beautiful Towers I (Medium)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution2865:\n",
    "    def maximum_sum_of_heights(self, max_heights: List[int]) -> int:\n",
    "        ans = 0\n",
    "        for i, _ in enumerate(max_heights):\n",
    "            cur = [0] * len(max_heights)\n",
    "            cur[i] = max_heights[i]\n",
    "            for j in range(i-1, -1, -1):\n",
    "                cur[j] = min(max_heights[j], cur[j+1])\n",
    "            for k in range(i+1, len(max_heights)):\n",
    "                cur[k] = min(max_heights[k], cur[k-1])\n",
    "            ans = max(ans, sum(cur))\n",
    "        return ans\n",
    "\n",
    "Solution2865().maximum_sum_of_heights(max_heights=[5,3,4,1,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution2865_1:\n",
    "    def maximum_sum_of_heights(self, max_heights: List[int]) -> int:\n",
    "        def pre(arr):\n",
    "            for i in range(len(arr)-2, -1, -1):\n",
    "                if arr[i] <= arr[i+1]:\n",
    "                    continue\n",
    "                else:\n",
    "                    arr[i] = arr[i+1]\n",
    "            return sum(arr)\n",
    "        def post(arr):\n",
    "            for i in range(1, len(arr)):\n",
    "                if arr[i] <= arr[i-1]:\n",
    "                    continue\n",
    "                else:\n",
    "                    arr[i] = arr[i-1]\n",
    "            return sum(arr)\n",
    "        ans = 0\n",
    "        for i, _ in enumerate(max_heights):\n",
    "            ans_temp = pre(max_heights[0:i+1]) + post(max_heights[i:]) - max_heights[i]\n",
    "            ans = max(ans_temp, ans)\n",
    "        return ans\n",
    "\n",
    "Solution2865_1().maximum_sum_of_heights(max_heights=[6,5,3,9,2,7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "class Solution2865_2:\n",
    "    def maximum_sum_of_heights(self, max_heights: List[int]) -> int:\n",
    "        ans = 0\n",
    "        for i, _ in enumerate(max_heights):\n",
    "            cur = 0\n",
    "            left = max_heights[i]\n",
    "            right = max_heights[i]\n",
    "            for j in range(i, -1, -1):\n",
    "                cur += min(right, max_heights[j])\n",
    "                right = min(right, max_heights[j])\n",
    "            for j in range(i+1, len(max_heights)):\n",
    "                cur += min(left, max_heights[j])\n",
    "                left = min(left, max_heights[j])\n",
    "            ans = max(ans, cur)\n",
    "        return ans\n",
    "\n",
    "Solution2865_2().maximum_sum_of_heights(max_heights=[3,2,5,5,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "notebooks-source-env",
   "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.10.9"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "a14721e391bd93d2ef762652f16c6071f845f371ae1109f269ccebb74cbd8121"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}