2.3 MORE EXERCISES Data Types and Variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.\tBiggest of 3 Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program that finds the biggest of 3 numbers.\n",
    "The input comes as 3 integers.\n",
    "The output is the biggest from the input numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-2\n",
      "7\n",
      "3\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "first_number = int(input())\n",
    "second_number = int(input())\n",
    "third_number = int(input())\n",
    "\n",
    "biggest_number = max(first_number, second_number, third_number)\n",
    "\n",
    "print(biggest_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.\tExchange Integers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Read two integer numbers and after that exchange their values by using some programming logic. Print the variable values before and after the exchange, as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "10\n",
      "Before:\n",
      "a = 5\n",
      "b = 10\n",
      "After:\n",
      "a = 10\n",
      "b = 5\n"
     ]
    }
   ],
   "source": [
    "first_number = int(input())\n",
    "second_number = int(input())\n",
    "\n",
    "print(f\"Before:\\na = {first_number}\\nb = {second_number}\")\n",
    "print(f\"After:\\na = {second_number}\\nb = {first_number}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.\tPrime Number Checker"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program to check if a number is prime (only wholly divisible by itself and one).\n",
    "The input comes as an integer number.\n",
    "The output should be true for prime number and false otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "number = int(input())\n",
    "\n",
    "counter = 0\n",
    "\n",
    "for i in range(2, number + 1):\n",
    "    if number % i == 0:\n",
    "        counter += 1\n",
    "        \n",
    "if counter == 1:\n",
    "    print(\"True\")\n",
    "else:\n",
    "    print(\"False\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.\tDecrypting Messages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will receive a key (integer) and n characters afterward. Add the key to each of the characters and append them to a message. At the end print the message, which you decrypted. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On the first line, you will receive the key\n",
    "- On the second line, you will receive n – the number of lines, which will follow\n",
    "- On the next n lines – you will receive lower and uppercase characters from the Latin alphabet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print the decrypted message."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constraints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The key will be in the interval [0…20]\n",
    "- n will be in the interval [1…20]\n",
    "- The characters will always be upper or lower-case letters from the English alphabet\n",
    "- You will receive one letter per line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "7\n",
      "P\n",
      "l\n",
      "c\n",
      "q\n",
      "R\n",
      "k\n",
      "f\n",
      "SoftUni\n"
     ]
    }
   ],
   "source": [
    "key = int(input())\n",
    "n_characters = int(input())\n",
    "result = \"\"\n",
    "for char in range(n_characters):\n",
    "    character = input()\n",
    "    key_character = chr(ord(character) + key)\n",
    "    result += key_character\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.\tBalanced Brackets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will receive n lines. On those lines, you will receive one of the following:\n",
    "- Opening bracket – “(“,\n",
    "- Closing bracket – “)” or\n",
    "- Random string\n",
    "- Your task is to find out if the brackets are balanced. That means after every closing bracket should follow an opening one. Nested parentheses are not valid, and if two consecutive opening brackets exist, the expression should be marked as unbalanced. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On the first line, you will receive n – the number of lines, which will follow\n",
    "- On the next n lines, you will receive “(”, “)” or another string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You have to print “BALANCED”, if the parentheses are balanced and “UNBALANCED” otherwise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constraints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- n will be in the interval [1…20]\n",
    "- The length of the stings will be between [1…100] characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "(\n",
      "5+10\n",
      ")\n",
      "*2+\n",
      "(\n",
      "5\n",
      ")\n",
      "-12\n",
      "BALANCED\n"
     ]
    }
   ],
   "source": [
    "n_symbols = int(input())\n",
    "counter = 0\n",
    "result = \"BALANCED\"\n",
    "for symbol in range(n_symbols):\n",
    "    char = input()\n",
    "    if char == \"(\":\n",
    "        counter += 1\n",
    "    if (char == \")\" and counter != 1) or counter == 2:\n",
    "        result = \"UNBALANCED\"\n",
    "        break\n",
    "    if char == \")\" and counter == 1:\n",
    "        result = \"BALANCED\"\n",
    "        counter = 0\n",
    "if counter == 1:\n",
    "    print(\"UNBALANCED\")\n",
    "else:\n",
    "    print(result)"
   ]
  }
 ],
 "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
}