Salve Array Problems.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "# Print alternate elements of an array\n",
    "def alternateArray(lst):\n",
    "    return [lst[i] for i in range(len(lst)) if i%2==0]\n",
    "\n",
    "print(alternateArray([1,2,3,4,5,6,7,8,9,10]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 10000]\n",
      "[1, 56789]\n"
     ]
    }
   ],
   "source": [
    "# Find minimum and maximum element in an array\n",
    "\n",
    "def findMaxAndMin(lst):\n",
    "    lst.sort()\n",
    "    minNum = lst[0]\n",
    "    maxNum = lst[-1]\n",
    "    return [minNum,maxNum]\n",
    "    \n",
    "print(findMaxAndMin([3,2 ,1, 56, 10000, 167]))\n",
    "print(findMaxAndMin([1 ,345, 234, 21, 56789]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "167\n",
      "345\n"
     ]
    }
   ],
   "source": [
    "# Find Second Largest\n",
    "\n",
    "def findSecondLargest(lst):\n",
    "    lst.sort()\n",
    "    return lst[-2]\n",
    "    \n",
    "print(findSecondLargest([3,2 ,1, 56, 10000, 167]))\n",
    "print(findSecondLargest([1 ,345, 234, 21, 56789]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10229\n",
      "57390\n"
     ]
    }
   ],
   "source": [
    "# Find Sum Of Array\n",
    "\n",
    "def findSumOfArray(lst):\n",
    "    return sum(lst)\n",
    "    \n",
    "print(findSumOfArray([3,2 ,1, 56, 10000, 167]))\n",
    "print(findSumOfArray([1 ,345, 234, 21, 56789]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 4, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "# Reverse the array \n",
    "def reverseArray(lst):\n",
    "    return lst[::-1]\n",
    "\n",
    "print(reverseArray([2,3,4,5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 10, 12, 14, 16, 18, 20, 2, 4, 6]\n"
     ]
    }
   ],
   "source": [
    "# Rotate Array\n",
    "def arrayRotate(arrayList,position):\n",
    "    rightArray = arrayList[position+1:]\n",
    "    leftArray = arrayList[:position+1]\n",
    "    return rightArray+leftArray\n",
    "    \n",
    "    \n",
    "print(arrayRotate([2, 4, 6, 8, 10, 12, 14, 16, 18, 20],2))   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Count of smaller elements\n",
    "def countSmallerElements(arrayList,element):\n",
    "    smallerCount = 0;\n",
    "    for value in arrayList:\n",
    "        if(value <= element):\n",
    "            smallerCount = smallerCount+1;\n",
    "            \n",
    "    return smallerCount\n",
    "            \n",
    "print(countSmallerElements([1, 2, 4, 5, 8, 10],9))   \n",
    "print(countSmallerElements([1, 2, 2, 2, 5, 7, 9],2))   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2}\n",
      "{1, 2}\n"
     ]
    }
   ],
   "source": [
    "# Remove duplicate elements from sorted Array 1\n",
    "def remove_duplicate(arrayList):\n",
    "    return set(arrayList)\n",
    "    \n",
    "print(remove_duplicate([2, 2, 2, 2, 2 ]))\n",
    "print(remove_duplicate([1, 2, 2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2]\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "# Remove duplicate elements from sorted Array 2\n",
    "def remove_duplicate1(arrayList):\n",
    "    new_Array = []\n",
    "    for value in arrayList:\n",
    "        if(value not in new_Array):\n",
    "            new_Array.append(value)\n",
    "    return new_Array     \n",
    "    \n",
    "print(remove_duplicate1([2, 2, 2, 2, 2 ]))\n",
    "print(remove_duplicate1([1, 2, 2,3,3,4,4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[17, 5, 2]\n",
      "[4, 0]\n"
     ]
    }
   ],
   "source": [
    "# Leaders in an array\n",
    "def LeadersArray(arrayList):\n",
    "    leaderElements = []\n",
    "    for i in range(len(arrayList)):\n",
    "        tempLeader = arrayList[i]\n",
    "        isGreater = 0\n",
    "        for j in range(i,len(arrayList)):\n",
    "            if(not(tempLeader>=arrayList[j])):\n",
    "                isGreater = 1\n",
    "        if(not(isGreater)):\n",
    "            leaderElements.append(tempLeader)\n",
    "            \n",
    "    return leaderElements\n",
    "    \n",
    "    \n",
    "    \n",
    "print(LeadersArray([16, 17, 4, 3, 5, 2]))\n",
    "print(LeadersArray([1, 2, 3, 4, 0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# Majority Element\n",
    "def MajorityElements(arrayList):\n",
    "    dist = {}\n",
    "    for i in range(len(arrayList)):\n",
    "        count = 0\n",
    "        for value in arrayList:\n",
    "            if(arrayList[i] == value):\n",
    "                count = count+1\n",
    "        dist[arrayList[i]]=count\n",
    "      \n",
    "    sortedList = {k: v for k, v in sorted(dist.items(), key=lambda item: item[1])}\n",
    "    if(len(arrayList)/2  < list(dist.values())[0]):\n",
    "        print(list(dist.keys())[0])\n",
    "    else:\n",
    "        print(-1)\n",
    "        \n",
    "        \n",
    "\n",
    "MajorityElements([3, 1, 3, 3, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3]\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "def findDuplicate(arrayList):\n",
    "    dist = {};\n",
    "    duplicate_List = []\n",
    "    for i in range(len(arrayList)):\n",
    "        count = 0;\n",
    "        for value in arrayList:\n",
    "            if(arrayList[i] == value):\n",
    "                count = count +1;\n",
    "        dist[arrayList[i]]=count\n",
    "    for key, value in dist.items():\n",
    "        if(value > 1):\n",
    "            duplicate_List.append(key)\n",
    "    if(len(duplicate_List)>0):\n",
    "        return duplicate_List\n",
    "    else:\n",
    "        return -1\n",
    "\n",
    "print(findDuplicate([2, 3, 1, 2, 3]))\n",
    "print(findDuplicate([0, 3, 1, 2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "# Smallest Starting element \n",
    "def smallestStartingElement(arrList):\n",
    "    for i in range(len(arrList)):\n",
    "        if(arrList[i]<arrList[i+1]):\n",
    "            return arrList[i]\n",
    "        \n",
    "print(smallestStartingElement([100, 180, 260, 310, 40, 535, 695]))\n",
    "print(smallestStartingElement([23, 13, 25, 29, 33, 19, 34, 45, 65, 67]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Indices [1, 3]\n"
     ]
    }
   ],
   "source": [
    "# Given an array of integers, return indices of the two numbers such that they add up to a specific target.\n",
    "# You may assume that each input would have exactly one solution, and you may not use the same element twice.\n",
    "\n",
    "def getSum(arr,sumRes):\n",
    "    set = tuple()\n",
    "    for i in range(len(arr)):\n",
    "        for j in range(len(arr)):\n",
    "            if(arr[i]+arr[j] == sumRes):\n",
    "                return [i,j]\n",
    "                break;\n",
    "    \n",
    "    return 0\n",
    "    \n",
    "print(\"Indices\",getSum([2,3,5,7],10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 10, 12, 14, 16]\n"
     ]
    }
   ],
   "source": [
    "# todo: Merse the Sorted Array 1 type\n",
    "array1 = [1,2,3,4,10]\n",
    "array2 = [12,14,16]\n",
    "\n",
    "print(array1+array2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merged Array\n",
      "[1, 2, 3, 4, 5, 6, 10, 11, 12, 16, 18, 20, 30, 40]\n"
     ]
    }
   ],
   "source": [
    "# todo: Merse the Sorted Array 2 type\n",
    "# n = int(input(\"Enter the size of list array1 : \"))\n",
    "# array1 = list(map(int, input(\"Enter the list numbers separated by space : \").strip().split()))[:n]\n",
    "\n",
    "# n = int(input(\"Enter the size of list array2 : \"))\n",
    "# array2 = list(map(int, input(\"Enter the list numbers separated by space : \").strip().split()))[:n]\n",
    "# print(\"array2: \", array2)\n",
    "\n",
    "array1 = [1,2,3,4,10,11,12]\n",
    "array2 = [5,6,16,18,20,30,40]\n",
    "\n",
    "newArray = [];\n",
    "for i in range(len(array1)+len(array2)):\n",
    "    if(i<len(array1)):\n",
    "        newArray.insert(i,array1[i])\n",
    "    else:\n",
    "        newArray.insert(i,array2[i-len(array1)])\n",
    "\n",
    "        \n",
    "print('Merged Array')\n",
    "newArray.sort()\n",
    "print(newArray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merged Array\n",
      "[1, 2, 5, 6, 10, 11, 16, 18, 20, 30, 40, 50, 100, 101, 102]\n"
     ]
    }
   ],
   "source": [
    "# # todo: Merse the Sorted Array 3 type\n",
    "# n = int(input(\"Enter the size of list array1 : \"))\n",
    "# array1 = list(map(int, input(\"Enter the list numbers separated by space : \").strip().split()))[:n]\n",
    "\n",
    "# n = int(input(\"Enter the size of list array2 : \"))\n",
    "# array2 = list(map(int, input(\"Enter the list numbers separated by space : \").strip().split()))[:n]\n",
    "# print(\"array2: \", array2)\n",
    "\n",
    "array1 = [1,2,11,50,101]\n",
    "array2 = [5,6,10,16,18,20,30,40,100,102]\n",
    "j=0\n",
    "k=0\n",
    "newArray = [];\n",
    "for i in range(len(array1)+len(array2)):\n",
    "    if((len(array1)>j) and (len(array2)>k)):\n",
    "        if((array1[j] <= array2[k])):\n",
    "            newArray.insert(i,array1[j])\n",
    "            j = j+1\n",
    "        else:\n",
    "            newArray.insert(i,array2[k])\n",
    "            k = k+1\n",
    "    else:\n",
    "        if((len(array1)>j)):\n",
    "            newArray.insert(i,array1[j])\n",
    "            j = j+1\n",
    "        else:\n",
    "            newArray.insert(i,array2[k])\n",
    "            k = k+1\n",
    "        \n",
    "        \n",
    "print('Merged Array')\n",
    "print(newArray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maxSUbArray Index -> [0, 2] -> with max sum -> 8\n",
      "maxSUbArray Index -> [11, 14] -> with max sum -> 17\n",
      "maxSUbArray Index -> [9, 11] -> with max sum -> 16\n"
     ]
    }
   ],
   "source": [
    "# Maximum Sub Array\n",
    "def summation(indexesLink,nums):\n",
    "    sumVal = 0\n",
    "    for i in range(indexesLink[0],indexesLink[1]+1):\n",
    "        sumVal += nums[i]\n",
    "        \n",
    "    return sumVal\n",
    "\n",
    "def MaximumSubArray(nums):\n",
    "    numsList = []\n",
    "    initial = 0\n",
    "    last = 0\n",
    "    sumList = []\n",
    "    for i in range(len(nums)):\n",
    "        if(nums[i] <= 0):\n",
    "            if((initial != last) and (initial < last)):\n",
    "                numsList.append([initial,last])\n",
    "                sumList.append(summation([initial,last],nums))\n",
    "            initial = i+1\n",
    "        last = i\n",
    "    if((initial != last) and (initial < last)):\n",
    "        numsList.append([initial,last])\n",
    "        sumList.append(summation([initial,last],nums))\n",
    "    \n",
    "    maxIndex = sumList.index(max(sumList)) \n",
    "    print('maxSUbArray Index ->',numsList[maxIndex],'-> with max sum ->',max(sumList))\n",
    "    \n",
    "\n",
    "\n",
    "MaximumSubArray([1, 2, 5, -7, 2, 3,-1,2])\n",
    "MaximumSubArray([1,2,-1, 2, 5, -7, 2, 3,2,1,-1,10,2,4,1])\n",
    "MaximumSubArray([-1, 2, 5, -7, 2, 3,2,1,-1,10,2,4,-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "# Link https://practice.geeksforgeeks.org/problems/sorted-subsequence-of-size-3/1\n",
    "# Sorted subsequence of size 3\n",
    "def find3Numbers(nums):\n",
    "    minIndex = 0;\n",
    "    minList = []\n",
    "    minList.append(nums[minIndex])\n",
    "    for i in range(len(nums)-1):\n",
    "        if(nums[minIndex]<nums[i+1]):\n",
    "            minList.append(nums[i+1])\n",
    "            minIndex = i+1\n",
    "    \n",
    "    if(len(minList)>= 3):\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "            \n",
    "    \n",
    "    \n",
    "\n",
    "print(find3Numbers([1,2,1,1,3,2,4,1,0,5,2,1,0]))\n",
    "print(find3Numbers([1,1,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Missing Elements -> [2, 4, 5, 6, 7, 9]\n",
      "Repeating Elements -> [3, 8]\n"
     ]
    }
   ],
   "source": [
    "# Find Missing And Repeating\n",
    "def FindMissingAndRepeating(nums):\n",
    "    missingEle = []\n",
    "    repetingEle = []\n",
    "    for i in range(1,max(nums)+1):\n",
    "        if(i not in nums):\n",
    "            missingEle.append(i)\n",
    "     \n",
    "    for j in range(len(nums)):\n",
    "        tempEle = nums.pop(j)\n",
    "        if(tempEle in nums):\n",
    "            if(tempEle not in repetingEle):\n",
    "                repetingEle.append(tempEle)\n",
    "        nums.insert(j,tempEle)\n",
    "        \n",
    "            \n",
    "    print('Missing Elements ->',missingEle)\n",
    "    print('Repeating Elements ->',repetingEle)\n",
    "            \n",
    "FindMissingAndRepeating([1,3,3,8,8,10])        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 3, 0, 4]\n"
     ]
    }
   ],
   "source": [
    "# Remove Element\n",
    "def removeElement(arr,removeEle):\n",
    "    newArr = []\n",
    "    for i in range(len(arr)):\n",
    "        if(arr[i] != removeEle):\n",
    "            newArr.append(arr[i])\n",
    "            \n",
    "    print(newArr)\n",
    "\n",
    "removeElement([0,1,2,2,3,0,4,2],2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 5, 4, 3, 1, 2]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def reverseArray(arr):\n",
    "    for i in range(len(arr)-1):\n",
    "        for j in range(len(arr)-i-1):\n",
    "            temp = arr[j]\n",
    "            arr[j] = arr[j+1]\n",
    "            arr[j+1] = temp\n",
    "    return arr\n",
    "\n",
    "reverseArray([2,1,3,4,5,6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Majority Element type -> 2 modified solution \n",
    "def MajorityElements(arrayList):\n",
    "    dist  = dict()\n",
    "    for i in range(len(arrayList)):\n",
    "        if(arrayList[i] in dist):\n",
    "            dist[arrayList[i]]=dist[arrayList[i]] +1\n",
    "        else:\n",
    "            dist[arrayList[i]]=1\n",
    "        if(dist[arrayList[i]] == (len(arrayList)//2)+1):\n",
    "            return arrayList[i]\n",
    "\n",
    "    return -1\n",
    "\n",
    "print(MajorityElements([3, 1, 3, 3, 2]))\n",
    "print(MajorityElements([2,2,1,1,1,2,2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'lovely'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "709. To Lower Case\n",
    "Implement function ToLowerCase() that has a string parameter str, and returns the same string in lowercase.\n",
    "\n",
    "Input: \"Hello\"\n",
    "Output: \"hello\"\n",
    "\"\"\"\n",
    "from typing import List \n",
    "def toLowerCase(str: str) -> str:\n",
    "    ASCII = [ord(c)  for c in str]\n",
    "    ASCII \n",
    "    Char_list = []\n",
    "    for i in ASCII :\n",
    "        if  i >= 97 and i<=122 :\n",
    "            Char_list.append(chr(i))\n",
    "        elif i >= 65 and i<=90 : ## capital to small\n",
    "            Char_list.append(chr(i+32))\n",
    "        else:\n",
    "            Char_list.append(chr(i))\n",
    "\n",
    "\n",
    "    Changed =''.join(Char_list)\n",
    "    return Changed\n",
    "\n",
    "toLowerCase(\"LOVELY\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "1295. Find Numbers with Even Number of Digits\n",
    "\n",
    "Given an array nums of integers, return how many of them contain an even number of digits.\n",
    " \n",
    "Input: nums = [12,345,2,6,7896]\n",
    "Output: 2\n",
    "\n",
    "Explanation: \n",
    "12 contains 2 digits (even number of digits). \n",
    "345 contains 3 digits (odd number of digits). \n",
    "2 contains 1 digit (odd number of digits). \n",
    "6 contains 1 digit (odd number of digits). \n",
    "7896 contains 4 digits (even number of digits). \n",
    "Therefore only 12 and 7896 contain an even number of digits.\n",
    "\n",
    "\"\"\"\n",
    "from typing import List\n",
    "def findNumbers(nums: List[int]) -> int:\n",
    "    count = 0\n",
    "    for i in nums:\n",
    "        digitCount = 0\n",
    "        temp = i;\n",
    "        while temp > 0:\n",
    "            temp = temp // 10\n",
    "            digitCount +=1\n",
    "        if digitCount % 2 == 0 :\n",
    "            count +=1\n",
    "    return count\n",
    "\n",
    "print(findNumbers([12,345,2,6,7896]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "1394. Find Lucky Integer in an Array\n",
    "\n",
    "Given an array of integers arr, a lucky integer is an integer which has a frequency in the array equal to its value.\n",
    "\n",
    "Return a lucky integer in the array. If there are multiple lucky integers return the largest of them. If there is no lucky integer return -1.\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input: arr = [2,2,3,4]\n",
    "Output: 2\n",
    "Explanation: The only lucky number in the array is 2 because frequency[2] == 2.\n",
    "\n",
    "Example 2:\n",
    "\n",
    "Input: arr = [1,2,2,3,3,3]\n",
    "Output: 3\n",
    "\n",
    "Explanation: 1, 2 and 3 are all lucky numbers, return the largest of them.\n",
    "\"\"\"\n",
    "from typing import List\n",
    "class Solution:\n",
    "    def findLucky(self, arr: List[int]) -> int:\n",
    "        Hash = dict()\n",
    "        luckyNum = []\n",
    "        for i in range(len(arr)):\n",
    "            if arr[i] not in Hash:\n",
    "                Hash[arr[i]] = 1\n",
    "            else:\n",
    "                Hash[arr[i]] = Hash[arr[i]] + 1\n",
    "                \n",
    "            if Hash[arr[i]] == arr[i] and arr[i] not in luckyNum:\n",
    "                luckyNum.append(arr[i])\n",
    "            elif arr[i] in luckyNum and Hash[arr[i]] > arr[i]:\n",
    "                luckyNum.remove(arr[i])\n",
    "                \n",
    "        if len(luckyNum) != 0:\n",
    "            return max(luckyNum)\n",
    "        else:\n",
    "            return -1\n",
    "\n",
    "sol = Solution()\n",
    "print(sol.findLucky([2,2,3,4]))\n",
    "print(sol.findLucky([1,2,2,3,3,3]))\n",
    "print(sol.findLucky([2,2,2,3,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n",
      "0\n",
      "0\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "1450. Number of Students Doing Homework at a Given Time\n",
    "\n",
    "Given two integer arrays startTime and endTime and given an integer queryTime.\n",
    "\n",
    "The ith student started doing their homework at the time startTime[i] and finished it at time endTime[i].\n",
    "\n",
    "Return the number of students doing their homework at time queryTime. More formally, return the number of students where queryTime lays in the interval [startTime[i], endTime[i]] inclusive.\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input: startTime = [1,2,3], endTime = [3,2,7], queryTime = 4\n",
    "Output: 1\n",
    "Explanation: We have 3 students where:\n",
    "The first student started doing homework at time 1 and finished at time 3 and wasn't doing anything at time 4.\n",
    "The second student started doing homework at time 2 and finished at time 2 and also wasn't doing anything at time 4.\n",
    "The third student started doing homework at time 3 and finished at time 7 and was the only student doing homework at time 4.\n",
    "Example 2:\n",
    "\n",
    "Input: startTime = [4], endTime = [4], queryTime = 4\n",
    "Output: 1\n",
    "Explanation: The only student was doing their homework at the queryTime.\n",
    "\n",
    "Example 3:\n",
    "\n",
    "Input: startTime = [4], endTime = [4], queryTime = 5\n",
    "Output: 0\n",
    "\n",
    "Example 4:\n",
    "\n",
    "Input: startTime = [1,1,1,1], endTime = [1,3,2,4], queryTime = 7\n",
    "Output: 0\n",
    "\n",
    "Example 5:\n",
    "\n",
    "Input: startTime = [9,8,7,6,5,4,3,2,1], endTime = [10,10,10,10,10,10,10,10,10], queryTime = 5\n",
    "Output: 5\n",
    " \n",
    "\n",
    "Constraints:\n",
    "\n",
    "startTime.length == endTime.length\n",
    "1 <= startTime.length <= 100\n",
    "1 <= startTime[i] <= endTime[i] <= 1000\n",
    "1 <= queryTime <= 1000\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "from typing import List\n",
    "class Solution:\n",
    "    def busyStudent(self, startTime: List[int], endTime: List[int], queryTime: int) -> int:\n",
    "        hardwork = 0\n",
    "        for i in range(len(startTime)):\n",
    "            if startTime[i] <= queryTime and endTime[i] >= queryTime :\n",
    "                hardwork +=1\n",
    "        return hardwork\n",
    "    \n",
    "sol = Solution()\n",
    "print(sol.busyStudent([1,2,3],[3,2,7],4))\n",
    "print(sol.busyStudent([4],[4],4))\n",
    "print(sol.busyStudent([4],[4],5))\n",
    "print(sol.busyStudent([1,1,1,1],[1,3,2,4],7))\n",
    "print(sol.busyStudent([9,8,7,6,5,4,3,2,1],[10,10,10,10,10,10,10,10,10],5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "26. Remove Duplicates from Sorted Array\n",
    "\n",
    "Given a sorted array nums, remove the duplicates in-place such that each element appear only once and return the new length.\n",
    "\n",
    "Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Given nums = [1,1,2],\n",
    "\n",
    "Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively.\n",
    "\n",
    "It doesn't matter what you leave beyond the returned length.\n",
    "Example 2:\n",
    "\n",
    "Given nums = [0,0,1,1,1,2,2,3,3,4],\n",
    "\n",
    "Your function should return length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively.\n",
    "\n",
    "It doesn't matter what values are set beyond the returned length.\n",
    "Clarification:\n",
    "\n",
    "Confused why the returned value is an integer but your answer is an array?\n",
    "\n",
    "Note that the input array is passed in by reference, which means modification to the input array will be known to the caller as well.\n",
    "\n",
    "Internally you can think of this:\n",
    "\n",
    "// nums is passed in by reference. (i.e., without making a copy)\n",
    "int len = removeDuplicates(nums);\n",
    "\n",
    "// any modification to nums in your function would be known by the caller.\n",
    "// using the length returned by your function, it prints the first len elements.\n",
    "for (int i = 0; i < len; i++) {\n",
    "    print(nums[i]);\n",
    "}\n",
    "\"\"\"\n",
    "from typing import List\n",
    "class Solution:\n",
    "    def removeDuplicates(self, nums: List[int]) -> int:\n",
    "        len_ = 1\n",
    "        if len(nums)==0:\n",
    "            return 0\n",
    "        for i in range(1,len(nums)):\n",
    "            if nums[i] != nums[i-1]:\n",
    "#                 print(nums[len_],nums[i])\n",
    "                nums[len_] = nums[i]\n",
    "                len_ +=1\n",
    "        return len_\n",
    "\n",
    "sol = Solution()\n",
    "print(sol.removeDuplicates([0,0,1,1,1,2,2,3,3,4]))\n",
    "print(sol.removeDuplicates([0,0,1]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HBeoyytse\n",
      "NBihsuhsahnatn\n"
     ]
    }
   ],
   "source": [
    "# todo: Merge two strings Day 4\n",
    "# link: https://practice.geeksforgeeks.org/problems/merge-two-strings/0\n",
    "def split(str):\n",
    "    return [char for char in str];\n",
    "\n",
    "def mergeAltString(strList):\n",
    "    stringCount1 = 0;\n",
    "    stringCount2 = 0;\n",
    "    newString = []\n",
    "    for i in range(len(strList[0])+len(strList[1])):\n",
    "        if(len(strList[0]) == stringCount1):\n",
    "            newString.append(strList[1][stringCount2])\n",
    "            stringCount2 = stringCount2+1\n",
    "            \n",
    "        elif(len(strList[1]) == stringCount2): \n",
    "            newString.append(strList[0][stringCount1]) \n",
    "            stringCount1 = stringCount1+1\n",
    "        else:\n",
    "            if(i%2==0):\n",
    "                newString.append(strList[0][stringCount1]) \n",
    "                stringCount1 = stringCount1+1\n",
    "            else:\n",
    "                newString.append(strList[1][stringCount2])\n",
    "                stringCount2 = stringCount2+1\n",
    "    print(\"\".join(newString))\n",
    "\n",
    "\n",
    "def mergeString(strArray):\n",
    "    for strArr in strArray:\n",
    "        arrayData = []\n",
    "        strA = strArr.split()\n",
    "    #     print(strA)\n",
    "        for strD in strA:\n",
    "            strArray = split(strD);\n",
    "            arrayData.append(strArray)\n",
    "        mergeAltString(arrayData)\n",
    "    \n",
    "mergeString(['Heyte Boys','Nishant Bhushan'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 6, 10]\n",
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "1480. Running Sum of 1d Array\n",
    "\n",
    "Given an array nums. We define a running sum of an array as runningSum[i] = sum(nums[0]…nums[i]).\n",
    "\n",
    "Return the running sum of nums.\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input: nums = [1,2,3,4]\n",
    "Output: [1,3,6,10]\n",
    "Explanation: Running sum is obtained as follows: [1, 1+2, 1+2+3, 1+2+3+4].\n",
    "\n",
    "Example 2:\n",
    "\n",
    "Input: nums = [1,1,1,1,1]\n",
    "Output: [1,2,3,4,5]\n",
    "Explanation: Running sum is obtained as follows: [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1].\n",
    "\"\"\"\n",
    "\n",
    "from typing import List\n",
    "class Solution:\n",
    "    def runningSum(self, nums: List[int]) -> List[int]:\n",
    "        runningSum = []\n",
    "        for i in range(len(nums)):\n",
    "            runningSum.append(sum(nums[:i+1]))\n",
    "        return runningSum\n",
    "    \n",
    "sol = Solution()\n",
    "print(sol.runningSum([1,2,3,4]))\n",
    "print(sol.runningSum([1,1,1,1,1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 4, 1, 7]\n",
      "[1, 4, 2, 3, 3, 2, 4, 1]\n",
      "[1, 2, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "1470. Shuffle the Array\n",
    "\n",
    "Given the array nums consisting of 2n elements in the form [x1,x2,...,xn,y1,y2,...,yn].\n",
    "\n",
    "Return the array in the form [x1,y1,x2,y2,...,xn,yn].\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input: nums = [2,5,1,3,4,7], n = 3\n",
    "Output: [2,3,5,4,1,7] \n",
    "Explanation: Since x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 then the answer is [2,3,5,4,1,7].\n",
    "Example 2:\n",
    "\n",
    "Input: nums = [1,2,3,4,4,3,2,1], n = 4\n",
    "Output: [1,4,2,3,3,2,4,1]\n",
    "Example 3:\n",
    "\n",
    "Input: nums = [1,1,2,2], n = 2\n",
    "Output: [1,2,1,2]\n",
    "\"\"\"\n",
    "from typing import List\n",
    "class Solution:\n",
    "    def shuffle(self, nums: List[int], n: int) -> List[int]:\n",
    "        newNums = []\n",
    "        for i in range(n):\n",
    "            newNums.append(nums[i])\n",
    "            newNums.append(nums[i+n])\n",
    "        return newNums\n",
    "    \n",
    "sol = Solution()\n",
    "print(sol.shuffle([2,5,1,3,4,7],3))\n",
    "print(sol.shuffle([1,2,3,4,4,3,2,1],4))\n",
    "print(sol.shuffle([1,1,2,2],2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "16\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "1464. Maximum Product of Two Elements in an Array\n",
    "\n",
    "Given the array of integers nums, you will choose two different indices i and j of that array. Return the maximum value of (nums[i]-1)*(nums[j]-1).\n",
    " \n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input: nums = [3,4,5,2]\n",
    "Output: 12 \n",
    "Explanation: If you choose the indices i=1 and j=2 (indexed from 0), you will get the maximum value, that is, (nums[1]-1)*(nums[2]-1) = (4-1)*(5-1) = 3*4 = 12. \n",
    "Example 2:\n",
    "\n",
    "Input: nums = [1,5,4,5]\n",
    "Output: 16\n",
    "Explanation: Choosing the indices i=1 and j=3 (indexed from 0), you will get the maximum value of (5-1)*(5-1) = 16.\n",
    "Example 3:\n",
    "\n",
    "Input: nums = [3,7]\n",
    "Output: 12\n",
    " \n",
    "\n",
    "Constraints:\n",
    "\n",
    "2 <= nums.length <= 500\n",
    "1 <= nums[i] <= 10^3\n",
    "\n",
    "\"\"\"\n",
    "from typing import List\n",
    "\n",
    "class Solution:\n",
    "    def maxProduct(self, nums: List[int]) -> int:\n",
    "        maxValue = 0\n",
    "        prod = 0\n",
    "        for i in range(len(nums)):\n",
    "            for j in range(len(nums)):\n",
    "                if j == i:\n",
    "                    continue;\n",
    "                prod = (nums[i]-1) * (nums[j]-1)\n",
    "                if prod > maxValue:\n",
    "                    maxValue = prod\n",
    "        return maxValue\n",
    "                \n",
    "            \n",
    "        \n",
    "sol = Solution()\n",
    "\n",
    "print(sol.maxProduct([3,4,5,2]))\n",
    "print(sol.maxProduct([1,5,4,5]))\n",
    "print(sol.maxProduct([3,7]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "8\n",
      "7\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "1486. XOR Operation in an Array\n",
    "\n",
    "Given an integer n and an integer start.\n",
    "\n",
    "Define an array nums where nums[i] = start + 2*i (0-indexed) and n == nums.length.\n",
    "\n",
    "Return the bitwise XOR of all elements of nums.\n",
    " \n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input: n = 5, start = 0\n",
    "Output: 8\n",
    "Explanation: Array nums is equal to [0, 2, 4, 6, 8] where (0 ^ 2 ^ 4 ^ 6 ^ 8) = 8.\n",
    "Where \"^\" corresponds to bitwise XOR operator.\n",
    "\n",
    "\n",
    "Example 2:\n",
    "\n",
    "Input: n = 4, start = 3\n",
    "Output: 8\n",
    "Explanation: Array nums is equal to [3, 5, 7, 9] where (3 ^ 5 ^ 7 ^ 9) = 8.\n",
    "Example 3:\n",
    "\n",
    "Input: n = 1, start = 7\n",
    "Output: 7\n",
    "\n",
    "\n",
    "Example 4:\n",
    "\n",
    "Input: n = 10, start = 5\n",
    "Output: 2\n",
    " \n",
    "\n",
    "Constraints:\n",
    "\n",
    "1 <= n <= 1000\n",
    "0 <= start <= 1000\n",
    "n == nums.length\n",
    "\"\"\"\n",
    "from typing import List\n",
    "from functools import reduce\n",
    "class Solution:\n",
    "    def xorOperation(self, n: int, start: int) -> int:\n",
    "        lst = [start+2*i for i in range(n)]\n",
    "#         print(lst)\n",
    "        res = reduce(lambda x, y: x ^ y, lst) \n",
    "        return res\n",
    "                \n",
    "sol = Solution()\n",
    "print(sol.xorOperation(5,0))\n",
    "print(sol.xorOperation(4,3))\n",
    "print(sol.xorOperation(1,7))\n",
    "print(sol.xorOperation(10,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "27. Remove Element\n",
    "\n",
    "Given an array nums and a value val, remove all instances of that value in-place and return the new length.\n",
    "\n",
    "Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.\n",
    "\n",
    "The order of elements can be changed. It doesn't matter what you leave beyond the new length.\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Given nums = [3,2,2,3], val = 3,\n",
    "\n",
    "Your function should return length = 2, with the first two elements of nums being 2.\n",
    "\n",
    "It doesn't matter what you leave beyond the returned length.\n",
    "Example 2:\n",
    "\n",
    "Given nums = [0,1,2,2,3,0,4,2], val = 2,\n",
    "\n",
    "Your function should return length = 5, with the first five elements of nums containing 0, 1, 3, 0, and 4.\n",
    "\n",
    "Note that the order of those five elements can be arbitrary.\n",
    "\n",
    "It doesn't matter what values are set beyond the returned length.\n",
    "Clarification:\n",
    "\n",
    "Confused why the returned value is an integer but your answer is an array?\n",
    "\n",
    "Note that the input array is passed in by reference, which means modification to the input array will be known to the caller as well.\n",
    "\"\"\"\n",
    "from typing import List\n",
    "class Solution:\n",
    "    def removeElement(self, nums: List[int], val: int) -> int:\n",
    "        while val in nums:\n",
    "            nums.remove(val)\n",
    "        return len(nums)\n",
    "    \n",
    "sol = Solution()\n",
    "print(sol.removeElement([3,2,2,3],3))\n",
    "print(sol.removeElement([0,1,2,2,3,0,4,2],2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n",
      "4\n",
      "0\n",
      "1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "35. Search Insert Position\n",
    "\n",
    "Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.\n",
    "\n",
    "You may assume no duplicates in the array.\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input: [1,3,5,6], 5\n",
    "Output: 2\n",
    "Example 2:\n",
    "\n",
    "Input: [1,3,5,6], 2\n",
    "Output: 1\n",
    "Example 3:\n",
    "\n",
    "Input: [1,3,5,6], 7\n",
    "Output: 4\n",
    "Example 4:\n",
    "\n",
    "Input: [1,3,5,6], 0\n",
    "Output: 0\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "from typing import List\n",
    "class Solution:\n",
    "    def searchInsert(self, nums: List[int], target: int) -> int:\n",
    "        \n",
    "        if target <= nums[0]:\n",
    "            return 0\n",
    "        if target > nums[-1]:\n",
    "            return len(nums)\n",
    "        \n",
    "        for i in range(len(nums)):\n",
    "            if nums[i]>=target :\n",
    "                return i\n",
    "        \n",
    "sol = Solution()\n",
    "print(sol.searchInsert([1,3,5,6],5))\n",
    "print(sol.searchInsert([1,3,5,6],2)) \n",
    "print(sol.searchInsert([1,3,5,6],7)) \n",
    "print(sol.searchInsert([1,3,5,6],0)) \n",
    "print(sol.searchInsert([1,3],2))   \n",
    "print(sol.searchInsert([1,3],3))   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, -1, 1, -2, 2]\n",
      "[0, -1, 1]\n",
      "[0]\n",
      "[-1, 1, -2, 2, -3, 3, -4, 4, -5, 5]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "1304. Find N Unique Integers Sum up to Zero\n",
    "\n",
    "Given an integer n, return any array containing n unique integers such that they add up to 0.\n",
    "\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input: n = 5\n",
    "Output: [-7,-1,1,3,4]\n",
    "Explanation: These arrays also are accepted [-5,-1,1,2,3] , [-3,-1,2,-2,4].\n",
    "\n",
    "\n",
    "Example 2:\n",
    "\n",
    "Input: n = 3\n",
    "Output: [-1,0,1]\n",
    "\n",
    "\n",
    "Example 3:\n",
    "\n",
    "Input: n = 1\n",
    "Output: [0]\n",
    " \n",
    "\n",
    "Constraints:\n",
    "\n",
    "1 <= n <= 1000\n",
    "\"\"\"\n",
    "\n",
    "from typing import List\n",
    "class Solution:\n",
    "    def sumZero(self, n: int) -> List[int]:\n",
    "        if n&1:\n",
    "            arr = [0]\n",
    "            for i in range(1,n//2+1):\n",
    "                # print(arr)\n",
    "                arr.extend([-i,i])\n",
    "            \n",
    "        else:\n",
    "            arr = []\n",
    "            for i in range(1,n//2+1):\n",
    "                arr.extend([-i,i])\n",
    "                \n",
    "        return arr\n",
    "            \n",
    "        \n",
    "sol = Solution()\n",
    "print(sol.sumZero(5))\n",
    "print(sol.sumZero(3))\n",
    "print(sol.sumZero(1))\n",
    "print(sol.sumZero(10))        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 3, 1]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "905. Sort Array By Parity\n",
    "\n",
    "Given an array A of non-negative integers, return an array consisting of all the even elements of A, followed by all the odd elements of A.\n",
    "\n",
    "You may return any answer array that satisfies this condition.\n",
    "\n",
    " \n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input: [3,1,2,4]\n",
    "Output: [2,4,3,1]\n",
    "The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.\n",
    " \n",
    "\n",
    "Note:\n",
    "\n",
    "1 <= A.length <= 5000\n",
    "0 <= A[i] <= 5000\n",
    "\"\"\"\n",
    "from typing import List\n",
    "class Solution:\n",
    "    def sortArrayByParity(self, A: List[int]) -> List[int]:\n",
    "        odd = []\n",
    "        even = []\n",
    "        for i in range(len(A)):\n",
    "            if 1&A[i]:\n",
    "                odd.append(A[i])\n",
    "            else:\n",
    "                even.append(A[i])\n",
    "        return even+odd\n",
    "        \n",
    "\n",
    "sol = Solution()\n",
    "print(sol.sortArrayByParity([3,1,2,4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['4', '3', '2', '2']\n",
      "['1', '2', '4']\n",
      "['1', '0']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Plus One\n",
    "\n",
    "Given a non-empty array of digits representing a non-negative integer, plus one to the integer.\n",
    "\n",
    "The digits are stored such that the most significant digit is at the head of the list, and each element in the array contain a single digit.\n",
    "\n",
    "You may assume the integer does not contain any leading zero, except the number 0 itself.\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input: [1,2,3]\n",
    "Output: [1,2,4]\n",
    "Explanation: The array represents the integer 123.\n",
    "\n",
    "\n",
    "Example 2:\n",
    "\n",
    "Input: [4,3,2,1]\n",
    "Output: [4,3,2,2]\n",
    "Explanation: The array represents the integer 4321.\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "from typing import List\n",
    "class Solution:\n",
    "    \n",
    "    def arrayToNumber(self,lst: List[int]) -> int :\n",
    "        s = 0\n",
    "        for i in range(len(lst)): \n",
    "            s = s*10+lst[i]\n",
    "        return s\n",
    "            \n",
    "    \n",
    "    def plusOne(self, digits: List[int]) -> List[int]:\n",
    "        newD = self.arrayToNumber(digits)\n",
    "        sumed = newD+1\n",
    "        return list(str(sumed))\n",
    "        \n",
    "        \n",
    "sol = Solution()\n",
    "print(sol.plusOne([4,3,2,1]))\n",
    "print(sol.plusOne([1,2,3]))\n",
    "print(sol.plusOne([9]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 12, 0, 0]\n",
      "[1, 0, 0]\n",
      "\n",
      "\n",
      "[1, 3, 12, 0, 0]\n",
      "[1, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "283. Move Zeroes\n",
    "\n",
    "Given an array nums, write a function to move all 0's to the end of it while maintaining the relative order of the non-zero elements.\n",
    "\n",
    "Example:\n",
    "\n",
    "Input: [0,1,0,3,12]\n",
    "Output: [1,3,12,0,0]\n",
    "Note:\n",
    "\n",
    "You must do this in-place without making a copy of the array.\n",
    "Minimize the total number of operations.\n",
    "\"\"\"\n",
    "\n",
    "class Solution:\n",
    "    def moveZeroes(self, nums: List[int]) -> None:\n",
    "        \"\"\"\n",
    "        Do not return anything, modify nums in-place instead.\n",
    "        \"\"\"\n",
    "        for i in range (len(nums)):\n",
    "            for j in range(len(nums)-1-i):\n",
    "                if nums[j] == 0:\n",
    "                    temp = nums[j]\n",
    "                    nums[j] = nums[j+1]\n",
    "                    nums[j+1] = temp\n",
    "        print(nums)\n",
    "        \n",
    "    def moveZeroesSolution2(self, nums: List[int]) -> None:\n",
    "        lastNonZeroFoundAt = 0\n",
    "        for i in range(len(nums)) :\n",
    "            if nums[i] != 0 :\n",
    "                nums[lastNonZeroFoundAt] = nums[i]\n",
    "                lastNonZeroFoundAt += 1\n",
    "        \n",
    "        for i in range(lastNonZeroFoundAt, len(nums)) :\n",
    "            nums[i] = 0\n",
    "        print(nums)\n",
    "                    \n",
    "sol = Solution()\n",
    "sol.moveZeroes([0,1,0,3,12])\n",
    "sol.moveZeroes([0,1,0])\n",
    "print(\"\\n\")\n",
    "sol.moveZeroesSolution2([0,1,0,3,12])\n",
    "sol.moveZeroesSolution2([0,1,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "1. Two Sum\n",
    "\n",
    "Given an array of integers, return indices of the two numbers such that they add up to a specific target.\n",
    "\n",
    "You may assume that each input would have exactly one solution, and you may not use the same element twice.\n",
    "\n",
    "Example:\n",
    "\n",
    "Given nums = [2, 7, 11, 15], target = 9,\n",
    "\n",
    "Because nums[0] + nums[1] = 2 + 7 = 9,\n",
    "return [0, 1].\n",
    "\"\"\"\n",
    "class Solution:\n",
    "    def twoSum(self, nums: List[int], target: int) -> List[int]:\n",
    "        for i in range(len(nums)):\n",
    "            for j in range(i+1,len(nums)):\n",
    "                if(nums[i]+nums[j] == target):\n",
    "                    return [i,j]\n",
    "        \n",
    "                \n",
    "sol = Solution()\n",
    "print(sol.twoSum([2, 7, 11, 15],9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}