week08.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c23623a9",
   "metadata": {},
   "source": [
    "#Challenge_Question"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "17589e1b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please Enter a number to test primality: 7\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# For this week’s challenge, I’d like you to create a program that asks a user to input a number\n",
    "# and tells that user if the number they entered is a prime number or not. Remember that\n",
    "# prime numbers are only divisible by one and itself and must be above the number 2. Create\n",
    "# a function called “isPrime” that you pass the input into, and return a True or False value. Be\n",
    "# sure to keep efficiency in mind when programming the function.\n",
    "\n",
    "from math import sqrt\n",
    "num = input(\"Please Enter a number to test primality: \")\n",
    "num = int(num)\n",
    "\n",
    "flag = 0\n",
    "def isPrime():\n",
    "    \n",
    "    if num >1:\n",
    "        for i in range(2, int(sqrt(num))+1):\n",
    "            if num % i == 0:\n",
    "                flag = 1\n",
    "                break\n",
    "            else:\n",
    "                flag = 0\n",
    "        if flag == 0:\n",
    "            print(\"True\")\n",
    "        else:\n",
    "            print(\"False\")\n",
    "    else:\n",
    "        print(\"False\")\n",
    "                \n",
    "isPrime()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba06733f",
   "metadata": {},
   "source": [
    "#List Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "adab8359",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]\n"
     ]
    }
   ],
   "source": [
    "#>>> *result* = [ *transform* *iteration* *filter* ] general syntax\n",
    "\n",
    "#>>> name_of_list = [ item_to_append for item in list ]\n",
    "\n",
    "#>>> name_of_list = [ item_to_append for item in list if condition ]\n",
    "\n",
    "#>>> name_of_list = [ item_to_append if condition else item_to_append for item in list ]\n",
    "\n",
    "#Generating a list of numbers\n",
    "\n",
    "#create a list of 10 numbers sing list comprehension\n",
    "\n",
    "nums = [x for x in range(100)] #generates a list from 0 to 100\n",
    "\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f7ce251a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "#using if statement within list comprehension\n",
    "\n",
    "nums = [x for x in range(10) if x % 2 == 0]\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d1b76c3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']\n"
     ]
    }
   ],
   "source": [
    "#using if/else within list comprehension\n",
    "\n",
    "nums = [\"even\" if x%2 == 0 else \"odd\" for x in range(10)]\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "1281527c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 16, 36, 64]\n"
     ]
    }
   ],
   "source": [
    "#List Comprehension with variables\n",
    "#creating a list of quared numbers rom another list of numbers using list comprehension\n",
    "\n",
    "nums = [2, 4, 6, 8]\n",
    "\n",
    "squared_nums = [num**2 for num in nums]\n",
    "\n",
    "print(squared_nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3b746e3f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 0, 2: 4, 4: 16, 6: 36, 8: 64}\n"
     ]
    }
   ],
   "source": [
    "#Dictionary Comprehension\n",
    "\n",
    "#creating a dictionary of even numbers and square values using comprehension\n",
    "\n",
    "numbers = [x for x in range(10)]\n",
    "\n",
    "squares = {num : num**2 for num in numbers if num%2==0}\n",
    "\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32191458",
   "metadata": {},
   "source": [
    "#Monday Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "b86153d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[53.6, 69.8, 59.0, 89.6]\n"
     ]
    }
   ],
   "source": [
    "# Degree Conversion: Using list comprehension, convert the following list to\n",
    "# Fahrenheit. Currently, the degrees are in Celsius temperatures. The conversion\n",
    "# formula is “(9/5) * C + 32”. Your output should be [ 53.6, 69.8, 59, 89.6 ].\n",
    "# >>> degrees = [ 12, 21, 15, 32 ]\n",
    "\n",
    "degrees = [ 12, 21, 15, 32 ]\n",
    "\n",
    "degree_f = [round(num*(9/5)+32, 1) for num in degrees]\n",
    "\n",
    "print(degree_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "b0813f88",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a number upto 10025\n",
      "[25, 50, 75, 100]\n"
     ]
    }
   ],
   "source": [
    "# User Input: Ask the user to input a single integer up to and including 100.\n",
    "# Generate a list of numbers that are exactly divisible by that number up to and\n",
    "# including 100 using list comprehension. For example, if the number 25 was\n",
    "# input, then the output should be [ 25, 50, 75, 100 ].\n",
    "\n",
    "\n",
    "inp = int(input(\"Please enter a number upto 100\"))\n",
    "\n",
    "lst = [x for x in range(1, 101) if x%inp==0]\n",
    "print(lst)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "6cecec03",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Tuesday : Lambda Functions\n",
    "\n",
    "#lambda arguments : expression\n",
    "\n",
    "#>>> lambda arguments : value_to_return if condition else value_to_return\n",
    "\n",
    "#using lambda to square a number\n",
    "\n",
    "(lambda x : x**2)(4)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "29d04cce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#passing multiple parameters in lambda function\n",
    "\n",
    "(lambda x,y : x*y)(10, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "7362fad6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function <lambda> at 0x7fdf2b371e50>\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "#saving lambda function into a variable\n",
    "\n",
    "multiplication = lambda x,y : x*y\n",
    "print(multiplication)\n",
    "result = multiplication(2,5)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "e68faaea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "#using if/else statements within a lambda to return greater number\n",
    "greater = lambda x,y : x if x>y else y\n",
    "rslt = greater(10,5)\n",
    "print(rslt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "2477217e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "#returning a lambda function from another function\n",
    "def myfunc(n):\n",
    "    return lambda x:x*n\n",
    "doubler = myfunc(2)\n",
    "\n",
    "print(doubler(5))\n",
    "\n",
    "tripler = myfunc(3)\n",
    "print(tripler(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45bcb2e6",
   "metadata": {},
   "source": [
    "Tuesday Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "6dcbd382",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Fill in the Blanks: Fill in the blanks for the following code so that it takes in a\n",
    "# parameter of “x” and returns “True” if it is greater than 50; otherwise, it should\n",
    "# return “False”:\n",
    "# >>> ____ x _ True if x _ 50 ____ False\n",
    "\n",
    "test = lambda x: True if x>50 else False\n",
    "    \n",
    "print(test(54))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "dd512b93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32.0\n"
     ]
    }
   ],
   "source": [
    "# Degree Conversion: Write a lambda function that takes in a degree value in\n",
    "# Celsius and returns the degree converted into Fahrenheit.\n",
    "\n",
    "\n",
    "f = lambda x: (x*9/5)+32\n",
    "print(f(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afe5c1f0",
   "metadata": {},
   "source": [
    "Map, Reduce and filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "b25b3798",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<map object at 0x7fdf2b3ec910>\n",
      "[54.5, 56.48, 59.0, 48.56]\n"
     ]
    }
   ],
   "source": [
    "#using map without lambda\n",
    "\n",
    "def convertDeg(C):\n",
    "    return (C*9/5)+32\n",
    "\n",
    "data = [12.5, 13.6, 15, 9.2]\n",
    "\n",
    "converted_temps = map(convertDeg, data)\n",
    "\n",
    "print(converted_temps)\n",
    "\n",
    "converted_temps = list(converted_temps)\n",
    "\n",
    "print(converted_temps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "0d8cf3e8",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[54.5, 56.480000000000004, 59.0, 48.56]\n"
     ]
    }
   ],
   "source": [
    "#using map with lambdas\n",
    "\n",
    "data = [12.5, 13.6, 15, 9.2]\n",
    "converted_temps = list(map(lambda c: (9/5)*c+32, data))\n",
    "\n",
    "print(converted_temps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "f1a75bb8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[13.6, 15]\n"
     ]
    }
   ],
   "source": [
    "#filter without lambdas\n",
    "def filterTemps(C):\n",
    "    converted_temp = (C*9/5) + 32\n",
    "    return True if converted_temp > 55 else False\n",
    "data = [12.5, 13.6, 15, 9.2]\n",
    "filtered_temps = filter(filterTemps, data)\n",
    "\n",
    "print(list(filtered_temps))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "3e5f5233",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[13.6, 15]\n"
     ]
    }
   ],
   "source": [
    "#filter with lambda\n",
    "data = [12.5, 13.6, 15, 9.2]\n",
    "\n",
    "filtered_temps = list(filter(lambda C : True if (C*9/5)+32 >55 else False, data))\n",
    "\n",
    "print(filtered_temps)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "7df47c07",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n"
     ]
    }
   ],
   "source": [
    "#how to use reduce\n",
    "\n",
    "from functools import reduce\n",
    "\n",
    "nums = [2, 3, 4, 1]\n",
    "\n",
    "result = reduce(lambda a,b : a*b, nums)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17f1e84c",
   "metadata": {},
   "source": [
    "WEDNESDAY EXERCISE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "e4ad1110",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[' Ryan', 'Paul', 'Kevin Connors ']\n"
     ]
    }
   ],
   "source": [
    "# Mapping Names: Use a lambda and map function to map over the list of\n",
    "# names in the following to produce the following result “[ “Ryan”, “Paul”,\n",
    "# “Kevin Connors” ].\n",
    "# >>> names = [ \" ryan\", \"PAUL\", \"kevin connors \" ]\n",
    "\n",
    "names = [ \" ryan\", \"PAUL\", \"kevin connors \" ]\n",
    "result = list(map(lambda x: x.title(), names))\n",
    "\n",
    "print(result)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "6c5f844d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Frank', 'Ripal']\n"
     ]
    }
   ],
   "source": [
    "# Filter Names: Using a lambda and filter function, filter out all the names that\n",
    "# start with the letter “A.” Make it case insensitive, so it filters out the name\n",
    "# whether it’s uppercase or not. The output of the following list should be\n",
    "# [ “Frank”, “Ripal” ].\n",
    "\n",
    "names = [ \"Amanda\", \"Frank\", \"abby\", \"Ripal\", \"Adam\" ]\n",
    "\n",
    "result = list(filter(lambda x : True if x[0].lower() != 'a' else False, names))\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abe0a3a1",
   "metadata": {},
   "source": [
    "Recursion and Memoization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "080ac5d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "#writing a factorial function\n",
    "\n",
    "\n",
    "def factorial(n):\n",
    "    \n",
    "    if (n==1 or n==0):\n",
    "        return 1\n",
    "    else:\n",
    "        return factorial(n-1)*n\n",
    "\n",
    "\n",
    "print(factorial(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "280ee37e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "#writing the recursive fibonacci series\n",
    "\n",
    "def fib(n):\n",
    "    if n<=1:\n",
    "        return 1\n",
    "    else:\n",
    "        return fib(n-2)+fib(n-1)\n",
    "    \n",
    "print(fib(5))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "2ce04926",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "20365011074\n",
      "{2: 2, 3: 3, 4: 5, 5: 8, 6: 13, 7: 21, 8: 34, 9: 55, 10: 89, 11: 144, 12: 233, 13: 377, 14: 610, 15: 987, 16: 1597, 17: 2584, 18: 4181, 19: 6765, 20: 10946, 21: 17711, 22: 28657, 23: 46368, 24: 75025, 25: 121393, 26: 196418, 27: 317811, 28: 514229, 29: 832040, 30: 1346269, 31: 2178309, 32: 3524578, 33: 5702887, 34: 9227465, 35: 14930352, 36: 24157817, 37: 39088169, 38: 63245986, 39: 102334155, 40: 165580141, 41: 267914296, 42: 433494437, 43: 701408733, 44: 1134903170, 45: 1836311903, 46: 2971215073, 47: 4807526976, 48: 7778742049, 49: 12586269025, 50: 20365011074}\n"
     ]
    }
   ],
   "source": [
    "#using memoization with the fibonacci series\n",
    "\n",
    "cache = {}\n",
    "def fib(n):\n",
    "    if n in cache:\n",
    "        return cache[n]\n",
    "    result = 0\n",
    "    \n",
    "    #base case\n",
    "    if n<=1:\n",
    "        return 1\n",
    "    else:\n",
    "        result = fib(n-2) + fib(n-1)\n",
    "    cache[n] = result\n",
    "    \n",
    "    return result\n",
    "\n",
    "print(fib(5))\n",
    "print(fib(50))\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "23e066a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20365011074\n"
     ]
    }
   ],
   "source": [
    "#using lru cache\n",
    "\n",
    "from functools import lru_cache\n",
    "\n",
    "@lru_cache()\n",
    "def fib(n):\n",
    "    if n<=1:\n",
    "        return 1\n",
    "    else:\n",
    "        return fib(n-1) + fib(n-2)\n",
    "    \n",
    "print(fib(50))\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7245598",
   "metadata": {},
   "source": [
    "Thursday Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "63910c69",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "# Factorial Caching: Apply either the lru_cache built-in decorator to the factorial\n",
    "# function that we created previously, or set up your own caching system.\n",
    "\n",
    "from functools import lru_cache\n",
    "\n",
    "@lru_cache(500)\n",
    "def factorial(n):\n",
    "    if n <= 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return factorial(n-1)*n\n",
    "    \n",
    "print(factorial(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "f8997006",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Searching Data: Create a function that takes in two arguments, a list of data\n",
    "# and an item to search for. Search through the list of data passed in and return\n",
    "# True if the item to search for appears, otherwise, return False. If one of the\n",
    "# items is another list, create a recursive call so that you don’t need to create\n",
    "# another loop. Use the example call in the following as a reference on what\n",
    "# data to expect:\n",
    "# >>> searchList( [ 2, 3, [ 18, 22 ], 6 ], 22 )\n",
    "\n",
    "#searchList( [ 2, 3, [ 18, 22 ], 6 ], 22 )\n",
    "def search(data, item):\n",
    "    result = False\n",
    "    for i in data:\n",
    "        if i == item:\n",
    "            result = True\n",
    "        elif isinstance(i, list):\n",
    "            return search(i, item)\n",
    "    return result\n",
    "\n",
    "search( [ 2, 3, [ 18, 22 ], 6 ], 22 )\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16046b96",
   "metadata": {},
   "source": [
    "Friday Project: writing a binary search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2ee21c77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 5, 5, 10, 11, 13, 14, 16, 19, 19]\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "data = [random.randint(0,20) for i in range(10)]\n",
    "print(sorted(data))\n",
    "\n",
    "\n",
    "def binarySearch(data, n):\n",
    "    data.sort()\n",
    "    while data:\n",
    "        mid = (len(data)-0)//2\n",
    "        if data[mid] == n:\n",
    "            return True\n",
    "        elif data[mid] > n:\n",
    "            data = data[:mid]\n",
    "        elif data[mid] < n:\n",
    "            data = data[mid+1 :]\n",
    "    return False\n",
    "    \n",
    "print(binarySearch(data, 34))\n",
    "print(binarySearch(data, 14))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccd826ba",
   "metadata": {},
   "source": [
    "Weekly Challenge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "08029ade",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 6, 7, 9, 9, 10, 12, 12, 16, 17]\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Recursive Binary Search: Turn the Binary Search algorithm that\n",
    "# we created together into a recursive function. Rather than using\n",
    "# a while loop, it should call itself in order to cut the list down and\n",
    "# eventually return True or False.\n",
    "import random\n",
    "\n",
    "data = [random.randint(0,20) for i in range(10)]\n",
    "print(sorted(data))\n",
    "\n",
    "def binarySearch(data, n):\n",
    "    data.sort()\n",
    "    \n",
    "    if not data:\n",
    "        return False\n",
    "    \n",
    "    mid = (len(data)-0)//2\n",
    "    if data[mid] == n:\n",
    "        return True\n",
    "    elif data[mid] > n:\n",
    "        data = data[:mid]\n",
    "        return binarySearch(data, n)\n",
    "    elif data[mid] < n:\n",
    "        data = data[mid+1 :]\n",
    "        return binarySearch(data, n)\n",
    "\n",
    "print(binarySearch(data, 3))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0802176",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Efficient Algorithms: Looking at the Binary Search we wrote, how\n",
    "# could you possibly make it even more efficient?\n",
    "\n",
    "#When you write the steps out, you can see that the algorithm always sorts the list, and \n",
    "#continues to do so, even if the list is sorted. It would be better to require the list to be \n",
    "#sorted before passing in the data to the function. This way if you use recursive functions that \n",
    "#we would not have to sort the list each time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "98163a9f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Case-Sensitive Search: Rewrite the Binary Search so that it\n",
    "# works with a list that holds both numbers and letters. It should be\n",
    "# case sensitive. Use the following function call to understand the\n",
    "# parameters being passed in. Hint: “22” < ‘a’ will return True.\n",
    "# >>> binarySearch( [ 'a', 22, '3', 'hello', 1022, 4, 'e' ] ,\n",
    "# 'hello') # returns True\n",
    "\n",
    "def binarySearch(data, n):\n",
    "    \n",
    "    for i in range(len(data)):\n",
    "        data[i] = str(data[i])\n",
    "    \n",
    "    data.sort()\n",
    "    \n",
    "    while data:\n",
    "        mid = len(data)//2\n",
    "        if str(data[mid]) == str(n):\n",
    "            return True\n",
    "        elif str(data[mid]) > str(n):\n",
    "            data = data[ : mid ]\n",
    "        elif str(data[mid]) < str(n):\n",
    "            data = data[ mid + 1 : ]\n",
    "            \n",
    "    return False\n",
    "\n",
    "binarySearch( [ 'a', 22, '3', 'hello', 1022, 4, 'e' ] ,'Hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc5c281e",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}