00ex_introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. The MickeyMouse problem\n",
    "\n",
    "a) Write a program that prints the numbers from 1 to 100. But for multiples of three print Mickey instead of the number and for the multiples of five print Mouse. For numbers which are multiples of both three and five print MickeyMouse\n",
    "\n",
    "b) Put the result in a tuple and substitute Mickey with Donald and Mouse with Duck"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "Mickey\n",
      "4\n",
      "Mouse\n",
      "Mickey\n",
      "7\n",
      "8\n",
      "Mickey\n",
      "Mouse\n",
      "11\n",
      "Mickey\n",
      "13\n",
      "14\n",
      "MickeyMouse\n",
      "16\n",
      "17\n",
      "Mickey\n",
      "19\n",
      "Mouse\n",
      "Mickey\n",
      "22\n",
      "23\n",
      "Mickey\n",
      "Mouse\n",
      "26\n",
      "Mickey\n",
      "28\n",
      "29\n",
      "MickeyMouse\n",
      "31\n",
      "32\n",
      "Mickey\n",
      "34\n",
      "Mouse\n",
      "Mickey\n",
      "37\n",
      "38\n",
      "Mickey\n",
      "Mouse\n",
      "41\n",
      "Mickey\n",
      "43\n",
      "44\n",
      "MickeyMouse\n",
      "46\n",
      "47\n",
      "Mickey\n",
      "49\n",
      "Mouse\n",
      "Mickey\n",
      "52\n",
      "53\n",
      "Mickey\n",
      "Mouse\n",
      "56\n",
      "Mickey\n",
      "58\n",
      "59\n",
      "MickeyMouse\n",
      "61\n",
      "62\n",
      "Mickey\n",
      "64\n",
      "Mouse\n",
      "Mickey\n",
      "67\n",
      "68\n",
      "Mickey\n",
      "Mouse\n",
      "71\n",
      "Mickey\n",
      "73\n",
      "74\n",
      "MickeyMouse\n",
      "76\n",
      "77\n",
      "Mickey\n",
      "79\n",
      "Mouse\n",
      "Mickey\n",
      "82\n",
      "83\n",
      "Mickey\n",
      "Mouse\n",
      "86\n",
      "Mickey\n",
      "88\n",
      "89\n",
      "MickeyMouse\n",
      "91\n",
      "92\n",
      "Mickey\n",
      "94\n",
      "Mouse\n",
      "Mickey\n",
      "97\n",
      "98\n",
      "Mickey\n",
      "Mouse\n",
      "[1, 2, 'Donald', 4, 'Duck', 'Donald', 7, 8, 'Donald', 'Duck', 11, 'Donald', 13, 14, 'DonaldDuck', 16, 17, 'Donald', 19, 'Duck', 'Donald', 22, 23, 'Donald', 'Duck', 26, 'Donald', 28, 29, 'DonaldDuck', 31, 32, 'Donald', 34, 'Duck', 'Donald', 37, 38, 'Donald', 'Duck', 41, 'Donald', 43, 44, 'DonaldDuck', 46, 47, 'Donald', 49, 'Duck', 'Donald', 52, 53, 'Donald', 'Duck', 56, 'Donald', 58, 59, 'DonaldDuck', 61, 62, 'Donald', 64, 'Duck', 'Donald', 67, 68, 'Donald', 'Duck', 71, 'Donald', 73, 74, 'DonaldDuck', 76, 77, 'Donald', 79, 'Duck', 'Donald', 82, 83, 'Donald', 'Duck', 86, 'Donald', 88, 89, 'DonaldDuck', 91, 92, 'Donald', 94, 'Duck', 'Donald', 97, 98, 'Donald', 'Duck']\n"
     ]
    }
   ],
   "source": [
    "# Part a\n",
    "mouse = \"Mouse\"\n",
    "micky = \"Mickey\"\n",
    "\n",
    "listNum = []\n",
    "for i in range(1,101):\n",
    "    if i % 3 == 0 and i % 5 == 0:\n",
    "        listNum.append(micky + mouse)\n",
    "        print(micky + mouse)\n",
    "    elif i % 3 == 0:\n",
    "        listNum.append(micky)\n",
    "        print(micky)\n",
    "    elif i % 5 == 0:\n",
    "        listNum.append(mouse)\n",
    "        print(mouse)\n",
    "    else:\n",
    "        listNum.append (i)\n",
    "        print(i)\n",
    "\n",
    "don = \"Donald\"\n",
    "duck = \"Duck\"\n",
    "\n",
    "# Part b\n",
    "for j in range (1, len(listNum)):\n",
    "    if listNum[j] == micky:\n",
    "        listNum[j] = don\n",
    "    if listNum[j] == mouse:\n",
    "        listNum[j] = duck\n",
    "    if listNum[j] == micky + mouse:\n",
    "        listNum[j] = don + duck\n",
    "        \n",
    "print(listNum)      \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2\\. The swap function\n",
    "\n",
    "Write a function that swap the values of two input variables x and y (whatever the type). Try to do that also without a temporary variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 5\n",
      "y = 6\n",
      "x =  6\n",
      "y =  5\n"
     ]
    }
   ],
   "source": [
    "def swap(a,b):\n",
    "    return b,a\n",
    "\n",
    "x = input(\"x = \")\n",
    "y = input(\"y = \")\n",
    "x,y = swap (x,y)\n",
    "print (\"x = \",x)\n",
    "print (\"y = \",y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3\\. Computing the distance\n",
    "\n",
    "Write a function that calculates and returns the euclidean distance between two points *u* and *v*, where *u* and *v* are both 2-tuples *(x,y)*. For example, if *u=(3,0)* and *v=(0,4)*, the function should return 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x1 =3\n",
      "x2 =0\n",
      "y1 =0\n",
      "y2 =4\n",
      "Distance is 5.0\n"
     ]
    }
   ],
   "source": [
    "def dist(u,v):\n",
    "    dist = ((u[0]-v[0])**2 + (u[1]-v[1])**2)**(1/2)\n",
    "    return dist\n",
    "\n",
    "u = [int(input(\"x1 =\")),int(input(\"x2 =\"))]\n",
    "v = [int(input(\"y1 =\")),int(input(\"y2 =\"))]\n",
    "\n",
    "print(\"Distance is\",dist(u,v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4\\. Counting letters\n",
    "\n",
    "Write a program to calculate the number of times each character occurs in a given string *s*. Ignore differneces in capitalization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Insert a character:w\n",
      "2\n",
      "2\n",
      "Letter: w appears: 2 times\n",
      "Letter: r appears: 17 times\n",
      "Letter: i appears: 14 times\n",
      "Letter: t appears: 19 times\n",
      "Letter: e appears: 22 times\n",
      "Letter:   appears: 41 times\n",
      "Letter: a appears: 7 times\n",
      "Letter: p appears: 8 times\n",
      "Letter: o appears: 13 times\n",
      "Letter: g appears: 1 times\n",
      "Letter: m appears: 12 times\n",
      "Letter: h appears: 9 times\n",
      "Letter: n appears: 10 times\n",
      "Letter: s appears: 9 times\n",
      "Letter: u appears: 9 times\n",
      "Letter: b appears: 5 times\n",
      "Letter: f appears: 10 times\n",
      "Letter: 1 appears: 2 times\n",
      "Letter: 0 appears: 2 times\n",
      "Letter: . appears: 2 times\n",
      "Letter: l appears: 6 times\n",
      "Letter: c appears: 3 times\n",
      "Letter: k appears: 2 times\n",
      "Letter: y appears: 2 times\n",
      "Letter: d appears: 3 times\n",
      "Letter: v appears: 2 times\n"
     ]
    }
   ],
   "source": [
    "s=\"Write a program that prints the numbers from 1 to 100. \\\n",
    "But for multiples of three print Mickey instead of the number and for the multiples of five print Mouse. \\\n",
    "For numbers which are multiples of both three and five print MickeyMouse\"\n",
    "\n",
    "def createDic(s):\n",
    "    dict = {}\n",
    "    for i in range(len(s)):\n",
    "        try:\n",
    "            dict[s[i].lower()] = dict[s[i].lower()] + 1\n",
    "        except:\n",
    "            dict[s[i].lower()] = 1\n",
    "    return dict\n",
    "\n",
    "def countChar(ch):\n",
    "    i = 0\n",
    "    characters = [x for x in s if x.lower() == ch.lower()]\n",
    "    print(len(characters))\n",
    "\n",
    "def easyCount(ch):\n",
    "    print((s.lower()).count(ch.lower()))\n",
    "            \n",
    "    \n",
    "ch = input(\"Insert a character:\")\n",
    "countChar(ch)\n",
    "easyCount(ch)\n",
    "d = createDic(s)\n",
    "for i in d:\n",
    "    print(\"Letter:\",i,\"appears:\",d[i],\"times\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5\\. Isolating the unique\n",
    "\n",
    "Write a function that determines and count the unique numbers in the list *l*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 37 unique numbers in the list, which are:\n",
      "[1, 5, 8, 9, 10, 16, 18, 19, 24, 30, 33, 37, 39, 41, 47, 53, 54, 55, 57, 58, 64, 72, 74, 75, 79, 81, 82, 86, 87, 88, 90, 92, 94, 95, 96, 98, 99]\n"
     ]
    }
   ],
   "source": [
    "l = [36, 45, 58, 3, 74, 96, 64, 45, 31, 10, 24, 19, 33, 86, 99, 18, 63, 70, 85,\n",
    " 85, 63, 47, 56, 42, 70, 84, 88, 55, 20, 54, 8, 56, 51, 79, 81, 57, 37, 91,\n",
    " 1, 84, 84, 36, 66, 9, 89, 50, 42, 91, 50, 95, 90, 98, 39, 16, 82, 31, 92, 41,\n",
    " 45, 30, 66, 70, 34, 85, 94, 5, 3, 36, 72, 91, 84, 34, 87, 75, 53, 51, 20, 89, 51, 20]\n",
    "\n",
    "def createDic(s):\n",
    "    dict = {}\n",
    "    for i in range(len(s)):\n",
    "        try:\n",
    "            dict[s[i]] = dict[s[i]] + 1\n",
    "        except:\n",
    "            dict[s[i]] = 1\n",
    "    return dict\n",
    "\n",
    "d = createDic(l)\n",
    "count = 0\n",
    "unique = []\n",
    "for i in d:\n",
    "    if d[i] == 1:\n",
    "        unique.append(i)\n",
    "        count += 1 \n",
    "print(\"There are\",count,\"unique numbers in the list, which are:\")\n",
    "unique.sort()\n",
    "print(unique)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6\\. Combination of functions\n",
    "\n",
    "Write two functions - one that returns the square of a number, and one that returns the cube. Now write a third function that returns the number raised to the 6th power using the two previous functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Insert a number:3\n",
      "729\n"
     ]
    }
   ],
   "source": [
    "def square(a):\n",
    "    return a**2\n",
    "\n",
    "def cube(a):\n",
    "    return a**3\n",
    "\n",
    "x = int(input(\"Insert a number:\"))\n",
    "print(cube(square(x)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7\\. Cubes\n",
    "\n",
    "Create a list of the cubes of x for x in *[0, 10]* using:\n",
    "\n",
    "a) a for loop\n",
    "\n",
    "b) a list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]\n",
      "[0, 1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]\n"
     ]
    }
   ],
   "source": [
    "# Part a \n",
    "cubeLoop = []\n",
    "for i in range(11):\n",
    "    cubeLoop.append(i**3)\n",
    "print(cubeLoop)\n",
    "    \n",
    "# Part b\n",
    "def cube(a):\n",
    "    return a**3\n",
    "\n",
    "cubeList = [cube(x) for x in range(11)]\n",
    "print(cubeList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8\\. Nested list comprehension\n",
    "\n",
    "A Pythagorean triple is an integer solution to the Pythagorean theorem $a^2+b^2=c^2$. The first Pythagorean triple is (3,4,5). Find and put in a tuple all unique Pythagorean triples for the positive integers a, b and c less than 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3, 4, 5], [6, 8, 10], [5, 12, 13], [9, 12, 15], [8, 15, 17], [12, 16, 20], [15, 20, 25], [20, 21, 29], [7, 24, 25], [10, 24, 26], [18, 24, 30], [21, 28, 35], [16, 30, 34], [24, 32, 40], [12, 35, 37], [15, 36, 39], [27, 36, 45], [9, 40, 41], [30, 40, 50], [40, 42, 58], [33, 44, 55], [24, 45, 51], [28, 45, 53], [14, 48, 50], [20, 48, 52], [36, 48, 60], [39, 52, 65], [48, 55, 73], [33, 56, 65], [42, 56, 70], [11, 60, 61], [25, 60, 65], [32, 60, 68], [45, 60, 75], [16, 63, 65], [60, 63, 87], [48, 64, 80], [51, 68, 85], [24, 70, 74], [21, 72, 75], [30, 72, 78], [54, 72, 90], [65, 72, 97], [40, 75, 85], [57, 76, 95], [36, 77, 85], [18, 80, 82], [39, 80, 89], [60, 80, 100], [13, 84, 85], [35, 84, 91], [28, 96, 100]]\n"
     ]
    }
   ],
   "source": [
    "triple = []\n",
    "limit = 101\n",
    "for x in range(limit):\n",
    "    for y in range(1,x):\n",
    "        z = (x**2 + y**2)**(1/2)\n",
    "        if (z % 1 == 0 and z < limit):\n",
    "            triple.append([y,x,int(z)])\n",
    "print(triple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9\\. Normalization\n",
    "\n",
    "Write a function that takes a tuple of numbers and returns it with the entries normalized to one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.06696495301824251, 0.26785981207297005, 0.3348247650912125, 0.6026845771641826, 0.669649530182425, 0.0]\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "# input vector\n",
    "vec = [1,4,5,9,10,0]\n",
    "\n",
    "# debug method\n",
    "def getNorm(v):\n",
    "    sum = 0\n",
    "    for i in v:\n",
    "        sum += i**2\n",
    "    return sum**(1/2)\n",
    "\n",
    "def normVec(v):\n",
    "    norm = getNorm(v)\n",
    "    for i in range(len(v)):\n",
    "        v[i] = v[i]/norm\n",
    "    return v\n",
    "\n",
    "print(normVec(vec))\n",
    "\n",
    "#debug\n",
    "print(getNorm(vec))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}