4.2 EXERCISE Function.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "09.10.2020 EXERCISE:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Smallest of Three Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function which receives three integer numbers and returns the smallest. Use appropriate name for the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "5\n",
      "3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "def small(first, second, third):\n",
    "    return min(first, second, third)\n",
    "\n",
    "\n",
    "first_number = int(input())\n",
    "second_number = int(input())\n",
    "third_number = int(input())\n",
    "\n",
    "print(small(first_number, second_number, third_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Add and Subtract"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will receive three integer numbers. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function sum_numbers() to get the sum of the first two integers and subtract() function that subtracts the third integer from the result. Wrap the two functions in a function called add_and_subtract() which will receive the three numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "17\n",
      "30\n",
      "-12\n"
     ]
    }
   ],
   "source": [
    "def add_and_subtract(first_num, second_num, third_num):\n",
    "    def sum_numbers(first, second):\n",
    "        return first + second\n",
    "\n",
    "    def subtract(sum_number, third):\n",
    "        return (sum_numbers(first_num, second_num)) - third\n",
    "\n",
    "    return subtract(sum_numbers, third_num)\n",
    "\n",
    "\n",
    "first_number = int(input())\n",
    "second_number = int(input())\n",
    "third_number = int(input())\n",
    "\n",
    "print(add_and_subtract(first_number, second_number, third_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Characters in Range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function that receives two characters and returns a single string with all the characters in between them according to the ASCII code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#\n",
      ":\n",
      "$ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9\n"
     ]
    }
   ],
   "source": [
    "def char_range(start, end):\n",
    "    result = []\n",
    "    for char in range(ord(start) + 1, ord(end)):\n",
    "        result.append(chr(char))\n",
    "    return \" \".join(result)\n",
    "\n",
    "\n",
    "first_char = input()\n",
    "second_char = input()\n",
    "\n",
    "print(char_range(first_char, second_char))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Odd and Even Sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will receive a single number. You have to write a function that returns the sum of all even and all odd digits from that number as a single string like in the examples below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3495892137259234\n",
      "Odd sum = 54, Even sum = 22\n"
     ]
    }
   ],
   "source": [
    "def odd_even_sum(num):\n",
    "    even_sum = 0\n",
    "    odd_sum = 0\n",
    "    for digit in num:\n",
    "        if int(digit) % 2 == 0:\n",
    "            even_sum += int(digit)\n",
    "        else:\n",
    "            odd_sum += int(digit)\n",
    "    return f\"Odd sum = {odd_sum}, Even sum = {even_sum}\"\n",
    "\n",
    "\n",
    "number = input()\n",
    "\n",
    "print(odd_even_sum(number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Palindrome Integers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A palindrome is a number which reads the same backward as forward, such as 323 or 1001. Write a function which receives a list of positive integers and checks if each integer is a palindrome or not. Print the results on the console"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The input will be a single string containing the numbers separated by comma and space \", \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32, 2, 232, 1010\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def palindrome(parameter):\n",
    "    for i in range(len(parameter)):\n",
    "        if parameter[i] == parameter[i][::-1]:\n",
    "            print(\"True\")\n",
    "        else:\n",
    "            print(\"False\")\n",
    "\n",
    "\n",
    "integers = input().split(\", \")\n",
    "\n",
    "palindrome(integers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Password Validator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function that checks if a given password is valid. Password validations are:\n",
    "- The length should be 6 - 10 characters (inclusive)\n",
    "- It should consists only letters and digits\n",
    "- It should have at least 2 digits "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If a password is valid print \"Password is valid\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If it is NOT valid, for every unfulfilled rule print a message:\n",
    "- \"Password must be between 6 and 10 characters\"\n",
    "- \"Password must consist only of letters and digits\"\n",
    "- \"Password must have at least 2 digits\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pa$s$s\n",
      "Password must consist only of letters and digits\n",
      "Password must have at least 2 digits\n"
     ]
    }
   ],
   "source": [
    "def validator(parameter):\n",
    "    valid = True\n",
    "    if not 6 <= len(parameter) <= 10:\n",
    "        print(\"Password must be between 6 and 10 characters\")\n",
    "        valid = False\n",
    "    if not parameter.isalnum():\n",
    "        print(\"Password must consist only of letters and digits\")\n",
    "        valid = False\n",
    "    digit_counter = 0\n",
    "    for i in parameter:\n",
    "        if i.isdigit():\n",
    "            digit_counter += 1\n",
    "    if digit_counter < 2:\n",
    "        print(\"Password must have at least 2 digits\")\n",
    "        valid = False\n",
    "    if valid:\n",
    "        print(\"Password is valid\")\n",
    "\n",
    "\n",
    "password = input()\n",
    "\n",
    "validator(password)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Perfect Number "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function that receives an integer number and returns if this number is perfect or NOT."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A perfect number is a positive integer that is equal to the sum of its proper positive divisors. That is the sum of its positive divisors excluding the number itself (also known as its aliquot sum)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33550336\n",
      "We have a perfect number!\n"
     ]
    }
   ],
   "source": [
    "def perfect_num(parameter):\n",
    "    iterator = parameter\n",
    "    sum_divisors = 0\n",
    "    while True:\n",
    "        if parameter % 2 == 0:\n",
    "            parameter = parameter // 2\n",
    "        else:\n",
    "            parameter = parameter // 2 + 1\n",
    "        sum_divisors += parameter\n",
    "        if parameter <= 1:\n",
    "            break\n",
    "    if sum_divisors == iterator:\n",
    "        print(\"We have a perfect number!\")\n",
    "    else:\n",
    "        print(\"It's not so perfect.\")\n",
    "\n",
    "\n",
    "number = int(input())\n",
    "\n",
    "perfect_num(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. * Loading Bar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will receive a single integer number between 0 and 100 which is divided with 10 without residue (0, 10, 20, 30...). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your task is to create a function that visualizes a loading bar depending on that number you have received in the input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "70\n",
      "70% [%%%%%%%...]\n",
      "Still loading...\n"
     ]
    }
   ],
   "source": [
    "def loading(percent):\n",
    "    bar = \"\"\n",
    "    for i in range(1, 101, 10):\n",
    "        if i <= number:\n",
    "            bar += \"%\"\n",
    "        else:\n",
    "            bar += \".\"\n",
    "    if number != 100:\n",
    "        printing = f\"{number}% [{bar}]\\nStill loading...\"\n",
    "    else:\n",
    "        printing = f\"100% Complete!\\n[{bar}]\"\n",
    "    return printing\n",
    "\n",
    "\n",
    "number = int(input())\n",
    "\n",
    "print(loading(number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. * Factorial Division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function that receives two integer numbers. Calculate factorial of each number. Divide the first result by the second and print the division formatted to the second decimal point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "2\n",
      "360.00\n"
     ]
    }
   ],
   "source": [
    "def factorial(num1, num2):\n",
    "    first_factorial = first_number\n",
    "    second_factorial = second_number\n",
    "    for i in range(1, num1):\n",
    "        first_factorial *= (first_number - i)\n",
    "    for i in range(1, num2):\n",
    "        second_factorial *= (second_number - i)\n",
    "    return first_factorial / second_factorial\n",
    "\n",
    "\n",
    "first_number = int(input())\n",
    "second_number = int(input())\n",
    "\n",
    "print(f\"{(factorial(first_number, second_number)):.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. *Array Manipulator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trifon has finally become a junior developer and has received his first task. It's about manipulating an array of integers. He is not quite happy about it, since he hates manipulating arrays. They are going to pay him a lot of money, though, and he is willing to give somebody half of it if to help him do his job. You, on the other hand, love arrays (and money) so you decide to try your luck."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The array may be manipulated by one of the following commands\n",
    "- exchange {index} – splits the array after the given index, and exchanges the places of the two resulting sub-arrays. E.g. [1, 2, 3, 4, 5] -> exchange 2 -> result: [4, 5, 1, 2, 3]\n",
    "- - If the index is outside the boundaries of the array, print \"Invalid index\"\n",
    "- max even/odd– returns the INDEX of the max even/odd element -> [1, 4, 8, 2, 3] -> max odd -> print 4\n",
    "- min even/odd – returns the INDEX of the min even/odd element -> [1, 4, 8, 2, 3] -> min even > print 3\n",
    "- - If there are two or more equal min/max elements, return the index of the rightmost one\n",
    "- - If a min/max even/odd element cannot be found, print \"No matches\"\n",
    "- first {count} even/odd– returns the first {count} elements -> [1, 8, 2, 3] -> first 2 even -> print [8, 2]\n",
    "- last {count} even/odd – returns the last {count} elements -> [1, 8, 2, 3] -> last 2 odd -> print [1, 3]\n",
    "- - If the count is greater than the array length, print \"Invalid count\"\n",
    "- - If there are not enough elements to satisfy the count, print as many as you can. If there are zero even/odd elements, print an empty array \"[]\"\n",
    "- end – stop taking input and print the final state of the array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The input data should be read from the console.\n",
    "- On the first line, the initial array is received as a line of integers, separated by a single space\n",
    "- On the next lines, until the command \"end\" is received, you will receive the array manipulation commands\n",
    "- The input data will always be valid and in the format described. There is no need to check it explicitly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The output should be printed on the console.\n",
    "- On a separate line, print the output of the corresponding command\n",
    "- On the last line, print the final array in square brackets with its elements separated by a comma and a space \n",
    "- See the examples below to get a better understanding of your task"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constraints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The number of input lines will be in the range [2 … 50].\n",
    "- The array elements will be integers in the range [0 … 1000].\n",
    "- The number of elements will be in the range [1 .. 50]\n",
    "- The split index will be an integer in the range [-231 … 231 – 1]\n",
    "- first/last count will be an integer in the range [1 … 231 – 1]\n",
    "- There will not be redundant whitespace anywhere in the input\n",
    "- Allowed working time for your program: 0.1 seconds. Allowed memory: 16 MB."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 10 100 1000\n",
      "max even\n",
      "3\n",
      "first 5 even\n",
      "Invalid count\n",
      "exchange 10\n",
      "Invalid index\n",
      "min odd\n",
      "0\n",
      "exchange 0\n",
      "max even\n",
      "2\n",
      "min even\n",
      "0\n",
      "end\n",
      "[10, 100, 1000, 1]\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "list_input = input().split()\n",
    "command = input()\n",
    "for i in range(len(list_input)):\n",
    "    list_input[i] = int(list_input[i])\n",
    "while command != \"end\":\n",
    "    command_list = command.split()\n",
    "    result = []\n",
    "\n",
    "\n",
    "    def exchange(list_input, index):\n",
    "        if index >= len(list_input):\n",
    "            print(\"Invalid index\")\n",
    "            return list_input\n",
    "        elif index < 0:\n",
    "            print(\"Invalid index\")\n",
    "            return list_input\n",
    "        else:\n",
    "            a_list = list_input[0:index + 1]\n",
    "            b_list = list_input[index + 1:]\n",
    "            list_input = b_list + a_list\n",
    "            return list_input\n",
    "\n",
    "\n",
    "    if command_list[0] == \"exchange\":\n",
    "        list_input = exchange(list_input, int(command_list[-1]))\n",
    "\n",
    "\n",
    "    def maximum_even_odd(list_input):\n",
    "        max_num_even = -1\n",
    "        max_num_odd = -1\n",
    "        for i in range(len(list_input)):\n",
    "            if list_input[i] % 2 == 0:\n",
    "                if list_input[i] >= max_num_even:\n",
    "                    max_num_even = list_input[i]\n",
    "                    max_num_even_index = i\n",
    "            elif list_input[i] % 2 != 0:\n",
    "                if list_input[i] >= max_num_odd:\n",
    "                    max_num_odd = list_input[i]\n",
    "                    max_num_odd_index = i\n",
    "        if command_list[-1] == \"even\":\n",
    "            if max_num_even == -1:\n",
    "                result = \"No matches\"\n",
    "            else:\n",
    "                result = max_num_even_index\n",
    "            return result\n",
    "        else:\n",
    "            if max_num_odd == -1:\n",
    "                result = \"No matches\"\n",
    "            else:\n",
    "                result = max_num_odd_index\n",
    "            return result\n",
    "\n",
    "\n",
    "    if command_list[0] == \"max\":\n",
    "        print(maximum_even_odd(list_input))\n",
    "\n",
    "\n",
    "    def minimum_even_odd(list_input):\n",
    "        min_num_even = sys.maxsize\n",
    "        min_num_odd = sys.maxsize\n",
    "        for i in range(len(list_input)):\n",
    "            if list_input[i] % 2 == 0:\n",
    "                if list_input[i] <= min_num_even:\n",
    "                    min_num_even = list_input[i]\n",
    "                    min_num_even_index = i\n",
    "            elif list_input[i] % 2 != 0:\n",
    "                if list_input[i] <= min_num_odd:\n",
    "                    min_num_odd = list_input[i]\n",
    "                    min_num_odd_index = i\n",
    "        if command_list[-1] == \"even\":\n",
    "            if min_num_even == sys.maxsize:\n",
    "                result = \"No matches\"\n",
    "            else:\n",
    "                result = min_num_even_index\n",
    "            return result\n",
    "        if command_list[-1] == \"odd\":\n",
    "            if min_num_odd == sys.maxsize:\n",
    "                result = \"No matches\"\n",
    "            else:\n",
    "                result = min_num_odd_index\n",
    "            return result\n",
    "\n",
    "\n",
    "    if command_list[0] == \"min\":\n",
    "        print(minimum_even_odd(list_input))\n",
    "\n",
    "\n",
    "    def first_even_odd(list_input, index):\n",
    "        if int(index) > len(list_input):\n",
    "            return \"Invalid count\"\n",
    "        even_list = []\n",
    "        odd_list = []\n",
    "        for i in range(len(list_input)):\n",
    "            if list_input[i] % 2 == 0:\n",
    "                even_list.append(list_input[i])\n",
    "            if list_input[i] % 2 != 0:\n",
    "                odd_list.append(list_input[i])\n",
    "        if command_list[0] == \"first\":\n",
    "            if command_list[2] == \"even\":\n",
    "                return even_list[:index]\n",
    "            else:\n",
    "                return odd_list[:index]\n",
    "        if command_list[0] == \"last\":\n",
    "            if command_list[2] == \"even\":\n",
    "                return even_list[-index:]\n",
    "            else:\n",
    "                return odd_list[-index:]\n",
    "\n",
    "\n",
    "    if command_list[0] == \"first\" or command_list[0] == \"last\":\n",
    "        print(first_even_odd(list_input, int(command_list[1])))\n",
    "\n",
    "    command = input()\n",
    "print(list_input)"
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}