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": 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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}