Assignments/Assignment_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1) Apply the appropriate string methods to the **x** variable (as '.upper') to change it exactly to: \"$Dichlorodiphenyltrichloroethane$\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"DiClOrod  IFeNi  lTRicLOr oETaNo  DiChlorod iPHeny lTrichL oroEThaNe\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dichlorodiphenyltrichloroethane\n"
     ]
    }
   ],
   "source": [
    "# since the string we are trying to achieve contains only elements of the second half of the given string: \n",
    "# we need to find the correct startpoint to match the word given above. that's why rfind is used. \n",
    "\n",
    "x = x[x.rfind('Di'):].capitalize().replace(' ', '')\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dichlorodiphenyltrichloroethane\n"
     ]
    }
   ],
   "source": [
    "# fun version using regex to find the correct starting point.\n",
    "\n",
    "import re\n",
    "\n",
    "y = re.findall('Di[cC]h[\\w ]+$', x)\n",
    "print(''.join(y).capitalize().replace(' ', ''))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2) Assign respectively the values: 'word', 15, 3.14 and 'list' to variables A, B, C and D in a single line of code. Then, print them in that same order on a single line separated by a space, using only one print statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "word 15 3.14 list\n"
     ]
    }
   ],
   "source": [
    "A, B, C, D = 'word', 15, 3.14, 'list'\n",
    "print(A, B, C, D, sep=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3) Use the **input()** function to receive an input in the form **'68.4 1.71'**, that is, two floating point numbers in a line separated by space. Then, assign these numbers to the variables **w** and **h** respectively, which represent an individual's weight and height (hint: take a look at the '.split()' method). With this data, calculate the individual's Body Mass Index (BMI) from the following relationship: \n",
    "    \n",
    "\\begin{equation}\n",
    "BMI = \\dfrac{weight}{height^2}\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your weight(in kg) and height(in m) as floating point numbers separated by a space 72 1.8\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22.22222222222222\n"
     ]
    }
   ],
   "source": [
    "x = input('Enter your weight(in kg) and height(in m) as floating point numbers separated by a space')\n",
    "w, h = float(x.split()[0]), float(x.split()[1])\n",
    "bmi = w / h ** 2\n",
    "print(bmi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### This value can also be classified according to ranges of values, following to the table below. Use conditional structures to classify and print the classification assigned to the individual. \n",
    "\n",
    "<center><img src=\"https://healthtravelguide.com/wp-content/uploads/2020/06/Body-mass-index-table.png\" width=\"30%\"><\\center>  \n",
    "\n",
    "\n",
    "(source: https://healthtravelguide.com/bmi-calculator/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "normal weight\n"
     ]
    }
   ],
   "source": [
    "if bmi < 18.5:\n",
    "    print('underweight')\n",
    "elif 18.5 < bmi < 24.9:\n",
    "    print('normal weight')\n",
    "elif 25.0 < bmi < 29.9:\n",
    "    print('pre-obesity')\n",
    "elif 30.0 < bmi < 34.9:\n",
    "    print('obesity class I')\n",
    "elif 35.0 < bmi < 39.9:\n",
    "    print('obesity class II')\n",
    "else:\n",
    "    print('obesity class III')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4) Receive an integer as an input and, using a loop, calculate the factorial of this number, that is, the product of all the integers from one to the number provided. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter an integer 8\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40320\n"
     ]
    }
   ],
   "source": [
    "i = input('enter an integer')\n",
    "y = 1\n",
    "for x in range(1, int(i) + 1):\n",
    "    y *= x\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5) Using a while loop and the input function, read an indefinite number of integers until the number read is -1. Present the sum of all these numbers in the form of a print, excluding the -1 read at the end. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter an integer 2\n",
      "enter an integer 3\n",
      "enter an integer 4\n",
      "enter an integer 5\n",
      "enter an integer 1\n",
      "enter an integer 8\n",
      "enter an integer -1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 5, 1, 8, -1] 23\n"
     ]
    }
   ],
   "source": [
    "su = []\n",
    "while True:\n",
    "    x = int(input('enter an integer'))\n",
    "    su.append(x)\n",
    "    if x == -1:\n",
    "        break\n",
    "print(su, sum(su[:len(su) - 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter an integer 2\n",
      "enter an integer 3\n",
      "enter an integer 4\n",
      "enter an integer 5\n",
      "enter an integer 1\n",
      "enter an integer 8\n",
      "enter an integer -1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n"
     ]
    }
   ],
   "source": [
    "# alternate version\n",
    "su = 0\n",
    "while True:\n",
    "    x = int(input('enter an integer'))\n",
    "    if x == -1:\n",
    "        break\n",
    "    su += x\n",
    "print(su)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6) Read the **first name** of an employee, his **amount of hours worked** and the **salary per hour** in a single line separated by commas. Next, calculate the **total salary** for this employee and show it to two decimal places."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first name of an employee, his amount of hours worked and the salary per hour separated by commas. Thomas,78.50,88.98\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thomas has a total salary of 6984.93\n"
     ]
    }
   ],
   "source": [
    "x = input('Enter the first name of an employee, his amount of hours worked and the salary per hour separated by commas.')\n",
    "name, amh, sah = x.split(',')[0], float(x.split(',')[1]), float(x.split(',')[2])\n",
    "totalsal = round(amh * sah, 2)\n",
    "print(f'{name} has a total salary of {totalsal}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7) Read three floating point values **A**, **B** and **C** respectively. Then calculate itens a, b, c, d and e: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter three floats separated by a space 3.5 6.8 2.9\n"
     ]
    }
   ],
   "source": [
    "inp = input('Enter three floats separated by a space') \n",
    "A, B, C = float(inp.split()[0]), float(inp.split()[1]), float(inp.split()[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    a) the area of the triangle rectangle with A as the base and C as the height."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.075\n"
     ]
    }
   ],
   "source": [
    "areatri = (A * C) * 0.5\n",
    "print(areatri)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    b) the area of the circle of radius C. (pi = 3.14159) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26.4207719\n"
     ]
    }
   ],
   "source": [
    "pi = 3.14159\n",
    "areacirc = pi * (C ** 2)\n",
    "print(areacirc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    c) the area of the trapezoid that has A and B for bases and C for height. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14.935\n"
     ]
    }
   ],
   "source": [
    "areatrap = (C/2) * (A + B) \n",
    "print(areatrap)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    d) the area of the square that has side B. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "46.239999999999995\n"
     ]
    }
   ],
   "source": [
    "areasquare = B ** 2\n",
    "print(areasquare)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    e) the area of the rectangle that has sides A and B. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23.8\n"
     ]
    }
   ],
   "source": [
    "arearect = A * B\n",
    "print(arearect)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 8) Read **the values a, b and c** and calculate the **roots of the second degree equation** $ax^{2}+bx+c=0$ using [this formula](https://en.wikipedia.org/wiki/Quadratic_equation). If it is not possible to calculate the roots, display the message **“There are no real roots”**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter three values separated by a space 2.5 16.3 4.6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are two solutions which are -0.29561136151145 and -6.22438863848855\n"
     ]
    }
   ],
   "source": [
    "inp1 = input('Enter three values separated by a space')\n",
    "a, b, c = float(inp1.split()[0]), float(inp1.split()[1]), float(inp1.split()[2])\n",
    "d = b ** 2 - 4*a*c\n",
    "x1 = (-b + d ** (1/2))/(2 * a)\n",
    "x2 = (-b - d ** (1/2))/(2 * a)\n",
    "if a == 0:\n",
    "    print('The equation is now linear, not quadratic, as there is no ax^2 term.')\n",
    "else:\n",
    "    if d < 0:\n",
    "        print('There are no real roots')\n",
    "    elif d == 0:\n",
    "        print(f'There is one solution which is {x1}') #since x1 == x2 is true.\n",
    "    else:\n",
    "        print(f'There are two solutions which are {x1} and {x2}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter three values separated by a space 2.5 16.3 4.6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are two solutions which are -0.29561136151145 and -6.22438863848855\n"
     ]
    }
   ],
   "source": [
    "# alternate version importing math module\n",
    "\n",
    "import math\n",
    "\n",
    "inp1 = input('Enter three values separated by a space')\n",
    "a, b, c = float(inp1.split()[0]), float(inp1.split()[1]), float(inp1.split()[2])\n",
    "d = b ** 2 - 4*a*c\n",
    "x1 = (-b + math.sqrt(d))/(2 * a)\n",
    "x2 = (-b - math.sqrt(d))/(2 * a)\n",
    "if a == 0:\n",
    "    print('The equation is now linear, not quadratic, as there is no ax^2 term.')\n",
    "else:\n",
    "    if d < 0:\n",
    "        print('There are no real roots')\n",
    "    elif d == 0:\n",
    "        print(f'There is one solution which is {x1}') #since x1 == x2 is true.\n",
    "    else:\n",
    "        print(f'There are two solutions which are {x1} and {x2}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 9) Read four floating point numerical values corresponding to the coordinates of two geographical coordinates in the cartesian plane. Each point will come in a line with its coordinates separated by space. Then calculate and show the distance between these two points. \n",
    "\n",
    "(obs: $d=\\sqrt{(x_1-x_2)^2 + (y_1-y_2)^2}$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the coordinates of the first point as floating point numbers separated by a space 2.4 5.6\n",
      "Enter the coordinates of the second point as floating point numbers separated by a space 6.7 8.9\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The distance of the two points is 5.420332093147062\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "inp1 = input('Enter the coordinates of the first point as floating point numbers separated by a space').split()\n",
    "inp2 = input('Enter the coordinates of the second point as floating point numbers separated by a space').split()\n",
    "x1, y1 = float(inp1[0]), float(inp1[1]) \n",
    "x2, y2 = float(inp2[0]), float(inp2[1]) \n",
    "print(f'The distance of the two points is {math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 10) Read **two floating point numbers** on a line that represent **coordinates of a cartesian point**. With this, use **conditional structures** to determine if you are at the origin, printing the message **'origin'**; in one of the axes, printing **'x axis'** or **'y axis'**; or in one of the four quadrants, printing **'q1'**, **'q2**', **'q3'** or **'q4'**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the coordinates of a point as floating point numbers separated by a space. 3.5 0.3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "q1\n"
     ]
    }
   ],
   "source": [
    "inp = input('Enter the coordinates of a point as floating point numbers separated by a space.').split()\n",
    "x, y = float(inp[0]), float(inp[1])\n",
    "if x == 0 and y == 0:\n",
    "    print('origin')\n",
    "elif x == 0:\n",
    "    print('y axis')\n",
    "elif y == 0:\n",
    "    print('x axis')\n",
    "else:\n",
    "    if x > 0 and y > 0:\n",
    "        print('q1')\n",
    "    elif x < 0 and y > 0:\n",
    "        print('q2')\n",
    "    elif x < 0 and y < 0:\n",
    "        print('q3')\n",
    "    elif x > 0 and y < 0:\n",
    "        print('q4')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 11) Read an integer that represents a phone code for international dialing.  \n",
    "#### Then, inform to which country the code belongs to, considering the generated table below:\n",
    "(You just need to consider the first 10 entries)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Country</th>\n",
       "      <th>Country calling code</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Austria</td>\n",
       "      <td>43</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Belgium</td>\n",
       "      <td>32</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Bulgaria</td>\n",
       "      <td>359</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Croatia</td>\n",
       "      <td>385</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Cyprus</td>\n",
       "      <td>357</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Czech Republic</td>\n",
       "      <td>420</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Denmark</td>\n",
       "      <td>45</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Estonia</td>\n",
       "      <td>372</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Finland</td>\n",
       "      <td>358</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>France</td>\n",
       "      <td>33</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>Germany</td>\n",
       "      <td>49</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>Greece</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>Hungary</td>\n",
       "      <td>36</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>Iceland</td>\n",
       "      <td>354</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>Ireland</td>\n",
       "      <td>353</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>Italy</td>\n",
       "      <td>39</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>Latvia</td>\n",
       "      <td>371</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>Liechtenstein</td>\n",
       "      <td>423</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>Lithuania</td>\n",
       "      <td>370</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>Luxembourg</td>\n",
       "      <td>352</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           Country Country calling code\n",
       "0          Austria                   43\n",
       "1          Belgium                   32\n",
       "2         Bulgaria                  359\n",
       "3          Croatia                  385\n",
       "4           Cyprus                  357\n",
       "5   Czech Republic                  420\n",
       "6          Denmark                   45\n",
       "7          Estonia                  372\n",
       "8          Finland                  358\n",
       "9           France                   33\n",
       "10         Germany                   49\n",
       "11          Greece                   30\n",
       "12         Hungary                   36\n",
       "13         Iceland                  354\n",
       "14         Ireland                  353\n",
       "15           Italy                   39\n",
       "16          Latvia                  371\n",
       "17   Liechtenstein                  423\n",
       "18       Lithuania                  370\n",
       "19      Luxembourg                  352"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_html('https://en.wikipedia.org/wiki/Telephone_numbers_in_Europe')[1]\n",
    "df = df.iloc[:,:2]\n",
    "df.head(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a phone code. 43\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Austria\n"
     ]
    }
   ],
   "source": [
    "phoco = {'Austria':43,\n",
    "'Belgium':32,\n",
    "'Bulgaria':359,\n",
    "'Croatia':385,\n",
    "'Cyprus':357,\n",
    "'Czech Republic':420,\n",
    "'Denmark':45,\n",
    "'Estonia':372,\n",
    "'Finland':358,\n",
    "'France':33,\n",
    "'Germany':49}\n",
    "inp = int(input('Enter a phone code.'))\n",
    "for a in phoco:\n",
    "    if phoco[a] == inp:\n",
    "        print(a)\n",
    "if inp not in phoco.values():\n",
    "    print('not available')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 12) Write a piece of code that reads 6 numbers in a row. Next, show the number of positive values entered. On the next line, print the average of the values to one decimal place. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number 3\n",
      "Enter a number 4\n",
      "Enter a number -5\n",
      "Enter a number 6\n",
      "Enter a number -7\n",
      "Enter a number 1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Positive numbers entered: 4\n",
      "Average of the values: 0.3\n"
     ]
    }
   ],
   "source": [
    "# version 1\n",
    "numb = []\n",
    "for a in range(6):\n",
    "    inp = float(input('Enter a number'))\n",
    "    numb.append(inp)\n",
    "count = 0\n",
    "for nu in numb:\n",
    "    if nu > 0:\n",
    "        count += 1\n",
    "print(f'Positive numbers entered: {count}' + '\\n' + f'Average of the values: {round(sum(numb)/len(numb), 1)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 6 numbers in a row spearated by a space 3 4 -5 6 -7 1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Positive numbers entered: 4\n",
      "Average of the values: 0.3\n"
     ]
    }
   ],
   "source": [
    "# version 2\n",
    "inp = input('Enter 6 numbers in a row spearated by a space').split()\n",
    "inp1 = [] \n",
    "count = 0\n",
    "for nu in inp:\n",
    "    nu = int(nu)\n",
    "    inp1.append(nu)\n",
    "    if nu > 0:\n",
    "        count += 1\n",
    "print(f'Positive numbers entered: {count}' + '\\n' + f'Average of the values: {round(sum(inp1)/len(inp1), 1)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 13) Read an integer **N**. Then print the **square of each of the even values**, from 1 to N, including N, if applicable, arranged one per line. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter an integer 9\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "16\n",
      "36\n",
      "64\n"
     ]
    }
   ],
   "source": [
    "inp = int(input('Enter an integer'))\n",
    "for a in range(1, inp + 1):\n",
    "    if a % 2 == 0:\n",
    "        print(a ** 2, end='\\n')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 14) Using **input()**, read an integer and print its classification as **'even / odd'** and **'positive / negative'** . The two classes for the number must be printed on the same line separated by a space. In the case of zero, print only **'null'**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter an integer -6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "negative even\n"
     ]
    }
   ],
   "source": [
    "inp = int(input('Enter an integer'))\n",
    "cl1 = ''\n",
    "cl2 = ''\n",
    "if inp == 0:\n",
    "    print('null')\n",
    "    \n",
    "if inp > 0:\n",
    "    cl1 = 'positive'\n",
    "else:\n",
    "    cl1 = 'negative'\n",
    "    \n",
    "if inp % 2 == 0:\n",
    "    cl2 = 'even'\n",
    "else:\n",
    "    cl2 = 'odd'\n",
    "print(f'{cl1} {cl2}')\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge\n",
    "#### 15) Ordering problems are recurrent in the history of programming. Over time, several algorithms have been developed to fulfill this function. The simplest of these algorithms is the [**Bubble Sort**](https://en.wikipedia.org/wiki/Bubble_sort), which is based on comparisons of elements two by two in a loop of passes through the elements. Your mission, if you decide to accept it, will be to input six whole numbers ramdonly ordered. Then implement the **Bubble Sort** principle to order these six numbers **using only loops and conditionals**.  \n",
    "#### At the end, print the six numbers in ascending order on a single line separated by spaces. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-10 -9 -2 1 2 10 "
     ]
    }
   ],
   "source": [
    "# bubble sort problem\n",
    "# version 1 generating random numbers by random module\n",
    "import random\n",
    "mylist1 = []\n",
    "for b in range(6):\n",
    "    y = random.randint(-10, 10)\n",
    "    mylist1.append(y)\n",
    "\n",
    "\n",
    "while True:\n",
    "    ct = 0\n",
    "    for a in range(len(mylist1) - 1):\n",
    "        if mylist1[a] > mylist1[a + 1]:\n",
    "            mylist1[a], mylist1[a + 1] = mylist1[a + 1], mylist1[a]\n",
    "            ct += 1\n",
    "    if ct == 0:\n",
    "        break\n",
    "\n",
    "for el in mylist1:\n",
    "    print(el, end=' ')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 6 integers in random order separated by a space 34 -10 100 45 2 230\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-10 2 34 45 100 230 "
     ]
    }
   ],
   "source": [
    "# bubble sort problem\n",
    "# version 2 entering numbers myself\n",
    "inp = input('Enter 6 integers in random order separated by a space').split()\n",
    "\n",
    "while True:\n",
    "    ct = 0\n",
    "    for a in range(len(inp) - 1):\n",
    "        if int(inp[a]) > int(inp[a + 1]):\n",
    "            inp[a], inp[a + 1] = inp[a + 1], inp[a]\n",
    "            ct += 1\n",
    "    if ct == 0:\n",
    "        break\n",
    "\n",
    "for el in inp:\n",
    "    print(el, end=' ')\n"
   ]
  },
  {
   "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}