3rd_Sep_Control_Flow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "187aec3b-d792-462a-82f1-a2fc5d7fddba",
   "metadata": {},
   "source": [
    "                                             Control Flow Assignment Questions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af469af3-da10-4075-999d-745950be72d3",
   "metadata": {},
   "source": [
    "Basic If-Else Statements:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdf0f2ab-6e42-49b1-acc4-f84d4119c968",
   "metadata": {},
   "source": [
    "1. Write a Python program to check if a given number is positive or negative."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4fee0f53-b43a-4928-ba81-e3b778b1cbba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number is positive.\n"
     ]
    }
   ],
   "source": [
    " def check_number(num):\n",
    "    if num > 0:\n",
    "        return \"The number is positive.\"\n",
    "    elif num < 0:\n",
    "        return \"The number is negative.\"\n",
    "    else:\n",
    "        return \"The number is zero.\" \n",
    "number = float(input(\"Enter a number: \")) \n",
    "result = check_number(number)\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef3710e3-3170-443c-8bbd-05d13bec6806",
   "metadata": {},
   "source": [
    "2. Create a program that determines if a person is eligible to vote based on their age."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ff1eaa57-aa15-4830-9a03-99023da63397",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age:  54\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are eligible to vote.\n"
     ]
    }
   ],
   "source": [
    "def check_voting_eligibility(age):\n",
    "    if age >= 18:\n",
    "        return \"You are eligible to vote.\"\n",
    "    else:\n",
    "        return \"You are not eligible to vote.\" \n",
    "age = int(input(\"Enter your age: \")) \n",
    "result = check_voting_eligibility(age)\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d92023f7-94aa-429d-b588-69b8abff7c1c",
   "metadata": {},
   "source": [
    "3. Develop a program to find the maximum of two numbers using if-else statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7227cfbe-4942-4e91-ac70-2303dd480115",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first number:  54\n",
      "Enter the second number:  100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The maximum of the two numbers is: 100.0\n"
     ]
    }
   ],
   "source": [
    "def find_maximum(num1, num2):\n",
    "    if num1 > num2:\n",
    "        return num1\n",
    "    elif num2 > num1:\n",
    "        return num2\n",
    "    else:\n",
    "        return \"Both numbers are equal.\" \n",
    "number1 = float(input(\"Enter the first number: \"))\n",
    "number2 = float(input(\"Enter the second number: \")) \n",
    "maximum = find_maximum(number1, number2)\n",
    "print(\"The maximum of the two numbers is:\", maximum)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "869ff60b-46dc-4ae5-a573-6ea1d74a5217",
   "metadata": {},
   "source": [
    "4. Write a Python script to classify a given year as a leap year or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "286f7652-5408-466c-b411-8fe0104bd613",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a year:  2000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2000 is a leap year.\n",
      "2000 is a leap year.\n"
     ]
    }
   ],
   "source": [
    "def is_leap_year(year):\n",
    "    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):\n",
    "        return True\n",
    "    else:\n",
    "        return False \n",
    "year = int(input(\"Enter a year: \")) \n",
    "if is_leap_year(year):\n",
    "    print(f\"{year} is a leap year.\")\n",
    "    print(f\"{year} is a leap year.\")\n",
    "else:\n",
    "    print(f\"{year} is not a leap year.\")\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc2462b4-d39b-472c-8bcd-ca1facf02200",
   "metadata": {},
   "source": [
    "5. Create a program that checks whether a character is a vowel or a consonant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0ed29c8f-4fa9-4b36-87a5-91e42b03edec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a character:  AMIT KUMAR\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a single alphabetic character.\n"
     ]
    }
   ],
   "source": [
    "def check_vowel_or_consonant(char):\n",
    "    vowels = \"aeiouAEIOU\"\n",
    "    if len(char) == 1 and char.isalpha():\n",
    "        if char in vowels:\n",
    "            return f\"{char} is a vowel.\"\n",
    "        else:\n",
    "            return f\"{char} is a consonant.\"\n",
    "    else:\n",
    "        return \"Please enter a single alphabetic character.\" \n",
    "character = input(\"Enter a character: \") \n",
    "result = check_vowel_or_consonant(character)\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3900dbe-c357-4687-9caf-fa20605adb4f",
   "metadata": {},
   "source": [
    "6. Implement a program to determine whether a given number is even or odd."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64b62c2b-1c7b-4778-8b55-a6a200503503",
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_even_or_odd(num):\n",
    "    if num % 2 == 0:\n",
    "        return f\"{num} is an even number.\"\n",
    "    else:\n",
    "        return f\"{num} is an odd number.\" \n",
    "number = int(input(\"Enter a number: \")) \n",
    "result = check_even_or_odd(number)\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72c1d376-c366-4d15-9584-61d1df74ffe5",
   "metadata": {},
   "source": [
    "7. Write a Python function to calculate the absolute value of a number without using the `abs()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "931a570a-bc70-4a4c-ac8d-fed4e605165d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  50\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The absolute value of 50.0 is 50.0.\n"
     ]
    }
   ],
   "source": [
    "def calculate_absolute_value(num):\n",
    "    if num < 0:\n",
    "        return -num\n",
    "    else:\n",
    "        return num \n",
    "number = float(input(\"Enter a number: \")) \n",
    "absolute_value = calculate_absolute_value(number)\n",
    "print(f\"The absolute value of {number} is {absolute_value}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2884ee4-9c83-4ab6-af08-83e1b5ff1275",
   "metadata": {},
   "source": [
    "8. Develop a program that determines the largest of three given numbers using if-else statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "51502453-686f-493a-a835-0248e3bc6769",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first number:  5\n",
      "Enter the second number:  521\n",
      "Enter the third number:  55\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The largest of the three numbers is: 521.0\n"
     ]
    }
   ],
   "source": [
    "def find_largest(num1, num2, num3):\n",
    "    if num1 >= num2 and num1 >= num3:\n",
    "        return num1\n",
    "    elif num2 >= num1 and num2 >= num3:\n",
    "        return num2\n",
    "    else:\n",
    "        return num3 \n",
    "number1 = float(input(\"Enter the first number: \"))\n",
    "number2 = float(input(\"Enter the second number: \"))\n",
    "number3 = float(input(\"Enter the third number: \")) \n",
    "largest = find_largest(number1, number2, number3)\n",
    "print(f\"The largest of the three numbers is: {largest}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c006999e-8707-4cf7-a316-ec9b6524bd00",
   "metadata": {},
   "source": [
    "9. Create a program that checks if a given string is a palindrome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a26a7bee-ebb6-46f0-a3d4-ebcd0bd4b5b7",
   "metadata": {},
   "outputs": [],
   "source": [
    " def is_palindrome(string): \n",
    "    cleaned_string = string.replace(\" \", \"\").lower() \n",
    "    return cleaned_string == cleaned_string[::-1] \n",
    "input_string = input(\"Enter a string: \") \n",
    "if is_palindrome(input_string):\n",
    "    print(f'\"{input_string}\" is a palindrome.')\n",
    "else:\n",
    "    print(f'\"{input_string}\" is not a palindrome.')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "023f3fc1-1f84-4831-becc-e7a6b86b1cd2",
   "metadata": {},
   "source": [
    "10. Write a Python program to calculate the grade based on a student's score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6e20f091-805a-4da9-bb2c-2fe428774712",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the student's score:  50\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The grade for a score of 50.0 is: F\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def calculate_grade(score):\n",
    "    if score >= 90:\n",
    "        return \"A\"\n",
    "    elif score >= 80:\n",
    "        return \"B\"\n",
    "    elif score >= 70:\n",
    "        return \"C\"\n",
    "    elif score >= 60:\n",
    "        return \"D\"\n",
    "    else:\n",
    "        return \"F\"\n",
    " \n",
    "score = float(input(\"Enter the student's score: \")) \n",
    "if 0 <= score <= 100: \n",
    "    grade = calculate_grade(score)\n",
    "    print(f\"The grade for a score of {score} is: {grade}\")\n",
    "else:\n",
    "    print(\"Please enter a valid score between 0 and 100.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8cdf18c-d151-47bc-89e4-46f071e679ed",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "60e1939e-8e20-4bf7-be08-550afd20d030",
   "metadata": {},
   "source": [
    "                                                    Nested If-Else Statements:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "627fbbf9-1fa8-4d38-8e94-f281cce7c3f1",
   "metadata": {},
   "source": [
    "11. Write a program to find the largest among three numbers using nested if-else statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e083229c-4c08-4405-9795-69508fad8f52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first number:  5\n",
      "Enter the second number:  55\n",
      "Enter the third number:  51\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The largest of the three numbers is: 55.0\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def find_largest(num1, num2, num3):\n",
    "    if num1 >= num2:\n",
    "        if num1 >= num3:\n",
    "            return num1\n",
    "        else:\n",
    "            return num3\n",
    "    else:\n",
    "        if num2 >= num3:\n",
    "            return num2\n",
    "        else:\n",
    "            return num3 \n",
    "number1 = float(input(\"Enter the first number: \"))\n",
    "number2 = float(input(\"Enter the second number: \"))\n",
    "number3 = float(input(\"Enter the third number: \")) \n",
    "largest = find_largest(number1, number2, number3)\n",
    "print(f\"The largest of the three numbers is: {largest}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5908274-6215-4b87-a17c-f0dc878c64e6",
   "metadata": {},
   "source": [
    "12. Implement a program to determine if a triangle is equilateral, isosceles, or scalene."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "87eea045-8d2d-425d-99a8-849de734b179",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the length of side 1:  5\n",
      "Enter the length of side 2:  62\n",
      "Enter the length of side 3:  32\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The triangle with sides 5.0, 62.0, 32.0 is a Scalene triangle.\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def triangle_type(side1, side2, side3):\n",
    "    if side1 == side2 == side3:\n",
    "        return \"Equilateral triangle\"\n",
    "    elif side1 == side2 or side1 == side3 or side2 == side3:\n",
    "        return \"Isosceles triangle\"\n",
    "    else:\n",
    "        return \"Scalene triangle\" \n",
    "try:\n",
    "    side1 = float(input(\"Enter the length of side 1: \"))\n",
    "    side2 = float(input(\"Enter the length of side 2: \"))\n",
    "    side3 = float(input(\"Enter the length of side 3: \")) \n",
    "    if side1 > 0 and side2 > 0 and side3 > 0: \n",
    "        result = triangle_type(side1, side2, side3)\n",
    "        print(f\"The triangle with sides {side1}, {side2}, {side3} is a {result}.\")\n",
    "    else:\n",
    "        print(\"Error: Side lengths must be positive.\")\n",
    "except ValueError:\n",
    "    print(\"Error: Please enter valid numeric values for side lengths.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6af607d0-58c6-4310-9a81-7892a65637f1",
   "metadata": {},
   "source": [
    "13. Develop a program that checks if a year is a leap year and also if it is a century year."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6972d8c4-154c-4676-b8d3-794497164f82",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a year:  4567\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4567 is not a leap year.\n",
      "4567 is not a century year.\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def is_leap_year(year):\n",
    "    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):\n",
    "        return True\n",
    "    else:\n",
    "        return False \n",
    "def is_century_year(year):\n",
    "    if year % 100 == 0:\n",
    "        return True\n",
    "    else:\n",
    "        return False \n",
    "try:\n",
    "    year = int(input(\"Enter a year: \")) \n",
    "    if year > 0: \n",
    "        if is_leap_year(year):\n",
    "            print(f\"{year} is a leap year.\")\n",
    "        else:\n",
    "            print(f\"{year} is not a leap year.\") \n",
    "        if is_century_year(year):\n",
    "            print(f\"{year} is a century year.\")\n",
    "        else:\n",
    "            print(f\"{year} is not a century year.\")\n",
    "    else:\n",
    "        print(\"Error: Please enter a valid positive year.\")\n",
    "except ValueError:\n",
    "    print(\"Error: Please enter a valid numeric value for the year.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79ce61f7-be33-4dce-8709-b3604e8e6575",
   "metadata": {},
   "source": [
    "14. Write a Python script to determine if a number is positive, negative, or zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ae9aeb4-5865-4f12-9867-c6f9afc1448e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  44\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number 44.0 is Positive.\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def check_number(num):\n",
    "    if num > 0:\n",
    "        return \"Positive\"\n",
    "    elif num < 0:\n",
    "        return \"Negative\"\n",
    "    else:\n",
    "        return \"Zero\" \n",
    "try:\n",
    "    number = float(input(\"Enter a number: \")) \n",
    "    result = check_number(number)\n",
    "    print(f\"The number {number} is {result}.\")\n",
    "except ValueError:\n",
    "    print(\"Error: Please enter a valid numeric value.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15df2100-8074-44b9-aa84-5e34240d9ebe",
   "metadata": {},
   "source": [
    "15. Create a program to check if a person is a teenager (between 13 and 19 years old)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "25c4e4a0-c78c-4280-a1c2-200fcca6b5da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age:  20\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are not a teenager.\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def is_teenager(age):\n",
    "    if age >= 13 and age <= 19:\n",
    "        return True\n",
    "    else:\n",
    "        return False \n",
    "try:\n",
    "    age = int(input(\"Enter your age: \")) \n",
    "    if is_teenager(age):\n",
    "        print(\"You are a teenager.\")\n",
    "    else:\n",
    "        print(\"You are not a teenager.\")\n",
    "except ValueError:\n",
    "    print(\"Error: Please enter a valid numeric age.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f3299a1-5bd7-47a2-83f0-f4925a4fd21e",
   "metadata": {},
   "source": [
    "16. Develop a program that determines the type of angle based on its measure (acute, obtuse, or right)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3ff53291-0640-40eb-9179-a01fc351fc1b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the measure of the angle (in degrees):  55\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The angle with measure 55.0 degrees is a Acute angle.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def determine_angle_type(angle):\n",
    "    if angle > 0 and angle < 90:\n",
    "        return \"Acute angle\"\n",
    "    elif angle == 90:\n",
    "        return \"Right angle\"\n",
    "    elif angle > 90 and angle < 180:\n",
    "        return \"Obtuse angle\"\n",
    "    elif angle == 180:\n",
    "        return \"Straight angle\"\n",
    "    else:\n",
    "        return \"Invalid angle\" \n",
    "try:\n",
    "    angle = float(input(\"Enter the measure of the angle (in degrees): \")) \n",
    "    angle_type = determine_angle_type(angle)\n",
    "    print(f\"The angle with measure {angle} degrees is a {angle_type}.\")\n",
    "except ValueError:\n",
    "    print(\"Error: Please enter a valid numeric angle measure.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07114a6b-ae1e-4f79-a9d3-c2309866e0ae",
   "metadata": {},
   "source": [
    "17. Write a Python program to calculate the roots of a quadratic equation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "658ed7e7-fcff-48e8-8392-2f267bb5516e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter coefficient a:  745\n",
      "Enter coefficient b:  45\n",
      "Enter coefficient c:  54\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The quadratic equation has Two complex roots:\n",
      "Root 1: -0.030201342281879196\n",
      "Root 2: 0.2675277563186348\n"
     ]
    }
   ],
   "source": [
    "import math \n",
    "def quadratic_roots(a, b, c):\n",
    "    discriminant = b**2 - 4*a*c \n",
    "    if discriminant > 0:\n",
    "        root1 = (-b + math.sqrt(discriminant)) / (2*a)\n",
    "        root2 = (-b - math.sqrt(discriminant)) / (2*a)\n",
    "        return root1, root2, \"Two distinct real roots\"\n",
    "    elif discriminant == 0:\n",
    "        root = -b / (2*a)\n",
    "        return root, \"One real root (double root)\"\n",
    "    else:\n",
    "        real_part = -b / (2*a)\n",
    "        imaginary_part = math.sqrt(abs(discriminant)) / (2*a)\n",
    "        return real_part, imaginary_part, \"Two complex roots\" \n",
    "try:\n",
    "    a = float(input(\"Enter coefficient a: \"))\n",
    "    b = float(input(\"Enter coefficient b: \"))\n",
    "    c = float(input(\"Enter coefficient c: \")) \n",
    "    if a != 0: \n",
    "        roots = quadratic_roots(a, b, c)\n",
    "        if len(roots) == 2:\n",
    "            root, message = roots\n",
    "            print(f\"The quadratic equation has {message}:\")\n",
    "            print(f\"Root: {root}\")\n",
    "        elif len(roots) == 3:\n",
    "            root1, root2, message = roots\n",
    "            print(f\"The quadratic equation has {message}:\")\n",
    "            print(f\"Root 1: {root1}\")\n",
    "            print(f\"Root 2: {root2}\")\n",
    "    else:\n",
    "        print(\"Error: Coefficient 'a' cannot be zero.\")\n",
    "except ValueError:\n",
    "    print(\"Error: Please enter valid numeric coefficients.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cd4d572-848a-495f-9cc6-22059eba1319",
   "metadata": {},
   "source": [
    "18. Implement a program to determine the day of the week based on a user-provided number (1 for Monday, 2\n",
    "for Tuesday, etc.)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "58e2adce-1b30-4d5e-93ac-638c8eadd16f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number (1 for Monday, 2 for Tuesday, etc.):  1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The day corresponding to number 1 is Monday.\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def determine_day_of_week(day_number):\n",
    "    days_of_week = [\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\", \"Sunday\"] \n",
    "    if day_number >= 1 and day_number <= 7:\n",
    "        return days_of_week[day_number - 1]\n",
    "    else:\n",
    "        return \"Invalid day number\" \n",
    "try:\n",
    "    day_number = int(input(\"Enter a number (1 for Monday, 2 for Tuesday, etc.): \")) \n",
    "    day_of_week = determine_day_of_week(day_number)\n",
    "    print(f\"The day corresponding to number {day_number} is {day_of_week}.\")\n",
    "except ValueError:\n",
    "    print(\"Error: Please enter a valid numeric day number.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07d32ad8-970a-4205-b1ff-6a63875b6fd5",
   "metadata": {},
   "source": [
    "19. Create a program that determines if a year is a leap year and also if it is evenly divisible by 400."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "dab79bf9-c5c2-49e5-a477-fd4ae22e03b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a year:  1996\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1996 is a leap year.\n",
      "1996 is a leap year but not evenly divisible by 400.\n"
     ]
    }
   ],
   "source": [
    "def is_leap_year(year):\n",
    "    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):\n",
    "        return True\n",
    "    else:\n",
    "        return False \n",
    "try:\n",
    "    year = int(input(\"Enter a year: \")) \n",
    "    if year > 0: \n",
    "        if is_leap_year(year):\n",
    "            print(f\"{year} is a leap year.\") \n",
    "            if year % 400 == 0:\n",
    "                print(f\"{year} is evenly divisible by 400.\")\n",
    "            else:\n",
    "                print(f\"{year} is a leap year but not evenly divisible by 400.\")\n",
    "        else:\n",
    "            print(f\"{year} is not a leap year.\")\n",
    "    else:\n",
    "        print(\"Error: Please enter a valid positive year.\")\n",
    "except ValueError:\n",
    "    print(\"Error: Please enter a valid numeric value for the year.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a7f91b3-27b0-42b9-a99a-9191dcaad6ee",
   "metadata": {},
   "source": [
    "20. Develop a program that checks if a given number is prime or not using nested if-else statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1287bcb2-2b5c-46c9-a710-d207c65bffb4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6e938a0f-0311-4096-bccb-03b6bf5cf607",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number to check if it is prime:  3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 is a prime number.\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    " \n",
    "def is_prime(number):\n",
    "    if number <= 1:\n",
    "        return False\n",
    "    elif number == 2:\n",
    "        return True  \n",
    "    elif number % 2 == 0:\n",
    "        return False   \n",
    "    else: \n",
    "        max_divisor = int(math.sqrt(number)) + 1\n",
    "        for divisor in range(3, max_divisor, 2):\n",
    "            if number % divisor == 0:\n",
    "                return False\n",
    "        return True \n",
    "try:\n",
    "    number = int(input(\"Enter a number to check if it is prime: \")) \n",
    "    if is_prime(number):\n",
    "        print(f\"{number} is a prime number.\")\n",
    "    else:\n",
    "        print(f\"{number} is not a prime number.\")\n",
    "except ValueError:\n",
    "    print(\"Error: Please enter a valid integer greater than 1.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20aa0fbd-fcbd-4ea2-9de6-d918d2b3721b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "bcc32abb-787f-4fda-81a6-3d7f4f66cb03",
   "metadata": {},
   "source": [
    "                                                      Elif Statements:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6a886ef-ab5a-4045-9b58-525c99105ca8",
   "metadata": {},
   "source": [
    "21. Create a program that calculates the income tax based on the user's income and tax brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "152bed9d-e317-489e-aa6d-1c64a436d3ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your income:  500000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For an income of $500,000.00, the income tax due is $222,000.00.\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def calculate_income_tax(income):\n",
    "    \n",
    "    tax_brackets = [10000, 40000, 80000, 150000]   \n",
    "    tax_rates = [0.1, 0.2, 0.3, 0.4, 0.5]          \n",
    "    \n",
    "    tax_due = 0\n",
    "    previous_bracket = 0 \n",
    "    for i, bracket in enumerate(tax_brackets):\n",
    "        if income > bracket:\n",
    "            tax_due += (bracket - previous_bracket) * tax_rates[i]\n",
    "        else:\n",
    "            tax_due += (income - previous_bracket) * tax_rates[i]\n",
    "            break\n",
    "        previous_bracket = bracket \n",
    "    if income > tax_brackets[-1]:\n",
    "        tax_due += (income - tax_brackets[-1]) * tax_rates[-1]\n",
    "\n",
    "    return tax_due \n",
    "try:\n",
    "    income = float(input(\"Enter your income: \")) \n",
    "    if income >= 0:\n",
    "        tax = calculate_income_tax(income)\n",
    "        print(f\"For an income of ${income:,.2f}, the income tax due is ${tax:,.2f}.\")\n",
    "    else:\n",
    "        print(\"Error: Income cannot be negative.\")\n",
    "except ValueError:\n",
    "    print(\"Error: Please enter a valid numeric income.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3020cd07-9cc4-42b2-a870-2600ebe7a685",
   "metadata": {},
   "source": [
    "22. Write a program that simulates a rock-paper-scissors game against the computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0add5d15-9281-4f0b-8cac-83b30cfceb87",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Rock-Paper-Scissors game!\n",
      "Enter your choice: rock, paper, or scissors.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Your choice:  ROCK\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player chose: rock\n",
      "Computer chose: rock\n",
      "It's a tie!\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    " \n",
    "def rock_paper_scissors(player_choice): \n",
    "    choices = ['rock', 'paper', 'scissors']\n",
    "    computer_choice = random.choice(choices) \n",
    "    if player_choice == computer_choice:\n",
    "        result = \"It's a tie!\"\n",
    "    elif (player_choice == 'rock' and computer_choice == 'scissors') or \\\n",
    "         (player_choice == 'paper' and computer_choice == 'rock') or \\\n",
    "         (player_choice == 'scissors' and computer_choice == 'paper'):\n",
    "        result = \"You win!\"\n",
    "    else:\n",
    "        result = \"Computer wins!\" \n",
    "    return result, player_choice, computer_choice \n",
    "try:\n",
    "    print(\"Welcome to Rock-Paper-Scissors game!\")\n",
    "    print(\"Enter your choice: rock, paper, or scissors.\")\n",
    "    player_choice = input(\"Your choice: \").lower() \n",
    "    if player_choice in ['rock', 'paper', 'scissors']:\n",
    "        result, player, computer = rock_paper_scissors(player_choice)\n",
    "        print(f\"Player chose: {player}\")\n",
    "        print(f\"Computer chose: {computer}\")\n",
    "        print(result)\n",
    "    else:\n",
    "        print(\"Error: Invalid choice! Please enter either 'rock', 'paper', or 'scissors'.\")\n",
    "except KeyboardInterrupt:\n",
    "    print(\"\\nGame terminated by user.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92f3c609-a966-46a2-b20f-7caf759c1bb9",
   "metadata": {},
   "source": [
    "23. Develop a program that generates a random password based on user preferences (length, complexity)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "0c311856-710e-4454-a6fc-fb55d30d831a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the length of the password:  amit lkumar\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "invalid literal for int() with base 10: 'amit lkumar'\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import string \n",
    "def generate_password(length, include_lowercase=True, include_uppercase=True, include_digits=True, include_special_chars=True):\n",
    "    \n",
    "    characters = []\n",
    "    if include_lowercase:\n",
    "        characters.extend(string.ascii_lowercase)\n",
    "    if include_uppercase:\n",
    "        characters.extend(string.ascii_uppercase)\n",
    "    if include_digits:\n",
    "        characters.extend(string.digits)\n",
    "    if include_special_chars:\n",
    "        characters.extend(string.punctuation) \n",
    "    password = ''.join(random.choice(characters) for _ in range(length))\n",
    "    return password \n",
    "try:\n",
    "    length = int(input(\"Enter the length of the password: \"))\n",
    "    include_lowercase = input(\"Include lowercase letters? (yes/no): \").lower() == 'yes'\n",
    "    include_uppercase = input(\"Include uppercase letters? (yes/no): \").lower() == 'yes'\n",
    "    include_digits = input(\"Include digits? (yes/no): \").lower() == 'yes'\n",
    "    include_special_chars = input(\"Include special characters? (yes/no): \").lower() == 'yes' \n",
    "    if not (include_lowercase or include_uppercase or include_digits or include_special_chars):\n",
    "        raise ValueError(\"Error: Please include at least one character type (lowercase, uppercase, digits, or special characters).\")\n",
    " \n",
    "    password = generate_password(length, include_lowercase, include_uppercase, include_digits, include_special_chars)\n",
    "    print(f\"Generated Password: {password}\")\n",
    "\n",
    "except ValueError as ve:\n",
    "    print(ve)\n",
    "except KeyboardInterrupt:\n",
    "    print(\"\\nPassword generation interrupted by user.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fba9cb39-6515-4e3d-957a-c2e873535404",
   "metadata": {},
   "source": [
    "24. Create a program that implements a simple text-based adventure game with branching scenarios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e4824e1d-a603-46de-874e-bfcfe2277e07",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to the Text-Based Adventure Game!\n",
      "\n",
      "You wake up in a mysterious room with three doors.\n",
      "Each door leads to a different path. Choose wisely!\n",
      "\n",
      "You see three doors in front of you:\n",
      "1. Door 1 - A door with a strange symbol.\n",
      "2. Door 2 - A door with ancient runes.\n",
      "3. Door 3 - A door covered in vines.\n",
      "\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Which door do you choose? (1/2/3):     1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "You stand indecisively in front of the doors.\n",
      "Time passes and you feel uncertain about your choices.\n",
      "\n",
      "Thank you for playing the Text-Based Adventure Game!\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    " \n",
    "def adventure_game():\n",
    "    print(\"Welcome to the Text-Based Adventure Game!\\n\")\n",
    "    time.sleep(1)\n",
    "\n",
    "    print(\"You wake up in a mysterious room with three doors.\")\n",
    "    print(\"Each door leads to a different path. Choose wisely!\\n\")\n",
    "    time.sleep(2)\n",
    " \n",
    "    print(\"You see three doors in front of you:\")\n",
    "    print(\"1. Door 1 - A door with a strange symbol.\")\n",
    "    print(\"2. Door 2 - A door with ancient runes.\")\n",
    "    print(\"3. Door 3 - A door covered in vines.\\n\")\n",
    "    time.sleep(1)\n",
    "\n",
    "    door_choice = input(\"Which door do you choose? (1/2/3): \")\n",
    " \n",
    "    if door_choice == '1':\n",
    "        print(\"\\nYou open Door 1 and find a treasure chest filled with gold!\")\n",
    "        print(\"Congratulations, you've found the treasure!\\n\")\n",
    "    elif door_choice == '2':\n",
    "        print(\"\\nDoor 2 leads to a dark cavern. You hear rumbling noises.\")\n",
    "        print(\"You decide to turn back and choose another door.\\n\")\n",
    "    elif door_choice == '3':\n",
    "        print(\"\\nYou enter Door 3 and find yourself in a lush garden.\")\n",
    "        print(\"You see a path leading deeper into the garden.\\n\")\n",
    "        time.sleep(1)\n",
    " \n",
    "        garden_choice = input(\"Do you follow the path deeper into the garden? (yes/no): \").lower()\n",
    "\n",
    "        if garden_choice == 'yes':\n",
    "            print(\"\\nYou follow the path and discover a hidden waterfall.\")\n",
    "            print(\"The waterfall leads to a secret cave with ancient artifacts!\\n\")\n",
    "        else:\n",
    "            print(\"\\nYou decide not to explore further and return to the room.\")\n",
    "            print(\"You contemplate your next move.\\n\")\n",
    "\n",
    "    else:\n",
    "        print(\"\\nYou stand indecisively in front of the doors.\")\n",
    "        print(\"Time passes and you feel uncertain about your choices.\\n\")\n",
    "\n",
    "    print(\"Thank you for playing the Text-Based Adventure Game!\")\n",
    " \n",
    "if __name__ == \"__main__\":\n",
    "    adventure_game()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ace76940-bdb9-4e18-b25e-4feed6d1dbfe",
   "metadata": {},
   "source": [
    "25. Build a program that solves a linear equation for x, considering different cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "92dd0f61-cd24-493b-9044-74d58e05e859",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to the Linear Equation Solver!\n",
      "Please enter coefficients and constants for the equation ax + b = c.\n",
      "\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the coefficient 'a':  .2205\n",
      "Enter the coefficient 'b':  .2554\n",
      "Enter the constant 'c':  .5544\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The equation is of the form 'ax + b = c'.\n",
      "The solution is x = 1.3560090702947845\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def solve_linear_equation_case1(a, b):\n",
    "    if a == 0:\n",
    "        if b == 0:\n",
    "            return \"Infinite solutions (identity equation)\"\n",
    "        else:\n",
    "            return \"No solution (contradiction)\"\n",
    "    else:\n",
    "        x = -b / a\n",
    "        return f\"The solution is x = {x}\"\n",
    " \n",
    " def solve_linear_equation_case2(a, b):\n",
    "    if a == 0:\n",
    "        if b == 0:\n",
    "            return \"Infinite solutions (identity equation)\"\n",
    "        else:\n",
    "            return \"No solution (contradiction)\"\n",
    "    else:\n",
    "        x = b / a\n",
    "        return f\"The solution is x = {x}\"\n",
    " \n",
    " def solve_linear_equation_general(a, b, c):\n",
    "    if a == 0:\n",
    "        if b == c:\n",
    "            return \"Infinite solutions (identity equation)\"\n",
    "        else:\n",
    "            return \"No solution (contradiction)\"\n",
    "    else:\n",
    "        x = (c - b) / a\n",
    "        return f\"The solution is x = {x}\"\n",
    " \n",
    " try:\n",
    "    print(\"Welcome to the Linear Equation Solver!\")\n",
    "    print(\"Please enter coefficients and constants for the equation ax + b = c.\\n\")\n",
    "\n",
    "    a = float(input(\"Enter the coefficient 'a': \"))\n",
    "    b = float(input(\"Enter the coefficient 'b': \"))\n",
    "    c = float(input(\"Enter the constant 'c': \"))\n",
    " \n",
    "    if b == 0 and c == 0:\n",
    "        print(\"The equation is of the form 'ax = 0'.\")\n",
    "        print(solve_linear_equation_case2(a, c))\n",
    "    elif c == 0:\n",
    "        print(\"The equation is of the form 'ax + b = 0'.\")\n",
    "        print(solve_linear_equation_case1(a, b))\n",
    "    else:\n",
    "        print(\"The equation is of the form 'ax + b = c'.\")\n",
    "        print(solve_linear_equation_general(a, b, c))\n",
    "\n",
    "except ValueError:\n",
    "    print(\"Error: Please enter valid numeric values for coefficients and constants.\")\n",
    "except ZeroDivisionError:\n",
    "    print(\"Error: 'a' cannot be zero in a linear equation.\")\n",
    "except KeyboardInterrupt:\n",
    "    print(\"\\nOperation interrupted by user.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f516d245-6fde-4794-9f89-aeb5dc6a8934",
   "metadata": {},
   "source": [
    "26. Write a program that simulates a basic quiz game with multiple-choice questions and scoring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d1b7cc4a-a14b-4ba0-bcd2-3a4f10346b45",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to the Basic Quiz Game!\n",
      "Answer the following multiple-choice questions.\n",
      "\n",
      "Question 1: What is the capital of France?\n",
      "A. Paris\n",
      "B. London\n",
      "C. Berlin\n",
      "D. Rome\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your answer (A/B/C/D):  4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Incorrect. The correct answer is A.\n",
      "\n",
      "Question 2: Who wrote 'Hamlet'?\n",
      "A. William Shakespeare\n",
      "B. Charles Dickens\n",
      "C. Jane Austen\n",
      "D. Mark Twain\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your answer (A/B/C/D):  A\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correct!\n",
      "\n",
      "Question 3: Which planet is known as the Red Planet?\n",
      "A. Venus\n",
      "B. Jupiter\n",
      "C. Mars\n",
      "D. Saturn\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your answer (A/B/C/D):  B\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Incorrect. The correct answer is C.\n",
      "\n",
      "Quiz completed! You scored 1/3.\n"
     ]
    }
   ],
   "source": [
    " \n",
    "quiz_questions = [\n",
    "    {\n",
    "        \"question\": \"What is the capital of France?\",\n",
    "        \"options\": [\"A. Paris\", \"B. London\", \"C. Berlin\", \"D. Rome\"],\n",
    "        \"answer\": \"A\"\n",
    "    },\n",
    "    {\n",
    "        \"question\": \"Who wrote 'Hamlet'?\",\n",
    "        \"options\": [\"A. William Shakespeare\", \"B. Charles Dickens\", \"C. Jane Austen\", \"D. Mark Twain\"],\n",
    "        \"answer\": \"A\"\n",
    "    },\n",
    "    {\n",
    "        \"question\": \"Which planet is known as the Red Planet?\",\n",
    "        \"options\": [\"A. Venus\", \"B. Jupiter\", \"C. Mars\", \"D. Saturn\"],\n",
    "        \"answer\": \"C\"\n",
    "    }\n",
    "]\n",
    " \n",
    "def conduct_quiz(questions):\n",
    "    score = 0\n",
    "     \n",
    "    for i, q in enumerate(questions, 1):\n",
    "        print(f\"Question {i}: {q['question']}\")\n",
    "         \n",
    "        for option in q['options']:\n",
    "            print(option)\n",
    "         \n",
    "        user_answer = input(\"Enter your answer (A/B/C/D): \").upper()\n",
    "         \n",
    "        if user_answer == q['answer']:\n",
    "            print(\"Correct!\\n\")\n",
    "            score += 1\n",
    "        else:\n",
    "            correct_answer = q['answer']\n",
    "            print(f\"Incorrect. The correct answer is {correct_answer}.\\n\")\n",
    "     \n",
    "    print(f\"Quiz completed! You scored {score}/{len(questions)}.\")\n",
    " \n",
    "if __name__ == \"__main__\":\n",
    "    print(\"Welcome to the Basic Quiz Game!\")\n",
    "    print(\"Answer the following multiple-choice questions.\\n\")\n",
    "    \n",
    "    conduct_quiz(quiz_questions)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4206c61-1161-4937-8c14-bb120c9b2a5c",
   "metadata": {},
   "source": [
    "27. Develop a program to calculate the electricity bill based on different consumption slabs using elif\n",
    "statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "40e75026-a37e-4145-b793-ee07f395e102",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the number of units consumed:  540\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The electricity bill for 540.0 units is: RS 605.00\n"
     ]
    }
   ],
   "source": [
    "def calculate_electricity_bill(units):\n",
    "    if units <= 100:\n",
    "        bill = units * 0.50\n",
    "    elif units <= 200:\n",
    "        bill = (100 * 0.50) + (units - 100) * 0.75\n",
    "    elif units <= 300:\n",
    "        bill = (100 * 0.50) + (100 * 0.75) + (units - 200) * 1.20\n",
    "    else:\n",
    "        bill = (100 * 0.50) + (100 * 0.75) + (100 * 1.20) + (units - 300) * 1.50\n",
    "    \n",
    "    return bill\n",
    " \n",
    "    \n",
    "units_consumed = float(input(\"Enter the number of units consumed: \"))\n",
    "bill_amount = calculate_electricity_bill(units_consumed)\n",
    "print(f\"The electricity bill for {units_consumed} units is: RS {bill_amount:.2f}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b9a9b40-df4a-4c00-930c-c4bab78f7a5a",
   "metadata": {},
   "source": [
    "28. Create a program to determine the type of quadrilateral based on its angles and sides using elif\n",
    "statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "124d795c-9dc0-4126-9a92-93c145b5203f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter length of side a:  54\n",
      "Enter length of side b:  55\n",
      "Enter length of side c:  55\n",
      "Enter length of side d:  88\n",
      "Enter angle A (in degrees):  585\n",
      "Enter angle B (in degrees):  55\n",
      "Enter angle C (in degrees):  545\n",
      "Enter angle D (in degrees):  11\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The quadrilateral is a: Invalid quadrilateral angles\n"
     ]
    }
   ],
   "source": [
    "def determine_quadrilateral_type(a, b, c, d, A, B, C, D):\n",
    "    \n",
    "    if A + B + C + D != 360:\n",
    "        return \"Invalid quadrilateral angles\" \n",
    "    if a == b == c == d and A == B == C == D == 90:\n",
    "        return \"Square\" \n",
    "    elif a == c and b == d and A == B == C == D == 90:\n",
    "        return \"Rectangle\" \n",
    "    elif a == b == c == d and A == C and B == D:\n",
    "        return \"Rhombus\" \n",
    "    elif a == c and b == d and A == C and B == D:\n",
    "        return \"Parallelogram\" \n",
    "    elif A + D == 180 or B + C == 180:\n",
    "        return \"Trapezoid\" \n",
    "    else:\n",
    "        return \"General Quadrilateral\" \n",
    "a = float(input(\"Enter length of side a: \"))\n",
    "b = float(input(\"Enter length of side b: \"))\n",
    "c = float(input(\"Enter length of side c: \"))\n",
    "d = float(input(\"Enter length of side d: \"))\n",
    "\n",
    "A = float(input(\"Enter angle A (in degrees): \"))\n",
    "B = float(input(\"Enter angle B (in degrees): \"))\n",
    "C = float(input(\"Enter angle C (in degrees): \"))\n",
    "D = float(input(\"Enter angle D (in degrees): \"))\n",
    "\n",
    "quadrilateral_type = determine_quadrilateral_type(a, b, c, d, A, B, C, D)\n",
    "print(f\"The quadrilateral is a: {quadrilateral_type}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4d88113-c073-4198-9f65-ecc292fd266d",
   "metadata": {},
   "source": [
    "29. Write a Python script to determine the season based on a user-provided month using elif statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5765728a-87ef-42e8-a149-c306c33f2981",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the month:  september\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The season for September is: Fall\n"
     ]
    }
   ],
   "source": [
    "def determine_season(month):\n",
    "    if month in ['December', 'January', 'February']:\n",
    "        return \"Winter\"\n",
    "    elif month in ['March', 'April', 'May']:\n",
    "        return \"Spring\"\n",
    "    elif month in ['June', 'July', 'August']:\n",
    "        return \"Summer\"\n",
    "    elif month in ['September', 'October', 'November']:\n",
    "        return \"Fall\"\n",
    "    else:\n",
    "        return \"Invalid month\"\n",
    "\n",
    "# Example usage:\n",
    "month = input(\"Enter the month: \").capitalize()\n",
    "season = determine_season(month)\n",
    "print(f\"The season for {month} is: {season}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf1f431c-079e-483d-ab03-674b5e452452",
   "metadata": {},
   "source": [
    "30. Implement a program to determine the type of a year (leap or common) and month (30 or 31 days) using\n",
    "elif statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9de3b248-117d-4a3e-a2c5-6cc42402c76b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the year:  1996\n",
      "Enter the month:  may\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1996 is a leap year.\n",
      "The month of May in the year 1996 has 31 days.\n"
     ]
    }
   ],
   "source": [
    "def is_leap_year(year):\n",
    "    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "def days_in_month(month, year):\n",
    "    if month in ['January', 'March', 'May', 'July', 'August', 'October', 'December']:\n",
    "        return 31\n",
    "    elif month in ['April', 'June', 'September', 'November']:\n",
    "        return 30\n",
    "    elif month == 'February':\n",
    "        if is_leap_year(year):\n",
    "            return 29\n",
    "        else:\n",
    "            return 28\n",
    "    else:\n",
    "        return \"Invalid month\" \n",
    "year = int(input(\"Enter the year: \"))\n",
    "month = input(\"Enter the month: \").capitalize() \n",
    "if is_leap_year(year):\n",
    "    print(f\"{year} is a leap year.\")\n",
    "else:\n",
    "    print(f\"{year} is a common year.\") \n",
    "days = days_in_month(month, year)\n",
    "if isinstance(days, int):\n",
    "    print(f\"The month of {month} in the year {year} has {days} days.\")\n",
    "else:\n",
    "    print(days)  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3713a8e0-5c22-4b24-98bb-66279446c371",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e608a5be-0529-462e-8221-3407ef5d88fc",
   "metadata": {},
   "source": [
    "                                                     Basic Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d561b33-de3f-4bc1-909c-b6430969878f",
   "metadata": {},
   "source": [
    "1. Write a Python program that checks if a given number is positive, negative, or zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8b93b77e-68d9-482e-8582-e0fe151292ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number is positive.\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def check_number(num):\n",
    "    if num > 0:\n",
    "        return \"The number is positive.\"\n",
    "    elif num < 0:\n",
    "        return \"The number is negative.\"\n",
    "    else:\n",
    "        return \"The number is zero.\" \n",
    "number = float(input(\"Enter a number: \"))\n",
    "result = check_number(number)\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33034a35-10ad-4af5-bdc4-afed1c90c350",
   "metadata": {},
   "source": [
    "2. Create a program to determine if a person is eligible to vote based on their age."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "99f59b16-f682-45b3-91ad-bcab14657fb7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are not eligible to vote.\n"
     ]
    }
   ],
   "source": [
    "def check_voting_eligibility(age):\n",
    "    if age >= 18:\n",
    "        return \"You are eligible to vote.\"\n",
    "    else:\n",
    "        return \"You are not eligible to vote.\"\n",
    " \n",
    "age = int(input(\"Enter your age: \"))\n",
    "result = check_voting_eligibility(age)\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2dd8241-fdaf-48a4-aaef-185007500bcf",
   "metadata": {},
   "source": [
    "3. Write a program to find the maximum of two given numbers using conditional statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3af62ae7-ab93-4134-ad27-e1510b62198a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the exam score:  78\n"
     ]
    }
   ],
   "source": [
    "def determine_grade(score):\n",
    "    if 90 <= score <= 100:\n",
    "        return \"A\"\n",
    "    elif 80 <= score < 90:\n",
    "        return \"B\"\n",
    "    elif 70 <= score < 80:\n",
    "        return \"C\"\n",
    "    elif 60 <= score < 70:\n",
    "        return \"D\"\n",
    "    elif 0 <= score < 60:\n",
    "        return \"F\"\n",
    "    else:\n",
    "        return \"Invalid score\" \n",
    "score = float(input(\"Enter the exam score: \"))\n",
    "grade = determine_grade(score)\n",
    "print(f\"The grade for a score of {score} is: {grade}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a1e65f0-0136-46c1-9c61-5728252b69d6",
   "metadata": {},
   "source": [
    "4. Develop a program that calculates the grade of a student based on their exam score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cde2202c-d598-4e0c-ab54-3f8cec33cdea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first number:  5\n",
      "Enter the second number:  4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The maximum of the two numbers is: 5.0\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def find_maximum(num1, num2):\n",
    "    if num1 > num2:\n",
    "        return num1\n",
    "    elif num2 > num1:\n",
    "        return num2\n",
    "    else:\n",
    "        return \"Both numbers are equal.\" \n",
    "number1 = float(input(\"Enter the first number: \"))\n",
    "number2 = float(input(\"Enter the second number: \"))\n",
    "result = find_maximum(number1, number2)\n",
    "print(f\"The maximum of the two numbers is: {result}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9128705d-faa5-4550-8a5c-7c26e9f030e2",
   "metadata": {},
   "source": [
    "5. Create a program that checks if a year is a leap year or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "04eff370-b360-4757-bf44-b3cd3b397c0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the year:  1996\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1996 is a leap year.\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def is_leap_year(year):\n",
    "    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):\n",
    "        return True\n",
    "    else:\n",
    "        return False \n",
    "year = int(input(\"Enter the year: \"))\n",
    "if is_leap_year(year):\n",
    "    print(f\"{year} is a leap year.\")\n",
    "else:\n",
    "    print(f\"{year} is not a leap year.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e8659f4-319a-4fc4-9936-34b1ffdb9a52",
   "metadata": {},
   "source": [
    "6. Write a program to classify a triangle based on its sides' lengths."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "de161e26-c105-4a03-ba38-190843c82bcd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the length of side a:  5\n",
      "Enter the length of side b:  65\n",
      "Enter the length of side c:  6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The entered lengths do not form a valid triangle.\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def classify_triangle(a, b, c):\n",
    "    if a == b == c:\n",
    "        return \"Equilateral Triangle\"\n",
    "    elif a == b or b == c or a == c:\n",
    "        return \"Isosceles Triangle\"\n",
    "    else:\n",
    "        return \"Scalene Triangle\" \n",
    "a = float(input(\"Enter the length of side a: \"))\n",
    "b = float(input(\"Enter the length of side b: \"))\n",
    "c = float(input(\"Enter the length of side c: \")) \n",
    "if a + b > c and a + c > b and b + c > a:\n",
    "    triangle_type = classify_triangle(a, b, c)\n",
    "    print(f\"The triangle is an {triangle_type}.\")\n",
    "else:\n",
    "    print(\"The entered lengths do not form a valid triangle.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00fdb1e7-f5a2-4bca-90a3-7f4759659a7a",
   "metadata": {},
   "source": [
    "7. Build a program that determines the largest of three given numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "001b174d-1c49-4b14-9ac7-6335e5510f4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first number:  5\n",
      "Enter the second number:  5\n",
      "Enter the third number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The largest of the three numbers is: 5.0\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def find_largest(num1, num2, num3):\n",
    "    if num1 >= num2 and num1 >= num3:\n",
    "        return num1\n",
    "    elif num2 >= num1 and num2 >= num3:\n",
    "        return num2\n",
    "    else:\n",
    "        return num3 \n",
    "number1 = float(input(\"Enter the first number: \"))\n",
    "number2 = float(input(\"Enter the second number: \"))\n",
    "number3 = float(input(\"Enter the third number: \"))\n",
    "\n",
    "largest = find_largest(number1, number2, number3)\n",
    "print(f\"The largest of the three numbers is: {largest}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b843775c-442a-40fd-bcb0-95532bf480be",
   "metadata": {},
   "source": [
    "8. Develop a program that checks whether a character is a vowel or a consonant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9e60a8f1-6c3c-4984-afe4-181b7a50f41b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a character:  c\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The character is a consonant.\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def check_vowel_or_consonant(char):\n",
    "    vowels = 'aeiouAEIOU'\n",
    "    if len(char) != 1:\n",
    "        return \"Invalid input. Please enter a single character.\"\n",
    "    elif char.isalpha():\n",
    "        if char in vowels:\n",
    "            return \"The character is a vowel.\"\n",
    "        else:\n",
    "            return \"The character is a consonant.\"\n",
    "    else:\n",
    "        return \"Invalid input. Please enter an alphabetic character.\" \n",
    "char = input(\"Enter a character: \")\n",
    "result = check_vowel_or_consonant(char)\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7b853c6-55cb-45e4-a6d4-c1ce1a2ea778",
   "metadata": {},
   "source": [
    "9. Create a program to calculate the total cost of a shopping cart based on discounts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e4571947-c83e-4672-a5fa-8cb32e4d8bc7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the price of an item (or 'done' to finish):  amit\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid input. Please enter a numerical value for the price.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the price of an item (or 'done' to finish):  500\n",
      "Enter the price of an item (or 'done' to finish):  done\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total amount before discount: $500.00\n",
      "Discount applied: $50.00\n",
      "Total amount to be paid: $450.00\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def calculate_total_cost(cart):\n",
    "    total_amount = sum(cart)\n",
    "    \n",
    "    if total_amount > 100:\n",
    "        discount = 0.10\n",
    "    elif total_amount > 50:\n",
    "        discount = 0.05\n",
    "    else:\n",
    "        discount = 0.00\n",
    "    \n",
    "    discount_amount = total_amount * discount\n",
    "    final_amount = total_amount - discount_amount\n",
    "    \n",
    "    return final_amount, discount_amount \n",
    "cart = []\n",
    "while True:\n",
    "    item_price = input(\"Enter the price of an item (or 'done' to finish): \")\n",
    "    if item_price.lower() == 'done':\n",
    "        break\n",
    "    try:\n",
    "        item_price = float(item_price)\n",
    "        cart.append(item_price)\n",
    "    except ValueError:\n",
    "        print(\"Invalid input. Please enter a numerical value for the price.\")\n",
    "\n",
    "if cart:\n",
    "    final_amount, discount_amount = calculate_total_cost(cart)\n",
    "    print(f\"Total amount before discount: ${sum(cart):.2f}\")\n",
    "    print(f\"Discount applied: ${discount_amount:.2f}\")\n",
    "    print(f\"Total amount to be paid: ${final_amount:.2f}\")\n",
    "else:\n",
    "    print(\"Your cart is empty.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8476db6-16e6-41b6-98b6-cc8666800537",
   "metadata": {},
   "source": [
    "10. Write a program that checks if a given number is even or odd."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c6714ae7-cedb-4b21-8c20-100768dfe9f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number 5 is Odd.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def check_even_or_odd(num):\n",
    "    if num % 2 == 0:\n",
    "        return \"Even\"\n",
    "    else:\n",
    "        return \"Odd\" \n",
    "number = int(input(\"Enter a number: \"))\n",
    "result = check_even_or_odd(number)\n",
    "print(f\"The number {number} is {result}.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1c6459f-81e3-4e4f-8291-0ede47f199c3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "170d3aed-e502-41cf-af70-a045c772f37f",
   "metadata": {},
   "source": [
    "                                                 Intermediate Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02fe5428-a126-4a63-ad83-c90d5a102d6c",
   "metadata": {},
   "source": [
    "11. Write a program that calculates the roots of a quadratic equation ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "85491d16-4675-4b70-8c1b-6b300c017fa7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given a quadratic equation of the form ax^2 + bx + c = 0\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the value of a:  5\n",
      "Enter the value of b:  5\n",
      "Enter the value of c:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The roots of the equation are: (-0.5+0.8660254037844387j) and (-0.5-0.8660254037844387j)\n"
     ]
    }
   ],
   "source": [
    "import cmath\n",
    " \n",
    "def calculate_roots(a, b, c): \n",
    "    discriminant = b**2 - 4*a*c \n",
    "    root1 = (-b + cmath.sqrt(discriminant)) / (2*a)\n",
    "    root2 = (-b - cmath.sqrt(discriminant)) / (2*a)\n",
    "    \n",
    "    return root1, root2 \n",
    "print(\"Given a quadratic equation of the form ax^2 + bx + c = 0\")\n",
    "a = float(input(\"Enter the value of a: \"))\n",
    "b = float(input(\"Enter the value of b: \"))\n",
    "c = float(input(\"Enter the value of c: \"))\n",
    " \n",
    "if a == 0:\n",
    "    print(\"The value of 'a' cannot be zero in a quadratic equation.\")\n",
    "else:\n",
    "    root1, root2 = calculate_roots(a, b, c)\n",
    "    print(f\"The roots of the equation are: {root1} and {root2}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4b1a9f2-7e97-44fb-8dc9-ea29627baaca",
   "metadata": {},
   "source": [
    "12. Create a program that determines the day of the week based on the day number (1-7)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "0585c3d0-fb9b-441d-9e52-44e24aaaf117",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the day number (1-7):  4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The day of the week is: Thursday\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def get_day_of_week(day_number):\n",
    "    days_of_week = {\n",
    "        1: \"Monday\",\n",
    "        2: \"Tuesday\",\n",
    "        3: \"Wednesday\",\n",
    "        4: \"Thursday\",\n",
    "        5: \"Friday\",\n",
    "        6: \"Saturday\",\n",
    "        7: \"Sunday\"\n",
    "    }\n",
    "    \n",
    "    return days_of_week.get(day_number, \"Invalid day number\") \n",
    "day_number = int(input(\"Enter the day number (1-7): \"))\n",
    "\n",
    "day_of_week = get_day_of_week(day_number)\n",
    "print(f\"The day of the week is: {day_of_week}\")\n",
    "\n",
    "     "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bb64e81-8e7d-4dae-8ebb-5388977fdb2c",
   "metadata": {},
   "source": [
    "13. Develop a program that calculates the factorial of a given number using recursion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bc95a692-3af9-4e3e-b343-a7358af999a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The factorial of 5 is 120.\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def factorial(n):\n",
    "    if n == 0 or n == 1: \n",
    "        return 1\n",
    "    else:\n",
    "        return n * factorial(n - 1)   \n",
    "number = int(input(\"Enter a number: \"))\n",
    "\n",
    "if number < 0:\n",
    "    print(\"Factorial is not defined for negative numbers.\")\n",
    "else:\n",
    "    result = factorial(number)\n",
    "    print(f\"The factorial of {number} is {result}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae30fc41-b61c-4bdb-acd8-504c040f23d6",
   "metadata": {},
   "source": [
    "14. Write a program to find the largest among three numbers without using the `max()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "768f5f3d-807d-4b63-8e93-70d14b10e2fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first number:  5\n",
      "Enter the second number:  4\n",
      "Enter the third number:  6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The largest of the three numbers is: 6.0\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def find_largest(num1, num2, num3):\n",
    "    if num1 >= num2 and num1 >= num3:\n",
    "        return num1\n",
    "    elif num2 >= num1 and num2 >= num3:\n",
    "        return num2\n",
    "    else:\n",
    "        return num3 \n",
    "number1 = float(input(\"Enter the first number: \"))\n",
    "number2 = float(input(\"Enter the second number: \"))\n",
    "number3 = float(input(\"Enter the third number: \"))\n",
    "\n",
    "largest = find_largest(number1, number2, number3)\n",
    "print(f\"The largest of the three numbers is: {largest}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f840f1f0-6307-4138-90c1-49d950328d6c",
   "metadata": {},
   "source": [
    "15. Create a program that simulates a basic ATM transaction menu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d91f96c7-3801-409c-a89d-2864fc15077d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=== ATM Menu ===\n",
      "1. Check Balance\n",
      "2. Deposit Money\n",
      "3. Withdraw Money\n",
      "4. Exit\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your choice (1-4):  1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your current balance is: $0.00\n",
      "\n",
      "=== ATM Menu ===\n",
      "1. Check Balance\n",
      "2. Deposit Money\n",
      "3. Withdraw Money\n",
      "4. Exit\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your choice (1-4):  3\n",
      "Enter the amount to withdraw: $ 500\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Insufficient funds. Please enter a smaller amount.\n",
      "\n",
      "=== ATM Menu ===\n",
      "1. Check Balance\n",
      "2. Deposit Money\n",
      "3. Withdraw Money\n",
      "4. Exit\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your choice (1-4):  4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thank you for using the ATM. Goodbye!\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def atm_menu():\n",
    "    balance = 0.0  \n",
    "    \n",
    "    while True:\n",
    "        print(\"\\n=== ATM Menu ===\")\n",
    "        print(\"1. Check Balance\")\n",
    "        print(\"2. Deposit Money\")\n",
    "        print(\"3. Withdraw Money\")\n",
    "        print(\"4. Exit\")\n",
    "        \n",
    "        choice = input(\"Enter your choice (1-4): \")\n",
    "        \n",
    "        if choice == '1':\n",
    "            print(f\"Your current balance is: ${balance:.2f}\")\n",
    "        \n",
    "        elif choice == '2':\n",
    "            amount = float(input(\"Enter the amount to deposit: $\"))\n",
    "            if amount > 0:\n",
    "                balance += amount\n",
    "                print(f\"${amount:.2f} has been deposited. Your new balance is: ${balance:.2f}\")\n",
    "            else:\n",
    "                print(\"Invalid amount. Please enter a positive number.\")\n",
    "        \n",
    "        elif choice == '3':\n",
    "            amount = float(input(\"Enter the amount to withdraw: $\"))\n",
    "            if amount > 0:\n",
    "                if amount <= balance:\n",
    "                    balance -= amount\n",
    "                    print(f\"${amount:.2f} has been withdrawn. Your new balance is: ${balance:.2f}\")\n",
    "                else:\n",
    "                    print(\"Insufficient funds. Please enter a smaller amount.\")\n",
    "            else:\n",
    "                print(\"Invalid amount. Please enter a positive number.\")\n",
    "        \n",
    "        elif choice == '4':\n",
    "            print(\"Thank you for using the ATM. Goodbye!\")\n",
    "            break\n",
    "        \n",
    "        else:\n",
    "            print(\"Invalid choice. Please enter a number between 1 and 4.\")\n",
    " \n",
    "atm_menu()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3844251-5834-4809-95c7-bada7edf5099",
   "metadata": {},
   "source": [
    "16. Build a program that checks if a given string is a palindrome or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2f96b439-c5c1-45cb-a060-6e48c46f8b0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  amiT\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'amiT' is not a palindrome.\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def is_palindrome(s): \n",
    "    s = s.replace(\" \", \"\").lower() \n",
    "    return s == s[::-1] \n",
    "string = input(\"Enter a string: \")\n",
    "\n",
    "if is_palindrome(string):\n",
    "    print(f\"'{string}' is a palindrome.\")\n",
    "else:\n",
    "    print(f\"'{string}' is not a palindrome.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b00fd87-7fc9-484f-9464-397beb37851c",
   "metadata": {},
   "source": [
    "17. Write a program that calculates the average of a list of numbers, excluding the smallest and largest values.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1ea5d188-cf2c-4f93-9780-9082b6ef69cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter numbers separated by space:  454\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not enough elements to exclude smallest and largest values.\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def calculate_average(numbers):\n",
    "    if len(numbers) <= 2:\n",
    "        return None   \n",
    "    sorted_numbers = sorted(numbers)\n",
    "     \n",
    "    trimmed_numbers = sorted_numbers[1:-1] \n",
    "    average = sum(trimmed_numbers) / len(trimmed_numbers)\n",
    "    \n",
    "    return average \n",
    "try: \n",
    "    numbers = [float(x) for x in input(\"Enter numbers separated by space: \").split()] \n",
    "    average = calculate_average(numbers)\n",
    "    \n",
    "    if average is not None:\n",
    "        print(f\"The average of the numbers excluding the smallest and largest values is: {average:.2f}\")\n",
    "    else:\n",
    "        print(\"Not enough elements to exclude smallest and largest values.\")\n",
    "except ValueError:\n",
    "    print(\"Invalid input. Please enter numbers separated by space.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03678be5-c26f-4fa5-8fff-e546fbdc1b6c",
   "metadata": {},
   "source": [
    "18. Develop a program that converts a given temperature from Celsius to Fahrenheit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "0d8ddf48-5d5a-43d5-9380-d58f8a4f812c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter temperature in Celsius:  50\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50.00 degrees Celsius is equal to 122.00 degrees Fahrenheit.\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def celsius_to_fahrenheit(celsius):\n",
    "    fahrenheit = (celsius * 9/5) + 32\n",
    "    return fahrenheit \n",
    "try:\n",
    "    celsius = float(input(\"Enter temperature in Celsius: \"))\n",
    "    fahrenheit = celsius_to_fahrenheit(celsius)\n",
    "    print(f\"{celsius:.2f} degrees Celsius is equal to {fahrenheit:.2f} degrees Fahrenheit.\")\n",
    "except ValueError:\n",
    "    print(\"Invalid input. Please enter a numerical value for temperature.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ea5f816-3b4d-4a00-9d6a-4816b43304db",
   "metadata": {},
   "source": [
    "19. Create a program that simulates a basic calculator for addition, subtraction, multiplication, and division."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "91c9fc2d-7aa0-4d78-9ea7-338502552db5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=== Simple Calculator ===\n",
      "Operations:\n",
      "1. Addition\n",
      "2. Subtraction\n",
      "3. Multiplication\n",
      "4. Division\n",
      "5. Exit\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your choice (1-5):  1\n",
      "Enter first number:  2\n",
      "Enter second number:  2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0 + 2.0 = 4.0\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your choice (1-5):  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thank you for using the calculator. Goodbye!\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def add(x, y):\n",
    "    return x + y \n",
    "def subtract(x, y):\n",
    "    return x - y\n",
    " \n",
    "def multiply(x, y):\n",
    "    return x * y\n",
    " \n",
    "def divide(x, y):\n",
    "    if y == 0:\n",
    "        return \"Cannot divide by zero\"\n",
    "    else:\n",
    "        return x / y\n",
    " \n",
    "def calculator():\n",
    "    print(\"=== Simple Calculator ===\")\n",
    "    print(\"Operations:\")\n",
    "    print(\"1. Addition\")\n",
    "    print(\"2. Subtraction\")\n",
    "    print(\"3. Multiplication\")\n",
    "    print(\"4. Division\")\n",
    "    print(\"5. Exit\")\n",
    "\n",
    "    while True:\n",
    "        choice = input(\"Enter your choice (1-5): \")\n",
    "\n",
    "        if choice in ('1', '2', '3', '4'):\n",
    "            num1 = float(input(\"Enter first number: \"))\n",
    "            num2 = float(input(\"Enter second number: \"))\n",
    "\n",
    "            if choice == '1':\n",
    "                print(f\"{num1} + {num2} = {add(num1, num2)}\")\n",
    "            elif choice == '2':\n",
    "                print(f\"{num1} - {num2} = {subtract(num1, num2)}\")\n",
    "            elif choice == '3':\n",
    "                print(f\"{num1} * {num2} = {multiply(num1, num2)}\")\n",
    "            elif choice == '4':\n",
    "                print(f\"{num1} / {num2} = {divide(num1, num2)}\")\n",
    "        \n",
    "        elif choice == '5':\n",
    "            print(\"Thank you for using the calculator. Goodbye!\")\n",
    "            break\n",
    "        \n",
    "        else:\n",
    "            print(\"Invalid input. Please enter a number between 1 and 5.\") \n",
    "calculator()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38dd441b-7a49-4aaf-a184-76f4a4758ef8",
   "metadata": {},
   "source": [
    "20. Write a program that determines the roots of a cubic equation using the Cardano formula."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f823111b-277a-4b30-bdd1-c903b6eb09dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter coefficient of x^3 (a):  4\n",
      "Enter coefficient of x^2 (b):  4\n",
      "Enter coefficient of x (c):  5\n",
      "Enter constant term (d):  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The roots of the cubic equation are:\n",
      "Root 1: -0.510585-0.847692j\n",
      "Root 2: -1.516246+1.626215j\n",
      "Root 3: 1.026831-0.778523j\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    " \n",
    "def solve_cubic(a, b, c, d): \n",
    "    p = (3*a*c - b**2) / (3*a**2)\n",
    "    q = (2*b**3 - 9*a*b*c + 27*a**2*d) / (27*a**3) \n",
    "    discriminant = (q/2)**2 + (p/3)**3\n",
    "\n",
    "    if discriminant > 0: \n",
    "        sqrt_discriminant = math.sqrt(discriminant)\n",
    "        u = (-q/2 + sqrt_discriminant)**(1/3) if (-q/2 + sqrt_discriminant) >= 0 else -((-q/2 + sqrt_discriminant)**(1/3))\n",
    "        v = (-q/2 - sqrt_discriminant)**(1/3) if (-q/2 - sqrt_discriminant) >= 0 else -((-q/2 - sqrt_discriminant)**(1/3))\n",
    "        \n",
    "        real_root = u + v\n",
    "        imaginary_part = (u - v) * math.sqrt(3) / 2 \n",
    "        root1 = real_root - b / (3*a)\n",
    "        root2_real = - (real_root / 2) - b / (3*a)\n",
    "        root2_imaginary = imaginary_part * math.sqrt(3)\n",
    "        root3_real = - (real_root / 2) - b / (3*a)\n",
    "        root3_imaginary = - imaginary_part * math.sqrt(3)\n",
    "\n",
    "        return root1, complex(root2_real, root2_imaginary), complex(root3_real, root3_imaginary)\n",
    "    \n",
    "    elif discriminant == 0: \n",
    "        u = (-q/2)**(1/3) if (-q/2) >= 0 else -((-q/2)**(1/3))\n",
    "        v = (-q/2)**(1/3) if (-q/2) >= 0 else -((-q/2)**(1/3))\n",
    "        \n",
    "        root1 = 2*u - b / (3*a)\n",
    "        root2_real = -u - b / (3*a)\n",
    "        root2_imaginary = 0\n",
    "        root3_real = -u - b / (3*a)\n",
    "        root3_imaginary = 0\n",
    "        \n",
    "        return root1, complex(root2_real, root2_imaginary), complex(root3_real, root3_imaginary)\n",
    "    \n",
    "    else: \n",
    "        r = math.sqrt(-(p**3) / 27)\n",
    "        theta = math.acos(-q / (2 * r))\n",
    "        \n",
    "        root1 = 2 * math.sqrt(-p / 3) * math.cos(theta/3) - b / (3*a)\n",
    "        root2 = 2 * math.sqrt(-p / 3) * math.cos((theta + 2*math.pi) / 3) - b / (3*a)\n",
    "        root3 = 2 * math.sqrt(-p / 3) * math.cos((theta + 4*math.pi) / 3) - b / (3*a)\n",
    "        \n",
    "        return root1, root2, root3 \n",
    "try:\n",
    "    a = float(input(\"Enter coefficient of x^3 (a): \"))\n",
    "    b = float(input(\"Enter coefficient of x^2 (b): \"))\n",
    "    c = float(input(\"Enter coefficient of x (c): \"))\n",
    "    d = float(input(\"Enter constant term (d): \"))\n",
    "    \n",
    "    roots = solve_cubic(a, b, c, d)\n",
    "    print(\"The roots of the cubic equation are:\")\n",
    "    for i, root in enumerate(roots, start=1):\n",
    "        print(f\"Root {i}: {root:.6f}\")\n",
    "except ValueError:\n",
    "    print(\"Invalid input. Please enter numerical coefficients.\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01584289-beba-418b-9281-3bf985e25222",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "46e9996c-5f1b-455a-920d-45ff6c3de552",
   "metadata": {},
   "source": [
    "                                                    Advanced Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63ed90c4-be1c-4ea5-a834-2a969b218710",
   "metadata": {},
   "source": [
    "21. Create a program that calculates the income tax based on the user's income and tax brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "89e58443-6ca8-4ef7-a1f1-b6f4dca287d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your income: $ 5000000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your income tax is: $2019000.00\n"
     ]
    }
   ],
   "source": [
    "# Function to calculate income tax based on tax brackets\n",
    "def calculate_income_tax(income):\n",
    "    # Tax brackets and corresponding tax rates\n",
    "    brackets = [10000, 40000, 80000, 180000]  # Upper limits of each tax bracket\n",
    "    rates = [0.1, 0.2, 0.3, 0.4, 0.45]         # Corresponding tax rates\n",
    "    \n",
    "    # Initial tax and previous bracket\n",
    "    tax = 0\n",
    "    previous_bracket = 0\n",
    "    \n",
    "    for i, bracket in enumerate(brackets):\n",
    "        if income <= 0:\n",
    "            break\n",
    "        if i == len(brackets) - 1 or income <= bracket:\n",
    "            tax += income * rates[i]\n",
    "            break\n",
    "        tax += (bracket - previous_bracket) * rates[i]\n",
    "        previous_bracket = bracket\n",
    "    \n",
    "    return tax\n",
    "\n",
    "# Example usage\n",
    "try:\n",
    "    income = float(input(\"Enter your income: $\"))\n",
    "    if income < 0:\n",
    "        print(\"Income cannot be negative.\")\n",
    "    else:\n",
    "        tax = calculate_income_tax(income)\n",
    "        print(f\"Your income tax is: ${tax:.2f}\")\n",
    "except ValueError:\n",
    "    print(\"Invalid input. Please enter a numerical value for income.\")\n",
    "\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44d652d7-2b26-4055-bc4c-db19a8f56e22",
   "metadata": {},
   "source": [
    "22. Write a program that simulates a rock-paper-scissors game against the computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b2245e9b-9310-40fb-9d15-ec9cc7552b28",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Rock-Paper-Scissors against the computer!\n",
      "Let's begin...\n",
      "\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your choice (rock, paper, scissors):  rock\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "You chose: rock\n",
      "Computer chose: rock\n",
      "\n",
      "Result: Tie\n",
      "\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Do you want to play again? (yes/no):  no\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Thanks for playing!\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "def get_user_choice():\n",
    "    \"\"\"Prompt user for their choice (rock, paper, or scissors)\"\"\"\n",
    "    while True:\n",
    "        user_input = input(\"Enter your choice (rock, paper, scissors): \").strip().lower()\n",
    "        if user_input in ['rock', 'paper', 'scissors']:\n",
    "            return user_input\n",
    "        else:\n",
    "            print(\"Invalid choice. Please enter 'rock', 'paper', or 'scissors'.\")\n",
    "\n",
    "def get_computer_choice():\n",
    "    \"\"\"Generate computer's choice (rock, paper, or scissors)\"\"\"\n",
    "    choices = ['rock', 'paper', 'scissors']\n",
    "    return random.choice(choices)\n",
    "\n",
    "def determine_winner(user_choice, computer_choice):\n",
    "    \"\"\"Determine the winner based on user and computer choices\"\"\"\n",
    "    outcomes = {\n",
    "        ('rock', 'rock'): 'Tie',\n",
    "        ('rock', 'paper'): 'Computer wins',\n",
    "        ('rock', 'scissors'): 'You win',\n",
    "        ('paper', 'rock'): 'You win',\n",
    "        ('paper', 'paper'): 'Tie',\n",
    "        ('paper', 'scissors'): 'Computer wins',\n",
    "        ('scissors', 'rock'): 'Computer wins',\n",
    "        ('scissors', 'paper'): 'You win',\n",
    "        ('scissors', 'scissors'): 'Tie'\n",
    "    }\n",
    "    return outcomes[(user_choice, computer_choice)]\n",
    "\n",
    "def rock_paper_scissors_game():\n",
    "    \"\"\"Main function to simulate the rock-paper-scissors game\"\"\"\n",
    "    print(\"Welcome to Rock-Paper-Scissors against the computer!\")\n",
    "    print(\"Let's begin...\\n\")\n",
    "\n",
    "    while True:\n",
    "        user_choice = get_user_choice()\n",
    "        computer_choice = get_computer_choice()\n",
    "\n",
    "        print(f\"\\nYou chose: {user_choice}\")\n",
    "        print(f\"Computer chose: {computer_choice}\")\n",
    "\n",
    "        winner = determine_winner(user_choice, computer_choice)\n",
    "        print(f\"\\nResult: {winner}\\n\")\n",
    "\n",
    "        play_again = input(\"Do you want to play again? (yes/no): \").strip().lower()\n",
    "        if play_again != 'yes':\n",
    "            print(\"\\nThanks for playing!\")\n",
    "            break\n",
    " \n",
    "rock_paper_scissors_game()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a7b26dd-dc94-46b5-8b68-362baf6c6c95",
   "metadata": {},
   "source": [
    "23. Develop a program that generates a random password based on user preferences (length, complexity)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "464552ca-8818-4af6-ac5b-9cdd036f1a2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Random Password Generator!\n",
      "Let's generate a password based on your preferences.\n",
      "\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the length of the password:  amit\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: invalid literal for int() with base 10: 'amit'\n",
      "Please enter valid inputs.\n",
      "\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the length of the password:  amit\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: invalid literal for int() with base 10: 'amit'\n",
      "Please enter valid inputs.\n",
      "\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the length of the password:  4\n",
      "Include digits? (yes/no):  no\n",
      "Include special characters? (yes/no):  @\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Generated Password: zJTX\n",
      "\n",
      "Thank you for using the Random Password Generator!\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import string\n",
    "\n",
    "def generate_password(length=8, include_digits=True, include_special_chars=False):\n",
    "    \"\"\"Generate a random password based on user preferences.\"\"\"\n",
    "    chars = string.ascii_letters  \n",
    "    if include_digits:\n",
    "        chars += string.digits  \n",
    "\n",
    "    if include_special_chars:\n",
    "        chars += string.punctuation   \n",
    "\n",
    "    password = ''.join(random.choice(chars) for _ in range(length))\n",
    "    return password\n",
    " \n",
    "print(\"Welcome to Random Password Generator!\")\n",
    "print(\"Let's generate a password based on your preferences.\\n\")\n",
    "\n",
    "while True:\n",
    "    try:\n",
    "        length = int(input(\"Enter the length of the password: \"))\n",
    "        if length <= 0:\n",
    "            raise ValueError(\"Password length should be a positive integer.\")\n",
    "        \n",
    "        include_digits = input(\"Include digits? (yes/no): \").strip().lower() == 'yes'\n",
    "        include_special_chars = input(\"Include special characters? (yes/no): \").strip().lower() == 'yes'\n",
    "\n",
    "        password = generate_password(length, include_digits, include_special_chars)\n",
    "        print(f\"\\nGenerated Password: {password}\\n\")\n",
    "\n",
    "        break   \n",
    "\n",
    "    except ValueError as e:\n",
    "        print(f\"Error: {e}\")\n",
    "        print(\"Please enter valid inputs.\\n\")\n",
    "\n",
    "print(\"Thank you for using the Random Password Generator!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d09a510-7cd0-4a9c-bf9c-5eed40680c55",
   "metadata": {},
   "source": [
    "24. Create a program that implements a simple text-based adventure game with branching scenarios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "527e0a48-75cb-4d3d-a9cc-1eb6a22fcd8e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to the Text Adventure Game!\n",
      "You find yourself standing in front of a mysterious cave entrance...\n",
      "\n",
      "You have two paths ahead of you:\n",
      "1. Enter the cave.\n",
      "2. Follow the path into the forest.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Which path will you choose? (1 or 2):  1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "You cautiously enter the dark cave...\n",
      "As you venture deeper, you encounter a fork in the cave.\n",
      "There are two tunnels:\n",
      "1. Take the left tunnel.\n",
      "2. Take the right tunnel.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Which tunnel will you explore? (1 or 2):  2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "You take the right tunnel...\n",
      "You encounter a sleeping dragon!\n",
      "You've been eaten... Game Over.\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def intro():\n",
    "    print(\"Welcome to the Text Adventure Game!\")\n",
    "    print(\"You find yourself standing in front of a mysterious cave entrance...\\n\")\n",
    "    time.sleep(2)   \n",
    "    \n",
    "def choose_path():\n",
    "    print(\"You have two paths ahead of you:\")\n",
    "    print(\"1. Enter the cave.\")\n",
    "    print(\"2. Follow the path into the forest.\")\n",
    "    choice = input(\"Which path will you choose? (1 or 2): \").strip()\n",
    "    return choice\n",
    "\n",
    "def cave_scenario():\n",
    "    print(\"\\nYou cautiously enter the dark cave...\")\n",
    "    time.sleep(2)\n",
    "    print(\"As you venture deeper, you encounter a fork in the cave.\")\n",
    "    time.sleep(2)\n",
    "    print(\"There are two tunnels:\")\n",
    "    print(\"1. Take the left tunnel.\")\n",
    "    print(\"2. Take the right tunnel.\")\n",
    "    choice = input(\"Which tunnel will you explore? (1 or 2): \").strip()\n",
    "    return choice\n",
    "\n",
    "def forest_scenario():\n",
    "    print(\"\\nYou decide to follow the path into the forest...\")\n",
    "    time.sleep(2)\n",
    "    print(\"You hear rustling in the bushes ahead.\")\n",
    "    time.sleep(2)\n",
    "    print(\"There is a clearing with a pond and a small cabin.\")\n",
    "    time.sleep(2)\n",
    "    print(\"What will you do?\")\n",
    "    print(\"1. Approach the cabin.\")\n",
    "    print(\"2. Investigate the pond.\")\n",
    "    choice = input(\"What is your next move? (1 or 2): \").strip()\n",
    "    return choice\n",
    "\n",
    "def play_game():\n",
    "    intro()\n",
    "    path_choice = choose_path()\n",
    "    \n",
    "    if path_choice == '1':\n",
    "        cave_choice = cave_scenario()\n",
    "        if cave_choice == '1':\n",
    "            print(\"\\nYou take the left tunnel...\")\n",
    "            time.sleep(2)\n",
    "            print(\"You find a hidden treasure chest!\")\n",
    "            print(\"Congratulations, you win!\")\n",
    "        elif cave_choice == '2':\n",
    "            print(\"\\nYou take the right tunnel...\")\n",
    "            time.sleep(2)\n",
    "            print(\"You encounter a sleeping dragon!\")\n",
    "            print(\"You've been eaten... Game Over.\")\n",
    "        else:\n",
    "            print(\"Invalid choice. Game Over.\")\n",
    "            \n",
    "    elif path_choice == '2':\n",
    "        forest_choice = forest_scenario()\n",
    "        if forest_choice == '1':\n",
    "            print(\"\\nYou approach the cabin...\")\n",
    "            time.sleep(2)\n",
    "            print(\"The cabin is abandoned. You find some supplies and rest.\")\n",
    "            print(\"You survive the night. Well done!\")\n",
    "        elif forest_choice == '2':\n",
    "            print(\"\\nYou investigate the pond...\")\n",
    "            time.sleep(2)\n",
    "            print(\"It's just a peaceful pond. Nothing exciting happens.\")\n",
    "            print(\"You wander back to the path.\")\n",
    "        else:\n",
    "            print(\"Invalid choice. Game Over.\")\n",
    "            \n",
    "    else:\n",
    "        print(\"Invalid choice. Game Over.\") \n",
    "play_game()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43b93ab8-3a3f-4915-b3b7-222cf663425f",
   "metadata": {},
   "source": [
    "25. Build a program that solves a linear equation for x, considering different cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "70ec7b2a-8f5c-4924-8b89-f4e96680323f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear Equation Solver: ax + b = 0\n",
      "Enter coefficients a and b:\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter coefficient a:  4\n",
      "Enter coefficient b:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The solution is x = -1.25\n"
     ]
    }
   ],
   "source": [
    "def solve_linear_equation(a, b):\n",
    "    if a == 0:\n",
    "        if b == 0:\n",
    "            print(\"Infinite solutions: Every value of x is a solution.\")\n",
    "        else:\n",
    "            print(\"No solution: The equation is inconsistent.\")\n",
    "    else:\n",
    "        x = -b / a\n",
    "        print(f\"The solution is x = {x}\") \n",
    "print(\"Linear Equation Solver: ax + b = 0\")\n",
    "print(\"Enter coefficients a and b:\")\n",
    "a = float(input(\"Enter coefficient a: \"))\n",
    "b = float(input(\"Enter coefficient b: \"))\n",
    "\n",
    "solve_linear_equation(a, b)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b93ff47-c34f-4c59-b506-d35669957202",
   "metadata": {},
   "source": [
    "26. Write a program that simulates a basic quiz game with multiple-choice questions and scoring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "12cf281c-3eea-44d5-a766-2dab81ab6d13",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to the Quiz Game!\n",
      "Answer the following questions:\n",
      "\n",
      "What is the capital of France?\n",
      "A. Paris\n",
      "B. London\n",
      "C. Rome\n",
      "D. Berlin\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your answer (A/B/C/D):  a\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correct!\n",
      "\n",
      "Which planet is known as the Red Planet?\n",
      "A. Jupiter\n",
      "B. Mars\n",
      "C. Venus\n",
      "D. Saturn\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your answer (A/B/C/D):  s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wrong! The correct answer is B.\n",
      "\n",
      "Who wrote 'Romeo and Juliet'?\n",
      "A. William Shakespeare\n",
      "B. Jane Austen\n",
      "C. Charles Dickens\n",
      "D. Mark Twain\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your answer (A/B/C/D):  s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wrong! The correct answer is A.\n",
      "\n",
      "Quiz ended. Your score is: 1/3\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "class Quiz:\n",
    "    def __init__(self):\n",
    "        self.questions = [\n",
    "            {\n",
    "                \"question\": \"What is the capital of France?\",\n",
    "                \"options\": [\"A. Paris\", \"B. London\", \"C. Rome\", \"D. Berlin\"],\n",
    "                \"answer\": \"A\"\n",
    "            },\n",
    "            {\n",
    "                \"question\": \"Which planet is known as the Red Planet?\",\n",
    "                \"options\": [\"A. Jupiter\", \"B. Mars\", \"C. Venus\", \"D. Saturn\"],\n",
    "                \"answer\": \"B\"\n",
    "            },\n",
    "            {\n",
    "                \"question\": \"Who wrote 'Romeo and Juliet'?\",\n",
    "                \"options\": [\"A. William Shakespeare\", \"B. Jane Austen\", \"C. Charles Dickens\", \"D. Mark Twain\"],\n",
    "                \"answer\": \"A\"\n",
    "            }\n",
    "        ]\n",
    "        self.score = 0\n",
    "    \n",
    "    def display_question(self, question):\n",
    "        print(question[\"question\"])\n",
    "        for option in question[\"options\"]:\n",
    "            print(option)\n",
    "        return input(\"Enter your answer (A/B/C/D): \").strip().upper()\n",
    "    \n",
    "    def play_quiz(self):\n",
    "        print(\"Welcome to the Quiz Game!\")\n",
    "        time.sleep(1)\n",
    "        print(\"Answer the following questions:\\n\")\n",
    "        time.sleep(1)\n",
    "        \n",
    "        for question in self.questions:\n",
    "            user_answer = self.display_question(question)\n",
    "            correct_answer = question[\"answer\"]\n",
    "            \n",
    "            if user_answer == correct_answer:\n",
    "                print(\"Correct!\\n\")\n",
    "                self.score += 1\n",
    "            else:\n",
    "                print(f\"Wrong! The correct answer is {correct_answer}.\\n\")\n",
    "            \n",
    "            time.sleep(1)\n",
    "        \n",
    "        print(f\"Quiz ended. Your score is: {self.score}/{len(self.questions)}\") \n",
    "quiz = Quiz()\n",
    "quiz.play_quiz()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc83f50f-1f29-47b9-adc1-9ac1135175d6",
   "metadata": {},
   "source": [
    "27. Develop a program that determines whether a given year is a prime number or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f548c0a-f1ec-46fe-952c-6060dace532f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_prime(year):\n",
    "    if year <= 1:\n",
    "        return False\n",
    "    if year == 2:\n",
    "        return True   \n",
    "    if year % 2 == 0:\n",
    "        return False   \n",
    "    sqrt_year = int(year**0.5) + 1\n",
    "    for i in range(3, sqrt_year, 2):\n",
    "        if year % i == 0:\n",
    "            return False\n",
    "    \n",
    "    return True \n",
    "year = int(input(\"Enter a year to check if it is prime: \"))\n",
    "if is_prime(year):\n",
    "    print(f\"{year} is a prime year.\")\n",
    "else:\n",
    "    print(f\"{year} is not a prime year.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "293026b7-13a8-4059-82d0-fd589d02be5e",
   "metadata": {},
   "source": [
    "28. Create a program that sorts three numbers in ascending order using conditional statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5e1d452d-2a33-4657-9c8c-01c078c2e6bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter three numbers to sort in ascending order:\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first number:  545\n",
      "Enter the second number:  55\n",
      "Enter the third number:  545\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The numbers in ascending order are: 55.0, 545.0, 545.0\n"
     ]
    }
   ],
   "source": [
    "def sort_three_numbers(a, b, c):\n",
    "    if a > b:\n",
    "        a, b = b, a   \n",
    "    if a > c:\n",
    "        a, c = c, a  \n",
    "    if b > c:\n",
    "        b, c = c, b   \n",
    "    return a, b, c \n",
    "print(\"Enter three numbers to sort in ascending order:\")\n",
    "a = float(input(\"Enter the first number: \"))\n",
    "b = float(input(\"Enter the second number: \"))\n",
    "c = float(input(\"Enter the third number: \"))\n",
    "\n",
    "sorted_numbers = sort_three_numbers(a, b, c)\n",
    "print(f\"The numbers in ascending order are: {sorted_numbers[0]}, {sorted_numbers[1]}, {sorted_numbers[2]}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da8bd786-6905-4e4a-b19f-89facf999049",
   "metadata": {},
   "source": [
    "29. Build a program that determines the roots of a quartic equation using numerical methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "11c0eff2-b6c5-4d1a-8141-4bf9dba09bb3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the coefficients of the quartic equation ax^4 + bx^3 + cx^2 + dx + e = 0:\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter coefficient a:  .554\n",
      "Enter coefficient b:  .551\n",
      "Enter coefficient c:  .5541\n",
      "Enter coefficient d:  0.5454\n",
      "Enter coefficient e:  .548445\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The roots of the quartic equation are:\n",
      "(0.3074725310697166+0.9477019895624941j)\n",
      "(0.3074725310697166-0.9477019895624941j)\n",
      "(-0.80476494984228+0.5912934353721391j)\n",
      "(-0.80476494984228-0.5912934353721391j)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "def find_roots(a, b, c, d, e):\n",
    "    \"\"\"\n",
    "    Finds the roots of a quartic equation ax^4 + bx^3 + cx^2 + dx + e = 0.\n",
    "    \n",
    "    Parameters:\n",
    "    a, b, c, d, e: coefficients of the quartic equation.\n",
    "    \n",
    "    Returns:\n",
    "    roots: a list of the roots of the quartic equation.\n",
    "    \"\"\"\n",
    "    coefficients = [a, b, c, d, e]\n",
    "    roots = np.roots(coefficients)\n",
    "    return roots \n",
    "print(\"Enter the coefficients of the quartic equation ax^4 + bx^3 + cx^2 + dx + e = 0:\")\n",
    "a = float(input(\"Enter coefficient a: \"))\n",
    "b = float(input(\"Enter coefficient b: \"))\n",
    "c = float(input(\"Enter coefficient c: \"))\n",
    "d = float(input(\"Enter coefficient d: \"))\n",
    "e = float(input(\"Enter coefficient e: \"))\n",
    "\n",
    "roots = find_roots(a, b, c, d, e)\n",
    "print(\"The roots of the quartic equation are:\")\n",
    "for root in roots:\n",
    "    print(root)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c87a41b9-2376-4dc2-b1c5-c56826d04af4",
   "metadata": {},
   "source": [
    "30. Write a program that calculates the BMI (Body Mass Index) and provides health recommendations based\n",
    "on the user's input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e989a0a1-cf10-4f29-8888-0ca0b0951c91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BMI Calculator\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your weight in kilograms:  65\n",
      "Enter your height in meters:  7.54\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your BMI is: 1.14\n",
      "You are underweight. It's important to eat a balanced diet and maintain a healthy lifestyle.\n"
     ]
    }
   ],
   "source": [
    "def calculate_bmi(weight, height):\n",
    "    \"\"\"Calculate the BMI given weight and height.\"\"\"\n",
    "    bmi = weight / (height ** 2)\n",
    "    return bmi\n",
    "\n",
    "def bmi_recommendation(bmi):\n",
    "    \"\"\"Provide health recommendations based on the BMI.\"\"\"\n",
    "    if bmi < 18.5:\n",
    "        return \"You are underweight. It's important to eat a balanced diet and maintain a healthy lifestyle.\"\n",
    "    elif 18.5 <= bmi < 24.9:\n",
    "        return \"You have a normal weight. Keep up the good work and maintain your healthy lifestyle!\"\n",
    "    elif 25 <= bmi < 29.9:\n",
    "        return \"You are overweight. Consider a balanced diet and regular exercise.\"\n",
    "    else:\n",
    "        return \"You are obese. It's recommended to seek advice from a healthcare provider for proper guidance.\" \n",
    "print(\"BMI Calculator\")\n",
    "\n",
    "weight = float(input(\"Enter your weight in kilograms: \"))\n",
    "height = float(input(\"Enter your height in meters: \"))\n",
    "\n",
    "bmi = calculate_bmi(weight, height)\n",
    "recommendation = bmi_recommendation(bmi)\n",
    "\n",
    "print(f\"Your BMI is: {bmi:.2f}\")\n",
    "print(recommendation)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "445b7287-3f1c-4751-9e65-ec2f1c4e8ee5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9070d37b-a1a2-4600-94c3-1754f7ff1626",
   "metadata": {},
   "source": [
    "                                                        Challenge Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5149e57d-26a9-426f-b9fb-e52379e0e15d",
   "metadata": {},
   "source": [
    "31. Create a program that validates a password based on complexity rules (length, characters, etc.)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "16600339-d533-442d-b710-db3bb6778af9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a password to validate:  amit kumar\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Password is invalid: Password must contain at least one uppercase letter.\n"
     ]
    }
   ],
   "source": [
    " import re\n",
    "\n",
    "def validate_password(password):\n",
    "    \"\"\"Validate the password based on complexity rules.\"\"\"\n",
    "    if len(password) < 8:\n",
    "        return False, \"Password must be at least 8 characters long.\"\n",
    "    if not re.search(r'[A-Z]', password):\n",
    "        return False, \"Password must contain at least one uppercase letter.\"\n",
    "    if not re.search(r'[a-z]', password):\n",
    "        return False, \"Password must contain at least one lowercase letter.\"\n",
    "    if not re.search(r'[0-9]', password):\n",
    "        return False, \"Password must contain at least one digit.\"\n",
    "    if not re.search(r'[!@#$%^&*(),.?\":{}|<>]', password):\n",
    "        return False, \"Password must contain at least one special character.\"\n",
    "    return True, \"Password is valid.\" \n",
    "\n",
    "password = input(\"Enter a password to validate: \")\n",
    "is_valid, message = validate_password(password)\n",
    "if is_valid:\n",
    "    print(\"Password is valid.\")\n",
    "else:\n",
    "    print(f\"Password is invalid: {message}\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a93e307-ff4a-4bd7-8b45-3b80e578c6c0",
   "metadata": {},
   "source": [
    "32. Develop a program that performs matrix addition and subtraction based on user input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5faedf46-0bc8-4bcf-b65e-82f545b5234d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the number of rows in the matrices:  5\n",
      "Enter the number of columns in the matrices:  4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix 1:\n",
      "Enter the elements of a 5x4 matrix row-wise:\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter row 1:  4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: Incorrect number of elements in the row.\n"
     ]
    }
   ],
   "source": [
    "def get_matrix(rows, cols):\n",
    "    \"\"\"Get a matrix from user input.\"\"\"\n",
    "    matrix = []\n",
    "    print(f\"Enter the elements of a {rows}x{cols} matrix row-wise:\")\n",
    "    for i in range(rows):\n",
    "        row = list(map(int, input(f\"Enter row {i + 1}: \").split()))\n",
    "        if len(row) != cols:\n",
    "            raise ValueError(\"Incorrect number of elements in the row.\")\n",
    "        matrix.append(row)\n",
    "    return matrix\n",
    "\n",
    "def add_matrices(matrix1, matrix2):\n",
    "    \"\"\"Add two matrices.\"\"\"\n",
    "    rows = len(matrix1)\n",
    "    cols = len(matrix1[0])\n",
    "    result = [[matrix1[i][j] + matrix2[i][j] for j in range(cols)] for i in range(rows)]\n",
    "    return result\n",
    "\n",
    "def subtract_matrices(matrix1, matrix2):\n",
    "    \"\"\"Subtract two matrices.\"\"\"\n",
    "    rows = len(matrix1)\n",
    "    cols = len(matrix1[0])\n",
    "    result = [[matrix1[i][j] - matrix2[i][j] for j in range(cols)] for i in range(rows)]\n",
    "    return result\n",
    "\n",
    "def print_matrix(matrix):\n",
    "    \"\"\"Print a matrix.\"\"\"\n",
    "    for row in matrix:\n",
    "        print(\" \".join(map(str, row))) \n",
    "        \n",
    "try:\n",
    "    rows = int(input(\"Enter the number of rows in the matrices: \"))\n",
    "    cols = int(input(\"Enter the number of columns in the matrices: \"))\n",
    "\n",
    "    print(\"Matrix 1:\")\n",
    "    matrix1 = get_matrix(rows, cols)\n",
    "\n",
    "    print(\"Matrix 2:\")\n",
    "    matrix2 = get_matrix(rows, cols)\n",
    "\n",
    "    print(\"Matrix Addition Result:\")\n",
    "    addition_result = add_matrices(matrix1, matrix2)\n",
    "    print_matrix(addition_result)\n",
    "\n",
    "    print(\"Matrix Subtraction Result:\")\n",
    "    subtraction_result = subtract_matrices(matrix1, matrix2)\n",
    "    print_matrix(subtraction_result)\n",
    "\n",
    "except ValueError as e:\n",
    "    print(f\"Error: {e}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8ecb22d-c3e8-4143-9e97-268cce96da9e",
   "metadata": {},
   "source": [
    "33. Write a program that calculates the greatest common divisor (GCD) of two numbers using the Euclidean\n",
    "algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4eaf7c91-bf67-49c4-a4fb-380eaf8bdc16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first number:  54\n",
      "Enter the second number:  58\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The GCD of 54 and 58 is: 2\n"
     ]
    }
   ],
   "source": [
    "def gcd(a, b):\n",
    "    \"\"\"Calculate the Greatest Common Divisor (GCD) of two numbers using the Euclidean algorithm.\"\"\"\n",
    "    while b:\n",
    "        a, b = b, a % b\n",
    "    return a \n",
    "\n",
    "try:\n",
    "    num1 = int(input(\"Enter the first number: \"))\n",
    "    num2 = int(input(\"Enter the second number: \"))\n",
    "    \n",
    "    result = gcd(num1, num2)\n",
    "    print(f\"The GCD of {num1} and {num2} is: {result}\")\n",
    "except ValueError:\n",
    "    print(\"Please enter valid integers.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "933e3b0b-19fb-422e-82d5-645991ba2945",
   "metadata": {},
   "source": [
    "34. Build a program that performs matrix multiplication using nested loops and conditional statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bc562066-99f1-4e3b-8fc7-af9be9b55e82",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the number of rows in the first matrix:  5\n",
      "Enter the number of columns in the first matrix:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix 1:\n",
      "Enter the elements of a 5x5 matrix row-wise:\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter row 1:  2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: Incorrect number of elements in the row.\n"
     ]
    }
   ],
   "source": [
    "def input_matrix(rows, cols):\n",
    "    \"\"\"Function to take a matrix input from the user.\"\"\"\n",
    "    matrix = []\n",
    "    print(f\"Enter the elements of a {rows}x{cols} matrix row-wise:\")\n",
    "    for i in range(rows):\n",
    "        row = list(map(int, input(f\"Enter row {i + 1}: \").split()))\n",
    "        if len(row) != cols:\n",
    "            raise ValueError(\"Incorrect number of elements in the row.\")\n",
    "        matrix.append(row)\n",
    "    return matrix\n",
    "\n",
    "def multiply_matrices(matrix1, matrix2):\n",
    "    \"\"\"Function to multiply two matrices.\"\"\"\n",
    "    rows1 = len(matrix1)\n",
    "    cols1 = len(matrix1[0])\n",
    "    rows2 = len(matrix2)\n",
    "    cols2 = len(matrix2[0])\n",
    "\n",
    "    if cols1 != rows2:\n",
    "        raise ValueError(\"Number of columns in the first matrix must be equal to the number of rows in the second matrix.\")\n",
    "\n",
    "    # Initialize the result matrix with zeros\n",
    "    result = [[0 for _ in range(cols2)] for _ in range(rows1)]\n",
    "\n",
    "    # Perform matrix multiplication\n",
    "    for i in range(rows1):\n",
    "        for j in range(cols2):\n",
    "            for k in range(cols1):\n",
    "                result[i][j] += matrix1[i][k] * matrix2[k][j]\n",
    "\n",
    "    return result\n",
    "\n",
    "def print_matrix(matrix):\n",
    "    \"\"\"Function to print a matrix.\"\"\"\n",
    "    for row in matrix:\n",
    "        print(\" \".join(map(str, row))) \n",
    "try:\n",
    "    rows1 = int(input(\"Enter the number of rows in the first matrix: \"))\n",
    "    cols1 = int(input(\"Enter the number of columns in the first matrix: \"))\n",
    "    \n",
    "    print(\"Matrix 1:\")\n",
    "    matrix1 = input_matrix(rows1, cols1)\n",
    "    \n",
    "    rows2 = int(input(\"Enter the number of rows in the second matrix: \"))\n",
    "    cols2 = int(input(\"Enter the number of columns in the second matrix: \"))\n",
    "    \n",
    "    print(\"Matrix 2:\")\n",
    "    matrix2 = input_matrix(rows2, cols2)\n",
    "\n",
    "    result = multiply_matrices(matrix1, matrix2)\n",
    "    \n",
    "    print(\"Resultant Matrix after Multiplication:\")\n",
    "    print_matrix(result)\n",
    "\n",
    "except ValueError as e:\n",
    "    print(f\"Error: {e}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8bf406f-1510-4c73-9e80-a16c8df1179d",
   "metadata": {},
   "source": [
    "35. Create a program that simulates a basic text-based tic-tac-toe game against the computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c2becc3a-d70e-451d-9972-4972e999869e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Tic-Tac-Toe!\n",
      "You are playing as: O\n",
      "Computer is playing as: X\n",
      "  |   |  \n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "Computer's turn:\n",
      "  |   |  \n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "X |   |  \n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "X |   |  \n",
      "---------\n",
      "Computer's turn:\n",
      "  |   | X\n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "X |   |  \n",
      "---------\n",
      "  |   | X\n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "X |   |  \n",
      "---------\n",
      "Computer's turn:\n",
      "  |   | X\n",
      "---------\n",
      "  | X |  \n",
      "---------\n",
      "X |   |  \n",
      "---------\n",
      "Computer wins!\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "def print_board(board):\n",
    "    \"\"\"Print the tic-tac-toe board.\"\"\"\n",
    "    for row in board:\n",
    "        print(\" | \".join(row))\n",
    "        print(\"-\" * 9)\n",
    "\n",
    "def check_win(board, player):\n",
    "    \"\"\"Check if the specified player has won.\"\"\"\n",
    "    for row in board:\n",
    "        if all([cell == player for cell in row]):\n",
    "            return True\n",
    "    for col in range(3):\n",
    "        if all([board[row][col] == player for row in range(3)]):\n",
    "            return True\n",
    "    if all([board[i][i] == player for i in range(3)]) or all([board[i][2-i] == player for i in range(3)]):\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "def check_draw(board):\n",
    "    \"\"\"Check if the game is a draw.\"\"\"\n",
    "    for row in board:\n",
    "        for cell in row:\n",
    "            if cell == \" \":\n",
    "                return False\n",
    "    return True\n",
    "\n",
    "def computer_move(board, computer_char, player_char):\n",
    "    \"\"\"Simulate the computer's move.\"\"\"\n",
    "     \n",
    "    for i in range(3):\n",
    "        for j in range(3):\n",
    "            if board[i][j] == \" \":\n",
    "                board[i][j] = computer_char\n",
    "                if check_win(board, computer_char):\n",
    "                    return\n",
    "                else:\n",
    "                    board[i][j] = \" \"\n",
    " \n",
    "    for i in range(3):\n",
    "        for j in range(3):\n",
    "            if board[i][j] == \" \":\n",
    "                board[i][j] = player_char\n",
    "                if check_win(board, player_char):\n",
    "                    board[i][j] = computer_char\n",
    "                    return\n",
    "                else:\n",
    "                    board[i][j] = \" \"\n",
    " \n",
    "    corners = [(0, 0), (0, 2), (2, 0), (2, 2)]\n",
    "    random.shuffle(corners)\n",
    "    for i, j in corners:\n",
    "        if board[i][j] == \" \":\n",
    "            board[i][j] = computer_char\n",
    "            return\n",
    " \n",
    "    if board[1][1] == \" \":\n",
    "        board[1][1] = computer_char\n",
    "        return\n",
    " \n",
    "    edges = [(0, 1), (1, 0), (1, 2), (2, 1)]\n",
    "    random.shuffle(edges)\n",
    "    for i, j in edges:\n",
    "        if board[i][j] == \" \":\n",
    "            board[i][j] = computer_char\n",
    "            return\n",
    "\n",
    "def tic_tac_toe_game():\n",
    "    \"\"\"Main function to play tic-tac-toe against the computer.\"\"\"\n",
    "    board = [[\" \" for _ in range(3)] for _ in range(3)]\n",
    "    players = ['X', 'O']\n",
    "    random.shuffle(players)\n",
    "    player_char = players[0]\n",
    "    computer_char = players[1]\n",
    "\n",
    "    print(\"Welcome to Tic-Tac-Toe!\")\n",
    "    print(\"You are playing as:\", player_char)\n",
    "    print(\"Computer is playing as:\", computer_char)\n",
    "    print_board(board)\n",
    "\n",
    "    while True: \n",
    "        \n",
    "        if player_char == 'X':\n",
    "            while True:\n",
    "                try:\n",
    "                    row = int(input(\"Enter the row (1-3): \")) - 1\n",
    "                    col = int(input(\"Enter the column (1-3): \")) - 1\n",
    "                    if 0 <= row <= 2 and 0 <= col <= 2 and board[row][col] == \" \":\n",
    "                        board[row][col] = player_char\n",
    "                        break\n",
    "                    else:\n",
    "                        print(\"Invalid move. Please try again.\")\n",
    "                except ValueError:\n",
    "                    print(\"Invalid input. Please enter a number.\")\n",
    "\n",
    "        print_board(board)\n",
    "         \n",
    "        if check_win(board, player_char):\n",
    "            print(\"Congratulations! You win!\")\n",
    "            break\n",
    "         \n",
    "        if check_draw(board):\n",
    "            print(\"It's a draw!\")\n",
    "            break\n",
    "         \n",
    "        print(\"Computer's turn:\")\n",
    "        computer_move(board, computer_char, player_char)\n",
    "        print_board(board)\n",
    "         \n",
    "        if check_win(board, computer_char):\n",
    "            print(\"Computer wins!\")\n",
    "            break\n",
    "         \n",
    "        if check_draw(board):\n",
    "            print(\"It's a draw!\")\n",
    "            break\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    tic_tac_toe_game()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a97ad5cd-3fd6-419d-a91f-b50aef25b2a6",
   "metadata": {},
   "source": [
    "36. Write a program that generates Fibonacci numbers up to a specified term using iterative methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5cff7f86-71f5-4935-a5fb-945a3a388ed9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the number of Fibonacci numbers to generate:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fibonacci sequence up to 5 terms:\n",
      "[0, 1, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "def generate_fibonacci(n):\n",
    "    \"\"\"Generate Fibonacci numbers up to the nth term using iteration.\"\"\"\n",
    "    fib_sequence = []\n",
    "    if n >= 1:\n",
    "        fib_sequence.append(0)\n",
    "    if n >= 2:\n",
    "        fib_sequence.append(1)\n",
    "    \n",
    "    for i in range(2, n):\n",
    "        next_fib = fib_sequence[-1] + fib_sequence[-2]\n",
    "        fib_sequence.append(next_fib)\n",
    "    \n",
    "    return fib_sequence \n",
    "try:\n",
    "    n = int(input(\"Enter the number of Fibonacci numbers to generate: \"))\n",
    "    if n < 1:\n",
    "        raise ValueError(\"Number of terms should be at least 1.\")\n",
    "    \n",
    "    fibonacci_numbers = generate_fibonacci(n)\n",
    "    print(f\"Fibonacci sequence up to {n} terms:\")\n",
    "    print(fibonacci_numbers)\n",
    "\n",
    "except ValueError as ve:\n",
    "    print(f\"Error: {ve}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81846a19-af15-4e6e-86a0-116f00ae17ac",
   "metadata": {},
   "source": [
    "37. Develop a program that calculates the nth term of the Fibonacci sequence using memoization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "fea2a198-9943-48dc-95ea-9a5fcb0b8003",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the term number to find in the Fibonacci sequence:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 5th term of the Fibonacci sequence is: 5\n"
     ]
    }
   ],
   "source": [
    "def fibonacci_memo(n, memo={}):\n",
    "    \"\"\"Calculate the nth Fibonacci number using memoization.\"\"\"\n",
    "    if n in memo:\n",
    "        return memo[n]\n",
    "    if n <= 1:\n",
    "        return n\n",
    "    memo[n] = fibonacci_memo(n-1, memo) + fibonacci_memo(n-2, memo)\n",
    "    return memo[n]\n",
    " \n",
    "try:\n",
    "    n = int(input(\"Enter the term number to find in the Fibonacci sequence: \"))\n",
    "    if n < 0:\n",
    "        raise ValueError(\"Term number should be a non-negative integer.\")\n",
    "    \n",
    "    result = fibonacci_memo(n)\n",
    "    print(f\"The {n}th term of the Fibonacci sequence is: {result}\")\n",
    "\n",
    "except ValueError as ve:\n",
    "    print(f\"Error: {ve}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08597469-d884-4deb-afac-83bbb5b13f5f",
   "metadata": {},
   "source": [
    "38. Create a program that generates a calendar for a given month and year using conditional statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "4f142b2c-4501-45cf-963d-00ea9db0227f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the year:  1996\n",
      "Enter the month (1-12):  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "May 1996\n",
      "Su Mo Tu We Th Fr Sa\n",
      "       1  2  3  4  5 \n",
      " 6  7  8  9 10 11 12 \n",
      "13 14 15 16 17 18 19 \n",
      "20 21 22 23 24 25 26 \n",
      "27 28 29 30 31       \n"
     ]
    }
   ],
   "source": [
    "import calendar\n",
    "\n",
    "def generate_calendar(year, month):\n",
    "    \"\"\"Generate a calendar for a given month and year.\"\"\"\n",
    "    # Create a calendar object\n",
    "    cal = calendar.Calendar(firstweekday=0)  # firstweekday=0 means Sunday\n",
    "\n",
    "    # Get the days in the specified month and year\n",
    "    month_days = cal.monthdayscalendar(year, month)\n",
    "\n",
    "    # Print the month and year\n",
    "    print(calendar.month_name[month], year)\n",
    "    print(\"Su Mo Tu We Th Fr Sa\")\n",
    "\n",
    "    # Print the days in the month\n",
    "    for week in month_days:\n",
    "        week_str = \"\"\n",
    "        for day in week:\n",
    "            if day == 0:\n",
    "                week_str += \"   \"\n",
    "            else:\n",
    "                week_str += f\"{day:2} \"\n",
    "        print(week_str)\n",
    "\n",
    "# Example usage\n",
    "try:\n",
    "    year = int(input(\"Enter the year: \"))\n",
    "    month = int(input(\"Enter the month (1-12): \"))\n",
    "    \n",
    "    if month < 1 or month > 12:\n",
    "        raise ValueError(\"Month must be between 1 and 12.\")\n",
    "    \n",
    "    generate_calendar(year, month)\n",
    "\n",
    "except ValueError as ve:\n",
    "    print(f\"Error: {ve}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fac31fb-818f-492b-94ff-d1f45f0954e7",
   "metadata": {},
   "source": [
    "40. Write a program that generates the prime factors of a given number using trial division."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd5ca675-d38c-4b85-84b3-0b3733a3b745",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prime_factors(n):\n",
    "    \"\"\"Generate the prime factors of a given number using trial division.\"\"\"\n",
    "    factors = []\n",
    "    \n",
    "    # Check for number of 2s that divide n\n",
    "    while n % 2 == 0:\n",
    "        factors.append(2)\n",
    "        n //= 2\n",
    "\n",
    "    # n must be odd at this point, thus skip even numbers\n",
    "    for i in range(3, int(n**0.5) + 1, 2):\n",
    "        while n % i == 0:\n",
    "            factors.append(i)\n",
    "            n //= i\n",
    "    \n",
    "    # This condition is to check if n is a prime number greater than 2\n",
    "    if n > 2:\n",
    "        factors.append(n)\n",
    "    \n",
    "    return factors\n",
    "\n",
    "# Example usage\n",
    "try:\n",
    "    number = int(input(\"Enter a number to find its prime factors: \"))\n",
    "    if number <= 0:\n",
    "        raise ValueError(\"Number must be greater than 0.\")\n",
    "    \n",
    "    result = prime_factors(number)\n",
    "    print(f\"The prime factors of {number} are: {result}\")\n",
    "\n",
    "except ValueError as ve:\n",
    "    print(f\"Error: {ve}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43cfe010-a1f1-4f50-98ca-ffb9ad8b2c72",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}