Assignment_2_Knöbel.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Second Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1) Create a function called **\"even_squared\"** that receives an integer value **N**, and returns a list containing, in ascending order, the square of each of the even values, from 1 to N, including N if applicable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def even_squared (N):\n",
    "    even_list = [] #create an empty list that will be filled with the for loop\n",
    "    for i in range(2, N+1, 2):\n",
    "        even_list.append(i**2)\n",
    "    return even_list\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 16, 36, 64]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "even_squared(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9%2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 16, 36, 64, 100, 144, 196]\n"
     ]
    }
   ],
   "source": [
    "# option with list comprehension\n",
    "def even_squared2 (N):\n",
    "     return [x**2 for x in range(2,N+1,2)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 16, 36, 64, 100, 144]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "even_squared2(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2) Using a while loop and the **input()** function, read an indefinite amount of **integers** until the number read is **-1**. After this process, print two lists on the screen: The first containing the even integers, and the second containing the odd integers. Both must be in ascending order. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please enter any integer you like:  1\n",
      "Please enter any integer you like:  2\n",
      "Please enter any integer you like:  6\n",
      "Please enter any integer you like:  12\n",
      "Please enter any integer you like:  2\n",
      "Please enter any integer you like:  3\n",
      "Please enter any integer you like:  -1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 2, 6, 12]\n",
      "[1, 3]\n"
     ]
    }
   ],
   "source": [
    "even, odd = [], []\n",
    "while True:\n",
    "    num = int(input(\"Please enter any integer you like: \"))\n",
    "    if num == -1: #while loop stops if -1 is entered\n",
    "        break\n",
    "    elif num%2 == 0:\n",
    "        even.append(num)\n",
    "    else:\n",
    "        odd.append(num)\n",
    "print(sorted(even))\n",
    "print(sorted(odd))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3) Create a function called **\"even_account\"** that receives a list of integers, counts the number of existing even elements, and returns this count. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def even_account(list_of_int):\n",
    "    list_even = [i for i in list_of_int if i%2==0]\n",
    "    return len(list_even)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "even_account([1,2,6,8,13])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4) Create a function called **\"squared_list\"** that receives a list of integers and returns another list whose elements are the squares of the elements of the first. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def squared_list (normal_list):\n",
    "    square = [i**2 for i in normal_list]\n",
    "    return square"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 9, 25, 81]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squared_list([2, 3, 5, 9])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5) Create a function called **\"descending\"** that receives two lists of integers and returns a single list, which contains all the elements in descending order, and may include repeated elements. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def descending (list_a, list_b):\n",
    "    desc_list = [sorted(list_a + list_b, reverse=True)]\n",
    "    return desc_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[88, 35, 5, 5, 3, 3, 2, 2]]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "descending([3, 5, 5], [88, 35, 2, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6) Create a function called **\"adding\"** that receives a list **A**, and an arbitrary number of integers as input. Return a new list containing the elements of **A** plus the integers passed as input, in the order in which they were given. Here is an example: \n",
    "\n",
    ">```python\n",
    ">>>> A = [10,20,30]\n",
    ">>>> adding(A, 4, 10, 50, 1)\n",
    "> [10, 20, 30, 4, 10, 50, 1]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def adding(list_A, *integers):\n",
    "    list_A.extend(integers)\n",
    "    return list_A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 33, 89, 20, 30, 4, 10, 50, 1]\n"
     ]
    }
   ],
   "source": [
    "print(adding([10, 33, 89, 20, 30], 4, 10, 50, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7) Create a function called **\"intersection\"** that receives two input lists and returns another list with the values that belong to the two lists simultaneously (intersection) without repetition of values and in ascending order. Use only lists (do not use sets); loops and conditionals. See the example: \n",
    "\n",
    ">```python\n",
    ">>>> A = [-2, 0, 1, 2, 3]\n",
    ">>>> B = [-1, 2, 3, 6, 8]\n",
    ">>>> intersection(A,B)\n",
    "> [2, 3]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def intersection(list_1, list_2):\n",
    "    holder_list = [x for x in list_1 if x in list_2] #this should only add values that are in both lists to holder_list\n",
    "    rest_list = [] # create an empty rest list and fill it with values that are in the holder list\n",
    "    [rest_list.append(i) for i in holder_list if i not in rest_list] #to avoid repitition\n",
    "    return rest_list\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 7, 4]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intersection([1,3,2,2,7,4,5,7],[2,4,8,16,7,7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 8) Create a function called **\"union\"** that receives two input lists and returns another list with the union of the elements of the two received, without repetition of elements and in ascending order. Use only lists (do not use sets); loops and conditionals. See the example: \n",
    "\n",
    ">```python\n",
    ">>>> A = [-2, 0, 1, 2]\n",
    ">>>> B = [-1, 1, 2, 10]\n",
    ">>>> union(A,B)\n",
    "> [-2, ,-1, 0, 1, 2, 10]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def union(list_1, list_2):\n",
    "    added_list = list_1 + list_2\n",
    "    added_final = []\n",
    "    [added_final.append(i) for i in added_list if i not in added_final]\n",
    "    return sorted(added_final)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-2, -1, 0, 1, 2, 10]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "union([-2, 0, 1, 1, 2], [-1, 1,1, 2, 10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 9) Generalize the **\"intersection\"** function so that it receives an indefinite number of lists and returns the intersection of all of them. Call the new function **intersection2**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "# map(fun, iter)\n",
    "#fun : It is a function to which map passes each element of given iterable.\n",
    "#iter : It is a iterable which is to be mapped.\n",
    "#Returns a list of the results after applying the given function  \n",
    "# to each item of a given iterable (list, tuple etc.) \n",
    "#NOTE : The returned value from map() (map object) \n",
    "# then can be passed to functions like list() (to create a list), set() (to create a set) .\n",
    "\n",
    "def intersection2(*lists):\n",
    "    intersec = [list(set.intersection(*map(set, lists)))]\n",
    "    return intersec\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2, 3, 5]]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intersection2([3, 3, 3, 3, 2, 5], [4, 5, 54, 76, 2, 3, 9], [4, 4, 3, 2, 5, 9])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge\n",
    "\n",
    "#### 10) Create a function named **\"matrix\"** that implements matrix multiplication:\n",
    "    \n",
    "Given the matrices:\n",
    "    \n",
    "$A_{m\\times n}=\n",
    "\\left[\\begin{matrix}\n",
    "a_{11}&a_{12}&...&a_{1n}\\\\\n",
    "a_{21}&a_{22}&...&a_{2n}\\\\\n",
    "\\vdots &\\vdots &&\\vdots\\\\\n",
    "a_{m1}&a_{m2}&...&a_{mn}\\\\\n",
    "\\end{matrix}\\right]$\n",
    "    \n",
    "We will represent then as a list of lists.\n",
    "\n",
    "$A = [[a_{11},a_{12},...,a_{1n}],[a_{21},a_{22},...,a_{2n}], . . . ,[a_{m1},a_{m2},...,a_{mn}]]$\n",
    "\n",
    "The **\"matrix\"** funtion must receive two matrices $A$ e $B$ in the specified format and return $A\\times B$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Goal is to multiply A and B but also try to handle different dimensions\n",
    "\n",
    "def matrix (A, B):\n",
    "    len_A = len(A) #should be 3 in this case as there are three rows in the list of list of A\n",
    "    len_A_col = len(A[0]) #in this case there are 3 columns\n",
    "    len_B = len(B)\n",
    "    len_B_col = len(B[0])\n",
    "    \n",
    "    # check if the dimensions are equal and if not provide an error message\n",
    "    if len_A != len_B_col or len_A_col != len_B:\n",
    "        return print('Error: The dimensions are not compatible for this matrix multiplication')\n",
    "    \n",
    "    multiple = [[0 for i in range(len_A)]for x in range(len_B)]\n",
    "    for i in range(len_A): # iterating by row of A\n",
    "        for j in range(len_B_col): # iterating by coloum by B \n",
    "            for k in range(len_B): # iterating by rows of B\n",
    "                multiple[i][j] += A[i][k] * B[k][j]\n",
    "    return multiple\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[67, 99, 55], [351, 471, 219], [114, 255, 123]]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [[1, 9, 3], [3, 54, 6], [6, 12, 9]]\n",
    "B = [[1, 21, 1], [6, 7, 3], [4, 5, 9]]\n",
    "matrix(A, B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: The dimensions are not compatible for this matrix multiplication\n"
     ]
    }
   ],
   "source": [
    "A = [[1, 9, 3, 8, 93], [3, 54, 6], [6, 12, 9]]\n",
    "B = [[1, 21, 1], [6, 7, 3], [4, 5, 9]]\n",
    "matrix(A, B)"
   ]
  }
 ],
 "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": 4
}