Project-based Python Algorithms DataStructures by M.Hossain Udemy instructor .ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello World, \n",
    "\n",
    "        I\\\"m doing \"programming\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hello World, \n",
    "\n",
    "        I'm doing \"programming\" ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( \"\"\" Hello World, \n",
    "\n",
    "        i'm doing \"programming\" \"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "price_1= \"1100\"; price_2=\"1200\"\n",
    "price_1 +\"    \"+ price_2# Since they are strings, they are simply added together as one followed by the other"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"\"\" I'm having a great day learning\n",
    "how to code\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_message= (\"Pratice makes perfect\")\n",
    "## end question 4\n",
    "\n",
    "# Question 5: Use the print function to print the variable my_message you defined above\n",
    "## write your code below\n",
    "print(my_message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "message = \"The price of stock is: \"\n",
    "id(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "message= \"4\"\n",
    "id(message)## different memory locations\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name= 'Elena'\n",
    "name[-1]# last one caracter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "name[-1]= \"n\"## string are inmutable "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name[0:3]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name[3:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name[3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers= \"012345689\"\n",
    "numbers[2:6:2]# 2 is start; 6 is stop+1 and 2 is step size "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers[0:9:-1]## here 1 is step size backward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers[2:8:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers[::-1]## reverse elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thought_of_the_day = \"If programmers write programs, who writes programmers?\"\n",
    "thought_of_the_day[0:21]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(thought_of_the_day)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(thought_of_the_day ))## string\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ego= 77 ## integer\n",
    "print(type(ego))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting= \"Good - Morning\"\n",
    "user= \"tiago\"\n",
    "message= \"  WeLcOmE To My LiFe\"\n",
    "direct_object= \"LOVE\"\n",
    "print(greeting.upper(), \n",
    "      user.capitalize(),\n",
    "      message.lower().strip(), direct_object.split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(message.find(\"To\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(greeting.split(\"-\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carta= [\"queso\", \"masa\", \"vino\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"-\".join(carta))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import string \n",
    "print(string.ascii_lowercase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from string import ascii_lowercase\n",
    "print(ascii_lowercase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "    message = \"practice makes perfect\"\n",
    "    print(message.split(\"m\"))### delete the m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 1: Given the string below, use the find method to determine\n",
    "# what index the word \"universe\" starts in? (and print it)\n",
    "my_string = \"There's a lot going on in the universe don't you think?\"\n",
    "## Write your code below, 1 line ##\n",
    "print(my_string.index(\"universe\"))\n",
    "#End question 1\n",
    "\n",
    "\n",
    "# Question 2: Create a variable my_slice. Using a step size of 2, assign\n",
    "# it to a slice of my_string from the beginning to the end (the whole string)\n",
    "# including white spaces. Print how many characters are in this new string? (my_slice)\n",
    "## Write your code below, 2 lines ##\n",
    "my_slice= \"a slice of my_string from the beginning to the end\"\n",
    "\n",
    "print (\"how many characters are in this new string? \" + str(len(my_slice)))\n",
    "## End question 2\n",
    "\n",
    "# Question 3: Given the two string below, use string concatenation to\n",
    "# create and print one string (one followed by the other) seperated by a\n",
    "# comma and a space \", \"\n",
    "## Write your code below, 1 line ##\n",
    "\n",
    "bright_idea = \"If we used yesterday's stock price instead\"\n",
    "result = \"it would result in a 2% increase in the value of our assets\"\n",
    "\n",
    "print(bright_idea, end=(\", \"))\n",
    "print(result)\n",
    "\n",
    "## End question 3\n",
    "\n",
    "# Question 4: You can test whether one string is equal to another by using the\n",
    "# equality test operator '=='. For example if you wanted to test whether \"Harry\"\n",
    "# was equal to \"Harry\", you would use the following code \"Harry\" == \"Harry\".\n",
    "# Python would evaluate that expression to True (capital T). If you tested if\n",
    "# \"Harry\" == \"harry\" instead, Python would evaluate that to False (capital F)\n",
    "# since \"harry\" in the second case is not capitalized. Given the string\n",
    "# word_to_test below, write and print an equality test in one line to check if\n",
    "# the string would be equal to a string if the order of its characters were\n",
    "# reversed. Hint: You can use the slice reverse trick.\n",
    "word_to_test = \"level\"\n",
    "\n",
    "## Write your code below, 1 line ##\n",
    "print(word_to_test==word_to_test[len(word_to_test)::-2])\n",
    "\n",
    "## End question 4\n",
    "\n",
    "# Question 5: You can use the len function to get the total characters or\n",
    "# 'length' of a string. For example len(\"hello\") will give you 5. If you divide\n",
    "# this length by 2 using the floor division operator '//', you can get the index\n",
    "# at half of your string. You can then use slice notation to capture half of\n",
    "# your string since you know the length//2. With this knowledge, print out the\n",
    "# second half of the string below in one line. Output should be \"I am the second\n",
    "# half\".\n",
    "my_daily_thought = \"I am the first half I am the second half\"\n",
    "## Write your code below, 1 line ##\n",
    "print(my_daily_thought[20:40].split(sep=\"\\n\"))\n",
    "\n",
    "## End question 5\n",
    "\n",
    "# Question 6: Import the hexdigits constant from the string module and print\n",
    "# them out.\n",
    "## Write your code below, 2 lines ##\n",
    "import string\n",
    "print(string.hexdigits)\n",
    "\n",
    "## End queston 6\n",
    "### "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "###### IMPORTANT\n",
    "# Print formating\n",
    "\n",
    "stock_price=\"1112\"\n",
    "yesterday_price= \"1105\"\n",
    "print(\"Today's price for google stock is: \"+ stock_price)\n",
    "print(\"Today's price for google stock is:\", stock_price)\n",
    "print(f\"Today's price for google stock is: {stock_price}\")### It looks so clean\n",
    "\n",
    "print(f\"Today's price: {stock_price}, yesterday's price: {yesterday_price}\")\n",
    "print(f\"Today's price: {stock_price}\" \" \" f\"yesterday's price: {yesterday_price}\")\n",
    "\n",
    "print(\"Today's price: {} , yesterday's price: {}\".format(stock_price, yesterday_price))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"I am Jon Snow, \\\n",
    "king of the North\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"I am Jon Snow \\n king of the North \\n\\t and the Seven Kingdoms\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"I'm using the \\\\n special caracter to create new lines\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "    name_of_book = \"Harry Potter\"\n",
    "    name_of_book.upper()\n",
    "    name_of_book = name_of_book[::-1]\n",
    "    new_name_of_book = name_of_book\n",
    "    new_name_of_book.lower()\n",
    "    name_of_book = new_name_of_book.upper()\n",
    "    new_name_of_book = name_of_book[::-1]\n",
    "    print(name_of_book)\n",
    "    print(new_name_of_book) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(10**10)\n",
    "import math\n",
    "print(math.pow(10,10))\n",
    "math.log2(100000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "random.randint(4,100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " print(type(\"elena\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=25 # it is an integer\n",
    "print(type(str(result)))# we transformed it in a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Welcome to the multiplication program\")\n",
    "print(\"-\"*30 )### Multiply by 30 the \"-\"\n",
    "num_1=int(input(\"enter a number to multiply -->\"))\n",
    "num_2=int(input(\"enter a second number to multiply -->\"))\n",
    "result_2= num_1* num_2\n",
    "print(result_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(100/3.3)\n",
    "print(100//3.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 1: What is the remainder when you divide 2510876961 by 7?\n",
    "# Don't forget to print your result to the screen!\n",
    "num_1 = 2510876961\n",
    "num_2 = 7\n",
    "\n",
    "## Fill in your code below, 1 line ##\n",
    "\n",
    "print(num_1 % num_2)\n",
    "\n",
    "## End question 1\n",
    "\n",
    "# Question 2: Python will place a higher order of importance to\n",
    "# operations specified within parenthesis. If you are given the 3\n",
    "# numbers below and asked to add the first two numbers first, then\n",
    "# divide by the third one, uncomment the line below that provides\n",
    "# the right result\n",
    "num_1 = 15\n",
    "num_2 = 25\n",
    "num_3 = 100\n",
    "\n",
    "## Uncomment the correct line below based on the question above\n",
    "print(num_1 + (num_2 / num_3))\n",
    "print((num_1 / num_2) + num_3)\n",
    "print(num_1 + (num_2 / num_3))\n",
    "print((num_1 + num_2) / num_3)\n",
    "\n",
    "## End question 2\n",
    "\n",
    "# Question 3: Import the randint function from the random module\n",
    "# so it can be used by it's name, randint, instead of referring\n",
    "# to the random module first\n",
    "## Write your code below, 1 line ##\n",
    "from random import randint\n",
    "my_num = randint(5,100) ; my_num\n",
    "## End question 3\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exam \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "###### First Question\n",
    "\n",
    "num_1 = 10\n",
    "num_2 = 300\n",
    "num_3 = 27.0\n",
    "num_4 = -10\n",
    "print(f\"Calculations section:\\nnum_1-> {num_1}\\nnum_2-> {num_2}\\nnum_3-> {num_3}\\nnum_4-> {num_4}\")\n",
    "print(f\"{num_1} multiplied by {num_2} is: {num_1*num_2}\")\n",
    "print(f\"{num_3} divided by {num_1} is: {num_3/num_1}\")\n",
    "print(f\"If I use floor division instead I get: {num_3//num_1}\")\n",
    "print(f\"The absolute value of {num_4} is: {abs(num_4)}\")\n",
    "print(f\"I converted {num_1} and {num_2} to strings, if I add them I get: {str(num_1+num_2)}\")\n",
    "print(f\"{num_4} is of the {type(num_4).__name__} class\")\n",
    "print(\"-\"*40)\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Second Question\n",
    "# Question 2a: Use two tabs to separate the evaluated variables in the string\n",
    "# below. Example output-> Added:     Price updater\n",
    "#                         Begin:     17:30:00\n",
    "#                         End:       18:30:00\n",
    "name_of_job = \"Price updater\"\n",
    "begin_time = \"17:30:00\"\n",
    "end_time = \"18:30:00\"\n",
    "print(f\"Added:\\t\\t{name_of_job}\")\n",
    "print(f\"Begin:\\t\\t{begin_time}\")\n",
    "print(f\"End:\\t\\t{end_time}\")\n",
    "print(\"-\"*40)\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 2b: Use new lines in addition to the two tabs noted above to\n",
    "# separate the evaluated variables in the string below.\n",
    "# Example output-> Added:     Price updater\n",
    "#                  Begin:     17:30:00\n",
    "#                  End:       18:30:00\n",
    "print(f\"Added:\\t\\t{name_of_job}\\nBegin:\\t\\t{begin_time}\\nEnd:\\t\\t{end_time}\")\n",
    "print(\"-\"*40)\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 3: Use the .format method to update the line below\n",
    "#name_of_job= input()\n",
    "#begin_time= input()\n",
    "#end_time= input()\n",
    "print(\"{} scheduled to begin at {} and end at {}\".format(name_of_job, begin_time,end_time))\n",
    "print(\"-\"*40)\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 4: Use the pow function from math module to evaluate 2 to the\n",
    "# power of 5, or 2^5\n",
    "import math\n",
    "print(\"2 to the power of 5 is listed below...\")\n",
    "print(str(math.pow(2,5)))\n",
    "print(\"-\"*40)\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 5: Use the log2 function from math module to evalute log base 2\n",
    "# of 32\n",
    "print(\"log base 2 of 32 is listed below...\")\n",
    "print(str(math.log2(32)))\n",
    "print(\"-\"*40)\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 6: Use slicing notation to print the last 6 letters of the string\n",
    "# below. Assume you donot know the start index or the length of the string upfront.\n",
    "# Hint: You will need to use a function to find the length first and then use that,\n",
    "# in combination with the number to come up with the start index\n",
    "welcome_message = \"Hello and welcome to the land of Python\"\n",
    "print(f\"The last 6 letters of the welcome message:\\n'{welcome_message}'\\nare: {welcome_message[32:39]}\")\n",
    "print(f\"The last 6 letters of the welcome message:\\n'{welcome_message}'\\nare: {welcome_message[len(welcome_message)-6:]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "print(\"Welcome to rule of three program\")\n",
    "print(\"-\"*30 )### Multiply by 30 the \"-\"\n",
    "\n",
    "choice=input(f\"Choose 1 to multiply,\\n 2 to divide-->\\t\")\n",
    "\n",
    "if choice== \"1\" or choice ==\"2\":\n",
    "    \n",
    "    num_1=float(input(\"enter a number -->\\t\"))or int(input(\"enter a number -->\\t\"))\n",
    "    num_2=int(input(\"enter a number-->\\t\")) or float(input(\"enter a number -->\\t\"))\n",
    "#     \n",
    "    if choice==\"1\":\n",
    "        print(f'{num_1} multiply by {num_2} is-->{round((num_1*num_2)/100,2)} are the Python\\'s lectures you have done')\n",
    "    else:\n",
    "        print(f'{num_1} divided by {num_2} is-->\\t{round((num_1*100)/num_2, 2)} percent of Python course \\n\\t\\t\\t you have done')\n",
    "else:\n",
    "    print(\"You've made an invalid selection\")\n",
    "          \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "(365*4)+3771.14\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_cond= False\n",
    "if truth_cond:\n",
    "    print(\"Truth\")\n",
    "else:\n",
    "        print(\"False\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "choice= \"1\"\n",
    "made_payment= False\n",
    "if choice == \"1\" and made_payment:\n",
    "    print(\"You have choosen option 1 \")\n",
    "elif choice==\"2\":\n",
    "    print(\"You have choosen option 2\")\n",
    "else: \n",
    "    print(\"You have choosen an invalid value\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "made_payment= False\n",
    "\n",
    "a=\"Please pay monthly premiun\"\n",
    "b=\"Welcome to your Homepage\"\n",
    "\n",
    "print(a) if not made_payment else print(b)\n",
    "print(b) if made_payment else print(a)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=10\n",
    "j=10\n",
    "k=10\n",
    "\n",
    "if i < j and i < k:\n",
    "    print(\"i is less than j and k\")\n",
    "\n",
    "elif i == j and i == k :\n",
    "    print(\"i is equal to j and k\")\n",
    "    \n",
    "elif i == j or i == k :\n",
    "    print(\"i is equal to either j or k\")\n",
    "\n",
    "else:\n",
    "    print(\"something else\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "course= \"Python\"\n",
    "a=\"Enrolled in Python course\"\n",
    "b=\"Enrolled in some other course\"\n",
    "\n",
    "if course== \"Python\":\n",
    "    print(a) if course== \"Python\" else print(b)\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 1: Write an if/else condition to print \"Access granted\"\n",
    "# if the account variable is equal to the string \"verified\" AND\n",
    "# payment_status is \"paid\". Else print \"Access denied\".\n",
    "account = \"verified\"\n",
    "payment_status = \"paid\"\n",
    "\n",
    "a= \"Access granted\"\n",
    "b= \"Access denied\"\n",
    "## Write your code below (variable number of lines)\n",
    "print(a) if not account== \"verified\" and payment_status== \"paid\" else print(b)\n",
    "\n",
    "\n",
    "## End question 1\n",
    "\n",
    "# Question 2: Modify your code above and introduce a check for\n",
    "# if account == \"verified\" and payment_status == \"pending\", then\n",
    "# print \"Temporary access granted, check payment status\", if the\n",
    "# payment status does not match either \"pending\" or \"paid\" (and\n",
    "# the account is still verified) then print \"Access denied, check payment\". \n",
    "# Other conditions from question 1 above still apply.\n",
    "account = \"verified\"\n",
    "payment_status = \"blocked\"\n",
    "## Write your code below (variable number of lines)\n",
    "\n",
    "if account == \"verified\" and payment_status == \"pending\":\n",
    "    print (\"Temporary access granted, check payment status\")\n",
    "elif account==\"verified\" or payment_status==\"pending\" or payment_status==\"paid\":\n",
    "    print (\"Access denied, check payment\")\n",
    "    \n",
    "## Copy/paste your code (entire block for question 2) below, this\n",
    "# if for a separate test for payment_status\n",
    "payment_status = \"blocked\"\n",
    "\n",
    "\n",
    "## End question 2\n",
    "\n",
    "# Question 3: Write an if/elif/else condition to check for the 3 account\n",
    "# types below and print the corresponding statement. If account type\n",
    "# matches none of these then it should print \"Access denied\"\n",
    "# a) account_type == \"admin\", should result in print \"Admin access\"\n",
    "# b) account_type == \"mod\", should result in print \"Moderator access\"\n",
    "# c) account_type == \"user\", should result in print \"User access\"\n",
    "account_type = \"mod\"\n",
    "## Write your code below (variable number of lines)\n",
    "\n",
    "if account_type== \"admin\":\n",
    "    print(\"Admin access\")\n",
    "elif account_type== \"mod\":\n",
    "    print(\"Moderator access\")\n",
    "elif account_type== \"user\":\n",
    "    print(\"User access\")\n",
    "else:\n",
    "    print(\"Access denied\")\n",
    "        \n",
    "## End question 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 3: Write an if/elif/else condition to check for the 3 account\n",
    "# types below and print the corresponding statement. If account type\n",
    "# matches none of these then it should print \"Access denied\"\n",
    "# a) account_type == \"admin\", should result in print \"Admin access\"\n",
    "# b) account_type == \"mod\", should result in print \"Moderator access\"\n",
    "# c) account_type == \"user\", should result in print \"User access\"\n",
    "account_type = \"mod\"\n",
    "## Write your code below (variable number of lines)\n",
    "\n",
    "if account_type== \"admin\":\n",
    "    print(\"Admin access\")\n",
    "elif account_type== \"mod\":\n",
    "    print(\"Moderator access\")\n",
    "elif account_type== \"user\":\n",
    "    print(\"User access\")\n",
    "else:\n",
    "    print(\"Access denied\")\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "node_1=\"custom object\"\n",
    "\n",
    "my_data_type=[1,2,False,4,\"mashur\", None, node_1, 5.0,1]\n",
    "print(my_data_type[4])\n",
    "print(type(my_data_type))\n",
    "#my_data_type[:-5]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ode_1=\"custom project\"\n",
    "\n",
    "y_data_type={1: \"hello\",2:\"elena\", 3:None, 5:5.0}\n",
    "print(y_data_type[2])\n",
    "print(type(y_data_type).__name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ode_1=\"custom project\"\n",
    "\n",
    "y_data_type={1,2,False,4,\"mashur\", None, node_1, 5.0,1}\n",
    "print(y_data_type)## i cannot use [](index) there is not ordering. The order have changed \n",
    "print(type(y_data_type).__name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples # are inmmutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ode_1=\"custom project\"\n",
    "\n",
    "y_data_type=(1,2,False,4,\"mashur\", None, node_1, 5.0,1)\n",
    "print(y_data_type[5])## It maintains the oder\n",
    "print(type(y_data_type).__name__)\n",
    "# we cannnot reassign values in tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "    my_list = [1,2,3,4,5,6,7,8]\n",
    "    my_list[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "    my_dict = {'name':'john','course':'python'}\n",
    "    print(my_dict[::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set = {1,6,2,'java','ruby',8,9,10,21,1000,'python',6}\n",
    "my_second_set = {6,2,'javascript','rails',8,9,10,21,1000,'c'}\n",
    "\n",
    "my_set.update(my_second_set); my_second_set \n",
    "# the items in my_second_set which are not in my_set simply get added to my_set, in no particular order"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Lists, both lectures 1 and 2\n",
    "\n",
    "# I have 3 lists declared below, play around with the following\n",
    "# functions, methods, slices or other ones you like on them\n",
    "# len(), min(), max(), append(), insert(), extend(), remove(), pop()\n",
    "# reverse()\n",
    "# Note: Some methods/functions above are covered in lecture 1\n",
    "# while others are covered in lecture 2\n",
    "\n",
    "my_list = [15, 6, 7, 8, 35, 12, 14, 4, 10, 15]\n",
    "my_strings_list = [\"comp sci\", \"physics\", \"elec engr\", \"philosophy\"]\n",
    "my_new_list = [\"art\", \"econ\"]\n",
    "#print(f\"Ints: {my_list}\")\n",
    "#print(f\"Strings: {my_strings_list}\")\n",
    "#print(f\"New list: {my_new_list}\")\n",
    "\n",
    "\n",
    "# Write your function or method code here\n",
    "#print(\"My altered lists...\")\n",
    "#print(my_strings_list)\n",
    "#print(my_new_list)\n",
    "\n",
    "info= print(sorted(my_list))\n",
    "\n",
    "my_list.sort()\n",
    "print(f\"Sorted Ints: {my_list}\")\n",
    "print(id(my_list))\n",
    "print(id(info))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [15, 6, 7, 8, 35, 12, 14, 4, 10, 15]\n",
    "my_strings_list = [\"comp sci\", \"physics\", \"elec engr\", \"philosophy\"]\n",
    "my_new_list = [\"art\", \"econ\"]\n",
    "print(f\"Ints: {my_list}\")\n",
    "print(f\"Strings: {my_strings_list}\")\n",
    "print(\"Finding info...\")\n",
    "\n",
    "print(2 in my_list)#there is not 2 in my_list. \n",
    "\n",
    "\n",
    "print(my_strings_list.index(\"elec engr\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [15, 6, 7, 8, 35, 12, 14, 4, 10, 15]\n",
    "my_strings_list = [\"comp sci\", \"physics\", \"elec engr\", \"philosophy\"]\n",
    "my_new_list = [\"art\", \"econ\"]\n",
    "print(f\"Ints: {my_list}\")\n",
    "print(f\"Strings: {my_strings_list}\")\n",
    "print(\"Finding info...\")\n",
    "print(my_strings_list[len(my_strings_list)-1])\n",
    "print(my_list[len(my_list)-2])## to find this value\n",
    "print(min(my_list))\n",
    "print(max(my_list))\n",
    "print(min(my_strings_list))\n",
    "print(dir(my_list))#all methods availables to list\n",
    "print(my_list.count(15)) #count appereance of a value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "    my_list = [15, 6, 7, 8, 35, 12, 14, 4, 10, 15]\n",
    "    my_new_list = my_list\n",
    "    my_new_list.sort()\n",
    "    print(f\"Sorted Ints: {my_new_list}\")\n",
    "    print(f\"Sorted Ints: {my_list}\")\n",
    "    print(my_list == my_new_list)\n",
    "    print(id(my_new_list))\n",
    "    print(id(my_list))\n",
    "#This is the correct answer(True). \n",
    "#Lists are mutable and the line my_new_list = my_list creates \n",
    "#a reference to the same object. When the sort() method is \n",
    "#run on my_new_list it sorts the list object that both my_new_list \n",
    "#and my_list are pointing to in-place. Since they are still the same object, \n",
    "#now in sorted order, the equality test returns True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 1: Given the list below, print the min value from the list using the\n",
    "# min function\n",
    "my_list = [903,373,223,4031,2033,535,677,601,403,340,370,352,441,293,567,8888,1031,788,161]\n",
    "## Write your code below, 1 line\n",
    "print(min(my_list))\n",
    "# End question 1\n",
    "\n",
    "# Question 2: Given the list below, using the 'in' operator, print (True or False) if\n",
    "# 'urgent' exists in the list.\n",
    "my_words_list = ['extreme', 'arrow', 'urgently', 'important', 'Urgent', 'imperative']\n",
    "## Write your code below, 1 line\n",
    "print(\"urgent\" in my_words_list)\n",
    "# End question 2\n",
    "\n",
    "# Question 3: Use the sorted function to sort my_list from question 1 and assign it to a variable\n",
    "# named my_sorted_list\n",
    "## Write your code below, 1 line\n",
    "my_list = [903,373,223,4031,2033,535,677,601,403,340,370,352,441,293,567,8888,1031,788,161]\n",
    "my_sorted_list=sorted(my_list); print(my_sorted_list)\n",
    "# End question 3\n",
    "\n",
    "# Question 4: Use the sort method to sort my_list from above and print out my_list below it\n",
    "## Write your code below, 2 lines\n",
    "my_list.sort()\n",
    "print(f\"Sorted list: {my_list}\")\n",
    "\n",
    "# End question 4\n",
    "\n",
    "# Question 5: Use the equality test to check if my_sorted_list is equal to my_list. Remember\n",
    "# to print the result.\n",
    "## Write your code below, 1 line\n",
    "print( my_sorted_list == my_list)\n",
    "    \n",
    "# End question 5\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### adding items or removing items\n",
    "## Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [15, 6, 7, 8, 35, 12, 14, 4, 10, 15]\n",
    "my_strings_list = [\"comp sci\", \"physics\", \"elec engr\", \"philosophy\"]\n",
    "my_new_list = [\"art\", \"econ\"]\n",
    "print(f\"Ints: {my_list}\")\n",
    "print(f\"Strings: {my_strings_list}\")\n",
    "print(\"Add/remove... \")\n",
    "\n",
    "    ### append(), insert(), extend()\n",
    "    #append: add elements at the end of the list\n",
    "    #insert: add elements in the index you choose \n",
    "    #extend: append two lists without index brackets([])\n",
    "\n",
    "#print(my_list.append(25))#print: None. WE sholud not do it\n",
    "my_list.append(25)\n",
    "print(my_list)\n",
    "\n",
    "my_list.insert(4,25)#first you provide the index and then the number you wanna append\n",
    "print(my_list)\n",
    "\n",
    "#my_strings_list.append(my_new_list)\n",
    "#print(my_strings_list)#### print: ['comp sci', 'physics', 'elec engr', 'philosophy', ['art', 'econ']]\n",
    "\n",
    "\n",
    "my_strings_list.extend(my_new_list)\n",
    "print(my_strings_list)#### print: ['comp sci', 'physics', 'elec engr', 'philosophy', 'art', 'econ']\n",
    "\n",
    "      #pop() and remove()\n",
    "      #pop: If you wanna do something with the value you are removing\n",
    "      #remove: remove a value. Remove the last value of a string\n",
    "\n",
    "my_strings_list.remove('comp sci')\n",
    "print(my_strings_list)#### print: ['physics', 'elec engr', 'philosophy', 'art', 'econ']\n",
    "\n",
    "print(my_strings_list.pop())#['physics', 'elec engr', 'philosophy', 'art', 'econ']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [15, 6, 7, 8, 35, 12, 14, 4, 10, 15]\n",
    "my_strings_list = [\"comp sci\", \"physics\", \"elec engr\", \"philosophy\"]\n",
    "my_new_list = [\"art\", \"econ\"]\n",
    "print(f\"Ints: {my_list}\")\n",
    "print(f\"Strings: {my_strings_list}\")\n",
    "print(\"Sublists... \")\n",
    "\n",
    "my_list[-1]=1000 ### Updating our list\n",
    "print(my_list[-1])\n",
    "print(my_list)\n",
    "\n",
    "print(my_list[:5])## the inicial 5 values\n",
    "print(my_list)\n",
    "\n",
    "print(my_list[5:])## the last five values\n",
    "print(my_list)\n",
    "\n",
    "print(my_list[:])## the full list\n",
    "print(my_list)\n",
    "\n",
    "print(my_list[::2])## print[15, 7, 35, 14, 10]\n",
    "print(my_list)\n",
    "\n",
    "print(my_list[::-1])## Reverse list\n",
    "#print[1000, 10, 4, 14, 12, 35, 8, 7, 6, 15]\n",
    "print(my_list)\n",
    "\n",
    "\n",
    "my_strings_list.reverse()## Reverse list\n",
    "print(my_strings_list)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [15, 6, 7, 8, 35, 12, 14, 4, 10, 15]\n",
    "my_strings_list = [\"comp sci\", \"physics\", \"elec engr\", \"philosophy\"]\n",
    "my_new_list = [\"art\", \"econ\"]\n",
    "print(f\"Ints: {my_list}\")\n",
    "print(f\"Strings: {my_strings_list}\")\n",
    "print(\"Sublists... \")\n",
    "\n",
    "for item in my_list:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "    my_list = [1,2,3,4,5]\n",
    "    my_new_list = []\n",
    "    for num in my_list:\n",
    "        my_new_list.append(num-my_list[num-1])\n",
    "    print(my_new_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "    my_string = \"level\"\n",
    "    for letter in my_string[::-1]:\n",
    "        print(letter, end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 1: Given the two lists below, add all the elements in the second list\n",
    "# to the end of the first list, then print out the first list. Choose the\n",
    "# appropriate method to add these elements so that you don't end up with a list\n",
    "# within a list (as in the first list 'my_courses' should only have string data, \n",
    "# not lists of strings).\n",
    "my_courses = ['comp sci','economics','physics','astronomy']\n",
    "new_courses = ['climate studies','artificial intelligence']\n",
    "## Write your code below, 2 lines ##\n",
    "my_courses.extend(new_courses)\n",
    "print(my_courses)\n",
    "\n",
    "## End question 1\n",
    "\n",
    "# Question 2: Given the string below, add it to the end of my_courses list which\n",
    "# you printed at the end of question 1, then print out my_courses\n",
    "new_course = 'tennis'\n",
    "## Write your code below, 2 lines\n",
    "my_courses.append(new_course)\n",
    "print(my_courses)\n",
    "\n",
    "# End question 2\n",
    "\n",
    "# Question 3: Choose the approprite method to delete 'economics' from my_courses\n",
    "# list and print the resulting my_courses list.\n",
    "## Write your code below, 2 lines\n",
    "my_courses.remove(\"economics\")\n",
    "print(my_courses)\n",
    "\n",
    "# End question 3\n",
    "\n",
    "# Question 4: Given the integer list below, print the length of the list (number\n",
    "# of integers in the list).\n",
    "my_int_list = [9,6,13,7,27,99,104,100,10,16,42,64]\n",
    "## Write your code below, 1 line\n",
    "print(len(my_int_list))\n",
    "# End question 4\n",
    "\n",
    "# Question 5: Grab the second half of my_int_list using slice notation and print\n",
    "# it to the screen\n",
    "## Write your code below, 1 line\n",
    "print(my_int_list[6:])\n",
    "# End question 5\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Dictionaries Notes provided by the course\n",
    "# Dictionaries are key value pairs and look like below:\n",
    "my_dictionary = {'name': 'mashrur', 'course': 'python', 'fav_food': 'ice cream'}\n",
    "phone_dict = {'mashrur': '555-55-5555',\n",
    "              'zoolander': '999-99-9999',\n",
    "              'jon_snow': 'fail-o-so-bad'}\n",
    "word_dict = {'a':\n",
    "                {\n",
    "                 'apple': 'the round fruit of a tree of the rose family',\n",
    "                 'ant': 'an insect which cleans up the floor'\n",
    "                },\n",
    "             'b':\n",
    "                {\n",
    "                 'bad': 'of poor quaity or low standard',\n",
    "                 'business': 'season 8 of GOT'\n",
    "                }\n",
    "            }\n",
    "print(my_dictionary)\n",
    "print(phone_dict)\n",
    "print(word_dict)\n",
    "\n",
    "# Dictionary keys should be immutable data types like strings and integers\n",
    "# To access a value, provide the key, for example if I wanted\n",
    "# the value associated with 'name' in my_dictionary above, I'd do\n",
    "# the following\n",
    "print(my_dictionary['name'])\n",
    "\n",
    "# I can re-assign the value associated with a key by using the key\n",
    "my_dictionary['name'] = 'john'\n",
    "print(my_dictionary)\n",
    "\n",
    "# I can add in a key value pair that doesn't exist in the dictionary\n",
    "my_dictionary['job'] = 'python programmer'\n",
    "print(my_dictionary)\n",
    "\n",
    "# I can keep going deeper by providing the keys one after the other\n",
    "# To access the value of business in the word_dict above, I can do\n",
    "# the following\n",
    "print(word_dict['b']['business'])\n",
    "\n",
    "# Use some methods to get keys, values and key, value pair as iterable\n",
    "print(my_dictionary.keys())\n",
    "print(my_dictionary.values())\n",
    "print(my_dictionary.items())\n",
    "\n",
    "# Get a listing of some methods available to dictionaries to test\n",
    "# them out by using the dir function\n",
    "print(dir(my_dictionary))\n",
    "\n",
    "# You can iterate through the key value pairs using a for loop\n",
    "for key, value in my_dictionary.items():\n",
    "    print(f'Key: {key}, Value: {value}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Dictionaries MY NOTES\n",
    "# Dictionaries are key value pairs and look like below:\n",
    "my_dictionary = {'name': 'mashrur', 'course': 'python', 'fav_food': 'ice cream'}\n",
    "phone_dict = {'mashrur': '555-55-5555',\n",
    "              'zoolander': '999-99-9999',\n",
    "              'jon_snow': 'fail-o-so-bad'}\n",
    "word_dict = {'a':\n",
    "                {\n",
    "                 'apple': 'the round fruit of a tree of the rose family',\n",
    "                 'ant': 'an insect which cleans up the floor'\n",
    "                },\n",
    "             'b':\n",
    "                {\n",
    "                 'bad': 'of poor quaity or low standard',\n",
    "                 'business': 'season 8 of GOT'\n",
    "                }\n",
    "            }\n",
    "print(word_dict[\"b\"][\"business\"], word_dict[\"b\"][\"bad\"])\n",
    "#method\n",
    "print(my_dictionary.get(\"course\"))\n",
    "my_dictionary[\"job\"]=\"python programmer\" ### change values or updating values\n",
    "my_dictionary[\"course\"]=\"java\"### change values or updating values\n",
    "print(my_dictionary)\n",
    "\n",
    "print(my_dictionary.keys())#give all the keys I have in \"my_dictionary\"\n",
    "print(my_dictionary.items())# give keys and given values\n",
    "\n",
    "for k,v in my_dictionary.items(): #k= keys\n",
    "                                  #v= values    \n",
    "    print(f\"Key: {k}, Value: {v}\")\n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Tuples Notes provided by the course\n",
    "# Key thing to remember about tuples is they are immutable\n",
    "\n",
    "my_random_tuple = ('first',1,7,6,4,5,8,'hi there',2,3,1,5,2,1,9,10)\n",
    "my_tuple = ('first_value','second_value','third_value')\n",
    "\n",
    "print(my_random_tuple)\n",
    "print(my_tuple)\n",
    "\n",
    "# You can 'unpack' the elements in a tuple by using tuple unpacking\n",
    "first_var, second_var, third_var = my_tuple\n",
    "print(first_var, second_var, third_var)\n",
    "\n",
    "# You can find out if an item exists in your tuple using 'in'\n",
    "print('hi there' in my_random_tuple)\n",
    "\n",
    "# You can use index and slice notation on tuples\n",
    "print(my_random_tuple[7])\n",
    "print(my_random_tuple[7:])\n",
    "\n",
    "# You can iterate through the items in a tuple using a simple for loop\n",
    "for item in my_random_tuple:\n",
    "    print(item)\n",
    "    \n",
    "# Try running the index and count methods on the tuples above\n",
    "# along with the len function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Tuples. My notes\n",
    "\n",
    "my_random_tuple = ('first',1,7,6,4,5,8,'hi there',2,3,1,5,2,1,9,10)\n",
    "my_tuple = ('first_value','second_value','third_value')\n",
    "\n",
    "print(my_random_tuple[5:])\n",
    "print(my_random_tuple[::-1])\n",
    "\n",
    "print(dir(my_random_tuple))### all aplicable methods\n",
    "print(my_random_tuple.count(5))#How many fives are in my_random_tuple?\n",
    "print(my_random_tuple.index(1))\n",
    "\n",
    "first_var, second_var, third_var= my_tuple\n",
    "print(third_var)\n",
    "print(\"first\" in my_random_tuple)\n",
    "\n",
    "\n",
    "for item in my_random_tuple:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### sets are in order \n",
    "### you cannot have duplicated values, the sets discard them\n",
    "my_set={1,6,2,\"java\", \"ruby\", 8,9,10,21,1000,\"python\",6}\n",
    "## How can I remove duplicated values in a list?\n",
    "my_list=[1,62,\"java\", \"ruby\",\"carlos\", 6, 8,9,10,21,1000,\"python\",6]\n",
    "### just  transform it in a set\n",
    "my_set= set(my_list)\n",
    "print(my_set)\n",
    "\n",
    "#### sets are good for finding information\n",
    "\n",
    "print(\"carlos\"in my_set)\n",
    "\n",
    "###### and also for mathematical operations\n",
    "my_set={1,6,2,\"java\", \"ruby\", 8,9,10,21,1000,\"python\",6}\n",
    "programming_set= {\"java\", \"ruby\",\"javascript\", \"python\", \"c\"}\n",
    "print(my_set.intersection(programming_set))##Gives us the values which appeared in both sets\n",
    "print(my_set.union(programming_set))## join both sets\n",
    "print(my_set.difference(programming_set))## elements which appeared in my_set but not in programming_set\n",
    "print(programming_set.difference(my_set))## elements which appeared in programming_set but not in my_set\n",
    "\n",
    "\n",
    "for item in my_set:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Dictionary exercises\n",
    "\n",
    "from collections import OrderedDict\n",
    "# Question 1: Create an empty dictionary called life_book of type OrderedDict. \n",
    "# From Python 3.6 onwards dictionaries maintain the order in which they were \n",
    "# created, however, this coding environment uses an earlier version of Python 3.\n",
    "# Therefore, use OrderedDict in this case, example my_dict = OrderedDict().\n",
    "# Once created, use the print function to print it.\n",
    "## Write your code below, 2 lines\n",
    "my_dict = OrderedDict()\n",
    "print(my_dict)\n",
    "\n",
    "# End question 1\n",
    "\n",
    "# Question 2: Add the following key, value pair to the life_book dictionary\n",
    "# 'pet' -> 'dog', so the key is pet and the value is dog and then print it.\n",
    "## Write your code below, 2 lines\n",
    "my_dict={\"pet\":\"dog\"}\n",
    "print(my_dict[\"pet\"])\n",
    "\n",
    "# End question 2\n",
    "\n",
    "# Question 3: Add the following key, value pairs to the dictionary\n",
    "# 'second_pet' -> 'cat'\n",
    "# 'first_child' -> 'boy'\n",
    "# 'second_child' -> 'girl'\n",
    "# Once added, print the dictionary.\n",
    "## Write your code below, variable lines\n",
    "my_dict['second pet'] = 'cat'\n",
    "my_dict['first_child'] = 'boy'\n",
    "my_dict['second_child'] = 'girl'\n",
    "print(my_dict)\n",
    "\n",
    "# End question 3\n",
    "\n",
    "# Question 4: Update the value associated with key 'pet' to be 'hamster', then\n",
    "# print the dictionary.\n",
    "## Write your code below, 2 lines\n",
    "my_dict[\"pet\"]= \"hamster\"\n",
    "print(my_dict[\"pet\"])\n",
    "\n",
    "# End question 4\n",
    "\n",
    "# Question 5: Given the dictionary below, use the items() method and save\n",
    "# the value of all the key value pairs to the variable courses_iterable.\n",
    "my_courses = {'a':'python', 'b':'javascript', 'c':'ruby on rails', 'd':'machine learning', 'e':'ai'}\n",
    "## Write your code below, 1 line\n",
    "print(my_courses.items())\n",
    "# End question 5\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 1: Create an empty set called my_ints, once it's created\n",
    "# use the type function (along with print) to print the type of my_ints.\n",
    "## Write your code below, 2 lines\n",
    "my_ints={ }\n",
    "print(type(my_ints).__name__)\n",
    "\n",
    "# End question 1\n",
    "\n",
    "# Question 2: Given the list below, convert it to a set named my_set and then\n",
    "# cast it back to a list called my_unique_list which only includes unique\n",
    "# elements. No print required.\n",
    "my_list = [1,1,'rails',7,6,2,'java','ruby',8,9,10,21,'rails',7,2,1000,6,'python','java']\n",
    "## Write your code below, 2 lines\n",
    "my_set=set(my_list)\n",
    "my_unique_list=list(my_set)\n",
    "\n",
    "\n",
    "# End question 2\n",
    "\n",
    "# Question 3: Add the int 8 to my_ints you created in question 1. Print the\n",
    "# output when you run the intersection method on my_ints and pass it my_set\n",
    "# (created in question 2) as the argument.\n",
    "## Write your code below, 2 lines\n",
    "my_ints={8}\n",
    "print(my_ints.intersection(my_set))\n",
    "\n",
    "# End question 3\n",
    "\n",
    "# Question 4: Test (and print) if 'rails' is in my_set\n",
    "## Write your code below, 1 line\n",
    "print(\"rails\" in my_set)\n",
    "# End question 4\n",
    "\n",
    "# Question 5: Given the tuple below, use a simple for loop and print out all\n",
    "# the elements in it (no special formatting).\n",
    "my_random_tuple = ('first',4,5,8,'hi there',5,2,1,9,10)\n",
    "## Write your code below\n",
    "for item in my_random_tuple:\n",
    "    print(item)\n",
    "\n",
    "# End question 5\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### iteration "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loop_1 =[6,8,1,4,10,7,8,9,3,2,5]\n",
    "my_dict={\"py\": \"python\", \"rb\":\"ruby\", \"js\":\"javascript\"}\n",
    "\n",
    "### sum of all ints\n",
    "sum=0\n",
    "\n",
    "for num in loop_1:\n",
    "    sum+= num#sum= sum+num. gives the same result\n",
    "    print(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for num in range(len(loop_1)):\n",
    "    sum+= loop_1[num] ## it gives the same value when we write sum=sum+loop_1[num]\n",
    "print(f\"Sum using range generator:\\t{sum}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loop_1 =[6,8,1,4,10,7,8,9,3,2,5]\n",
    "my_dict={\"py\": \"python\", \"rb\":\"ruby\", \"js\":\"javascript\"}\n",
    "run_times=int(input(\"How many times do you want to run\\t\"))\n",
    "\n",
    "# list(range(1,20,2))\n",
    "\n",
    "for num in range(run_times):\n",
    "    print(f\"Run\\t\\t{num+1}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loop_1 =[6,8,1,4,10,7,8,9,3,2,5]\n",
    "my_dict={\"py\": \"python\", \"rb\":\"ruby\", \"js\":\"javascript\"}\n",
    "\n",
    "for item in my_dict:\n",
    "    print(item)## gives just the Keys\n",
    "\n",
    "print(my_dict.items())## gives the keys and the given values\n",
    "\n",
    "for item in my_dict.items():\n",
    "    key, value= item\n",
    "    print(f\"Key: {key}, Value: {value}\")\n",
    "\n",
    "for key, value in my_dict.items():\n",
    "    print(f\"Key: {key}, Value: {value}\")    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate 100 random integers between 1 and 100\n",
    "from random import randint\n",
    "l1=[]\n",
    "for num in range(100):\n",
    "    l1.append(randint(1,100))\n",
    "    print(l1)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1=[randint(1,100) for num in range(100)]\n",
    "print(l1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1=[num+1 for num in range(100)]\n",
    "print(l1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint, choice\n",
    "from string import ascii_lowercase\n",
    "\n",
    "letters_1=[choice(ascii_lowercase) for num in range(100)]\n",
    "print(letters_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "# Question 1: Use list comprehension to update the code below and\n",
    "# assign my_list to be a list of 200 random integers ranging in values\n",
    "# between 25 and 500. Hint: Use the randint function\n",
    "my_list = [1,2,3,4,5] \n",
    "for num in range(200):\n",
    "    my_list.append(random.randint(25,500))\n",
    "    print(my_list)\n",
    "    \n",
    "# QUESTIO 2 i NEED TO CHECK IT OUT(4 parts): Cast my_list to a set and re-assign to my_list as a list.\n",
    "\n",
    "# How many duplicate values were removed?\n",
    "initial_size = len(my_list) \n",
    "print(f\"Initial size of my_list: {initial_size}\")\n",
    "\n",
    "# cast the list to a set to remove duplicates and re-assign to my_list as a list\n",
    "my_list = list(set(my_list)) \n",
    "final_size = len(my_list) \n",
    "\n",
    "print(f\"Final size of my_list after removing duplicates: {final_size}\")\n",
    "dups_removed = initial_size - final_size \n",
    "print(f\"Number of integers removed: {dups_removed}\")\n",
    "print('-'*40)\n",
    "print()\n",
    "\n",
    "# Question 3: What is the largest integer in my_list?\n",
    "largest_val = max(my_list) \n",
    "print(f\"Largest integer in my_list: {largest_val}\")\n",
    "print('-'*40)\n",
    "print()\n",
    "\n",
    "# Question 4: What is the smallest value in my_list?\n",
    "smallest_val = min(my_list) \n",
    "print(f\"Smallest integer in my_list: {smallest_val}\")\n",
    "print('-'*40)\n",
    "print()\n",
    "\n",
    "# Question 5: Create a tuple with the exact same values as my_list\n",
    "# name it my_tuple\n",
    "my_tuple = tuple(my_list)\n",
    "\n",
    "# Question 6: What are the last 3 values of my_tuple?\n",
    "my_tuple_last_val = my_tuple[-3] \n",
    "my_tuple_sec_last_val =my_tuple[-2]\n",
    "my_tuple_third_last_val = my_tuple[-1]\n",
    "print(f\"The last 3 values of the tuple are {(my_tuple_third_last_val,my_tuple_sec_last_val,my_tuple_last_val)}\")\n",
    "print('-'*40)\n",
    "print()\n",
    "\n",
    "# Question 7: Create a new tuple with all the values of my_tuple in\n",
    "# reversed order\n",
    "my_new_tuple = my_tuple[::-1] \n",
    "print(my_new_tuple)\n",
    "\n",
    "# Question 8: Does the first value of my_new_tuple match my_tuple_last_val?\n",
    "# Enter in the conditional below that will evaluate to True or False\n",
    "comparison = my_new_tuple[0]==my_tuple_last_val # replace the code to the left\n",
    "print(f\"First integer of my_tuple matches last integer of my_new_tuple is a {comparison} statement\")\n",
    "print('-'*40)\n",
    "print()\n",
    "\n",
    "\n",
    "# Question 9: Create a new tuple with the first 5 values of my_new_tuple\n",
    "my_other_tuple = my_new_tuple[:5] # replace the code to the left\n",
    "print(f\"My newly created 5 integer tuple is {my_other_tuple}\")\n",
    "print('-'*40)\n",
    "print()\n",
    "\n",
    "# Question 10: Do the integers (ignore order) of my_other_tuple match the values of\n",
    "# the last 5 integers in my_list? replace the boolean below with\n",
    "# a conditional that evaluates to True or False. You can use other variables\n",
    "# below as you need to complete this.\n",
    "tuple_and_list_comp = sorted(my_other_tuple) == my_list[len(my_list)-5:]\n",
    "print(f\"Integers in my_other_tuple match the last 5 integers of my_list is a {tuple_and_list_comp} statement\")\n",
    "print('-'*40)\n",
    "print()\n",
    "\n",
    "# Question 11: Find the intersection between the following two sets and\n",
    "# store it in my_match\n",
    "my_requirements = {'ruby','python'}\n",
    "available_languages = {\"comp sci\", \"physics\", \"elec engr\", \"philosophy\", \"python\"}\n",
    "my_match = my_requirements.intersection(available_languages)\n",
    "print(f\"I can take {my_match} since I need it and it's available\")\n",
    "print('-'*40)\n",
    "print()\n",
    "\n",
    "# Question 12: Given the dictionary below, create a list called my_al_list\n",
    "# which includes only the values (meaning) associated with each word.\n",
    "# my_al_list should look like ['the round fruit of a tree of the rose family',\n",
    "# 'an insect which cleans up the floor'......].\n",
    "# Obviously do this programmatically and don't hardcode it, you may use\n",
    "# other lines of code and variables as you see fit. Solution code has a couple of\n",
    "# options displayed.\n",
    "\n",
    "word_dict = {'a':\n",
    "                {\n",
    "                 'apple': 'the round fruit of a tree of the rose family',\n",
    "                 'ant': 'an insect which cleans up the floor'\n",
    "                },\n",
    "             'b':\n",
    "                {\n",
    "                 'bad': 'of poor quaity or low standard',\n",
    "                 'business': 'season 8 of GOT'\n",
    "                }\n",
    "            }\n",
    "\n",
    "my_al_list = [] \n",
    "for key, valueS in word_dict.items():\n",
    "    for meaning in valueS.values():\n",
    "        my_al_list.append(meaning)\n",
    "    \n",
    "print(f\"The meanings in the dictionary are {my_al_list}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## While loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_cond= True\n",
    "while truth_cond:\n",
    "    print(\"Hello\")\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=0\n",
    "while i<10:\n",
    "    i+=1\n",
    "    print(i)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=0\n",
    "while i<10:\n",
    "    print(i)\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint\n",
    "\n",
    "truth_cond= True\n",
    "\n",
    "loop_2= [randint(1,100)for num in range(1000)]### it is a list\n",
    "i=0\n",
    "num_to_search= 25### What index have the number 25?\n",
    "while i < len(loop_2):\n",
    "    if loop_2[i]== num_to_search:\n",
    "        print(f\"{num_to_search} found at index {i}\")\n",
    "        break\n",
    "    i+=1\n",
    " \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### doing the same with a simple loop\n",
    "loop_2= [randint(1,100)for num in range(1000)]### it is a list\n",
    "i=0\n",
    "num_to_search= 25### What index have the number 25?\n",
    "\n",
    "for num in loop_2:\n",
    "    i+=1\n",
    "    if num == num_to_search:\n",
    "        print(f\"{num_to_search} found at index {i}\")\n",
    "        break\n",
    "\n",
    " \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loop_2= [randint(1,100)for num in range(1000)]### it is a list\n",
    "i=0\n",
    "num_to_search= 25### What index have the number 25?\n",
    "\n",
    "for index, num in enumerate(loop_2):\n",
    "    if num == num_to_search:\n",
    "        print(f\"{num_to_search} found at index {index}\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    print(\"Please choose an option frm the list bellow:\\t\")\n",
    "    print(\"Press 1 for selection 1\")\n",
    "    print(\"Press 2 for selection 2\")\n",
    "    print(\"Press 3 to quit\")\n",
    "    selection =input(\"Enter your choice-->\\t\")\n",
    "    if int(selection)==3:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lopi=[\"comp sci\", \"physics\", \"elec engr\", \"philosophy\"]\n",
    "lopo=[\"cs\", \"phy\", \"elngr\", \"philo\"]\n",
    "tupled_list=list(zip(lopo,lopi))\n",
    "print(tupled_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Functions\n",
    "\n",
    "# The example custom functions used in the video are listed below:\n",
    "# This function uses no parameters as input and can be simply\n",
    "# called by it's name, say_hello()\n",
    "def say_hello():\n",
    "    print('Hello World!')\n",
    "\n",
    "# This function uses 2 parameters to perform the add operation\n",
    "# within it, therefore two numbers (strings will work too) will need\n",
    "# to be provided as arguments when the function is called\n",
    "# add_two_nums(4, 5)\n",
    "def add_two_nums(num_1, num_2):\n",
    "    print(num_1 + num_2)\n",
    "\n",
    "# Instead of printing out the summed value of the two numbers, the\n",
    "# function can be made to return the value instead. If nothing is\n",
    "# specified by the explicit use of the return keyword, then the None\n",
    "# datatype is returned by default by all functions to the caller\n",
    "def add_two_nums(num_1, num_2):\n",
    "    return num_1 + num_2\n",
    "\n",
    "my_added_num = add_two_nums(4,5) # The return value from function\n",
    "                                # call is being assigned to my_added_num\n",
    "print(my_added_num)             # printing out value of my_added_num\n",
    "# We can do this without the variable\n",
    "print(add_two_nums(4,5))\n",
    "\n",
    "# If we try to print out the value of a function call that returns None\n",
    "# meaning no return value was specified, then it prints None to the screen\n",
    "print(say_hello())\n",
    "# The call above will return in Hello World being printed to the screen\n",
    "# due to the code inside the function, followed by None, printed due\n",
    "# to the print function printing the returned value from the function\n",
    "\n",
    "# You can use doctstrings to provide information about your function\n",
    "# Example docstring\n",
    "def say_hello():\n",
    "    \"\"\"This function prints Hello World! to the screen\"\"\"\n",
    "    print('Hello World!')\n",
    "\n",
    "# More detailed docstring\n",
    "def add_two_nums(num_1, num_2):\n",
    "    \"\"\"\n",
    "    This function adds two objects\n",
    "    Input: Two objects to add, num_1 and num_2\n",
    "    Output: The value of the two objects added together\n",
    "    \"\"\"\n",
    "    return num_1 + num_2\n",
    "\n",
    "# In Python when a function returns multiple values separated by\n",
    "# commas in its return statement, these values are returned as tuples\n",
    "# which can then be unpacked by the caller\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bubble_sort(arr):\n",
    "    \"\"\"\n",
    "    Use bubblesort algorithm to sort a list of numbers\n",
    "    Input:list of integers (will work for stringd as well)\n",
    "    Output: sorted list of integers\n",
    "    \"\"\"\n",
    "    swap_happened= True\n",
    "    while swap_happened:\n",
    "        print(\"buble sort values\" +str(arr))\n",
    "        swap_happened= False\n",
    "        for num in range(len(arr)-1):\n",
    "            if arr[num]> arr[num+1]:\n",
    "                swap_happened= True\n",
    "                arr[num],arr[num+1]=arr[num+1],arr[num]\n",
    "\n",
    "long=[8,5,9,6,7,1,3,2,4,9,100,80,55]\n",
    "bubble_sort(long)\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "def recur_countdown_timer(n):\n",
    "    if n==0:\n",
    "        return n\n",
    "    else:\n",
    "        print(n)\n",
    "        time.sleep(1)\n",
    "        return recur_countdown_timer(n-1)\n",
    "\n",
    "def iter_countdown_timer(n):\n",
    "    while n> 0:\n",
    "        print(n)\n",
    "        time.sleep(1)\n",
    "        n-=1\n",
    "    print(n)   \n",
    "\n",
    "z=41\n",
    "\n",
    "print(f\"Countind dowm from {z}:\")\n",
    "iter_countdown_timer(z)\n",
    "#print(recur_countdown_timer(z))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note: We will practice writing simple functions in this exercise to get\n",
    "# the muscle memory in our fingers going (with typing python functions).\n",
    "\n",
    "# Question 1: You can define a function using the 'def' keyword. Create\n",
    "# a function called say_hello which does not take any arguments as parameters\n",
    "# and simply prints \"Hello\" within the function. If this function were called\n",
    "# it would print \"Hello\" to the screen. Note: No explicit return values.\n",
    "## Write your code below\n",
    "def say_hello():\n",
    "    print(\"Hello\")\n",
    "say_hello()\n",
    "\n",
    "# End question 1\n",
    "\n",
    "# Question 2: Create a new function called say_hello_premium(). This will return\n",
    "# the string \"Hello\" to the caller. Note: No print required.\n",
    "## Write your code below\n",
    "def say_hello_premium():\n",
    "    return \"Hello\"\n",
    "say_hello_premium()\n",
    "\n",
    "# End question 2\n",
    "\n",
    "# Question 3: Create a new function called yell_message() which takes a string\n",
    "# as an argument. Example def yell_message(some_string). This function takes\n",
    "# the parameter some_string, and prints it out to the screen after using the\n",
    "# upper method on it to capitalize all the letters in the string. Example, if\n",
    "# you called the function like this: yell_message(\"lol\"), the output to the\n",
    "# screen would be LOL.\n",
    "## Write your code below\n",
    "def yell_message(some_string):\n",
    "    return some_string.upper()\n",
    "    \n",
    "some_string= \"lol\"  \n",
    "yell_message(some_string)\n",
    "# End question 3\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_input_from_user():\n",
    "    return input(\"Enter your answer here -->\")\n",
    "print(\"welcome to the program, what is your name?\")\n",
    "name_result= get_input_from_user()\n",
    "\n",
    "print(\"What did you think of the food you ate today?\")\n",
    "food_result= get_input_from_user()\n",
    "\n",
    "print(\"What TV Show ending did you dislike the most ever\")\n",
    "show_result= get_input_from_user()\n",
    "\n",
    "print(f\"\\n To sumarize: your name is {name_result.capitalize()},\\\n",
    "you ate {food_result} food today and hated the ending of {show_result.upper()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note: We will practice writing some more simple functions in this exercise\n",
    "\n",
    "# Question 1: Write a function called simple_mult. It takes 2 arguments\n",
    "# as parameters and returns their multiplied value. Assume only numbers are\n",
    "# passed in as arguments, so you don't have to test for if the parameters\n",
    "# are numbers are not.\n",
    "## Write your code below\n",
    "def simple_mult(x,y):\n",
    "    return x*y\n",
    "simple_mult(5,4)\n",
    "\n",
    "# End question 1\n",
    "\n",
    "# Question 2: Create a new function called simple_mult_premium(). This will\n",
    "# take two numbers as parameters (int or float). You will need to check for if\n",
    "# both the parameters passed in are either of type \"int\" or \"float\" and return\n",
    "# their multiplied value if they are. If either of them are not \"int\" or \"float\"\n",
    "# return the string \"Need either int or float\". You can use the isinstance\n",
    "# function to test the type of the parameter. Example if you were testing num_1,\n",
    "# you can use code like isinstance(num_1, (int, float)) to test for int or float.\n",
    "# This expression will return True if num_1 is of type int or float (passed in\n",
    "# as a tuple here). You can also do this individually like below\n",
    "# isinstance(num_1, int)\n",
    "## Write your code below\n",
    "def simple_mult_premium(num_1,num_2):\n",
    "    if isinstance(num_1, (int, float)) == True and isinstance(num_2, (int, float))== True:\n",
    "        return num_1*num_2\n",
    "    else:\n",
    "        return \"Need either int or float\"\n",
    "simple_mult_premium(\"-\",5)\n",
    "\n",
    "\n",
    "# End question 2\n",
    "\n",
    "# Question 3: Create a new function called create_divider() which takes a string\n",
    "# as an argument and multiplies it by 40 to create a line full of the string\n",
    "# and prints it out to the screen. Example \"-\" * 10 would give you\n",
    "# ---------- so you can then use this function later on to create dividers in\n",
    "# your output if you wanted. Remember to multiply by 40 and not 10.\n",
    "## Write your code below\n",
    "def creater_divider(n):\n",
    "    return \"-\"*n\n",
    "creater_divider(40)\n",
    "\n",
    "# End question 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func_0(start_num):\n",
    "    start_num+=1\n",
    "    return func_1(start_num)\n",
    "\n",
    "def func_1(start_num):\n",
    "    start_num+=1\n",
    "    return start_num\n",
    "\n",
    "start_num=1\n",
    "print(f\"start_num\\t-->{start_num}\")\n",
    "finish_num= func_0(start_num)\n",
    "print(f\"calc'd_num\\t-->{finish_num}\")\n",
    "print(f\"start_num\\t-->{start_num}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func_0(other_num):\n",
    "    other_num[0] +=1\n",
    "    return func_1(other_num)\n",
    "\n",
    "def func_1(another_num):\n",
    "    another_num[0] +=1\n",
    "    return another_num\n",
    "\n",
    "start_num=[1]\n",
    "print(f\"start_num\\t-->{start_num}\")\n",
    "finish_num= func_0(start_num.copy())#finish_num= func_0(start_num[:]\n",
    "print(f\"calc'd_num\\t-->{finish_num}\")\n",
    "print(f\"start_num\\t-->{start_num}\")\n",
    "print(finish_num== start_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_func(func_name, some_list):\n",
    "    return func_name(some_list)\n",
    "l1 = [78,39,6,5,4,9,10,23,12]\n",
    "print(run_func(sorted, l1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func_0(arr_1, arr_2):\n",
    "    arr_3=[]       \n",
    "    for j in range(len(arr_1)):\n",
    "        if arr_1[j] < arr_2[j]:\n",
    "             arr_3.append(arr_1[j])\n",
    "        elif arr_1[j]> arr_2[j]:\n",
    "            arr_3.append(arr_2[j])\n",
    "    return(list(arr_3))\n",
    "        \n",
    "arr_1= list([5,9,3])\n",
    "arr_2= list([2,16,4])\n",
    "# output\n",
    "# arr_3= list([2,9,3])\n",
    "\n",
    "func_0(arr_1, arr_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func_1(arr_1, arr_2):\n",
    "    \n",
    "    sorting_1= list(sorted(arr_1))\n",
    "    sorting_2= list(sorted(arr_2))\n",
    "    arr_3= []\n",
    "    \n",
    "    for j in range(len(sorting_1)):\n",
    "        if sorting_1[j] < sorting_2[j]:\n",
    "             arr_3.append(sorting_1[j])\n",
    "        elif sorting_1[j]> sorting_2[j]:\n",
    "            arr_3.append(sorting_2[j])\n",
    "    return(list(arr_3))\n",
    "        \n",
    "# output\n",
    "# arr_3= list([2,4,9])\n",
    "arr_1= list([6,9,3])\n",
    "arr_2= list([11,2,4])\n",
    "\n",
    "print(func_0(arr_1,arr_2))\n",
    "\n",
    "print(func_1(arr_1,arr_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Hello\"\n",
    "\n",
    "def func_2(my_string):\n",
    "    my_string== \"\"\n",
    "    return '->'.join([my_string[0:1], my_string[1:2],my_string[2:3], my_string[3:4],my_string[4:5]])\n",
    "\n",
    "print(func_2(my_string))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Challenge exercise - list, tuple, dictionary and functions.\n",
    "# Sample execution code is provided at the bottom, you may run it now\n",
    "# to see and get a feel for the existing output then build each function\n",
    "# and re-run the script.\n",
    "from collections import Counter\n",
    "\n",
    "buckets = [ ('john.doe@example.com',{'first_name':'john','last_name':'doe'}),\n",
    "            ('jane.doe@example.com',{'first_name':'jane','last_name':'doe'}),\n",
    "            ('derek.zoo@example.com',{'first_name':'derek','last_name':'zoolander'}),\n",
    "            ('murph.cooper@example.com',{'first_name':'murph','last_name':'cooper'}),\n",
    "            ('ned.stark@example.com',{'first_name':'ned','last_name':'stark'})\n",
    "            ]\n",
    "# Question 1: Create a function that returns all last names in the list\n",
    "# with the number of occurances of that last name, example 'doe': 2, 'stark': 1\n",
    "# use the Counter function from collections module to count the occurances with ease.\n",
    "def get_last_name_count(list_of_records):\n",
    "    \"\"\"\n",
    "    fill in docstring\n",
    "    \"\"\"\n",
    "    list_of_last_names = []\n",
    "    for item in list_of_records:\n",
    "        email, full_name = item\n",
    "        list_of_last_names.append(full_name['last_name'])\n",
    "    return Counter(list_of_last_names)\n",
    "# Question 2: Create a function that compares first and last names of records\n",
    "# given the email address, first and last names to compare. Exact matches only,\n",
    "# ignore case. Return True if exact match, return False otherwise.\n",
    "\n",
    "def compare_full_name(list_of_records, email, first_name, last_name):\n",
    "    \"\"\"\n",
    "    fill in docstring\n",
    "    \"\"\"\n",
    "    for item in list_of_records:\n",
    "        record_email, full_name = item\n",
    "        if email == record_email:\n",
    "            return first_name == full_name['first_name'] and last_name == full_name['last_name']\n",
    "    return False\n",
    "\n",
    "# (CHALLENGE) Question 3: Create a function that can reset the value for first_name\n",
    "# and last_name for a record found with a specific email address\n",
    "# while leaving the rest of the list unchanged, if the email address\n",
    "# does not exist, then append a new record to the list with the new email\n",
    "# address, first name and last name.\n",
    "# Hint: Solutions use the enumerate function to track index of a record.\n",
    "\n",
    "def update_record(list_of_records, email, first_name, last_name):\n",
    "    \"\"\"\n",
    "    fill in docstring\n",
    "    \"\"\"\n",
    "    found_email = False\n",
    "    for index, record in enumerate(list_of_records):\n",
    "        record_email, full_name = record\n",
    "        if record_email == email:\n",
    "            found_email = True\n",
    "            break\n",
    "    if found_email:\n",
    "        list_of_records[index] = (email, {'first_name':first_name, 'last_name':last_name})\n",
    "    else:\n",
    "        list_of_records.append((email, {'first_name':first_name, 'last_name':last_name}))\n",
    "\n",
    "def divider():\n",
    "    print()\n",
    "    print(\"-\"*40)\n",
    "    print()\n",
    "\n",
    "print(\"The last names and their counts are as follows:\")\n",
    "result = get_last_name_count(buckets)\n",
    "for k, v in result.items():\n",
    "    print(f\"{k}: {v}\")\n",
    "divider()\n",
    "\n",
    "print(\"Does ned's first and last name match our records?\")\n",
    "print(compare_full_name(buckets,'ned.stark@example.com','ned','stark'))\n",
    "divider()\n",
    "\n",
    "print(\"Changing john's first name to jon and last name to snow\")\n",
    "update_record(buckets,'john.doe@example.com','jon','snow')\n",
    "divider()\n",
    "\n",
    "print(\"Adding new record ironman@example.com\")\n",
    "update_record(buckets,'ironman@example.com','iron','man')\n",
    "divider()\n",
    "\n",
    "print(\"Updated last names and their count are as follows:\")\n",
    "result = get_last_name_count(buckets)\n",
    "for k, v in result.items():\n",
    "    print(f\"{k}: {v}\")\n",
    "divider()\n",
    "\n",
    "print(\"Full list\")\n",
    "for item in buckets:\n",
    "    record_email, full_name = item\n",
    "    print(f\"Email: {record_email}, first name: {full_name['first_name']}, last_name: {full_name['last_name']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list=[0,8,78]\n",
    "my_String=\"elena\"\n",
    "my_dictionary={\"a\":\"apple\",\"b\":\"banana\"}\n",
    "\n",
    "dir(my_list)## methods available to list type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## build student class\n",
    "class Student:\n",
    "    pass\n",
    "elena=Student()## self\n",
    "elena.first_name=\"elena\"\n",
    "elena.last_name=\"peña gallardo\"\n",
    "jan=Student()\n",
    "jan.first_name=\"jan\"\n",
    "jan.last_name=\"scheller\"\n",
    "#different instancies\n",
    "print(elena.first_name, elena.last_name)\n",
    "print(jan.first_name, jan.last_name)\n",
    "\n",
    "\n",
    "# How can we sum up the code and save time coding?\n",
    "class Student:\n",
    "    def __init__(self, first, last ):\n",
    "        self.first_name= first\n",
    "        self.last_name= last\n",
    "        \n",
    "elena=Student(\"elena\",\"peña gallardo\")        \n",
    "jan=Student(\"jan\", \"scheller\")\n",
    "\n",
    "print(elena.first_name, elena.last_name)\n",
    "print(jan.first_name, jan.last_name)\n",
    "\n",
    "\n",
    "#### another example\n",
    "\n",
    "class Student:\n",
    "    def __init__(self, first, last,courses=None ):\n",
    "        self.first_name= first\n",
    "        self.last_name= last\n",
    "        if courses == None:\n",
    "            self.courses=[]\n",
    "        else:\n",
    "            self.courses=courses\n",
    "\n",
    "courses_1=[\"python\",\"rails\", \"javascript\"]        \n",
    "courses_2=[\"c\",\"rails\", \"java\"]        \n",
    "\n",
    "elena=Student(\"elena\",\"peña gallardo\", courses_1)   \n",
    "# elena= Student(\"elena\",\"peña gallardo\") \n",
    "jan=Student(\"jan\", \"scheller\",courses_2)\n",
    "\n",
    "print(elena.first_name, elena.last_name, elena.courses)\n",
    "print(jan.first_name, jan.last_name, jan.courses)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### adding some methods to class\n",
    "\n",
    "class Student:\n",
    "    def __init__(self, first, last,courses=None ):\n",
    "        self.first_name= first\n",
    "        self.last_name= last\n",
    "        if courses == None:\n",
    "            self.courses=[]\n",
    "        else:\n",
    "            self.courses=courses\n",
    "    \n",
    "    def add_course(self,course):\n",
    "        if course not in self.courses:\n",
    "            self.courses.append(course)\n",
    "        else:\n",
    "            print(f\"{self.first_name}is already enrolled in the {course})\"\n",
    "    \n",
    "    def remove_course(self,course):\n",
    "        if course in self.courses:\n",
    "                  self.courses.remove(course)\n",
    "        else:\n",
    "            print(f\"{course} not found\")\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"Student('{self.first_name}','{self.last_name}', {self.courses})\"\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.courses)\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f'First name: {self.first_name.capitalize()}\\\n",
    "        \\n Last name: {\"\".join(map(str.capitalize,self.last_name))} \\\n",
    "        \\n Courses:{\",\".join(map(str.capitalize,self.courses))}'\n",
    "        \n",
    "\n",
    "courses_1=[\"python\",\"rails\", \"javascript\"]        \n",
    "courses_2=[\"c\",\"rails\", \"java\"]        \n",
    "\n",
    "elena=Student(\"elena\",\"peña gallardo\", courses_1)   \n",
    "# elena= Student(\"elena\",\"peña gallardo\") \n",
    "jan=Student(\"jan\", \"scheller\",courses_2)\n",
    "\n",
    "print(len(elena))\n",
    "\n",
    "# elena.add_course(\"python\")\n",
    "# jan.remove_course(\"c\")\n",
    "# jan.remove_course(\"c\")\n",
    "\n",
    "# print(elena.first_name, elena.last_name, elena.courses, sep=\" \")\n",
    "# print(jan.first_name, jan.last_name, jan.courses)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 1: Write the minimum possible code necessary to create a class Company.\n",
    "# I will test this class by writing code such as below:\n",
    "## Write your code below, 2 lines ##\n",
    "class Company():\n",
    "    pass\n",
    "    \n",
    "\n",
    "company_a = Company()\n",
    "# company_a.name = \"School of Python\"\n",
    " company_a.name = \"\"\n",
    "print(company_a.name)\n",
    "\n",
    "## End question 1\n",
    "\n",
    "# Question 2: Write a class Travel which is a subclass of Company (Travel inherits\n",
    "# from Company). The Travel class should have the following features:\n",
    "# a) It should have an __init__() method which take a name as argument. \n",
    "# b) The default (if no name is provided) for name should be \"Generic\". So if \n",
    "# anyone created a Travel object with no name, it should automatically\n",
    "# be set to Generic.\n",
    "## Write your code below, variable lines ##\n",
    "class  Travel(Company):\n",
    "    def __init__(self,name=None):\n",
    "        if self.name== None:\n",
    "            print(\"Generic\")\n",
    "        else:\n",
    "            self.name=name\n",
    "\n",
    "# Travel.name = \"School of Python\"            \n",
    "# Travel.name=[]        \n",
    "    \n",
    "\n",
    "## End question 2\n",
    "\n",
    "# Question 3: Add a dunder str method to the Travel class (make sure it's tabbed in). \n",
    "# If we print an object of the class whose name is 'Adrenaline Junkies', it will\n",
    "# print \"Company name: Adrenaline Junkies\" to the screen. Use the .format() method.\n",
    "## Write your code below, 2 lines ##\n",
    "\n",
    "\n",
    "##\n",
    "\n",
    "# Question 4: Write a repr() method for the Travel class (make sure it's tabbed in), \n",
    "# so if we write the following code:\n",
    "# bever = Travel('bever')\n",
    "# print(repr(bever))\n",
    "# \n",
    "# The output will be like below:\n",
    "# Travel('bever')\n",
    "# Use the .format() method.\n",
    "## Write your code below, 2 lines\n",
    "\n",
    "\n",
    "##\n",
    "\n",
    "# Question 5: Write a set_name() method for the Travel class (make sure it's tabbed in).\n",
    "# This method accepts a new_name argument as a parameter and sets the name attribute\n",
    "# of the object to this new_name string. If we wrote the code below:\n",
    "# bever = Travel('bever')\n",
    "# print(bever)\n",
    "# bever.set_name('beverly hills')\n",
    "# print(bever)\n",
    "#\n",
    "# It would result in the following output\n",
    "# Company name: bever\n",
    "# Company name: beverly hills\n",
    "## Write your code below, 2 lines\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### lambda "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_math_func(x,f):\n",
    "    return f(x)\n",
    "def x_cube (x):\n",
    "    return x**3\n",
    "print(my_math_func(3, x_cube))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_math_func(x,f):\n",
    "    return f(x)\n",
    "# lambda x: x**3\n",
    "# print(my_math_func(3,lambda x: x**3))\n",
    "my_lambda= lambda x: x**3\n",
    "print(my_lambda(3))\n",
    "print(my_lambda(10))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint\n",
    "\n",
    "def my_math_func(x,f):\n",
    "    return f(x)\n",
    "my_lambda=lambda x: x**3\n",
    "\n",
    "my_letters=[\"a\",\"b\",\"c\",\"d\",\"e\"]\n",
    "# list(map(str.capitalize, my_letters))\n",
    "list(map(lambda x:x+x+x.capitalize(), my_letters))\n",
    "\n",
    "my_ints=[randint(1,1000)for num in range(100)]\n",
    "my_ints\n",
    "list(map(lambda x:x**3, my_ints))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 1: Write a lambda expression which takes an argument x as a parameter and simply returns x.\n",
    "# Assign this expression to a variable named my_lambda_func.\n",
    "## Write your code below, 1 line\n",
    "my_lambda_func= lambda x: x\n",
    "print(my_lambda_func(1))\n",
    "## End question 1\n",
    "\n",
    "# Question 2: Print the type of my_lambda_func. Hint: did you accidentally call the function?\n",
    "## Write your code below, 1 line\n",
    "print(type(my_lambda_func))\n",
    "## End question 2\n",
    "\n",
    "# Question 3: Write a lambda expression which returns the cosine of an argument x and assign it\n",
    "# to a variable named my_cos. Hint: math module\n",
    "## Write your code below, 2 lines\n",
    "import math\n",
    "my_cos=lambda x: math.cos(x)\n",
    "print(my_cos(5))\n",
    "\n",
    "## End question 3\n",
    "\n",
    "# Question 4: Write a lambda expression which models this equation f(x) = x^3 + 3x^2 + 200.\n",
    "# Asssign it to a variable my_eq1\n",
    "## Write your code below, 1 line\n",
    "my_eq1= lambda x: x^3+3*x^2 +200\n",
    "print(my_eq1(5))\n",
    "\n",
    "## End question 4\n",
    "\n",
    "# Question 5: Write a lambda expression which models this equation f(x,y,z) = x^3 + 3y^2 + z\n",
    "# where z is optional. If no value for z is provided use the default value of 100.\n",
    "# Assign this expression to a variable my_eq2\n",
    "## Write your code below, 1 line\n",
    "my_eq2= lambda x,y,z=100: x^3 + 3*y^2 + z(2,1,8)\n",
    "# print(my_eq2(2,1,8))\n",
    "## End question 5\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1=  [num for num in range(1,11)]\n",
    "l2=  [num for num in range(1,11)]\n",
    "## zip\n",
    "my_zipped_generator =zip(l1,l2)\n",
    "\n",
    "\n",
    "# print(next(my_zipped_generator))\n",
    "# print(next(my_zipped_generator))\n",
    "# print(next(my_zipped_generator))\n",
    "# print(next(my_zipped_generator))\n",
    "# print(next(my_zipped_generator))\n",
    "# print(next(my_zipped_generator))\n",
    "# print(next(my_zipped_generator))\n",
    "# print(next(my_zipped_generator))\n",
    "# print(next(my_zipped_generator))\n",
    "# print(next(my_zipped_generator))\n",
    "\n",
    "\n",
    "for item in my_zipped_generator:\n",
    "    print(item)\n",
    "\n",
    "\n",
    "print(list(my_zipped_generator))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## map\n",
    "my_cubed_ints=map(lambda x: x**3,l1)\n",
    "# print(list(my_cubed_ints))\n",
    "# for item in my_cubed_ints:\n",
    "#     print(item)\n",
    "# print(next(my_cubed_ints))\n",
    "\n",
    "def mash_map(f,some_iterable):\n",
    "    for item in some_iterable:\n",
    "        yield f(item)\n",
    "        \n",
    "print(l1)\n",
    "my_cubed_ints=mash_map(lambda x: x**3,l1)\n",
    "print(my_cubed_ints)\n",
    "\n",
    "print(next(my_cubed_ints))\n",
    "print(next(my_cubed_ints))\n",
    "print(next(my_cubed_ints))\n",
    "\n",
    "print(list(my_cubed_ints))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sorting Algorithms\n",
    "\n",
    "BiG O Notation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bubble_sort(arr):\n",
    "    \"\"\"\n",
    "    Fill in this docstring to practice writing docstrings\n",
    "    along with summarizing what the function does\n",
    "    \"\"\"\n",
    "    swap_happened = True\n",
    "    while swap_happened:\n",
    "        print('bubble sort status: ' + str(arr))\n",
    "        swap_happened = False\n",
    "        for num in range(len(arr)-1):\n",
    "            if arr[num] > arr[num+1]:\n",
    "                swap_happened = True\n",
    "                arr[num], arr[num+1] = arr[num+1], arr[num]\n",
    "\n",
    "l = [6, 8, 1, 4, 10, 7, 8, 9, 3, 2, 5] # original case\n",
    "# l = [10, 9, 8, 8, 7, 6, 5, 4, 3, 2, 1] # worst case\n",
    "# l = [1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10] # best case\n",
    "bubble_sort(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def selection_sort(arr):\n",
    "    spot_marker= 0\n",
    "    while spot_marker < len(arr):\n",
    "        for num in range(spot_marker, len(arr)):\n",
    "            if arr[num] < arr[spot_marker]:\n",
    "                arr[spot_marker], arr[num] = arr[num] , arr[spot_marker]\n",
    "        spot_marker += 1\n",
    "        print(arr)\n",
    "    \n",
    "\n",
    "l = [6, 8, 1, 4, 10, 7, 8, 9, 3, 2, 5] # original case\n",
    "selection_sort(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def insertion_sort(arr):\n",
    "    for key in range(1, len(arr)):\n",
    "        if arr[key] < arr[key-1]:\n",
    "            j = key\n",
    "            while j > 0 and arr[j] < arr[j-1]:\n",
    "                arr[j], arr[j-1] = arr[j-1], arr[j]\n",
    "                j -= 1\n",
    "            print (arr)\n",
    "l = [6, 1, 8, 4, 10] # original case\n",
    "insertion_sort(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### performance mesaures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bubble_sort(arr):\n",
    "    \"\"\"\n",
    "    Fill in this docstring to practice writing docstrings\n",
    "    along with summarizing what the function does\n",
    "    \"\"\"\n",
    "    swap_happened = True\n",
    "    comparisons   = 0\n",
    "    while swap_happened:\n",
    "        comparisons  += 1\n",
    "#         print('bubble sort status: ' + str(arr))\n",
    "        swap_happened = False\n",
    "        for num in range(len(arr)-1):\n",
    "            comparisons  += 1\n",
    "            if arr[num] > arr[num+1]:\n",
    "                swap_happened = True\n",
    "                arr[num], arr[num+1] = arr[num+1], arr[num]\n",
    "#     print(comparisons)### number of comparisons\n",
    "\n",
    "# l = [6, 8, 1, 4, 10, 7, 8, 9, 3, 2, 5] # original case, 99 comparisons\n",
    "# l = [10, 9, 8, 8, 7, 6, 5, 4, 3, 2, 1] # worst case o(n^2), 121 comparisons\n",
    "# l = [1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10] # best case is O(n), just 11 comparisons\n",
    "bubble_sort(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def selection_sort(arr):\n",
    "    spot_marker= 0\n",
    "    comparisons   = 0\n",
    "    while spot_marker < len(arr):\n",
    "        comparisons   += 1\n",
    "        for num in range(spot_marker, len(arr)):\n",
    "            comparisons   += 1\n",
    "            if arr[num] < arr[spot_marker]:\n",
    "                arr[spot_marker], arr[num] = arr[num] , arr[spot_marker]\n",
    "        spot_marker += 1\n",
    "    print(comparisons)\n",
    "    \n",
    "\n",
    "# l = [6, 8, 1, 4, 10, 7, 8, 9, 3, 2, 5] # original case, 77 comparisons\n",
    "# l = [10, 9, 8, 8, 7, 6, 5, 4, 3, 2, 1] # worst case o(n^2), 77 comparisons\n",
    "# l = [1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10] # best case is O(n^2), just 77 comparisons\n",
    "selection_sort(l)\n",
    "\n",
    "## "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$O(nlog(n))=n*log_2(n)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import log2\n",
    "5000*log2(5000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## merge sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_sorted(arr1,arr2):\n",
    "#     print(\"Merge function called with lists below:\")\n",
    "#     print(f\"left: {arr1} and right: {arr2}\")\n",
    "    sorted_arr = []\n",
    "    i, j = 0, 0\n",
    "    while i< len(arr1)and j< len(arr2):\n",
    "        if arr1[i]<arr2[j]:\n",
    "            sorted_arr.append(arr1[i])\n",
    "            i+=1\n",
    "        else:\n",
    "            sorted_arr.append(arr2[j])\n",
    "            j+=1\n",
    "        print(sorted_arr)\n",
    "    while i<len(arr1):\n",
    "        sorted_arr.append(arr1[i])\n",
    "        i+=1\n",
    "    while j< len(arr2):\n",
    "        sorted_arr.append(arr2[j])\n",
    "        j+=1\n",
    "    return sorted_arr\n",
    "\n",
    "# xxxxxxxxxxxxxxxx Program Execution xxxxxxxxxxxxxxxx\n",
    "l1 = [1,4,6,8,10]\n",
    "l2 = [2,3,5,7,8,9]\n",
    "print(f\"Merged list: {merge_sorted(l1,l2)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recurse divide function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def divide_arr(arr):\n",
    "    if len(arr)< 2:\n",
    "        print(f\"Base condition reched with {arr[:]}\")\n",
    "        return arr[:]\n",
    "    else:\n",
    "        middle=len(arr)//2\n",
    "        print(\"Current list to work with:\", arr)\n",
    "        print(\"Left split:\", arr[:middle])\n",
    "        print(\"Right split:\", arr[middle:])\n",
    "        l1= divide_arr(arr[:middle])\n",
    "        l2= divide_arr(arr[middle:])\n",
    "        return merge_sorted(l1,l2)\n",
    "\n",
    "l= [6,8,1,4,10,7,8,9,3,2,5]\n",
    "print(divide_arr(l))\n",
    "\n",
    "# l=[8,6,2,5]\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Countdown timer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "def recur_countdown_timer(n):\n",
    "    if n== 0:\n",
    "        return n\n",
    "    else:\n",
    "        print(n)\n",
    "        time.sleep(1)\n",
    "        return recur_countdown_timer(n-1)\n",
    "\n",
    "def iter_countdown_timer(n):\n",
    "    while n >0:\n",
    "        print(n)\n",
    "        time.sleep(1)## delay for 1 second\n",
    "#         return iter_countdown_timer(n-1)# it returns just from 5 until 1\n",
    "        n-=1\n",
    "    print(n)#it returns from 5 until 0\n",
    "\n",
    "\n",
    "z=5\n",
    "\n",
    "print(f\"Counting down from {z}\")\n",
    "iter_countdown_timer(z)\n",
    "# print(recur_countdown_timer(z))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## factorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial_recur(n):\n",
    "    if n== 0  :\n",
    "        return 1\n",
    "    else:\n",
    "        print(n)\n",
    "        time.sleep(1)\n",
    "        return n*factorial_recur(n-1)\n",
    "\n",
    "\n",
    "# z=0#expecting 1\n",
    "# print(f\"The value of {z}: is {factorial_recur(z)}\")\n",
    "\n",
    "z= 6#expecting 1\n",
    "print(f\"The value of {z}: is {factorial_recur(z)}\")\n",
    "\n",
    "# z=2 #expecting 2\n",
    "# print(f\"The value of {z}: is {factorial_recur(z)}\")\n",
    "\n",
    "# z=5 #expecting 120\n",
    "# print(f\"The value of {z}: is {factorial_recur(z)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### fibonacci series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fb_recur(n):\n",
    "    if n== 0:\n",
    "        return 0\n",
    "    elif n== 1  :\n",
    "        return 1\n",
    "    else:\n",
    "        fibs = [0, 1]\n",
    "        for i in range(2, n+1):\n",
    "            fibs.append(fibs[-1] + fibs[-2])\n",
    "    return fibs\n",
    "def fib_runner(z):\n",
    "    pass\n",
    "#     print(f\"The {z}th number in the Fibonacci sequence is {fib_recur(z)}\")\n",
    "\n",
    "z=10\n",
    "print(fb_recur(z))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def fib_to(n):\n",
    "# fibs = [0, 1]\n",
    "#     for i in range(2, n+1):\n",
    "#         fibs.append(fibs[-1] + fibs[-2])\n",
    "#     return fibs\n",
    "# fib_to(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## quicksort\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quicksort(arr):\n",
    "    \"\"\"\"\n",
    "    Input: unsorted integers list \n",
    "    returns sorted integers list using Quicksort\n",
    "    Note: This is not in-place implementation\n",
    "    \"\"\"\n",
    "    if len(arr)< 2:\n",
    "        return arr\n",
    "    else:\n",
    "        pivot= arr[-1]\n",
    "        smaller, equal, larger= [], [] , []\n",
    "        for num in arr:\n",
    "            if num < pivot: \n",
    "                smaller.append(num)\n",
    "            elif num== pivot: \n",
    "                equal.append(num)\n",
    "            else: \n",
    "                    larger.append(num)\n",
    "        return quicksort(smaller) + equal + quicksort(larger)\n",
    "\n",
    "l = [6,8,1,4,10,7,8,9,3,2,5]\n",
    "print(quicksort(l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mergesort(arr):\n",
    "    if len(arr) < 2:\n",
    "        return arr[:]\n",
    "    else:\n",
    "        middle = len(arr)//2\n",
    "        l1 = mergesort(arr[:middle])\n",
    "        l2 = mergesort(arr[middle:])\n",
    "#         return merge_sorted(l1, l2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### exercises "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### generate a random integers list\n",
    "from random import randint\n",
    "import time\n",
    "\n",
    "\n",
    "def random_list(size, max_val):\n",
    "    random_numbers= []\n",
    "    for num in range(size):\n",
    "        random_numbers.append(randint(1,max_val))\n",
    "    return random_numbers\n",
    "\n",
    "def analyze_func(func_name, arr):\n",
    "    tic = time.time()\n",
    "    func_name(arr)\n",
    "    toc= time.time()\n",
    "    seconds= toc-tic\n",
    "    print(f\"{func_name.__name__.capitalize()}\\t Elapsed time -> {seconds:.5f}\")\n",
    "    \n",
    "    \n",
    "size=int(input(\"What size list do you want to create \\t\" ))\n",
    "max_val=int(input(\"What is the maximum value do you want to create \\t\" ))\n",
    "run_times= int(input(\"How many times do you want to run ? \\t\" ))\n",
    "\n",
    "# run_time \n",
    "\n",
    "for num in range(run_times):\n",
    "    print(f\"Run: {num+1}\")\n",
    "    l=random_list(size,max_val)\n",
    "#     analyze_func(bubble_sort,l.copy())\n",
    "    analyze_func(quicksort,l)\n",
    "#     analyze_func(mergesort,l)\n",
    "    analyze_func(sorted,l)\n",
    "    print(\"-\"*40)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Searching, Data Structures, Projects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import log\n",
    "log(10000000,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Binary/Bisection search algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bisection_iter(n,arr):\n",
    "    start=0\n",
    "    stop=len(arr)-1\n",
    "    while start <= stop:\n",
    "        mid= (start+stop) // 2\n",
    "\n",
    "    #     print(arr[mid])\n",
    "        if n == arr[mid]:\n",
    "            return f\"{n}\\t found at index:\\t{mid}\"\n",
    "        elif n > arr[mid]:\n",
    "            start= mid+1\n",
    "        else:\n",
    "            stop=mid-1\n",
    "        print(\"start\", start)\n",
    "        print(\"stop\", stop)\n",
    "    return  f\"{n} not found in list\"\n",
    "\n",
    "def create_list(max_value):\n",
    "    arr=[]\n",
    "    for num in range(1, max_val+1):\n",
    "        arr.append(num)\n",
    "    return arr\n",
    "\n",
    "l=  [1,2,3,4,5,6,7,8,9,10]\n",
    "#ind 0 1 2 3 4 5 6 7 8 9\n",
    "\n",
    "# num_to_search= 5\n",
    "# num_to_search= 8\n",
    "# num_To_search= 2\n",
    "# num_to_search=-1\n",
    "num_to_search= 1\n",
    "\n",
    "print(bisection_iter(num_to_search, l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bisection_iter(n,arr):\n",
    "    start=0\n",
    "    stop=len(arr)-1\n",
    "    while start <= stop:\n",
    "        mid= (start+stop) // 2\n",
    "\n",
    "    #     print(arr[mid])\n",
    "        if n == arr[mid]:\n",
    "            return f\"{n}\\t found at index:\\t{mid}\"\n",
    "        elif n > arr[mid]:\n",
    "            start= mid+1\n",
    "        else:\n",
    "            stop=mid-1\n",
    "    \n",
    "    return  f\"{n}\\t not found in list\"\n",
    "\n",
    "def create_list(max_val):\n",
    "    arr=[]\n",
    "    for num in range(1, max_val+1):\n",
    "        arr.append(num)\n",
    "    return arr\n",
    "\n",
    "l= create_list(7)\n",
    "for num in range(16):\n",
    "    print(bisection_iter(num, l))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Binary search. Recursive implementation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bisection_recur(n,arr, start, stop):\n",
    "    if start > stop: \n",
    "        return f\"{n} not found in list\"\n",
    "    else:\n",
    "        mid=(start+stop)//2\n",
    "        if n == arr[mid]:\n",
    "            return f\"{n}\\t found at index:\\t{mid}\"\n",
    "        elif n > arr[mid]:\n",
    "            return bisection_recur(n, arr, mid+1,stop)# check list to the right of mid\n",
    "        else:\n",
    "            return bisection_recur(n, arr, stop, mid-1)# check list to the left of mid \n",
    "\n",
    "\n",
    "def create_list(max_value):\n",
    "    arr=[]\n",
    "    for num in range(1, max_val+1):\n",
    "        arr.append(num)\n",
    "    return arr\n",
    "\n",
    "l=  [1,2,3,4,5,6,7,8,9,10]\n",
    "#ind 0 1 2 3 4 5 6 7 8 9\n",
    "\n",
    "\n",
    "for num in range(16):\n",
    "    print(bisection_recur(num, l, 0, len(l)-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### code for preparing the project"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from random import choice\n",
    "from string import ascii_lowercase as letters\n",
    "\n",
    "def bisection_iter(n, arr):\n",
    "    start = 0\n",
    "    stop = len(arr)-1\n",
    "    while start <= stop:\n",
    "        mid = (start + stop)//2\n",
    "        if n == arr[mid]:\n",
    "            return mid, f\"{n} found at index: {mid}\" # return tuple\n",
    "        elif n > arr[mid]:\n",
    "            start = mid + 1\n",
    "        else:\n",
    "            stop = mid - 1\n",
    "    return None, f\"{n} not found in list\"\n",
    "\n",
    "def analyze_func(func_name, *args):\n",
    "    tic = time.time()\n",
    "    func_name(*args) # accept variable list of arguments\n",
    "    toc = time.time()\n",
    "    seconds = toc-tic\n",
    "    print(f\"{func_name.__name__.capitalize()}\\t-> Elapsed time: {seconds:.5f}\")\n",
    "\n",
    "###### functions to generate lists of random emails ######\n",
    "def generate_name(length_of_name):\n",
    "    return ''.join(choice(letters) for i in range(length_of_name))\n",
    "\n",
    "def get_domain(list_of_domains):\n",
    "    return choice(list_of_domains)\n",
    "\n",
    "def generate_emails(length_of_name, list_of_domains, total_emails):\n",
    "    emails = []\n",
    "    for num in range(total_emails):\n",
    "        emails.append(generate_name(length_of_name)+\"@\"+get_domain(list_of_domains))\n",
    "    return emails\n",
    "\n",
    "# print(generate_name(188))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Add domains to list below for additional email extensions\n",
    "list_of_domains = ['yaexample.com','goexample.com','example.com']\n",
    "\n",
    "# Generate emails\n",
    "emails = generate_emails(7,list_of_domains,1000000)# 7=lenght of the email, 1000000=number of emails\n",
    "\n",
    "\n",
    "# Test email to add to list of emails, followed by append to list\n",
    "email = 'mashrur@example.com'\n",
    "emails.append(email)\n",
    "\n",
    "# Sort list of generated emails\n",
    "sorted_emails = sorted(emails)#;sorted_emails \n",
    "\n",
    "\n",
    "# # Run bisection search to find test email in sorted list of emails\n",
    "index, found = bisection_iter(email, sorted_emails)\n",
    "\n",
    "# # Print result from function\n",
    "print(found)\n",
    "\n",
    "# # Print index returned by function used on the list of sorted emails\n",
    "if index:   print(f\"element at index: {index} is {sorted_emails[index]}\")\n",
    "\n",
    "# # Run analysis of functions\n",
    "analyze_func(bisection_iter, email, sorted_emails)\n",
    "analyze_func(generate_emails, 7, list_of_domains, 1000000)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hashmaps O(1) for search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AlgoHashTable:\n",
    "    def __init__(self,size):\n",
    "        self.size=size\n",
    "        self.hash_table= self.create_buckets()\n",
    "        \n",
    "    def create_buckets(self):\n",
    "        return [[]for _ in range(self.size)]\n",
    "    \n",
    "    def set_val(self,key,value):\n",
    "        hashed_key= hash(key)%self.size\n",
    "        bucket=self.hash_table[hashed_key]\n",
    "        found_key= False\n",
    "       \n",
    "        for index, records in enumerate(bucket):\n",
    "            record_key,record_value=records\n",
    "            if record_key ==key:\n",
    "                found_key= True\n",
    "                break\n",
    "        if found_key:#key exists\n",
    "            bucket[index]=(key,value)\n",
    "        \n",
    "        else:\n",
    "            bucket.append((key,value))\n",
    "\n",
    "  \n",
    "    def get_val(self,key):\n",
    "        hashed_key= hash(key)%self.size\n",
    "        bucket=self.hash_table[hashed_key]\n",
    "        found_key= False\n",
    "        for index, records in enumerate(bucket):\n",
    "            record_key,record_value=records\n",
    "            if record_key ==key:\n",
    "                found_key= True\n",
    "                break\n",
    "        if found_key:\n",
    "            return record_value\n",
    "        else:\n",
    "            return \"No record found with that email address\"\n",
    "   ###### I don't know how delete keys or values\n",
    "#     def remove_val(self,key):\n",
    "#         hashed_key= hash(key)%self.size\n",
    "#         bucket=self.hash_table[hashed_key]\n",
    "#         found_key= False\n",
    "#         for index, records in enumerate(bucket):\n",
    "#             record_key,record_value=records\n",
    "#             if record_key ==key:\n",
    "#                 found_key= True\n",
    "#                 break\n",
    "#         if found_key:\n",
    "#             del key\n",
    "#             return key\n",
    "        else:\n",
    "            return \"No record found with that email address\"\n",
    "    \n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"\".join(str(item)for item in self.hash_table)\n",
    "  \n",
    "    \n",
    "hash_table= AlgoHashTable(256)\n",
    "# # print(Hash_table)\n",
    "hash_table.set_val('elenpena@ucm.es', {'first_name':'Elena', 'last_name': 'Peña'})\n",
    "hash_table.set_val('cala@ucm.es', {'first_name':'Cala', 'last_name': 'Peña'})\n",
    "hash_table.set_val('ca@ucm.es', {'first_name':'Ca', 'last_name': 'Peña'})\n",
    "\n",
    "#1 hash_table.set_val(\"cala@ucm.es\",\"some value\")\n",
    "# print(hash_table)\n",
    "# hash_table.set_val(\"elenpena@ucm.es\",\"soy la mejor\")\n",
    "#print(hash_table)\n",
    "# print(hash_table.get_val('elenpena@ucm.es'))\n",
    "# print(hash_table.get_val('cala@ucm.es'))\n",
    "\n",
    "print(hash_table.remove_val('first_name'))\n",
    "print(hash_table)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "records=[(\"elenpena@ucm.es\",\"some value\"),\n",
    "         (\"ela@ucm.es\",\"some value\"),\n",
    "         (\"cala@ucm.es\",\"some value\")]\n",
    "\n",
    "for index, records in enumerate(records):\n",
    "    key,value=records\n",
    "    if key ==\"ela@ucm.es\":\n",
    "        break\n",
    "\n",
    "    print(index,key,value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import choice\n",
    "from string import ascii_lowercase as letters\n",
    "\n",
    "list_of_domains = ['yaexample.com','goexample.com','example.com']\n",
    "\n",
    "quotes = [  'Luck is what happens when preparation meets opportunity',\n",
    "            'All cruelty springs from weakness',\n",
    "            'Begin at once to live, and count each separate day as a separate life',\n",
    "            'Throw me to the wolves and I will return leading the pack']\n",
    "\n",
    "def generate_name(length_of_name):\n",
    "    return ''.join(choice(letters) for i in range(length_of_name))\n",
    "\n",
    "def get_domain(list_of_domains):\n",
    "    return choice(list_of_domains)\n",
    "\n",
    "def get_quotes(list_of_quotes):\n",
    "    return choice(list_of_quotes)\n",
    "\n",
    "def generate_records(length_of_name, list_of_domains, total_records, list_of_quotes):\n",
    "    with open(\"data.txt\", \"w\") as to_write:\n",
    "        for num in range(total_records):\n",
    "            key = generate_name(length_of_name)+\"@\"+get_domain(list_of_domains)\n",
    "            value = get_quotes(quotes)\n",
    "            to_write.write(key + \":\" + value + \"\\n\")\n",
    "        to_write.write(\"mashrur@example.com:Don't let me leave Murph\\n\")\n",
    "        to_write.write(\"evgeny@example.com:All I do is win win win no matter what!\\n\")\n",
    "\n",
    "generate_records(10, list_of_domains, 100000, quotes)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# linked list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "    \n",
    "    def __init__(self,data=None): ## data and the pointer\n",
    "        self.data= data\n",
    "        self.next=None\n",
    "        \n",
    "    def __str__(self):\n",
    "        return f\"{self.data}\"\n",
    "    \n",
    "    \n",
    "class Linkedlist:\n",
    "    \n",
    "    def __init__ (self):\n",
    "        self.head= None\n",
    "        self.tail=None\n",
    "    \n",
    "    def append_val(self,x):\n",
    "        \n",
    "        \"\"\" add x to the end of the list\"\"\"\n",
    "        if not isinstance(x,Node):\n",
    "            x= Node(x)\n",
    "        if self.head== None:\n",
    "            self.head=x\n",
    "        else:\n",
    "            self.tail.next=x\n",
    "        self.tail=x\n",
    "    \n",
    "    def __str__(self):\n",
    "        \n",
    "        to_print= \"\"\n",
    "        curr=self.head\n",
    "        while curr is not None:\n",
    "            to_print += str(curr.data)+ \"->\"\n",
    "            curr= curr.next\n",
    "        if to_print:\n",
    "            return \"[\" + to_print[:-2] + \"]\"\n",
    "        return \"[]\"\n",
    "    \n",
    "    \n",
    "    def add_to_start(self,x):\n",
    "        \"\"\" add x tp the left of the list making it the head\"\"\"\n",
    "        pass\n",
    "    def search_val(self, x):\n",
    "        \"\"\" return indices where x was found\"\"\"\n",
    "        pass\n",
    "    def remove_val_by_index(self, x):\n",
    "        \"\"\" remove and return value at index x provided as parameter\"\"\"\n",
    "        pass\n",
    "    def length(self):\n",
    "        \"\"\" return the length of the list, rep'd by number of nodes\"\"\"\n",
    "        pass\n",
    "\n",
    "node1= Node(1)\n",
    "node2= Node(2)\n",
    "node3= Node(3)\n",
    "node4= Node(4)\n",
    "node5= 5\n",
    "# node5= Node(5)\n",
    "\n",
    "\n",
    "mylist=Linkedlist()\n",
    "print(mylist)\n",
    "\n",
    "mylist.append_val(node1)\n",
    "mylist.append_val(node2)\n",
    "mylist.append_val(node3)\n",
    "mylist.append_val(node4)\n",
    "mylist.append_val(node5)\n",
    "print(mylist)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "    \n",
    "    def __init__(self,data=None): ## data and the pointer\n",
    "        self.data= data\n",
    "        self.next=None\n",
    "        \n",
    "    def __str__(self):\n",
    "        return f\"{self.data}\"\n",
    "    \n",
    "    \n",
    "class Linkedlist:\n",
    "    \n",
    "    def __init__ (self):\n",
    "        self.head= None\n",
    "        self.tail=None\n",
    "    \n",
    "    def append_val(self,x):\n",
    "        \n",
    "        \"\"\" add x to the end of the list\"\"\"\n",
    "        if not isinstance(x,Node):\n",
    "            x= Node(x)\n",
    "        if self.head== None:\n",
    "            self.head=x\n",
    "        else:\n",
    "            self.tail.next=x\n",
    "        self.tail=x\n",
    "    \n",
    "    def __str__(self):\n",
    "        \n",
    "        to_print= \"\"\n",
    "        curr=self.head\n",
    "        while curr is not None:\n",
    "            to_print += str(curr.data)+ \"->\"\n",
    "            curr= curr.next\n",
    "        if to_print:\n",
    "            return \"[\" + to_print[:-2] + \"]\"\n",
    "        return \"[]\"\n",
    "    \n",
    "    def reverse_list_recur(self, current, previous):\n",
    "        \"\"\" reverse the sequence of node pointers in the linked list\"\"\"\n",
    "        if self.head==None:\n",
    "            return\n",
    "        elif current.next==None:\n",
    "            self.tail= self.head\n",
    "            current.next= previous\n",
    "            self.head= current\n",
    "        else:\n",
    "            next= current.next\n",
    "            current.next=previous\n",
    "            self.reverse_list_recur(next,current)\n",
    "    \n",
    "mylist=Linkedlist()\n",
    "############## Recursive  exercise\n",
    "mylist.append_val(1)\n",
    "mylist.append_val(2)\n",
    "mylist.append_val(3)\n",
    "mylist.append_val(4)\n",
    "mylist.append_val(5)\n",
    "print(mylist)\n",
    "\n",
    "mylist.reverse_list_recur(mylist.head, None)\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Stacks and Queues"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A B C F G H K \n",
      "F C A B G K H \n",
      "C A B G K H F \n",
      "Value not found in tree\n",
      "A B C F H K \n"
     ]
    }
   ],
   "source": [
    "class Node:\n",
    "    def __init__(self, key):\n",
    "        self.data = key\n",
    "        self.left_child = None\n",
    "        self.right_child = None\n",
    "\n",
    "class BSTDemo:\n",
    "    def __init__(self):\n",
    "        self.root = None\n",
    "\n",
    "    def insert(self, key): #\n",
    "        if not isinstance(key, Node):\n",
    "            key = Node(key)\n",
    "        if self.root == None:\n",
    "            self.root = key\n",
    "        else:\n",
    "            self._insert(self.root, key)\n",
    "\n",
    "    def _insert(self, curr, key):#private method in python; _name it is just used inside classes\n",
    "        if key.data > curr.data:\n",
    "            if curr.right_child == None:\n",
    "                curr.right_child = key\n",
    "            else:\n",
    "                self._insert(curr.right_child, key)\n",
    "        elif key.data < curr.data:\n",
    "            if curr.left_child == None:\n",
    "                curr.left_child = key\n",
    "            else:\n",
    "                self._insert(curr.left_child, key)\n",
    "\n",
    "    def in_order(self):\n",
    "        self._in_order(self.root)\n",
    "        print(\"\")\n",
    "\n",
    "    def _in_order(self, curr):## private method\n",
    "        if curr:\n",
    "            self._in_order(curr.left_child)\n",
    "            print(curr.data, end=\" \")\n",
    "            self._in_order(curr.right_child)\n",
    "\n",
    "    def pre_order(self):\n",
    "        '''root, left, right'''\n",
    "        self._pre_order(self.root)\n",
    "        print(\"\")\n",
    "\n",
    "    def _pre_order(self, curr):\n",
    "    \n",
    "        if curr is not None:\n",
    "            print(curr.data, end=\" \")\n",
    "            self._pre_order(curr.left_child)\n",
    "            self._pre_order(curr.right_child)\n",
    "        \n",
    "      \n",
    "    def post_order(self):\n",
    "        '''left, right, root'''\n",
    "        self._post_order(self.root)\n",
    "        print(\"\")\n",
    "        \n",
    "    def _post_order(self, curr):\n",
    "        if curr is not None:\n",
    "            self._pre_order(curr.left_child)\n",
    "            self._pre_order(curr.right_child)\n",
    "            print(curr.data, end=\" \")\n",
    "\n",
    "    def find_val(self, key):\n",
    "        return self._find_val(self.root,key)\n",
    "\n",
    "    def _find_val(self, curr, key):\n",
    "        if curr:\n",
    "            \n",
    "            if key== curr.data:\n",
    "                return \"Value found in tree\"\n",
    "            \n",
    "            elif key < curr.data:\n",
    "                return self._find_val(curr.left_child,key)\n",
    "            \n",
    "            else:\n",
    "                return self._find_val(curr.right_child, key)\n",
    "            \n",
    "        return \"Value not found in tree\"\n",
    "            \n",
    "\n",
    "    def delete_val(self, key):\n",
    "        self._delete_val(self.root,None, None, key)\n",
    "\n",
    "    def _delete_val(self, curr, prev, is_left, key):\n",
    "        if curr:\n",
    "            if key== curr.data:\n",
    "                if curr.left_child and curr.right_child:\n",
    "                    print(\"Problem scenario\")\n",
    "                elif curr.left_child==None and curr.right_child==None:\n",
    "                    if is_left:\n",
    "                        prev.left_child = None\n",
    "                    else:\n",
    "                        prev.right_child= None\n",
    "                elif  curr.left_child==None:\n",
    "                    if prev:\n",
    "                        if is_left:\n",
    "                            prev.left_child = curr.right_child\n",
    "                        else:\n",
    "                            prev.right_child= curr.right_child\n",
    "                    else:\n",
    "                        self.root=curr.right_child\n",
    "                else:\n",
    "                    if prev:\n",
    "                        if is_left:\n",
    "                            prev.left_child = curr. left_child\n",
    "                        else:\n",
    "                            prev.right_child= curr.left_child\n",
    "                    else:\n",
    "                        self.root=curr.left_child\n",
    "                    \n",
    "            elif key< curr.data:\n",
    "                self._delete_val(curr.left_child, curr, True,key)\n",
    "            elif key > curr.data:\n",
    "                self._delete_val(curr.right_child,curr, False, key)\n",
    "        else:\n",
    "            print(f\"{key} not found in Tree\")\n",
    "\n",
    "tree = BSTDemo()\n",
    "tree.insert(\"F\")\n",
    "# print(tree.root.data)\n",
    "tree.insert(\"C\")\n",
    "# print(tree.root.left_child.data)\n",
    "tree.insert(\"G\")\n",
    "# print(tree.root.right_child.data)\n",
    "tree.insert(\"A\")\n",
    "# print(tree.root.left_child.left_child.data)\n",
    "tree.insert(\"B\")\n",
    "# print(tree.root.left_child.left_child.right_child.data)\n",
    "tree.insert(\"K\")\n",
    "# print(tree.root.right_child.right_child.data)\n",
    "tree.insert(\"H\")\n",
    "# print(tree.root.right_child.right_child.left_child.data)\n",
    "\n",
    "tree.in_order()\n",
    "tree.pre_order()\n",
    "tree.post_order()\n",
    "\n",
    "print(tree.find_val(\"D\"))\n",
    "\n",
    "tree.delete_val(\"G\")\n",
    "tree.in_order()"
   ]
  },
  {
   "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
}