Case Studies.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem Statement 1\n",
    "\n",
    "There is a JAR full of candies for sale at a mall counter. JAR has the capacity N, that is JAR can contain maximum N candies when JAR is full. At any point of time. JAR can have M number of Candies where M<=N. Candies are served to the customers. JAR is never remain empty as when last k candies are left. JAR if refilled with new candies in such a way that JAR get full.\n",
    "Write a code to implement above scenario. Display JAR at counter with available number of candies. Input should be the number of candies one customer can order at point of time. Update the JAR after each purchase and display JAR at Counter.\n",
    "\n",
    "Output should give number of Candies sold and updated number of Candies in JAR.\n",
    "\n",
    "If Input is more than candies in JAR, return: “INVALID INPUT”"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "total_candles=N\\\n",
    "total_candles_instant=M\\\n",
    "where M<=N\\\n",
    "min_candles=k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_candles_jar=10\n",
    "candles_sold=int(input(\"Enter the number of candles sold: \"))\n",
    "if candles_sold in range(1,7):\n",
    "    print(f\"{candles_sold} Candles sold\")\n",
    "    print(f\"{max_candles_jar-candles_sold} Candles remaining\")\n",
    "else:\n",
    "    print(\"Invalid Input\")\n",
    "    print(f\"{max_candles_jar} Candles remaining \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem Statement 2\n",
    "\n",
    "Selection of MPCS exams include a fitness test which is conducted on ground. There will be a batch of 3 trainees, appearing for running test in track for 3 rounds. You need to record their oxygen level after every round. After trainee are finished with all rounds, calculate for each trainee his average oxygen level over the 3 rounds and select one with highest oxygen level as the most fit trainee. If more than one trainee attains the same highest average level, they all need to be selected.\n",
    "\n",
    "Display the most fit trainee (or trainees) and the highest average oxygen level.\n",
    "\n",
    "Note:\n",
    "\n",
    "The oxygen value entered should not be accepted if it is not in the range between 1 and 100.\n",
    "If the calculated maximum average oxygen value of trainees is below 70 then declare the trainees as unfit with meaningful message as “All trainees are unfit.\n",
    "Average Oxygen Values should be rounded.\n",
    "Example 1:\n",
    "\n",
    "INPUT VALUES\n",
    "            95, 92, 95, 92, 90, 92, 90, 92, 90\n",
    "OUTPUT VALUES\\\n",
    "Trainee Number : 1\\\n",
    "Trainee Number : 3\\\n",
    "Note:\n",
    "\n",
    "Input should be 9 integer values representing oxygen levels entered in order as\n",
    "\n",
    "Round 1\n",
    "\n",
    "Oxygen value of trainee 1,\n",
    "Oxygen value of trainee 2,\n",
    "Oxygen value of trainee 3\\\n",
    "Round 2\n",
    "\n",
    "Oxygen value of trainee 1,\n",
    "Oxygen value of trainee 2,\n",
    "Oxygen value of trainee 3\\\n",
    "Round 3\n",
    "\n",
    "Oxygen value of trainee 1,\n",
    "Oxygen value of trainee 2,\n",
    "Oxygen value of trainee 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainee=[[], [], [], []]\n",
    "for i in range(3):\n",
    "    for j in range(3):\n",
    "        trainee[i].append(int(input(\"Enter Oxygebn level values for trainees: \")))\n",
    "        if trainee[i][-1] not in range(1,101):\n",
    "            print(\"Invalid Input\")\n",
    "\n",
    "for k in range(3):\n",
    "    trainee[3].append((trainee[2][k]+trainee[1][k]+trainee[0][k])//3)\n",
    "    \n",
    "maximum = max(trainee[3])\n",
    "\n",
    "for i in range(3):\n",
    "    if trainee[3][i] < 70 :\n",
    "        print(f\"Trainee {i+1} is unfit\")\n",
    "    elif trainee[3][i] == maximum:\n",
    "        print(f\"Trainee Number: {i+1} is fit\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem Statement 3\n",
    "\n",
    "A washing machine works on the principle of Fuzzy System, the weight of clothes put inside it for washing is uncertain But based on weight measured by sensors, it decides time and water level which can be changed by menus given on the machine control area.  \n",
    "\n",
    "For low level water, the time estimate is 25 minutes, where approximately weight is between 2000 grams or any nonzero positive number below that.\n",
    "\n",
    "For medium level water, the time estimate is 35 minutes, where approximately weight is between 2001 grams and 4000 grams.\n",
    "\n",
    "For high level water, the time estimate is 45 minutes, where approximately weight is above 4000 grams.\n",
    "\n",
    "Assume the capacity of machine is maximum 7000 grams\n",
    "\n",
    "Where approximately weight is zero, time estimate is 0 minutes.\n",
    "\n",
    "Write a function which takes a numeric weight in the range [0,7000] as input and produces estimated time as output is: “OVERLOADED”, and for all other inputs, the output statement is\n",
    "\n",
    "“INVALID INPUT”.\n",
    "\n",
    "Input should be in the form of integer value –\n",
    "\n",
    "Output must have the following format –\n",
    "\n",
    "Time Estimated: Minutes\n",
    "\n",
    "Example:\n",
    "\n",
    "Input value\n",
    "2000\n",
    "\n",
    "Output value\n",
    "Time Estimated: 25 minutes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weight=int(input(\"Enter the weight of the clothes (in gms)\"))\n",
    "if weight==0:\n",
    "    print(\"The time estimate is 0 minute\")\n",
    "elif weight in range(1,2001):\n",
    "    print(\"The time estimate is 25 minutes\")\n",
    "elif weight in range(2001,4001):\n",
    "    print(\"The time estimate is 35 minutes\")\n",
    "elif weight in range(4001,7001):\n",
    "    print(\"The time estimate is 45 minutes\")\n",
    "else:\n",
    "    print(\"The machine is OVERLOADED so, INVALID INPUT\")        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem Statement 4\n",
    "\n",
    "The Caesar cipher is a type of substitution cipher in which each alphabet in the plaintext or messages is shifted by a number of places down the alphabet.\n",
    "For example,with a shift of 1, P would be replaced by Q, Q would become R, and so on.\n",
    "To pass an encrypted message from one person to another, it is first necessary that both parties have the ‘Key’ for the cipher, so that the sender may encrypt and the receiver may decrypt it.\n",
    "Key is the number of OFFSET to shift the cipher alphabet. Key can have basic shifts from 1 to 25 positions as there are 26 total alphabets.\n",
    "As we are designing custom Caesar Cipher, in addition to alphabets, we are considering numeric digits from 0 to 9. Digits can also be shifted by key places.\n",
    "For Example, if a given plain text contains any digit with values 5 and keyy =2, then 5 will be replaced by 7, “-”(minus sign) will remain as it is. Key value less than 0 should result into “INVALID INPUT”\n",
    "\n",
    "Example 1:\n",
    "Enter your PlainText: All the best\\\n",
    "Enter the Key: 1\n",
    "\n",
    "The encrypted Text is: Bmm uif Cftu\n",
    "\n",
    "Write a function CustomCaesarCipher(int key, String message) which will accept plaintext and key as input parameters and returns its cipher text as output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CustomCaesarCipher(string_input):\n",
    "\n",
    "    alphabets=\"abcdefghijklmnopqrstuvwxyz\"\n",
    "    n=len(string_input)\n",
    "    string_output=\"\"\n",
    "    \n",
    "    for i in range(n):\n",
    "        char=string_input[i]\n",
    "        location=alphabets.find(char)\n",
    "        new_location=(location+key)%26\n",
    "        string_output=string_output+alphabets[new_location]\n",
    "    print(string_output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "key=int(input(\"Enter the key value\"))\n",
    "string_input=str(input(\"Please enter the text\")).lower()\n",
    "CustomCaesarCipher(string_input)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem Statement 5\n",
    "\n",
    "A City Bus is a Ring Route Bus which runs in circular fashion.That is, Bus once starts at the Source Bus Stop, halts at each Bus Stop in its Route and at the end it reaches the Source Bus Stop again.\n",
    "If there are n  number of Stops and if the bus starts at Bus Stop 1, then after nth Bus Stop, the next stop in the Route will be Bus Stop number 1 always.\n",
    "If there are n stops, there will be n paths.One path connects two stops. Distances (in meters) for all paths in Ring Route is given in array Path[] as given below:\n",
    "Path = [800, 600, 750, 900, 1400, 1200, 1100, 1500]\n",
    "Fare is determined based on the distance covered from source to destination stop as  Distance between Input Source and Destination Stops can be measured by looking at values in array Path[] and fare can be calculated as per following criteria:\n",
    "\n",
    "If d =1000 metres, then fare=5 INR\n",
    "(When calculating fare for others, the calculated fare containing any fraction value should be ceiled. For example, for distance 900n when fare initially calculated is 4.5 which must be ceiled to 5)\n",
    "Path is circular in function. Value at each index indicates distance till current stop from the previous one. And each index position can be mapped with values at same index in BusStops [] array, which is a string array holding abbreviation of names for all stops as-\n",
    "“THANERAILWAYSTN” = ”TH”, “GAONDEVI” = “GA”, “ICEFACTROY” = “IC”, “HARINIWASCIRCLE” = “HA”, “TEENHATHNAKA” = “TE”, “LUISWADI” = “LU”, “NITINCOMPANYJUNCTION” = “NI”, “CADBURRYJUNCTION” = “CA”\n",
    "\n",
    "Given, n=8, where n is number of total BusStops.\n",
    "BusStops = [ “TH”, ”GA”, ”IC”, ”HA”, ”TE”, ”LU”, ”NI”,”CA” ]\n",
    "\n",
    "Write a code with function getFare(String Source, String Destination) which take Input as source and destination stops(in the format containing first two characters of the Name of the Bus Stop) and calculate and return travel fare.\n",
    "\n",
    "Example 1:\n",
    "Input Values\n",
    "ca\n",
    "Ca\n",
    "\n",
    "Output Values\n",
    "INVALID OUTPUT\n",
    "\n",
    "Example 2:\n",
    "Input Values\n",
    "NI\n",
    "HA\n",
    "Output Values\n",
    "23.0 INR\n",
    "\n",
    "Note: Input and Output should be in format given in example.\n",
    "Input should not be case sensitive and output should be in the format   INR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fare(source, destination):\n",
    "    path = [800, 600, 750, 900, 1400, 1200, 1100, 1500] \n",
    "    stops = [ \"TH\", \"GA\", \"IC\", \"HA\", \"TE\", \"LU\", \"NI\", \"CA\"]\n",
    "    \n",
    "    fare=0\n",
    "    distance=0\n",
    "    \n",
    "    if source==destination:\n",
    "        return \"Invalid Input\"\n",
    "    else:\n",
    "        source=source.upper()\n",
    "        destination=destination.upper()\n",
    "        start=min(stops.index(source), stops.index(destination))\n",
    "        end=max(stops.index(source), stops.index(destination))\n",
    "        \n",
    "        for i in range(start, end+1):\n",
    "            distance=distance+path[i]\n",
    "        \n",
    "        fare=(distance/1000)*5\n",
    "        fare=str(fare)\n",
    "    return fare+'INR'\n",
    "\n",
    "source=str(input())\n",
    "destination=str(input())\n",
    "fare(source, destination)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "Path = [800, 600, 750, 900, 1400, 1200, 1100, 1500] \n",
    "BusStops = [ \"TH\", \"GA\", \"IC\", \"HA\", \"TE\", \"LU\", \"NI\", \"CA\"]\n",
    "\n",
    "route=pd.DataFrame(Path, BusStops).reset_index()\n",
    "route.columns=[\"Path\", \"BusStops\"]\n",
    "route"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem Statement 6\n",
    "\n",
    "We want to estimate the cost of painting a property. Interior wall painting cost is Rs.18 per sq.ft. and exterior wall painting cost is Rs.12 per sq.ft.\n",
    "\n",
    "Take input as\n",
    "1. Number of Interior walls\n",
    "2. Number of Exterior walls\n",
    "3. Surface Area of each Interior Wall in units of square feet\n",
    "4. Surface Area of each Exterior Wall in units of square feet\n",
    "\n",
    "If a user enters zero  as the number of walls then skip Surface area values as User may don’t  want to paint that wall.\n",
    "\n",
    "Calculate and display the total cost of painting the property\n",
    "\n",
    "Example 1:\n",
    "\n",
    "6\\\n",
    "3\\\n",
    "12.3\\\n",
    "15.2\\\n",
    "12.3\\\n",
    "15.2\\\n",
    "12.3\\\n",
    "15.2\\\n",
    "10.10\\\n",
    "10.10\\\n",
    "10.00\\\n",
    "Total estimated Cost : 1847.4 INR\n",
    "\n",
    "Note: Follow in input and output format as given in above example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "interior_walls=int(input(\"Enter the number of interior walls: \"))\n",
    "exterior_walls=int(input(\"Enter the number of exterior walls: \"))\n",
    "\n",
    "interior_cost=18#per feet\n",
    "exterior_cost=12#per feet\n",
    "\n",
    "if exterior_walls < 0 or interior_walls < 0:\n",
    "    print(\"Invalid Input\")\n",
    "    exit()  \n",
    "    \n",
    "interior_surface_area=[]\n",
    "exterior_surface_area=[]\n",
    "\n",
    "for i in range(interior_walls):\n",
    "    interior_surface_area.append(float(input(\"Enter each interior walls' surface area: \")))\n",
    "    \n",
    "for i in range(exterior_walls):\n",
    "    exterior_surface_area.append(float(input(\"Enter each exterior walls' surface area: \")))\n",
    "\n",
    "Total_sum=sum(exterior_surface_area)*exterior_cost+sum(interior_surface_area)*interior_cost\n",
    "print(f\"The total cost of painting all the walls is {Total_sum} INR\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exterior_surface_area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum(exterior_surface_area)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem Statement 7\n",
    "\n",
    "There are total n number of Monkeys sitting on the branches of a huge Tree. As travelers offer Bananas and Peanuts, the Monkeys jump down the Tree. If every Monkey can eat k Bananas and j Peanuts. If total m number of Bananas and p number of Peanuts are offered by travelers, calculate how many Monkeys remain on the Tree after some of them jumped down to eat.\n",
    "At a time one Monkeys gets down and finishes eating and go to the other side of the road. The Monkey who climbed down does not climb up again after eating until the other Monkeys finish eating.\n",
    "Monkey can either eat k Bananas or j Peanuts. If for last Monkey there are less than k Bananas left on the ground or less than j Peanuts left on the ground, only that Monkey can eat Bananas(<k) along with the Peanuts(<j).\n",
    "Write code to take inputs as n, m, p, k, j and return  the number of Monkeys left on the Tree.\n",
    "\n",
    "Where, n= Total no of Monkeys\\\n",
    "        k= Number of eatable Bananas by Single Monkey (Monkey that jumped down last may get less than k Bananas)\\\n",
    "        j = Number of eatable Peanuts by single Monkey(Monkey that jumped down last may get less than j Peanuts)\\\n",
    "        m = Total number of Bananas\\\n",
    "        p  = Total number of Peanuts\\\n",
    "Remember that the Monkeys always eat Bananas and Peanuts, so there is no possibility of k and j having a value zero\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input Values    \n",
    "20\\\n",
    "2\\\n",
    "3\\\n",
    "12\\\n",
    "12\\\n",
    "\n",
    "Output Values\\\n",
    "Number of  Monkeys left on the tree:10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=20\n",
    "k=2\n",
    "j=3\n",
    "m=12\n",
    "l=12\n",
    "\"\"\"monkeys=int(input(\"Enter number of monkeys: \"))\n",
    "bananas=int(input(\"Enter total number of bananas: \"))\n",
    "bananas=int(input(\"Enter total number of peanuts: \"))\n",
    "#monkey can eat k bananas tops\n",
    "eat_bananas=2\n",
    "eat_peanuts=3\"\"\"\n",
    "monkeys_eat_bananas=m/k\n",
    "monkeys_eat_peanuts=l/j\n",
    "\n",
    "Total_left = n-monkeys_eat_bananas-monkeys_eat_peanuts\n",
    "Total_left"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def monkeys(n,k, j, m, l):\n",
    "    n=int(input(\"Enter number of monkeys: \"))\n",
    "    k=int(input(\"Enter number of bananas monkey can eat at a time: \"))\n",
    "    assert k>0\n",
    "    j=int(input(\"Enter number of peanuts monkey can eat at a time: \"))\n",
    "    assert j>0\n",
    "        \n",
    "    m=int(input(\"Enter number of bananas available for monkeys: \"))\n",
    "    l=int(input(\"Enter number of peanuts available for monkeys: \"))\n",
    "    \n",
    "    monkeys_eat_banans=m/k\n",
    "    monkeys_eat_peanuts=l/j\n",
    "    \n",
    "    monkeys_left=n-monkeys_eat_banans-monkeys_eat_peanuts\n",
    "    \n",
    "    if monkeys_left<0:\n",
    "        print(\"The operation is Invalid\")\n",
    "    else:\n",
    "        print(f\"The monkeys left who didn't eat are: {int(monkeys_left)} monkeys\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monkeys(n,k, j, m, l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem Statement 8\n",
    "\n",
    "Chain Marketing Organization has has a scheme for income generation, through which its members generate income for themselves. The scheme is such that suppose A joins the scheme and makes R and V to join this scheme  then A is Parent Member of R and V who are child Members. When any member joins the scheme then the parent gets total commission of 10% from each of its child members.\n",
    "Child members receive commission of 5% respectively. If a Parent member does not have any member joined under him, then he gets commission of 5%.\n",
    "Take name of the members joining the scheme as input.\n",
    "Display how many members joined the scheme including parent member.Calculate the Total commission gained by each members in the scheme. The fixed amount for joining the scheme is Rs.5000 on which commission will be generated\n",
    "SchemeAmount = 5000\n",
    "\n",
    "Example 1: When there are more than one child members\\\n",
    "Input : (Do not give input prompts.Accept values as follows. )\n",
    "\n",
    "Amit                     //Enter parent Member as this\\\n",
    "Y                           //Enter Y if  Parent member has child members otherwise enter N\\\n",
    "Rajesh,Virat        //Enter names of child members of Amit in comma separated\\\n",
    "Output:(Final Output must be in format given below.)\\\n",
    "TOTAL MEMBERS:3\\\n",
    "COMISSION DETAILS\\\n",
    "Amit: 1000 INR\\\n",
    "Rajesh :250 INR\\\n",
    "Virat: 250 INR\\\n",
    "\n",
    "Example 2: When there is only one child member in the hierarchy\\\n",
    "Input :\\\n",
    "Amit\\\n",
    "Y\\\n",
    "Rajesh\\\n",
    "Output:\\\n",
    "Total Members: 2\\ \n",
    "Comission Details\\\n",
    "Amit: 500 INR\\\n",
    "Rajesh: 250 INR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parent_member=str(input(\"Enter Parent Member Name: \"))\n",
    "\n",
    "child_members=str(input(\"Enter Yes or No for child members: \"))\n",
    "if child_members.upper().startswith(\"Y\"):\n",
    "    print(\"Parent member has child memeber(s)\")\n",
    "    members=str(input(\"Enter names of members: \")).split()\n",
    "    \n",
    "    if len(members)==2:\n",
    "        print(f\"{parent_member} will be get a commission of 1000 INR and {members[0]} & {members[1]} will get a commission of 500 INR each\")\n",
    "    elif len(members)==1:\n",
    "        print(f\"{parent_member} will be get a commission of 500 INR and {members[0]} will get a commission of 250 INR\")\n",
    "else:\n",
    "    print(\"Nobody gets commission\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list=[\"Yes, No\"]\n",
    "list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str=\"Yes\"\n",
    "str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(str.split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str.split()[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem Statement 9\n",
    "\n",
    "FULLY AUTOMATIC VENDING MACHINE – dispenses your cuppa on just press of button. A vending machine can serve range of products as follows:\n",
    "\n",
    "**Coffee**\\\n",
    "Espresso Coffee\\\n",
    "Cappuccino Coffee\\\n",
    "Latte Coffee\\\n",
    "\n",
    "**Tea**\\\n",
    "Plain Tea\\\n",
    "Assam Tea\\\n",
    "Ginger Tea\\\n",
    "Cardamom Tea\\\n",
    "Masala Tea\\\n",
    "Lemon Tea\\\n",
    "Green Tea\\\n",
    "Organic Darjeeling Tea\\\n",
    "\n",
    "**Soups**\\ \n",
    "Hot and Sour Soup\\\n",
    "Veg Corn Soup\\\n",
    "Tomato Soup\\\n",
    "Spicy Tomato Soup\n",
    "\n",
    "**Beverages**\\\n",
    "Hot Chocolate Drink\\\n",
    "Badam Drink\\\n",
    "Badam-Pista Drink\n",
    "\n",
    "Write a program to take input for main menu & sub menu and display the name of sub menu selected in the following format (enter the first letter to select main menu):\n",
    "\n",
    "Welcome to CCD \n",
    "\n",
    "Enjoy your\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input:\n",
    "c\\\n",
    "1\\\n",
    "Output\\\n",
    "Welcome to CCD!\\\n",
    "Enjoy your Espresso Coffee!\\\n",
    "\n",
    "Example 2:\n",
    "\n",
    "Input\\\n",
    "t\\\n",
    "9\n",
    "\n",
    "Output\\\n",
    "INVALID OUTPUT!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "menu={\"Coffees\":[\"Espresso Coffee\", \"Cappuccino Coffee\", \"Latte Coffee\"], \n",
    "     \"Tea\":[\"Plain Tea\",\"Assam Tea\", \"Ginger Tea\",\"Cardamom Tea\",\"Masala Tea\",\"Lemon Tea\",\"Green Tea\",\n",
    "      \"Organic Darjeeling Tea\"], \"Soups\": [\"Hot and Sour Soup\", \"Veg Corn Soup\", \"Tomato Soup\", \"Spicy Tomato Soup\"],\n",
    "    \"Beverages\":[\"Hot Chocolate Drink\", \"Badam Drink\", \"Badam-Pista Drink\"]}\n",
    "\n",
    "order=str(input(\"Welcome to CCD. What would you like?: \"))\n",
    "\n",
    "if not (order.upper().startswith(\"C\") or order.upper().startswith(\"T\") or order.upper().startswith(\"S\") or order.upper().startswith(\"B\")):\n",
    "    print(\"Invalid Input. PLease choose from the mmenu\")\n",
    "    exit()\n",
    "    \n",
    "\n",
    "if order.upper().startswith(\"C\"):\n",
    "    print(\"What kind of coffee would you like?\")\n",
    "    c=int(input(\"Enter your coffee type. Choose from  1, 2, or 3: \"))\n",
    "    if c in range(1,4):\n",
    "        print(f\"Enjoy your {menu['Coffees'][c-1]}\")\n",
    "    else:\n",
    "        print(\"Invalid Input\")\n",
    "        exit()\n",
    "    \n",
    "if order.upper().startswith(\"T\"):\n",
    "    print(\"What kind of Tea would you like?\")\n",
    "    t=int(input(\"Enter the Tea type you want. Choose from  1 to 8: \"))\n",
    "    if t in range(1,9):\n",
    "        print(f\"Enjoy your {menu['Tea'][t-1]}\")\n",
    "    else:\n",
    "        print(\"Invalid Input\")\n",
    "        exit()\n",
    "        \n",
    "if order.upper().startswith(\"S\"):\n",
    "    print(\"What kind of Soup would you like?\")\n",
    "    s=int(input(\"Enter the Soup type you want. Choose from 1 to 4: \"))\n",
    "    if s in range(1,5):\n",
    "        print(f\"Enjoy your {menu['Soups'][s-1]}\")\n",
    "    else:\n",
    "        print(\"Invalid Input\")\n",
    "        exit()\n",
    "        \n",
    "if order.upper().startswith(\"B\"):\n",
    "    print(\"What kind of Beverages would you like?\")\n",
    "    b=int(input(\"Enter the Beverage type you want.Choose from 1 to 3: \"))\n",
    "    if b in range(1,4):\n",
    "        print(f\"Enjoy your {menu['Beverages'][b-1]}\")\n",
    "    else:\n",
    "        print(\"Invalid Input\")\n",
    "        exit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "menu={\"Coffees\":[\"Espresso Coffee\", \"Cappuccino Coffee\", \"Latte Coffee\"]}\n",
    "c=2\n",
    "menu['Coffees'][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem Statement 10\n",
    "\n",
    "A doctor has a clinic where he serves his patients. The doctor’s consultation fees are different for different groups of patients depending on their age. If the patient’s age is below 17, fees is 200 INR. If the patient’s age is between 17 and 40, fees is 400 INR. If patient’s age is above 40, fees is 300 INR. Write a code to calculate earnings in a day for which one array/List of values representing age of patients visited on that day is passed as input.\n",
    "\n",
    "Note:\n",
    "\n",
    "Age should not be zero or less than zero or above 120\n",
    "Doctor consults a maximum of 20 patients a day\n",
    "Enter age value (press Enter without a value to stop):\n",
    "Example 1:\n",
    "\n",
    "Input\n",
    "20\n",
    "30\n",
    "40\n",
    "50\n",
    "2\n",
    "3\n",
    "14\n",
    " \n",
    "\n",
    "Output\n",
    "Total Income 2000 INR\n",
    " \n",
    "\n",
    "Note: Input and Output Format should be same as given in the above example.\n",
    "For any wrong input display INVALID INPUT\n",
    "\n",
    "Output Format\n",
    "\n",
    "Total Income <Integer> INR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "patients=[]\n",
    "\n",
    "for i in range(1,21):\n",
    "    age=int(input(\"Please provide your age: \"))\n",
    "    if age in range(1,121):\n",
    "        patients.append(age)\n",
    "    elif not (age in range(1,121)):\n",
    "        continue\n",
    "\n",
    "fees=0\n",
    "for age in patients:\n",
    "    if age<17:\n",
    "        fees=fees+200\n",
    "    elif age<40:\n",
    "        fees=fees+400\n",
    "    else:\n",
    "        fees=fees+300\n",
    "print(f\"Total fees for the day is {fees} INR\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "patients"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Probelm Statement 11\n",
    "\n",
    "#### To check whether a year is leap or not\n",
    "\n",
    "Step 1:\n",
    "\n",
    "We first divide the year by 4. If it is not divisible by 4 then it is not a leap year. If it is divisible by 4 leaving remainder 0 \n",
    "\n",
    "Step 2:\n",
    "\n",
    "We divide the year by 100. If it is not divisible by 100 then it is a leap year.If it is divisible by 100 leaving remainder 0\n",
    "\n",
    "Step 3:\n",
    "\n",
    "We divide the year by 400. If it is not divisible by 400 then it is a leap year. If it is divisible by 400 leaving remainder 0 \n",
    "\n",
    "Then it is a leap year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def leap_year(year):\n",
    "    year=int(input(\"Please enter the year value you want to check: \"))\n",
    "    if year%4==0 and year%100!=0 and year%400!=0:\n",
    "        print(f\"The {year} year is a leap year\")\n",
    "    else:\n",
    "        print(f\"The {year} year is not a leap year\")\n",
    "        \n",
    "leap_year(year)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Probelm Statement 12\n",
    "\n",
    "#### Prime Numbers with a Twist\n",
    "Ques. Write a code to check whether no is prime or not. Condition use function check() to find whether entered no is positive or negative ,if negative then enter the no, And if yes pas no as a parameter to prime() and check whether no is prime or not?\n",
    "\n",
    "Whether the number is positive or not, if it is negative then print the message “please enter the positive number”\n",
    "It is positive then call the function prime and check whether the take positive number is prime or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num=int(input(\"Please enter a number: \"))\n",
    "if num>1:\n",
    "    for i in range(2,num):\n",
    "        if num%i==0:\n",
    "            print(f\"{num} is not a Prime Number\")\n",
    "            break\n",
    "    else:\n",
    "            print(f\"{num} is a Prime Number\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Probelm Statement 13\n",
    "\n",
    "#### Number Series with a Twist – 1\n",
    "\n",
    "Find the 15th term of the series?\n",
    "\n",
    "0,0,7,6,14,12,21,18, 28\n",
    "\n",
    "Explanation : In this series the odd term is increment of 7 {0, 7, 14, 21, 28, 35 – – – – – – }\n",
    "\n",
    "                        And even term is a increment of 6 {0, 6, 12, 18, 24, 30 – – – – – – }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num=int(input(\"Enter n: \"))\n",
    "\n",
    "if num%2==0:\n",
    "    print(f\"The #{num+1} term is {7*(num//2)}\")\n",
    "elif num%2==1:\n",
    "    print(f\"The #{num+1} term is {6*(num//2)}\")  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Probelm Statement 14\n",
    "\n",
    "#### Number Series with a Twist 2\n",
    "\n",
    "Consider the following series: 1, 1, 2, 3, 4, 9, 8, 27, 16, 81, 32, 243, 64, 729, 128, 2187 …\n",
    "\n",
    "This series is a mixture of 2 series – all the odd terms in this series form a geometric series and all the even terms form yet another geometric series. Write a program to find the Nth term in the series.\n",
    "\n",
    "The value N in a positive integer that should be read from STDIN. The Nth term that is calculated by the program should be written to STDOUT. Other than value of n th term,no other character / string or message should be written to STDOUT. For example , if N=16, the 16th term in the series is 2187, so only value 2187 should be printed to STDOUT.\n",
    "\n",
    "You can assume that N will not exceed 30."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = int(input(\"Enter the term number which you want to determine: \"))\n",
    "\n",
    "if(num%2==0):\n",
    "    num = num // 2\n",
    "    print(3**(num-1))\n",
    "else:\n",
    "    num = num // 2 + 1\n",
    "    print(2**(num-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Probelm Statement 15\n",
    "\n",
    "#### Number Series with a Twist 3\n",
    "\n",
    "Consider the below series :\n",
    "\n",
    "0, 0, 2, 1, 4, 2, 6, 3, 8, 4, 10, 5, 12, 6, 14, 7, 16, 8\n",
    "\n",
    "This series is a mixture of 2 series all the odd terms in this series form even numbers in ascending order and every even terms is derived from the previous  term using the formula (x/2)\n",
    "\n",
    "Write a program to find the nth term in this series.\n",
    "\n",
    "The value n in a positive integer that should be read from STDIN the nth term that is calculated by the program should be written to STDOUT. Other than the value of the nth term no other characters /strings or message should be written to STDOUT.\n",
    "\n",
    "For example if n=10,the 10 th term in the series is to be derived from the 9th term in the series. The 9th term is 8 so the 10th term is (8/2)=4. Only the value 4 should be printed to STDOUT.\n",
    "\n",
    "You can assume that the n will not exceed 20,000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input(\"Enter the number: \"))\n",
    "\n",
    "if n%2==0:\n",
    "        print(f\"The #{n+1} term is {n}\")\n",
    "elif n%2==1:\n",
    "        print(f\"The #{n+1} term is {n//2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Probelm Statement 16\n",
    "\n",
    "#### String with a Twist\n",
    "\n",
    "The program will recieve 3 English words inputs from STDIN\n",
    "\n",
    "These three words will be read one at a time, in three separate line\n",
    "The first word should be changed like all vowels should be replaced by %\n",
    "The second word should be changed like all consonants should be replaced by #\n",
    "The third word should be changed like all char should be converted to upper case\n",
    "Then concatenate the three words and print them\n",
    "Other than these concatenated word, no other characters/string should or message should be written to STDOUT\n",
    "\n",
    "For example if you print how are you then output should be h%wa#eYOU.\n",
    "\n",
    "You can assume that input of each word will not exceed more than 5 chars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word1=str(input(\"Enter word1: \")).lower()\n",
    "word2=str(input(\"Enter word2: \")).lower()\n",
    "word3=str(input(\"Enter word3: \")).upper()\n",
    "\n",
    "vowels=\"aeiou\"\n",
    "\n",
    "for char in word1:\n",
    "    if char in vowels:\n",
    "        word1=word1.replace(char, \"%\")\n",
    "        \n",
    "for char in word2:\n",
    "    if not char in vowels:\n",
    "        word2=word2.replace(char, \"#\")   \n",
    "        \n",
    "print(f\"The transformed string formed by a combination of 3 words is {word1+word2+word3}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Probelm Statement 17\n",
    "\n",
    "#### Addition of two numbers a Twist\n",
    "\n",
    "Using a method, pass two variables and find the sum of two numbers.\n",
    "\n",
    "Test case:\n",
    "\n",
    "Number 1 – 20\n",
    "\n",
    "Number 2 – 20.38\n",
    "\n",
    "Sum = 40.38\n",
    "\n",
    "There were a total of 4 test cases. Once you compile 3 of them will be shown to you and 1 will be a hidden one. You have to display error message if numbers are not numeric."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_nums(num1, num2):\n",
    "    num1 = float(input(\"Enter number 1: \"))\n",
    "    num2 = float(input(\"Enter number 2: \"))\n",
    "    add_nums=num1+num2\n",
    "    print(round((add_nums), 2))\n",
    "add_nums(num1, num2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Probelm Statement 18\n",
    "\n",
    "#### Consider the below series :\n",
    "0, 0, 2, 1, 4, 2, 6, 3, 8, 4, 10, 5, 12, 6, 14, 7, 16, 8\n",
    "This series is a mixture of 2 series all the odd terms in this series form even numbers in ascending order and every even terms is derived from the previous  term using the formula (x/2)\n",
    "\n",
    "Write a program to find the nth term in this series.\n",
    "\n",
    "The value n in a positive integer that should be read from STDIN the nth term that is calculated by the program should be written to STDOUT. Other than the value of the nth term no other characters /strings or message should be written to STDOUT.\n",
    "\n",
    "For example if n=10,the 10 th term in the series is to be derived from the 9th term in the series. The 9th term is 8 so the 10th term is (8/2)=4. Only the value 4 should be printed to STDOUT.\n",
    "\n",
    "You can assume that the n will not exceed 20,000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = int(input(\"Enter the term number which you want to determine: \"))\n",
    "\n",
    "if(num%2==0):\n",
    "    print(f\"The #{num+1} term has value {2*(num//2)}\")\n",
    "elif num%2==1:\n",
    "    print(f\"The #{num+1} term has value {num//2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Probelm Statement 19\n",
    "\n",
    "#### Find the nth term of the series.\n",
    "\n",
    "1,1,2,3,4,9,8,27,16,81,32,243,…."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = int(input(\"Enter the term number which you want to determine: \"))\n",
    "\n",
    "if(num%2==0):\n",
    "    print(f\"The #{num+1} term has value {2**(num//2)}\")\n",
    "elif num%2==1:\n",
    "    print(f\"The #{num+1} term has value {3**(num//2)}\")"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}