lets code.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pallendrom\n"
     ]
    }
   ],
   "source": [
    "def checKStringPallendrom(stringA):\n",
    "    reversedStr = stringA [::-1]\n",
    "    if(stringA == reversedStr):\n",
    "        return 'Pallendrom'\n",
    "    else:\n",
    "        return 'Not Pallendrom'    \n",
    "    \n",
    "print(checKStringPallendrom('ABA'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pallendrom\n"
     ]
    }
   ],
   "source": [
    "def checKNumberPallendrom(num):\n",
    "    temp =  num\n",
    "    rev=0\n",
    "    while(num > 0):\n",
    "        rem = num%10;\n",
    "        rev=rev*10+rem\n",
    "        num = num//10\n",
    "    \n",
    "    if(rev == temp):\n",
    "        return 'Pallendrom'\n",
    "    else:\n",
    "        return 'Not Pallendrom'\n",
    "    \n",
    "print(checKNumberPallendrom(121))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nishant Bhushan\n"
     ]
    }
   ],
   "source": [
    "# Upper case conversion/ Title case conversion\n",
    "def split(str):\n",
    "    return [char for char in str];\n",
    "\n",
    "def ReverseStr(str):\n",
    "    return [rev for rev in reversed(str)]\n",
    "def Uppercaseconversion(stringS):\n",
    "    strArr = stringS.split()\n",
    "    newStringArray = []\n",
    "    for word in strArr:\n",
    "        tempStrArr = split(word)\n",
    "        tempStrArr.pop(0);\n",
    "        tempStrArr.insert(0,chr(ord(word[0])-32))\n",
    "        newStringArray.append(\"\".join(tempStrArr))\n",
    "    temp = \" \".join(newStringArray)\n",
    "    return temp\n",
    "\n",
    "print(Uppercaseconversion('nishant bhushan'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes\n",
      "Yes\n"
     ]
    }
   ],
   "source": [
    "def removeSpecialCharacter(string):\n",
    "    specialCharacterList = [':',';',',','?','/']\n",
    "    return ''.join(i for i in string if not i in specialCharacterList)\n",
    "\n",
    "# Save Ironman \n",
    "\n",
    "def SaveIronMan(stringA):\n",
    "#     stringA = removeSpecialCharacter(stringA)\n",
    "    strHalfLen = int(len(stringA)/2);\n",
    "    leftStr = removeSpecialCharacter(stringA[:strHalfLen])\n",
    "    rightStr = removeSpecialCharacter(stringA[strHalfLen:])\n",
    "    \n",
    "    templeftStr = leftStr[::-1]\n",
    "    if(templeftStr.lower() == rightStr.lower()):\n",
    "        return 'Yes'\n",
    "    else:\n",
    "        return 'No'\n",
    "    \n",
    "#     print(templeftStr.lower())\n",
    "#     print(rightStr.lower())\n",
    "\n",
    "print(SaveIronMan('I am :IronnorI Ma, i'))\n",
    "print(SaveIronMan('Ab?/Ba'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 6, 3, 12, 0, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "# Given an array nums, write a function to move all 0's to the end of it while maintaining the relative order \n",
    "# of the non-zero elements.\n",
    "lst = [0,1,0,0,6,3,12]\n",
    "zero = 0\n",
    "for i in range(len(lst)):\n",
    "    if(lst[i] == 0):\n",
    "        for i in range(len(lst)-zero-1):\n",
    "            if(lst[i] == 0):\n",
    "                temp = lst[i+1];\n",
    "                lst[i+1] = lst[i]\n",
    "                lst[i] = temp\n",
    "            \n",
    "        zero =zero+1\n",
    "\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# Longest Distinct characters in string\n",
    "def checkDuplicate(newStr):\n",
    "    Str =  split(newStr.lower())\n",
    "    for i in range(len(Str)):\n",
    "        poped=Str.pop(i)\n",
    "        if(poped in Str):\n",
    "            return 1\n",
    "        Str.insert(i,poped)\n",
    "    return 0\n",
    "\n",
    "print(checkDuplicate('geeksforgeeks'))\n",
    "print(checkDuplicate('Nishant'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Longest Distinct Substring 7\n",
      "Longest Distinct Substring 6\n",
      "Longest Distinct Substring 5\n"
     ]
    }
   ],
   "source": [
    "# Longest Distinct characters in string\n",
    "def split(str):\n",
    "    return [char for char in str];\n",
    "\n",
    "def checkDuplicate(newStr):\n",
    "#     print(newStr)\n",
    "    for i in range(len(newStr)):\n",
    "        poped=newStr.pop(i)\n",
    "        if(poped in newStr):\n",
    "            return 1\n",
    "        newStr.insert(i,poped)\n",
    "    return 0\n",
    "    \n",
    "    \n",
    "\n",
    "def LongestDistinctcharactersinstring(strArray):\n",
    "    Str =  split(strArray) \n",
    "    arrayLen = len(Str)\n",
    "    nonDup = []\n",
    "    while (arrayLen>0):\n",
    "        for i in range(arrayLen):\n",
    "            if(checkDuplicate(Str[i:arrayLen]) != 1):\n",
    "                nonDup.append(len(Str[i:arrayLen]))\n",
    "            \n",
    "        arrayLen -= 1\n",
    "    \n",
    "    return max(nonDup)\n",
    "        \n",
    "        \n",
    "\n",
    "print('Longest Distinct Substring',LongestDistinctcharactersinstring('geeksforgeeks'))\n",
    "print('Longest Distinct Substring',LongestDistinctcharactersinstring('abababcdefabab cdab'))\n",
    "print('Longest Distinct Substring',LongestDistinctcharactersinstring('tmmzuxt'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Longest Distinct Substring {'substring': 'eksforg', 'length': 7}\n",
      "Longest Distinct Substring {'substring': 'mzuxt', 'length': 5}\n"
     ]
    }
   ],
   "source": [
    "# Above code with optimized solution\n",
    "def LongestDistinctcharactersinstring(s):\n",
    "    Hash = dict()\n",
    "    mCount = 0\n",
    "    count = 0\n",
    "    bestWord = \"\"\n",
    "    for x in s:\n",
    "        if(x not in Hash):\n",
    "            Hash[x] = 1\n",
    "            count += 1\n",
    "            if(count>mCount):\n",
    "                mCount = count\n",
    "                bestWord = \"\".join(Hash.keys())\n",
    "        else:\n",
    "            Hash = dict()\n",
    "            Hash[x] = 1\n",
    "            count = 1\n",
    "        \n",
    "#         print(x,Hash,count,mCount)\n",
    "\n",
    "    \n",
    "    return {'substring':bestWord,'length' :mCount}\n",
    "    \n",
    "print('Longest Distinct Substring',LongestDistinctcharactersinstring('geeksforgeeks'))\n",
    "print('Longest Distinct Substring',LongestDistinctcharactersinstring('tmmzuxt'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Matrix\n",
      "[2, 2, 2, 2, 2, 2, 2]\n",
      "[4, 4, 4, 4, 4, 4, 4]\n",
      "[6, 6, 6, 6, 6, 6, 6]\n",
      "[8, 8, 8, 8, 8, 8, 8]\n",
      "Rotated Matrix\n",
      "[2, 4, 6, 8]\n",
      "[2, 4, 6, 8]\n",
      "[2, 4, 6, 8]\n",
      "[2, 4, 6, 8]\n",
      "[2, 4, 6, 8]\n",
      "[2, 4, 6, 8]\n",
      "[2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "def rotateMatrix(matrix):\n",
    "    newMatrix = []\n",
    "    for i in range(len(matrix[0])):\n",
    "        newMatrix.append([row[i] for row in matrix])\n",
    "    return newMatrix\n",
    "\n",
    "\n",
    "matrix = [[i*2]*7 for i in range(1,5)]\n",
    "print('Original Matrix')\n",
    "for i in matrix:\n",
    "    print(i)\n",
    "mat = rotateMatrix(matrix)\n",
    "print('Rotated Matrix')\n",
    "for i in mat:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'c', 'r', 'l', 'p', 'b'}\n"
     ]
    }
   ],
   "source": [
    "# Uncommon characters\n",
    "def Uncommoncharacters(str1,str2):\n",
    "    matrix = [[0]*len(str1) for i in range(len(str2))]\n",
    "    letters = []\n",
    "    \n",
    "    for i in range(len(str2)):\n",
    "        for j in range(len(str1)):\n",
    "            if(str2[i] == str1[j]):\n",
    "                matrix[i][j] = 1\n",
    "                \n",
    "        if 1 not in matrix[i]:\n",
    "            letters.append(str2[i])\n",
    "            \n",
    "    for j in range(len(matrix[0])):\n",
    "        if 1 not in [row[j] for row in matrix]:\n",
    "            letters.append(str1[j])\n",
    "            \n",
    "    return set(letters)\n",
    "                \n",
    "    \n",
    "print(Uncommoncharacters('characters','alphabets'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-132\n"
     ]
    }
   ],
   "source": [
    "class Solution:\n",
    "    def reverse(self, x: int) -> int:\n",
    "        s=0\n",
    "        temp = abs(x)\n",
    "        while(temp>0):\n",
    "            r = temp%10\n",
    "            s = s*10+r\n",
    "            temp=temp//10\n",
    "        if(x<0):\n",
    "            return -s\n",
    "        else:\n",
    "            return s\n",
    "            \n",
    "sol = Solution()\n",
    "print(sol.reverse(-231))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def centuryFromYear(year):\n",
    "    r = year//100\n",
    "    d = year/100\n",
    "    if(r<d):\n",
    "        return r+1\n",
    "    else:\n",
    "        return r\n",
    "    return r\n",
    "\n",
    "centuryFromYear(1701)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def checkPalindrome(inputString):\n",
    "    revString = inputString[::-1]\n",
    "    if(revString == inputString):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "checkPalindrome('test')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[21, [7, 3]]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def adjacentElementsProduct(inputArray):\n",
    "    product = []\n",
    "    index = []\n",
    "    for i in range(len(inputArray)-1):\n",
    "        product.append(inputArray[i]*inputArray[i+1])\n",
    "        index.append([inputArray[i],inputArray[i+1]])\n",
    "    maxValueIndex = product.index(max(product))\n",
    "    return [product[maxValueIndex],index[maxValueIndex]]\n",
    "\n",
    "adjacentElementsProduct([3, 6, -2, -5, 7, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sumOfTwo(a, b, v):\n",
    "    for i in range(len(a)):\n",
    "        for j in range(len(b)):\n",
    "            if(a[i]+b[j] == v):\n",
    "                return True\n",
    "    return False\n",
    "sumOfTwo([1, 2, 3],[10, 20, 30, 40],42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def searchInsert(nums, target):\n",
    "        for i in range(len(nums)):\n",
    "            if(nums[i] == target):\n",
    "                return i\n",
    "        return 0\n",
    "\n",
    "searchInsert([3,2,1,4,5],5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']])"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def groupAnagrams(strs):\n",
    "    Hash = dict()\n",
    "    for x in strs:\n",
    "        freq = [0]*26\n",
    "        for y in x: #making hash of all words char\n",
    "            freq[ord(y)-ord('a')] +=1\n",
    "        key = tuple(freq) \n",
    "        if key not in Hash:\n",
    "            Hash[key] = list()\n",
    "        Hash[key].append(x)\n",
    "    return Hash.values()\n",
    "\n",
    "groupAnagrams([\"eat\", \"tea\", \"tan\", \"ate\", \"nat\", \"bat\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def twoSumIndex(nums, target):\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",
    "twoSumIndex([2, 7, 11, 15],9)       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def findMinimum(nums):\n",
    "    minVal = nums[0]\n",
    "    for i in range(len(nums)):\n",
    "        if(nums[i]< minVal):\n",
    "            minVal = nums[i]\n",
    "    return minVal\n",
    "\n",
    "\n",
    "findMinimum([2,4,5,10,1])        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hACKERrANK.COM PRESENTS \"pYTHONIST 2\".\n"
     ]
    }
   ],
   "source": [
    "s= 'HackerRank.com presents \"Pythonist 2\".'\n",
    "ASCII = [ord(c)  for c in s]\n",
    "ASCII \n",
    "Char_list = []\n",
    "for i in ASCII :\n",
    "    if  i >= 97 and i<=122 :\n",
    "        Char_list.append(chr(i-32))\n",
    "    elif i >= 65 and i<=90 : ## capital to small\n",
    "        Char_list.append(chr(i+32))\n",
    "    elif i == 32:\n",
    "        Char_list.append(' ')\n",
    "    else :\n",
    "        Char_list.append(chr(i))\n",
    "        \n",
    "\n",
    "Changed =''.join(Char_list)\n",
    "print(Changed)       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 5]\n",
      "[1, 3, 3, 4]\n",
      "[1, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# sort matrix rows\n",
    "def selectionSort(nums):\n",
    "    for i in range(len(nums)-1):\n",
    "        imin = i  #setting the current index as minimum \n",
    "        for j in range(i + 1,len(nums)):\n",
    "            if (nums[j] < nums[imin]):\n",
    "                imin = j; # update the current index if current index islower than  previous\n",
    "        \n",
    "        temp = nums[i];  # swapping smallerst number at the current starting index one by one \n",
    "        nums[i] = nums[imin];\n",
    "        nums[imin] = temp;\n",
    "    return nums\n",
    "    \n",
    "square = [[2,1,4,5],[4,3,1,3],[5,4,3,1]]\n",
    "for k in range(len(square)):\n",
    "    print(selectionSort(square[k]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "-18\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "# Closest Number\n",
    "def returnClosestNumber(N,M):\n",
    "    r = N%M\n",
    "    left = N-r\n",
    "    right = N+(M-r)\n",
    "    diff = [abs(N-left),abs(N-right)]\n",
    "    if(diff[0]<=diff[1]):\n",
    "        return left\n",
    "    else: \n",
    "        return right\n",
    "    return [left,right,test]\n",
    "\n",
    "print(returnClosestNumber(13,4))\n",
    "print(returnClosestNumber(-15,6))\n",
    "print(returnClosestNumber(15,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def findMaximum(nums):\n",
    "    maxVal = nums[0]\n",
    "    for i in range(len(nums)):\n",
    "        if(nums[i]> maxVal):\n",
    "            maxVal = nums[i]\n",
    "    return maxVal\n",
    "\n",
    "\n",
    "findMaximum([2,4,5,10,1])        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{20, 80}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def Commonelements(nums1,nums2,nums3):\n",
    "    return nums1.intersection(nums2).intersection(nums3)\n",
    "\n",
    "Commonelements({1, 5, 10, 20, 40, 80},{6, 7, 20, 80, 100},{3, 4, 15, 20, 30, 70, 80, 120})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Q. Given an array of integers arr, write a function that returns true if and only \n",
    "#if the number of occurrences of each value in the array is unique.\n",
    "def uniqueOccurrences(arr):\n",
    "    values = set(arr)\n",
    "    Hash = dict()\n",
    "    for val in values:\n",
    "        count=0\n",
    "        for i in range(len(arr)):\n",
    "            if(val == arr[i]):\n",
    "                count+=1\n",
    "        if count in Hash.values():\n",
    "            return False\n",
    "        Hash[val] = count\n",
    "\n",
    "    return True\n",
    "\n",
    "uniqueOccurrences([1,2,2,1,1,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "1 \n",
      "2 3 \n",
      "4 5 6 \n",
      "7 8 9 10 \n"
     ]
    }
   ],
   "source": [
    "count=0\n",
    "for i in range(5):\n",
    "    for j in range(0,i):\n",
    "        count+=1\n",
    "        print(count,end=\" \")\n",
    "    print(\"\")   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "def tribonacci(n: int) -> int:\n",
    "    if(n==0):return 0\n",
    "    if(n<3):return 1\n",
    "    \n",
    "    dp = [0]*(n+1)\n",
    "    \n",
    "    dp[1] = dp[2] = 1\n",
    "\n",
    "    for x in range(3,n+1):\n",
    "        dp[x] = dp[x-1]+dp[x-2]+dp[x-3]\n",
    "    \n",
    "    return dp[n]\n",
    "\n",
    "n = 3\n",
    "print(tribonacci(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def singleNumber(nums):\n",
    "    initial =0;\n",
    "    for val in nums:\n",
    "        initial = initial ^ val\n",
    "    \n",
    "    return initial\n",
    "\n",
    "singleNumber([1,2,2,9,9,9,9,1,1,1,8,3,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 0, 1, 1, 3]\n"
     ]
    }
   ],
   "source": [
    "# How Many Numbers Are Smaller Than the Current Number\n",
    "def smallerNumbersThanCurrent(nums):\n",
    "    numsCount = []\n",
    "    for i in range(len(nums)):\n",
    "        count =0\n",
    "        for j in range(len(nums)):\n",
    "            if(nums[j]<nums[i]):\n",
    "                count = count +1\n",
    "        numsCount.append(count)\n",
    "    return numsCount\n",
    "\n",
    "print(smallerNumbersThanCurrent([8,1,2,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "def numJewelsInStones(J, S):\n",
    "    list(S)\n",
    "    list(J)\n",
    "    totalCount = 0\n",
    "    Hash = dict()\n",
    "    for i in range(len(S)):\n",
    "        if S[i] in Hash:\n",
    "            Hash[S[i]] = Hash[S[i]] + 1\n",
    "        else :\n",
    "            Hash[S[i]]=1\n",
    "    for k in range(len(J)):\n",
    "        if(J[k] in Hash):\n",
    "            totalCount = totalCount + Hash[J[k]]\n",
    "    # print(totalCount)        \n",
    "    return totalCount\n",
    "\n",
    "print(numJewelsInStones(\"aA\",\"aAAbbbb\"))\n",
    "print(numJewelsInStones(\"z\",\"ZZ\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# In a array A of size 2N, there are N+1 unique elements, and exactly one of these elements is repeated N times. \n",
    "# Return the element repeated N times.\n",
    "def repeatedNTimes(A):\n",
    "    Hash = dict()\n",
    "    size = len(A)//2\n",
    "    for i in range(len(A)):\n",
    "        if A[i] in Hash:\n",
    "            Hash[A[i]] = Hash[A[i]] + 1\n",
    "        else :\n",
    "            Hash[A[i]]=1\n",
    "        if(Hash[A[i]] == size):\n",
    "            return A[i]\n",
    "\n",
    "print(repeatedNTimes([1,2,3,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "1342. Number of Steps to Reduce a Number to Zero\n",
    "\n",
    "Given a non-negative integer num, return the number of steps to reduce it to zero. If the current number is even, you have to divide it by 2, otherwise, you have to subtract 1 from it.\n",
    "\n",
    "Input: num = 14\n",
    "Output: 6\n",
    "\n",
    "Explanation: \n",
    "Step 1) 14 is even; divide by 2 and obtain 7. \n",
    "Step 2) 7 is odd; subtract 1 and obtain 6.\n",
    "Step 3) 6 is even; divide by 2 and obtain 3. \n",
    "Step 4) 3 is odd; subtract 1 and obtain 2. \n",
    "Step 5) 2 is even; divide by 2 and obtain 1. \n",
    "Step 6) 1 is odd; subtract 1 and obtain 0.\n",
    "\"\"\"\n",
    "class Solution:\n",
    "    def numberOfSteps (self, num: int) -> int:\n",
    "        temp = num \n",
    "        setps = 0\n",
    "        while temp >0:\n",
    "#             print(temp)\n",
    "            if temp % 2 == 0:\n",
    "                temp = temp // 2\n",
    "            else:\n",
    "                temp = temp -1\n",
    "            setps +=1\n",
    "        return setps\n",
    "            \n",
    "sol = Solution()\n",
    "\n",
    "print(sol.numberOfSteps(14))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 0, 5, 5, 0]\n",
      "[5, 5, 0]\n"
     ]
    }
   ],
   "source": [
    "def nextLargerNodes(newArr):\n",
    "    newList = []\n",
    "    for i in range(len(newArr)):\n",
    "        currMax = newArr[i]\n",
    "        for j in range(i+1,len(newArr)):\n",
    "            if currMax < newArr[j]:\n",
    "                currMax = newArr[j]\n",
    "#             print(newArr[i],newArr[j])\n",
    "            \n",
    "        if(currMax == newArr[i]):\n",
    "            newList.append(0)\n",
    "        else:\n",
    "            newList.append(currMax)\n",
    "#         print(\"\\n\")\n",
    "    return newList\n",
    "\n",
    "print(nextLargerNodes([2,7,4,3,5]))\n",
    "print(nextLargerNodes([2,1,5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "728. Self Dividing Numbers\n",
    "\n",
    "A self-dividing number is a number that is divisible by every digit it contains.\n",
    "\n",
    "For example, 128 is a self-dividing number because 128 % 1 == 0, 128 % 2 == 0, and 128 % 8 == 0.\n",
    "\n",
    "Also, a self-dividing number is not allowed to contain the digit zero.\n",
    "\n",
    "Given a lower and upper number bound, output a list of every possible self dividing number, including the bounds if possible.\n",
    "\n",
    "Input: \n",
    "left = 1, right = 22\n",
    "Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]\n",
    "\"\"\"\n",
    "from typing import List\n",
    "class Solution:\n",
    "    def isSelfDividingNo(self,num):\n",
    "        temp = num\n",
    "        while temp > 0:\n",
    "            d = temp%10\n",
    "            if d == 0 or num%d != 0 :\n",
    "                return False\n",
    "            temp = temp//10\n",
    "        return True\n",
    "    \n",
    "    def selfDividingNumbers(self, left: int, right: int) -> List[int]:\n",
    "        divNumsList = []\n",
    "        for i in range(left,right+1):\n",
    "            if(self.isSelfDividingNo(i)):\n",
    "                divNumsList.append(i)\n",
    "        # print(divNumsList)\n",
    "        return divNumsList\n",
    "    \n",
    "sol = Solution()\n",
    "print(sol.selfDividingNumbers(1,22))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 4, 4]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "1313. Decompress Run-Length Encoded List\n",
    "\n",
    "We are given a list nums of integers representing a list compressed with run-length encoding.\n",
    "\n",
    "Consider each adjacent pair of elements [freq, val] = [nums[2*i], nums[2*i+1]] (with i >= 0).  For each such pair, there are freq elements with value val concatenated in a sublist. Concatenate all the sublists from left to right to generate the decompressed list.\n",
    "\n",
    "Return the decompressed list.\n",
    "\n",
    "Input: nums = [1,2,3,4]\n",
    "Output: [2,4,4,4]\n",
    "\n",
    "Explanation: The first pair [1,2] means we have freq = 1 and val = 2 so we generate the array [2].\n",
    "The second pair [3,4] means we have freq = 3 and val = 4 so we generate [4,4,4].\n",
    "At the end the concatenation [2] + [4,4,4] is [2,4,4,4].\n",
    "\"\"\"\n",
    "from typing import List\n",
    "class Solution:\n",
    "    def decompressRLElist(self, nums: List[int]) -> List[int]:\n",
    "        outList = []\n",
    "        for i in range(0,len(nums),2):\n",
    "#             print(nums[i],nums[i+1])\n",
    "            freq = nums[i] \n",
    "            val = nums[i+1]\n",
    "            for i in range(freq):\n",
    "                outList.append(val)\n",
    "        return outList\n",
    "            \n",
    "            \n",
    "sol = Solution();\n",
    "print(sol.decompressRLElist([1,2,3,4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27\n",
      "15\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "def make_multiplier_of(n):\n",
    "    def multiplier(x):\n",
    "        return x * n\n",
    "    return multiplier\n",
    "\n",
    "# Multiplier of 3\n",
    "times3 = make_multiplier_of(3)\n",
    "\n",
    "# Multiplier of 5\n",
    "times5 = make_multiplier_of(5)\n",
    "\n",
    "# Output: 27\n",
    "print(times3(9))\n",
    "\n",
    "# Output: 15\n",
    "print(times5(3))\n",
    "\n",
    "# Output: 30\n",
    "print(times5(times3(2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "136. Single Number\n",
    "\n",
    "Given a non-empty array of integers, every element appears twice except for one. Find that single one.\n",
    "\n",
    "Note:\n",
    "Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input: [2,2,1]\n",
    "Output: 1\n",
    "\n",
    "Example 2:\n",
    "\n",
    "Input: [4,1,2,1,2]\n",
    "Output: 4\n",
    "\n",
    "\"\"\"\n",
    "from typing import List \n",
    "class Solution:\n",
    "    def singleNumber(self, nums: List[int]) -> int:\n",
    "        Hash = dict()\n",
    "        distVal = nums[0]\n",
    "        for i in range(len(nums)):\n",
    "            if nums[i] not in Hash:\n",
    "                Hash[nums[i]] = 1\n",
    "            else:\n",
    "                Hash[nums[i]] = Hash[nums[i]]+1\n",
    "            \n",
    "#         print(Hash)\n",
    "        return min(Hash,key=Hash.get)\n",
    "        \n",
    "sol = Solution()\n",
    "print(sol.singleNumber([2,2,1]))\n",
    "print(sol.singleNumber([4,1,2,1,2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', '2', 'Fizz', '4', 'Buzz', 'Fizz', '7', '8', 'Fizz', 'Buzz', '11', 'Fizz', '13', '14', 'FizzBuzz']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "412. Fizz Buzz\n",
    "\n",
    "Write a program that outputs the string representation of numbers from 1 to n.\n",
    "\n",
    "But for multiples of three it should output “Fizz” instead of the number and for the multiples of five output “Buzz”. For numbers which are multiples of both three and five output “FizzBuzz”.\n",
    "\n",
    "Example:\n",
    "\n",
    "n = 15,\n",
    "\n",
    "Return:\n",
    "[\n",
    "    \"1\",\n",
    "    \"2\",\n",
    "    \"Fizz\",\n",
    "    \"4\",\n",
    "    \"Buzz\",\n",
    "    \"Fizz\",\n",
    "    \"7\",\n",
    "    \"8\",\n",
    "    \"Fizz\",\n",
    "    \"Buzz\",\n",
    "    \"11\",\n",
    "    \"Fizz\",\n",
    "    \"13\",\n",
    "    \"14\",\n",
    "    \"FizzBuzz\"\n",
    "]\n",
    "\"\"\"\n",
    "class Solution:\n",
    "    def fizzBuzz(self, n: int) -> List[str]:\n",
    "        solList = []\n",
    "        for i in range(1,n+1):\n",
    "            if i % 3 ==0 and i %5 == 0:\n",
    "                solList.append(\"FizzBuzz\")\n",
    "            elif i % 3 == 0:\n",
    "                solList.append(\"Fizz\")\n",
    "            elif i % 5 == 0:\n",
    "                solList.append(\"Buzz\")\n",
    "            else:\n",
    "                solList.append(str(i))\n",
    "                \n",
    "        return solList\n",
    "                \n",
    "sol = Solution()\n",
    "print(sol.fizzBuzz(15))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['sweet', 'sour']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "884. Uncommon Words from Two Sentences\n",
    "\n",
    "We are given two sentences A and B.  (A sentence is a string of space separated words. Each word consists only of lowercase letters.)\n",
    "A word is uncommon if it appears exactly once in one of the sentences, and does not appear in the other sentence.\n",
    "\n",
    "Return a list of all uncommon words. \n",
    "\n",
    "You may return the list in any order.\n",
    "\n",
    "Input: A = \"this apple is sweet\", B = \"this apple is sour\"\n",
    "Output: [\"sweet\",\"sour\"]\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "from typing import List\n",
    "class Solution:\n",
    "    def uncommonFromSentences(self, A: str, B: str) -> List[str]:\n",
    "        uncommonList = []\n",
    "        Hash = dict()\n",
    "        aWords = A.split(' ')\n",
    "        bWords = B.split(' ')\n",
    "        i =0\n",
    "        while i < len(aWords) or i < len(bWords):\n",
    "            if i < len(aWords):\n",
    "                if aWords[i] not in Hash:\n",
    "                    Hash[aWords[i]] = 1\n",
    "                else:\n",
    "                    Hash[aWords[i]] = Hash[aWords[i]]+1\n",
    "            if i < len(bWords):\n",
    "                if bWords[i] not in Hash:\n",
    "                    Hash[bWords[i]] = 1\n",
    "                else:\n",
    "                    Hash[bWords[i]] = Hash[bWords[i]]+1\n",
    "            i +=1\n",
    "            \n",
    "        for key in Hash:\n",
    "            if Hash[key] == 1:\n",
    "                uncommonList.append(key)\n",
    "#         print(uncommonList)\n",
    "        return uncommonList\n",
    "\n",
    "sol = Solution()\n",
    "print(sol.uncommonFromSentences(\"this apple is sweet\",\"this apple is sour\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "351. Count Negative Numbers in a Sorted Matrix\n",
    "\n",
    "Given a m * n matrix grid which is sorted in non-increasing order both row-wise and column-wise. \n",
    "\n",
    "Return the number of negative numbers in grid.\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input: grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]\n",
    "Output: 8\n",
    "Explanation: There are 8 negatives number in the matrix.\n",
    "\"\"\"\n",
    "\n",
    "from typing import List\n",
    "class Solution:\n",
    "    def countNegatives(self, grid: List[List[int]]) -> int:\n",
    "        negativeCount = 0\n",
    "        for i in range(len(grid)):\n",
    "            for j in range(len(grid[0])):\n",
    "                if grid[i][j] < 0:\n",
    "                    negativeCount +=1\n",
    "        return negativeCount\n",
    "\n",
    "    \n",
    "sol = Solution()\n",
    "print(sol.countNegatives([[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 1, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Given two arrays of integers nums and index. Your task is to create target array under the following rules:\n",
    "\n",
    "Initially target array is empty.\n",
    "From left to right read nums[i] and index[i], insert at index index[i] the value nums[i] in target array.\n",
    "Repeat the previous step until there are no elements to read in nums and index.\n",
    "Return the target array.\n",
    "\n",
    "It is guaranteed that the insertion operations will be valid.\n",
    "\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input: nums = [0,1,2,3,4], index = [0,1,2,2,1]\n",
    "Output: [0,4,1,3,2]\n",
    "Explanation:\n",
    "nums       index     target\n",
    "0            0        [0]\n",
    "1            1        [0,1]\n",
    "2            2        [0,1,2]\n",
    "3            2        [0,1,3,2]\n",
    "4            1        [0,4,1,3,2]\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "from typing import List\n",
    "class Solution:\n",
    "    def createTargetArray(self, nums: List[int], index: List[int]) -> List[int]:\n",
    "        target = []\n",
    "        count = 0\n",
    "        for i in index:\n",
    "            target.insert(i,nums[count])\n",
    "            count += 1\n",
    "        return target\n",
    "            \n",
    "            \n",
    "sol = Solution()\n",
    "print(sol.createTargetArray([0,1,2,3,4],[0,1,2,2,1]))        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values([['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']])\n"
     ]
    }
   ],
   "source": [
    "from typing import List\n",
    "class Solution:\n",
    "    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:\n",
    "        Hash = dict()\n",
    "        for x in strs:\n",
    "            freq = [0]*26\n",
    "            for y in x:\n",
    "                freq[ord(y)-ord('a')] +=1\n",
    "            \n",
    "            key = tuple(freq) \n",
    "            if key not in Hash:\n",
    "                Hash[key] = list()\n",
    "            \n",
    "                \n",
    "            Hash[key].append(x)\n",
    "        \n",
    "        return Hash.values()\n",
    "    \n",
    "sol = Solution()\n",
    "print(sol.groupAnagrams([\"eat\",\"tea\",\"tan\",\"ate\",\"nat\",\"bat\"]))       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[True, True, True, False, True]\n",
      "[True, False, False, False, False]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "1431. Kids With the Greatest Number of Candies\n",
    "\n",
    "Given the array candies and the integer extraCandies, where candies[i] represents the number of candies that the ith kid has.\n",
    "\n",
    "For each kid check if there is a way to distribute extraCandies among the kids such that he or she can have the greatest number of candies among them. Notice that multiple kids can have the greatest number of candies.\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input: candies = [2,3,5,1,3], extraCandies = 3\n",
    "Output: [true,true,true,false,true] \n",
    "Explanation: \n",
    "Kid 1 has 2 candies and if he or she receives all extra candies (3) will have 5 candies --- the greatest number of candies among the kids. \n",
    "Kid 2 has 3 candies and if he or she receives at least 2 extra candies will have the greatest number of candies among the kids. \n",
    "Kid 3 has 5 candies and this is already the greatest number of candies among the kids. \n",
    "Kid 4 has 1 candy and even if he or she receives all extra candies will only have 4 candies. \n",
    "Kid 5 has 3 candies and if he or she receives at least 2 extra candies will have the greatest number of candies among the kids.\n",
    "\n",
    "Example 2:\n",
    "\n",
    "Input: candies = [4,2,1,1,2], extraCandies = 1\n",
    "Output: [true,false,false,false,false] \n",
    "Explanation: There is only 1 extra candy, therefore only kid 1 will have the greatest number of candies among the kids regardless of who takes the extra candy.\n",
    "\"\"\"\n",
    "from typing import List\n",
    "class Solution:\n",
    "    def kidsWithCandies(self, candies: List[int], extraCandies: int) -> List[bool]:\n",
    "        greaterCandie = max(candies)\n",
    "        outputList = []\n",
    "        for i in range(len(candies)):\n",
    "            checkCandie = candies[i] + extraCandies\n",
    "            if checkCandie >= greaterCandie:\n",
    "                outputList.append(True)\n",
    "            else:\n",
    "                outputList.append(False) \n",
    "        return outputList\n",
    "\n",
    "sol = Solution()\n",
    "print(sol.kidsWithCandies([2,3,5,1,3],3))   \n",
    "print(sol.kidsWithCandies([4,2,1,1,2],1)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def is_int32(number):\n",
    "    try:\n",
    "        return not(int(number)>>32)\n",
    "    except ValueError:\n",
    "        return False\n",
    "is_int32(1534236469)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Leap Year\n"
     ]
    }
   ],
   "source": [
    "# Program to check leap year\n",
    "def checkLeapYear(year):\n",
    "    if (((year % 100 != 0) and (year % 4 == 0)) or (year % 400 == 0)):\n",
    "        return 'Leap Year'\n",
    "    else:\n",
    "        return 'not a leap year'\n",
    "    return \n",
    "\n",
    "\n",
    "print(checkLeapYear(2000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 3, 2, 5]\n"
     ]
    }
   ],
   "source": [
    "# Python program to swap two elements in a list\n",
    "\n",
    "def swap(lst,p1,p2):\n",
    "    lst[p1],lst[p2] = lst[p2],lst[p1]\n",
    "    return lst\n",
    "  \n",
    "print(swap([1,2,3,4,5],3,1))"
   ]
  },
  {
   "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
}