3rd_Sept_Python_Control_Flow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "85288a2a",
   "metadata": {},
   "source": [
    "# Basic If-Else Statmeents:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e5ba932",
   "metadata": {},
   "source": [
    "#### 1. Write a Python program to check if a given number is positive or negative.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "99a0630f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number is Negative\n"
     ]
    }
   ],
   "source": [
    "number = -20\n",
    "\n",
    "if number < 0: \n",
    "    print('Number is Negative')\n",
    "else:\n",
    "    print('Number is Positive')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f6ae259",
   "metadata": {},
   "source": [
    "#### 2. Create a program that determines if a person is eligible to vote based on their age.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ab312600",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Person is not eligible\n"
     ]
    }
   ],
   "source": [
    "age = 21\n",
    "\n",
    "if age <20:\n",
    "    print('Person is Eligible')\n",
    "else:\n",
    "    print('Person is not eligible')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4802c04e",
   "metadata": {},
   "source": [
    "#### 3. Develop a program to find the maximum of two numbers using if-else statements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f7dc68a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B is Max\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "b = 20\n",
    "\n",
    "if a>b:\n",
    "    print('A is max')\n",
    "else:\n",
    "    print('B is Max')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24602692",
   "metadata": {},
   "source": [
    "#### 4. Write a Python script to classify a given year as a leap year or not.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d2e388b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Its a Leap Year\n"
     ]
    }
   ],
   "source": [
    "year = 400\n",
    "\n",
    "if (year%4 ==0 and year%100 != 0) or (year%400 == 0):\n",
    "    print('Its a Leap Year')\n",
    "else:\n",
    "    print('its not leap year')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22a4dd41",
   "metadata": {},
   "source": [
    "#### 5. Create a program that checks whether a character is a vowel or a consonant.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "14ac025c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Character is Consonant\n"
     ]
    }
   ],
   "source": [
    "char = 'z'\n",
    "if char.lower() in ['a','e','i','o','u']:\n",
    "    print('Character is Vowel')\n",
    "else: \n",
    "    print('Character is Consonant')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21d0d65d",
   "metadata": {},
   "source": [
    "#### 6. Implement a program to determine whether a given number is even or odd.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "36cacfcd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number is even\n"
     ]
    }
   ],
   "source": [
    "number = 10\n",
    "\n",
    "if number%2 == 0:\n",
    "    print('number is even')\n",
    "else:\n",
    "    print('Number is odd')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d72bbd38",
   "metadata": {},
   "source": [
    "#### 7. Write a Python function to calculate the absolute value of a number without using the `abs()` function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "7fc604f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "number = -20\n",
    "if number < 0:\n",
    "    number = -number\n",
    "\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92dcdb1e",
   "metadata": {},
   "source": [
    "#### 8. Develop a program that determines the largest of three given numbers using if-else statements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "0e7001c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B is greatest\n"
     ]
    }
   ],
   "source": [
    "a,b,c = 10,40,30\n",
    "\n",
    "if a>b and a>c:\n",
    "    print('A is greatest')\n",
    "else:\n",
    "    if b>a and b>c:\n",
    "        print('B is greatest')\n",
    "    else:\n",
    "        print('C is greatest')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c61d2971",
   "metadata": {},
   "source": [
    "#### 9. Create a program that checks if a given string is a palindrome.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "2f7a7aee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String is Palindrome\n"
     ]
    }
   ],
   "source": [
    "string = 'level'\n",
    "\n",
    "if string.lower() == string[::-1].lower():\n",
    "    print('String is Palindrome')\n",
    "else:\n",
    "    print('String is Not Palindrome')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a56b7cf",
   "metadata": {},
   "source": [
    "#### 10. Write a Python program to calculate the grade based on a student's score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "26b4a199",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The student's grade is: B\n"
     ]
    }
   ],
   "source": [
    "score = 80\n",
    "\n",
    "if score >= 90:\n",
    "    grade = 'A'\n",
    "else:\n",
    "    if score >= 80:\n",
    "        grade = 'B'\n",
    "    else:\n",
    "        if score >= 70:\n",
    "            grade = 'C'\n",
    "        else:\n",
    "            if score >= 60:\n",
    "                grade = 'D'\n",
    "            else:\n",
    "                grade = 'F'\n",
    "\n",
    "print(f\"The student's grade is: {grade}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e93b77e",
   "metadata": {},
   "source": [
    "# Nested If-Else Statements:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ddb3f2f7",
   "metadata": {},
   "source": [
    "#### 11. Write a program to find the largest among three numbers using nested if-else statements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "e152aba7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B is greatest\n"
     ]
    }
   ],
   "source": [
    "a,b,c = 10,40,30\n",
    "\n",
    "if a>b and a>c:\n",
    "    print('A is greatest')\n",
    "else:\n",
    "    if b>a and b>c:\n",
    "        print('B is greatest')\n",
    "    else:\n",
    "        print('C is greatest')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faec5cd8",
   "metadata": {},
   "source": [
    "#### 12. Implement a program to determine if a triangle is equilateral, isosceles, or scalene.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "612963ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The triangle is Isosceles.\n"
     ]
    }
   ],
   "source": [
    "a,b,c = 1,1,2\n",
    "\n",
    "# Determine the type of triangle\n",
    "if a == b == c:\n",
    "    triangle_type = \"Equilateral\"\n",
    "else:\n",
    "    if a == b or a == c or b == c:\n",
    "        triangle_type = \"Isosceles\"\n",
    "    else:\n",
    "        triangle_type = \"Scalene\"\n",
    "\n",
    "\n",
    "print(f\"The triangle is {triangle_type}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad7c4086",
   "metadata": {},
   "source": [
    "#### 13. Develop a program that checks if a year is a leap year and also if it is a century year.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "cee65e1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a year: 400\n",
      "year is leap year and century\n"
     ]
    }
   ],
   "source": [
    "# Input the year from the user\n",
    "year = int(input(\"Enter a year: \"))\n",
    "\n",
    "if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0) and year % 100 == 0:\n",
    "    print('year is leap year and century')\n",
    "else:\n",
    "    if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):\n",
    "        print('year is leap year')\n",
    "    else:\n",
    "        print('Year is Not Leap year or centuary')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2828b67",
   "metadata": {},
   "source": [
    "#### 14. Write a Python script to determine if a number is positive, negative, or zero.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "781937ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number is Negative\n"
     ]
    }
   ],
   "source": [
    "number = -20\n",
    "\n",
    "if number < 0: \n",
    "    print('Number is Negative')\n",
    "else:\n",
    "    if number == 0:\n",
    "        print('Number is zero')\n",
    "    else:\n",
    "        print('Number is Positive')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6d2acba",
   "metadata": {},
   "source": [
    "#### 15. Create a program to check if a person is a teenager (between 13 and 19 years old).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "39e8db10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Teenager\n"
     ]
    }
   ],
   "source": [
    "age = 19\n",
    "\n",
    "\n",
    "if age < 13:\n",
    "    print('Child')\n",
    "else:\n",
    "    if 13<=age<=19:\n",
    "        print('Teenager')\n",
    "    else:\n",
    "        print('Adult')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0328c22b",
   "metadata": {},
   "source": [
    "#### 16. Develop a program that determines the type of angle based on its measure (acute, obtuse, or right).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "717a1f2e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The angle with measure 20 degrees is a Acute angle.\n"
     ]
    }
   ],
   "source": [
    "angle_measure = 20\n",
    "\n",
    "\n",
    "if angle_measure < 90:\n",
    "    angle_type = \"Acute\"\n",
    "else:\n",
    "    if angle_measure == 90:\n",
    "        angle_type = \"Right\"\n",
    "    else:\n",
    "        angle_type = \"Obtuse\"\n",
    "\n",
    "print(f\"The angle with measure {angle_measure} degrees is a {angle_type} angle.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fdb16a5",
   "metadata": {},
   "source": [
    "#### 17. Write a Python program to calculate the roots of a quadratic equation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "9463b244",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the coefficient 'a': 12\n",
      "Enter the coefficient 'b': 123\n",
      "Enter the coefficient 'c': 13\n",
      "The roots are real and distinct: -0.10680394298243219 and -10.143196057017567\n"
     ]
    }
   ],
   "source": [
    "# Input the coefficients of the quadratic equation\n",
    "a = float(input(\"Enter the coefficient 'a': \"))\n",
    "b = float(input(\"Enter the coefficient 'b': \"))\n",
    "c = float(input(\"Enter the coefficient 'c': \"))\n",
    "\n",
    "discriminant = b**2 - 4*a*c\n",
    "\n",
    "if discriminant > 0:\n",
    "    root1 = (-b + (discriminant ** 0.5)) / (2 * a)\n",
    "    root2 = (-b - (discriminant ** 0.5)) / (2 * a)\n",
    "    print(f\"The roots are real and distinct: {root1} and {root2}\")\n",
    "else:\n",
    "    if discriminant == 0:\n",
    "        root = -b / (2 * a)\n",
    "        print(f\"The root is a repeated (real) root: {root}\")\n",
    "    else:\n",
    "        real_part = -b / (2 * a)\n",
    "        imaginary_part = ((-discriminant) ** 0.5) / (2 * a)\n",
    "        root1 = complex(real_part, imaginary_part)\n",
    "        root2 = complex(real_part, -imaginary_part)\n",
    "        print(f\"The roots are complex: {root1} and {root2}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a89fa807",
   "metadata": {},
   "source": [
    "#### 18. Implement a program to determine the day of the week based on a user-provided number (1 for Monday, 2 for Tuesday, etc.).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "657b0335",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number (1 for Monday, 2 for Tuesday, etc.): 2\n",
      "The day of the week is: Tuesday\n"
     ]
    }
   ],
   "source": [
    "day_number = int(input(\"Enter a number (1 for Monday, 2 for Tuesday, etc.): \"))\n",
    "\n",
    "if day_number == 1:\n",
    "    day = \"Monday\"\n",
    "elif day_number == 2:\n",
    "    day = \"Tuesday\"\n",
    "elif day_number == 3:\n",
    "    day = \"Wednesday\"\n",
    "elif day_number == 4:\n",
    "    day = \"Thursday\"\n",
    "elif day_number == 5:\n",
    "    day = \"Friday\"\n",
    "elif day_number == 6:\n",
    "    day = \"Saturday\"\n",
    "elif day_number == 7:\n",
    "    day = \"Sunday\"\n",
    "else:\n",
    "    day = \"Invalid input\"\n",
    "\n",
    "print(f\"The day of the week is: {day}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fa64014",
   "metadata": {},
   "source": [
    "#### 19. Create a program that determines if a year is a leap year and also if it is evenly divisible by 400.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "29b4a718",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a year: 404\n",
      "404 is not a leap year or not evenly divisible by 400.\n"
     ]
    }
   ],
   "source": [
    "# Input the year from the user\n",
    "year = int(input(\"Enter a year: \"))\n",
    "\n",
    "# Check if it's a leap year and evenly divisible by 400\n",
    "if year % 4 == 0 and (year % 400 == 0 or year % 100 != 0):\n",
    "    print(f\"{year} is a leap year and evenly divisible by 400.\")\n",
    "else:\n",
    "    print(f\"{year} is not a leap year or not evenly divisible by 400.\")\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebc90c48",
   "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": 83,
   "id": "4b581d0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 12\n",
      "12 is not a prime number.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "num = int(input(\"Enter a number: \"))\n",
    "\n",
    "if num > 1:\n",
    "    is_prime = True  \n",
    "    for i in range(2, num):\n",
    "        if num % i == 0:\n",
    "            is_prime = False\n",
    "            break\n",
    "    if is_prime:\n",
    "        print(f\"{num} is a prime number.\")\n",
    "    else:\n",
    "        print(f\"{num} is not a prime number.\")\n",
    "else:\n",
    "    print(f\"{num} is not a prime number.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37a81cad",
   "metadata": {},
   "source": [
    "# Elif Statements:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b06419b",
   "metadata": {},
   "source": [
    "#### 21. Write a Python program to assign grades based on different ranges of scores using elif statements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "272d603d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the student's score: 90\n",
      "The student's grade is: A\n"
     ]
    }
   ],
   "source": [
    "score = float(input(\"Enter the student's score: \"))\n",
    "\n",
    "if score >= 90:\n",
    "    grade = 'A'\n",
    "elif score >= 80:\n",
    "    grade = 'B'\n",
    "elif score >= 70:\n",
    "    grade = 'C'\n",
    "elif score >= 60:\n",
    "    grade = 'D'\n",
    "else:\n",
    "    grade = 'F'\n",
    "\n",
    "print(f\"The student's grade is: {grade}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10b9bff2",
   "metadata": {},
   "source": [
    "#### 22. Implement a program to determine the type of a triangle based on its angles.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "e47fa64d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first angle: 40\n",
      "Enter the second angle: 50\n",
      "Enter the third angle: 90\n",
      "The triangle is Scalene.\n"
     ]
    }
   ],
   "source": [
    "angle1 = int(input(\"Enter the first angle: \"))\n",
    "angle2 = int(input(\"Enter the second angle: \"))\n",
    "angle3 = int(input(\"Enter the third angle: \"))\n",
    "\n",
    "# Determine the type of triangle based on angles\n",
    "if angle1 + angle2 + angle3 == 180:\n",
    "    if angle1 == angle2 == angle3:\n",
    "        triangle_type = \"Equilateral\"\n",
    "    elif angle1 == angle2 or angle1 == angle3 or angle2 == angle3:\n",
    "        triangle_type = \"Isosceles\"\n",
    "    else:\n",
    "        triangle_type = \"Scalene\"\n",
    "else:\n",
    "    triangle_type = \"Invalid\"\n",
    "\n",
    "print(f\"The triangle is {triangle_type}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a34cb6a",
   "metadata": {},
   "source": [
    "#### 23. Develop a program to categorize a given person's BMI into underweight, normal, overweight, or obese using elif statements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "16f41689",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the person's weight (kg): 52\n",
      "Enter the person's height (m): 175\n",
      "The person's BMI category is: Underweight\n"
     ]
    }
   ],
   "source": [
    "weight = float(input(\"Enter the person's weight (kg): \"))\n",
    "height = float(input(\"Enter the person's height (m): \"))\n",
    "\n",
    "bmi = weight / (height ** 2)\n",
    "\n",
    "# Categorize BMI\n",
    "if bmi < 18.5:\n",
    "    category = \"Underweight\"\n",
    "elif 18.5 <= bmi < 24.9:\n",
    "    category = \"Normal Weight\"\n",
    "elif 25 <= bmi < 29.9:\n",
    "    category = \"Overweight\"\n",
    "else:\n",
    "    category = \"Obese\"\n",
    "\n",
    "print(f\"The person's BMI category is: {category}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95022903",
   "metadata": {},
   "source": [
    "#### 24. Create a program that determines whether a given number is positive, negative, or zero using elif statements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e3ac585",
   "metadata": {},
   "outputs": [],
   "source": [
    "number = float(input(\"Enter a number: \"))\n",
    "\n",
    "if number > 0:\n",
    "    category = \"Positive\"\n",
    "elif number < 0:\n",
    "    category = \"Negative\"\n",
    "else:\n",
    "    category = \"Zero\"\n",
    "\n",
    "print(f\"The number is {category}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39230cb3",
   "metadata": {},
   "source": [
    "#### 25. Write a Python script to determine the type of a character (uppercase, lowercase, or special) using elif statements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "8da294a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a character: a\n",
      "The character is Lowercase.\n"
     ]
    }
   ],
   "source": [
    "character = input(\"Enter a character: \")\n",
    "\n",
    "if character.isalpha() and character.islower():\n",
    "        category = \"Lowercase\"\n",
    "elif character.isalpha() and character.isupper():\n",
    "        category = \"Uppercase\"\n",
    "else:\n",
    "    category = \"Special character\"\n",
    "\n",
    "print(f\"The character is {category}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "759fc4ad",
   "metadata": {},
   "source": [
    "#### 26. Implement a program to calculate the discounted price based on different purchase amounts using elif statements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53670fa0",
   "metadata": {},
   "outputs": [],
   "source": [
    "purchase_amount = float(input(\"Enter the purchase amount: \"))\n",
    "\n",
    "if purchase_amount >= 1000:\n",
    "    discount = 0.1  # 10% discount\n",
    "elif purchase_amount >= 500:\n",
    "    discount = 0.05  # 5% discount\n",
    "else:\n",
    "    discount = 0  # No discount\n",
    "\n",
    "discounted_price = purchase_amount - (purchase_amount * discount)\n",
    "\n",
    "print(f\"The discounted price is: {discounted_price}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee6dc170",
   "metadata": {},
   "source": [
    "#### 27. Develop a program to calculate the electricity bill based on different consumption slabs using elif statements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "7d943dc6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the electricity consumption (kWh): 1200\n",
      "The electricity bill is: RS 96000.00\n"
     ]
    }
   ],
   "source": [
    "# Input the electricity consumption in kWh\n",
    "consumption = float(input(\"Enter the electricity consumption (kWh): \"))\n",
    "\n",
    "if consumption <= 100:\n",
    "    rate = 40  # 40 rs per kWh\n",
    "elif consumption <= 200:\n",
    "    rate = 60  # 60 rs per kWh\n",
    "else:\n",
    "    rate = 80  # 80r s per kWh\n",
    "\n",
    "electricity_bill = consumption * rate\n",
    "\n",
    "print(f\"The electricity bill is: RS {electricity_bill:.2f}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "211c1e12",
   "metadata": {},
   "source": [
    "#### 28. Create a program to determine the type of quadrilateral based on its angles and sides using elif statements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "5f776f5a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first angle: 90\n",
      "Enter the second angle: 90\n",
      "Enter the third angle: 90\n",
      "Enter the fourth angle: 90\n",
      "Enter the length of the first side: 1\n",
      "Enter the length of the second side: 1\n",
      "Enter the length of the third side: 1\n",
      "Enter the length of the fourth side: 1\n",
      "The quadrilateral is a Square.\n"
     ]
    }
   ],
   "source": [
    "# Input the angles and sides of the quadrilateral\n",
    "angle1 = int(input(\"Enter the first angle: \"))\n",
    "angle2 = int(input(\"Enter the second angle: \"))\n",
    "angle3 = int(input(\"Enter the third angle: \"))\n",
    "angle4 = int(input(\"Enter the fourth angle: \"))\n",
    "side1 = float(input(\"Enter the length of the first side: \"))\n",
    "side2 = float(input(\"Enter the length of the second side: \"))\n",
    "side3 = float(input(\"Enter the length of the third side: \"))\n",
    "side4 = float(input(\"Enter the length of the fourth side: \"))\n",
    "\n",
    "# Determine the type of quadrilateral based on angles and sides\n",
    "if angle1 == angle2 == angle3 == angle4 == 90:\n",
    "    if side1 == side2 == side3 == side4:\n",
    "        quadrilateral_type = \"Square\"\n",
    "    elif side1 == side3 and side2 == side4:\n",
    "        quadrilateral_type = \"Rectangle\"\n",
    "    else:\n",
    "        quadrilateral_type = \"Quadrilateral\"\n",
    "elif (angle1 + angle2 + angle3 + angle4 == 360) and (side1 == side2 == side3 == side4):\n",
    "    quadrilateral_type = \"Trapezoid\"\n",
    "elif angle1 == angle2 and angle3 == angle4:\n",
    "    quadrilateral_type = \"Kite\"\n",
    "else:\n",
    "    quadrilateral_type = \"Other\"\n",
    "\n",
    "print(f\"The quadrilateral is a {quadrilateral_type}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2adfcb4c",
   "metadata": {},
   "source": [
    "#### 29. Write a Python script to determine the season based on a user-provided month using elif statements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "e4f47c68",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the month (1-12): 3\n",
      "The season for the given month is Spring.\n"
     ]
    }
   ],
   "source": [
    "# Input the month as a number (1 for January, 2 for February, etc.)\n",
    "month = int(input(\"Enter the month (1-12): \"))\n",
    "\n",
    "# Determine the season based on the month\n",
    "if 3 <= month <= 5:\n",
    "    season = \"Spring\"\n",
    "elif 6 <= month <= 8:\n",
    "    season = \"Summer\"\n",
    "elif 9 <= month <= 11:\n",
    "    season = \"Autumn\"\n",
    "else:\n",
    "    season = \"Winter\"\n",
    "\n",
    "print(f\"The season for the given month is {season}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7576b10",
   "metadata": {},
   "source": [
    "#### 30. Implement a program to determine the type of a year (leap or common) and month (30 or 31 days) using elif statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "99615971",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a year: 2022\n",
      "Enter a month (1-12): 2\n",
      "The month has 28 days.\n"
     ]
    }
   ],
   "source": [
    "# Input the year and month\n",
    "year = int(input(\"Enter a year: \"))\n",
    "month = int(input(\"Enter a month (1-12): \"))\n",
    "\n",
    "# Determine if it's a leap year\n",
    "if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):\n",
    "    is_leap_year = True\n",
    "else:\n",
    "    is_leap_year = False\n",
    "\n",
    "# Determine the number of days in the month\n",
    "if month in {1, 3, 5, 7, 8, 10, 12}:\n",
    "    days_in_month = 31\n",
    "elif month in {4, 6, 9, 11}:\n",
    "    days_in_month = 30\n",
    "else:\n",
    "    if month == 2:\n",
    "        if is_leap_year:\n",
    "            days_in_month = 29\n",
    "        else:\n",
    "            days_in_month = 28\n",
    "    else:\n",
    "        days_in_month = -1\n",
    "\n",
    "if days_in_month != -1:\n",
    "    print(f\"The month has {days_in_month} days.\")\n",
    "else:\n",
    "    print(\"Invalid month entered.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ddef858",
   "metadata": {},
   "source": [
    "# Basic Level:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d6ca5fa",
   "metadata": {},
   "source": [
    "#### 1. Write a Python program that checks if a given number is positive, negative, or zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "c415bd61",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: -10\n",
      "Negative\n"
     ]
    }
   ],
   "source": [
    "number = float(input(\"Enter a number: \"))\n",
    "\n",
    "if number > 0:\n",
    "    print(\"Positive\")\n",
    "elif number < 0:\n",
    "    print(\"Negative\")\n",
    "else:\n",
    "    print(\"Zero\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0ac2278",
   "metadata": {},
   "source": [
    "#### 2. Create a program to determine if a person is eligible to vote based on their age.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "e650300f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your age: 18\n",
      "You are not eligible to vote.\n"
     ]
    }
   ],
   "source": [
    "# Input the person's age\n",
    "age = int(input(\"Enter your age: \"))\n",
    "\n",
    "if age >= 20:\n",
    "    print(\"You are eligible to vote.\")\n",
    "else:\n",
    "    print(\"You are not eligible to vote.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffac85e6",
   "metadata": {},
   "source": [
    "#### 3. Write a program to find the maximum of two given numbers using conditional statements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "0fe19990",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The maximum number is: 2\n"
     ]
    }
   ],
   "source": [
    "# Input two numbers\n",
    "num1,num2 =1,2 \n",
    "\n",
    "\n",
    "if num1 > num2:\n",
    "    maximum = num1\n",
    "else:\n",
    "    maximum = num2\n",
    "\n",
    "print(f\"The maximum number is: {maximum}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a297f0e",
   "metadata": {},
   "source": [
    "#### 4. Develop a program that calculates the grade of a student based on their exam score.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "70922f91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your exam score: 12\n",
      "Your grade is: F\n"
     ]
    }
   ],
   "source": [
    "# Input the exam score\n",
    "score = float(input(\"Enter your exam score: \"))\n",
    "\n",
    "if score >= 90:\n",
    "    grade = \"A\"\n",
    "elif score >= 80:\n",
    "    grade = \"B\"\n",
    "elif score >= 70:\n",
    "    grade = \"C\"\n",
    "elif score >= 60:\n",
    "    grade = \"D\"\n",
    "else:\n",
    "    grade = \"F\"\n",
    "\n",
    "print(f\"Your grade is: {grade}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f68af39b",
   "metadata": {},
   "source": [
    "#### 5. Create a program that checks if a year is a leap year or not.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "49d6e9f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a year: 400\n",
      "Leap year\n"
     ]
    }
   ],
   "source": [
    "# Input a year\n",
    "year = int(input(\"Enter a year: \"))\n",
    "\n",
    "if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):\n",
    "    print(\"Leap year\")\n",
    "else:\n",
    "    print(\"Not a leap year\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1702b03c",
   "metadata": {},
   "source": [
    "#### 6. Write a program to classify a triangle based on its sides' lengths.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "5ffdcc0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The triangle is Isosceles.\n"
     ]
    }
   ],
   "source": [
    "a,b,c = 1,1,2\n",
    "\n",
    "# Determine the type of triangle\n",
    "if a == b == c:\n",
    "    triangle_type = \"Equilateral\"\n",
    "else:\n",
    "    if a == b or a == c or b == c:\n",
    "        triangle_type = \"Isosceles\"\n",
    "    else:\n",
    "        triangle_type = \"Scalene\"\n",
    "\n",
    "\n",
    "print(f\"The triangle is {triangle_type}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76502bbb",
   "metadata": {},
   "source": [
    "#### 7. Build a program that determines the largest of three given numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "7fe8f18d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first number: 1\n",
      "Enter the second number: 2\n",
      "Enter the third number: 3\n",
      "The largest number is: 3\n"
     ]
    }
   ],
   "source": [
    "# Input three numbers\n",
    "num1 = int(input(\"Enter the first number: \"))\n",
    "num2 = int(input(\"Enter the second number: \"))\n",
    "num3 = int(input(\"Enter the third number: \"))\n",
    "\n",
    "if num1 >= num2 and num1 >= num3:\n",
    "    largest = num1\n",
    "elif num2 >= num1 and num2 >= num3:\n",
    "    largest = num2\n",
    "else:\n",
    "    largest = num3\n",
    "\n",
    "print(f\"The largest number is: {largest}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a764d42a",
   "metadata": {},
   "source": [
    "#### 8. Develop a program that checks whether a character is a vowel or a consonant.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "4b9976bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a character: A\n",
      "Vowel\n"
     ]
    }
   ],
   "source": [
    "# Input a character\n",
    "char = input(\"Enter a character: \")\n",
    "\n",
    "if char in \"aeiouAEIOU\":\n",
    "    print(\"Vowel\")\n",
    "else:\n",
    "    print(\"Consonant\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9e38f10",
   "metadata": {},
   "source": [
    "#### 9. Create a program to calculate the total cost of a shopping cart based on discounts.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "b9462cf3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the purchase amount: 1200\n",
      "The discounted price is: 1080.0\n"
     ]
    }
   ],
   "source": [
    "purchase_amount = float(input(\"Enter the purchase amount: \"))\n",
    "\n",
    "if purchase_amount >= 1000:\n",
    "    discount = 0.1  # 10% discount\n",
    "elif purchase_amount >= 500:\n",
    "    discount = 0.05  # 5% discount\n",
    "else:\n",
    "    discount = 0  # No discount\n",
    "\n",
    "discounted_price = purchase_amount - (purchase_amount * discount)\n",
    "\n",
    "print(f\"The discounted price is: {discounted_price}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43f49440",
   "metadata": {},
   "source": [
    "#### 10. Write a program that checks if a given number is even or odd."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "03569527",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 12\n",
      "Even\n"
     ]
    }
   ],
   "source": [
    "# Input a number\n",
    "number = int(input(\"Enter a number: \"))\n",
    "\n",
    "if number % 2 == 0:\n",
    "    print(\"Even\")\n",
    "else:\n",
    "    print(\"Odd\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5373707f",
   "metadata": {},
   "source": [
    "# Intermediate Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2050669",
   "metadata": {},
   "source": [
    "#### 11. Write a program that calculates the roots of a quadratic equation .\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "5e0a1e7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the coefficient 'a': 1\n",
      "Enter the coefficient 'b': 2\n",
      "Enter the coefficient 'c': 3\n",
      "The roots are complex: (-1+1.4142135623730951j) and (-1-1.4142135623730951j)\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "a = float(input(\"Enter the coefficient 'a': \"))\n",
    "b = float(input(\"Enter the coefficient 'b': \"))\n",
    "c = float(input(\"Enter the coefficient 'c': \"))\n",
    "\n",
    "discriminant = b**2 - 4*a*c\n",
    "\n",
    "# Check the nature of roots\n",
    "if discriminant > 0:\n",
    "    root1 = (-b + math.sqrt(discriminant)) / (2*a)\n",
    "    root2 = (-b - math.sqrt(discriminant)) / (2*a)\n",
    "    print(f\"The roots are real and distinct: {root1} and {root2}\")\n",
    "elif discriminant == 0:\n",
    "    root = -b / (2*a)\n",
    "    print(f\"The root is real and repeated: {root}\")\n",
    "else:\n",
    "    real_part = -b / (2*a)\n",
    "    imaginary_part = math.sqrt(abs(discriminant)) / (2*a)\n",
    "    root1 = complex(real_part, imaginary_part)\n",
    "    root2 = complex(real_part, -imaginary_part)\n",
    "    print(f\"The roots are complex: {root1} and {root2}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1072020c",
   "metadata": {},
   "source": [
    "#### 12. Create a program that determines the day of the week based on the day number (1-7).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "27af4fd8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the day number (1-7): 4\n",
      "The day is Thursday\n"
     ]
    }
   ],
   "source": [
    "day_number = int(input(\"Enter the day number (1-7): \"))\n",
    "\n",
    "days_of_week = [\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\", \"Sunday\"]\n",
    "\n",
    "if 1 <= day_number <= 7:\n",
    "    day = days_of_week[day_number - 1]\n",
    "    print(f\"The day is {day}\")\n",
    "else:\n",
    "    print(\"Invalid day number.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1728a0cd",
   "metadata": {},
   "source": [
    "#### 13. Develop a program that calculates the factorial of a given number using recursion.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "12384bcc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 12\n",
      "The factorial of 12 is 479001600\n"
     ]
    }
   ],
   "source": [
    "def factorial(n):\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return n * factorial(n - 1)\n",
    "\n",
    "# Input a number\n",
    "num = int(input(\"Enter a number: \"))\n",
    "\n",
    "if num < 0:\n",
    "    print(\"Factorial is not defined for negative numbers.\")\n",
    "else:\n",
    "    result = factorial(num)\n",
    "    print(f\"The factorial of {num} is {result}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c56c4e52",
   "metadata": {},
   "source": [
    "#### 14. Write a program to find the largest among three numbers without using the `max()` function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "474de854",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first number: 14\n",
      "Enter the second number: 12\n",
      "Enter the third number: 10\n",
      "The largest number is: 14\n"
     ]
    }
   ],
   "source": [
    "# Input three numbers\n",
    "num1 = int(input(\"Enter the first number: \"))\n",
    "num2 = int(input(\"Enter the second number: \"))\n",
    "num3 = int(input(\"Enter the third number: \"))\n",
    "\n",
    "if num1 > num2 and num1 > num3:\n",
    "    largest = num1\n",
    "elif num2 > num3 and num2 > num1:\n",
    "    largest = num2\n",
    "else:\n",
    "    largest = num3\n",
    "\n",
    "print(f\"The largest number is: {largest}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18979ca6",
   "metadata": {},
   "source": [
    "#### 15. Create a program that simulates a basic ATM transaction menu.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "20ef9f66",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to the ATM\n",
      "1. Check Balance\n",
      "2. Withdraw Money\n",
      "3. Deposit Money\n",
      "4. Quit\n",
      "Enter your choice: 1\n",
      "Your balance is: $1000\n",
      "Welcome to the ATM\n",
      "1. Check Balance\n",
      "2. Withdraw Money\n",
      "3. Deposit Money\n",
      "4. Quit\n",
      "Enter your choice: 2\n",
      "Enter the amount to withdraw: 12\n",
      "Withdrew: $12.0\n",
      "Welcome to the ATM\n",
      "1. Check Balance\n",
      "2. Withdraw Money\n",
      "3. Deposit Money\n",
      "4. Quit\n",
      "Enter your choice: 1\n",
      "Your balance is: $988.0\n",
      "Welcome to the ATM\n",
      "1. Check Balance\n",
      "2. Withdraw Money\n",
      "3. Deposit Money\n",
      "4. Quit\n",
      "Enter your choice: 4\n",
      "Thank you for using the ATM.\n"
     ]
    }
   ],
   "source": [
    "# ATM balance\n",
    "balance = 1000\n",
    "\n",
    "while True:\n",
    "    print(\"Welcome to the ATM\")\n",
    "    print(\"1. Check Balance\")\n",
    "    print(\"2. Withdraw Money\")\n",
    "    print(\"3. Deposit Money\")\n",
    "    print(\"4. Quit\")\n",
    "    choice = int(input(\"Enter your choice: \"))\n",
    "\n",
    "    if choice == 1:\n",
    "        print(f\"Your balance is: ${balance}\")\n",
    "    elif choice == 2:\n",
    "        amount = float(input(\"Enter the amount to withdraw: \"))\n",
    "        if amount <= balance:\n",
    "            balance -= amount\n",
    "            print(f\"Withdrew: ${amount}\")\n",
    "        else:\n",
    "            print(\"Insufficient balance.\")\n",
    "    elif choice == 3:\n",
    "        amount = float(input(\"Enter the amount to deposit: \"))\n",
    "        balance += amount\n",
    "        print(f\"Deposited: ${amount}\")\n",
    "    elif choice == 4:\n",
    "        print(\"Thank you for using the ATM.\")\n",
    "        break\n",
    "    else:\n",
    "        print(\"Invalid choice. Please select a valid option.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b550d0a",
   "metadata": {},
   "source": [
    "#### 16. Build a program that checks if a given string is a palindrome or not.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af723ddf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Input a string\n",
    "string = input(\"Enter a string: \")\n",
    "\n",
    "cleaned_string = ''.join(string.split()).lower()\n",
    "\n",
    "if cleaned_string == cleaned_string[::-1]:\n",
    "    print(\"The string is a palindrome.\")\n",
    "else:\n",
    "    print(\"The string is not a palindrome.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ab5e57d",
   "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": 137,
   "id": "c1e632b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a list of numbers separated by spaces:  4 2 1 2 3 3\n",
      "The average (excluding the smallest and largest values) is: 2.50\n"
     ]
    }
   ],
   "source": [
    "# Input a list of numbers\n",
    "numbers = [float(x) for x in input(\"Enter a list of numbers separated by spaces: \").split()]\n",
    "\n",
    "if len(numbers) < 3:\n",
    "    print(\"At least three numbers are required.\")\n",
    "else:\n",
    "    numbers.sort()\n",
    "    # Exclude the smallest and largest values\n",
    "    trimmed_numbers = numbers[1:-1]\n",
    "    average = sum(trimmed_numbers) / len(trimmed_numbers)\n",
    "    print(f\"The average (excluding the smallest and largest values) is: {average:.2f}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fa836b8",
   "metadata": {},
   "source": [
    "#### 18. Develop a program that converts a given temperature from Celsius to Fahrenheit.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "0912e7e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter temperature in Celsius: 12\n",
      "12.0°C is equal to 53.6°F.\n"
     ]
    }
   ],
   "source": [
    "# Input temperature in Celsius\n",
    "celsius = float(input(\"Enter temperature in Celsius: \"))\n",
    "\n",
    "# Convert to Fahrenheit\n",
    "fahrenheit = (celsius * 9/5) + 32\n",
    "\n",
    "print(f\"{celsius}°C is equal to {fahrenheit}°F.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ccdedb6",
   "metadata": {},
   "source": [
    "#### 19. Create a program that simulates a basic calculator for addition, subtraction, multiplication, and division.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "899d970b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first number: 12.2\n",
      "Enter the second number: 212\n",
      "Enter the operation (+, -, *, /): *\n",
      "Result: 2586.3999999999996\n"
     ]
    }
   ],
   "source": [
    "# Input two numbers\n",
    "num1 = float(input(\"Enter the first number: \"))\n",
    "num2 = float(input(\"Enter the second number: \"))\n",
    "\n",
    "operation = input(\"Enter the operation (+, -, *, /): \")\n",
    "\n",
    "if operation == '+':\n",
    "    result = num1 + num2\n",
    "elif operation == '-':\n",
    "    result = num1 - num2\n",
    "elif operation == '*':\n",
    "    result = num1 * num2\n",
    "elif operation == '/':\n",
    "    if num2 != 0:\n",
    "        result = num1 / num2\n",
    "    else:\n",
    "        result = \"Division by zero is not allowed.\"\n",
    "else:\n",
    "    result = \"Invalid operation.\"\n",
    "\n",
    "print(f\"Result: {result}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "478c136f",
   "metadata": {},
   "source": [
    "#### 20. Write a program that determines the roots of a cubic equation using the Cardano formula."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "162f15c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the coefficient 'a': 1\n",
      "Enter the coefficient 'b': 2\n",
      "Enter the coefficient 'c': 3\n",
      "Enter the coefficient 'd': 4\n",
      "The roots are: 1.0784076850393964, -2.4117410183727297, and (-0.4139870394480636+0.4376539523801843j)\n"
     ]
    }
   ],
   "source": [
    "# Input coefficients of the cubic equation\n",
    "a = float(input(\"Enter the coefficient 'a': \"))\n",
    "b = float(input(\"Enter the coefficient 'b': \"))\n",
    "c = float(input(\"Enter the coefficient 'c': \"))\n",
    "d = float(input(\"Enter the coefficient 'd': \"))\n",
    "\n",
    "discriminant1 = b**2 - 3*a*c\n",
    "discriminant2 = 2*b**3 - 9*a*b*c + 27*a**2*d\n",
    "discriminant = discriminant2**2 - 4*discriminant1**3\n",
    "\n",
    "if discriminant > 0:\n",
    "    root1 = (-1*b + (discriminant2 + discriminant**0.5)**(1/3)) / (3*a)\n",
    "    root2 = (-1*b - (discriminant2 + discriminant**0.5)**(1/3)) / (3*a)\n",
    "    root3 = (-1*b + (discriminant2 - discriminant**0.5)**(1/3)) / (3*a)\n",
    "    print(f\"The roots are: {root1}, {root2}, and {root3}\")\n",
    "elif discriminant == 0:\n",
    "    root1 = (-1*b + (discriminant2 + discriminant**0.5)**(1/3)) / (3*a)\n",
    "    root2 = (-1*b - (discriminant2 + discriminant**0.5)**(1/3)) / (3*a)\n",
    "    print(f\"The roots are: {root1} (real) and {root2} (repeated)\")\n",
    "else:\n",
    "    real_part = -1*b / (3*a)\n",
    "    imaginary_part = (3**0.5 * (-discriminant2 + 1j * (-discriminant)**0.5)) / (6*a)\n",
    "    root1 = complex(real_part, imaginary_part)\n",
    "    root2 = complex(real_part, -imaginary_part)\n",
    "    root3 = complex(real_part, (discriminant2 + 1j * (abs(discriminant))**0.5) / (6*a))\n",
    "    print(f\"The roots are: {root1}, {root2}, and {root3} (complex)\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cfb6282",
   "metadata": {},
   "source": [
    "# Advanced Level:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc153f41",
   "metadata": {},
   "source": [
    "#### 21. Create a program that calculates the income tax based on the user's income and tax brackets.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "a9980260",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your income: 34000\n",
      "Your income tax is: Rs7800.00\n"
     ]
    }
   ],
   "source": [
    "# Input the user's income\n",
    "income = float(input(\"Enter your income: \"))\n",
    "\n",
    "# Define tax brackets and rates\n",
    "tax_brackets = [(0, 10000), (10001, 40000), (40001, 80000), (80001, float('inf'))]\n",
    "tax_rates = [0.10, 0.20, 0.30, 0.40]\n",
    "\n",
    "# Calculate income tax\n",
    "tax = 0\n",
    "for i in range(len(tax_brackets)):\n",
    "    lower_limit, upper_limit = tax_brackets[i]\n",
    "    rate = tax_rates[i]\n",
    "    if income <= upper_limit:\n",
    "        tax += rate * income\n",
    "        break\n",
    "    else:\n",
    "        tax += rate * (upper_limit - lower_limit)\n",
    "\n",
    "print(f\"Your income tax is: Rs{tax:.2f}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e606cd3b",
   "metadata": {},
   "source": [
    "#### 22. Write a program that simulates a rock-paper-scissors game against the computer.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "fda0ce1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Choose rock, paper, or scissors: rock\n",
      "It's a tie!\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "# User's choice\n",
    "user_choice = input(\"Choose rock, paper, or scissors: \").lower()\n",
    "\n",
    "# Computer's choice\n",
    "choices = [\"rock\", \"paper\", \"scissors\"]\n",
    "computer_choice = random.choice(choices)\n",
    "\n",
    "# Determine the winner\n",
    "if user_choice in choices:\n",
    "    if user_choice == computer_choice:\n",
    "        result = \"It's a tie!\"\n",
    "    elif (user_choice == \"rock\" and computer_choice == \"scissors\") or (user_choice == \"scissors\" and computer_choice == \"paper\") or (user_choice == \"paper\" and computer_choice == \"rock\"):\n",
    "        result = f\"You win! Computer chose {computer_choice}.\"\n",
    "    else:\n",
    "        result = f\"Computer wins! Computer chose {computer_choice}.\"\n",
    "else:\n",
    "    result = \"Invalid choice. Please choose rock, paper, or scissors.\"\n",
    "\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1a7f9b8",
   "metadata": {},
   "source": [
    "#### 23. Develop a program that generates a random password based on user preferences (length, complexity).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "e486fd37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the desired password length: 12\n",
      "Include digits? (yes/no): yes\n",
      "Include letters? (yes/no): yes\n",
      "Include special characters? (yes/no): yes\n",
      "Your generated password is: 1rlD?55$\"C?4\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import string\n",
    "\n",
    "# Input password length and complexity\n",
    "password_length = int(input(\"Enter the desired password length: \"))\n",
    "use_digits = input(\"Include digits? (yes/no): \").lower() == \"yes\"\n",
    "use_letters = input(\"Include letters? (yes/no): \").lower() == \"yes\"\n",
    "use_special_chars = input(\"Include special characters? (yes/no): \").lower() == \"yes\"\n",
    "\n",
    "# Define character sets\n",
    "characters = \"\"\n",
    "if use_digits:\n",
    "    characters += string.digits\n",
    "if use_letters:\n",
    "    characters += string.ascii_letters\n",
    "if use_special_chars:\n",
    "    characters += string.punctuation\n",
    "\n",
    "# Generate the password\n",
    "password = ''.join(random.choice(characters) for _ in range(password_length))\n",
    "\n",
    "print(f\"Your generated password is: {password}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05d705df",
   "metadata": {},
   "source": [
    "#### 24. Create a program that implements a simple text-based adventure game with branching scenarios.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "3cf42be6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to the Adventure Game!\n",
      "\n",
      "You find yourself at a crossroads. What do you do?\n",
      "1. Go left\n",
      "2. Go right\n",
      "3. Quit\n",
      "Enter your choice: 1\n",
      "You chose to go left. You discover a hidden treasure!\n",
      "\n",
      "You find yourself at a crossroads. What do you do?\n",
      "1. Go left\n",
      "2. Go right\n",
      "3. Quit\n",
      "Enter your choice: 1\n",
      "You chose to go left. You discover a hidden treasure!\n",
      "\n",
      "You find yourself at a crossroads. What do you do?\n",
      "1. Go left\n",
      "2. Go right\n",
      "3. Quit\n",
      "Enter your choice: 1\n",
      "You chose to go left. You discover a hidden treasure!\n",
      "\n",
      "You find yourself at a crossroads. What do you do?\n",
      "1. Go left\n",
      "2. Go right\n",
      "3. Quit\n",
      "Enter your choice: 1\n",
      "You chose to go left. You discover a hidden treasure!\n",
      "\n",
      "You find yourself at a crossroads. What do you do?\n",
      "1. Go left\n",
      "2. Go right\n",
      "3. Quit\n",
      "Enter your choice: 1\n",
      "You chose to go left. You discover a hidden treasure!\n",
      "\n",
      "You find yourself at a crossroads. What do you do?\n",
      "1. Go left\n",
      "2. Go right\n",
      "3. Quit\n",
      "Enter your choice: 1\n",
      "You chose to go left. You discover a hidden treasure!\n",
      "\n",
      "You find yourself at a crossroads. What do you do?\n",
      "1. Go left\n",
      "2. Go right\n",
      "3. Quit\n",
      "Enter your choice: 1\n",
      "You chose to go left. You discover a hidden treasure!\n",
      "\n",
      "You find yourself at a crossroads. What do you do?\n",
      "1. Go left\n",
      "2. Go right\n",
      "3. Quit\n",
      "Enter your choice: 1\n",
      "You chose to go left. You discover a hidden treasure!\n",
      "\n",
      "You find yourself at a crossroads. What do you do?\n",
      "1. Go left\n",
      "2. Go right\n",
      "3. Quit\n",
      "Enter your choice: 2\n",
      "You chose to go right. You encounter a dragon and must run back!\n",
      "\n",
      "You find yourself at a crossroads. What do you do?\n",
      "1. Go left\n",
      "2. Go right\n",
      "3. Quit\n",
      "Enter your choice: 1\n",
      "You chose to go left. You discover a hidden treasure!\n",
      "\n",
      "You find yourself at a crossroads. What do you do?\n",
      "1. Go left\n",
      "2. Go right\n",
      "3. Quit\n",
      "Enter your choice: 3\n",
      "Thanks for playing! Goodbye!\n"
     ]
    }
   ],
   "source": [
    "print(\"Welcome to the Adventure Game!\")\n",
    "\n",
    "while True:\n",
    "    print(\"\\nYou find yourself at a crossroads. What do you do?\")\n",
    "    choice = input(\"1. Go left\\n2. Go right\\n3. Quit\\nEnter your choice: \")\n",
    "\n",
    "    if choice == \"1\":\n",
    "        print(\"You chose to go left. You discover a hidden treasure!\")\n",
    "    elif choice == \"2\":\n",
    "        print(\"You chose to go right. You encounter a dragon and must run back!\")\n",
    "    elif choice == \"3\":\n",
    "        print(\"Thanks for playing! Goodbye!\")\n",
    "        break\n",
    "    else:\n",
    "        print(\"Invalid choice. Please select a valid option.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fcda8c0",
   "metadata": {},
   "source": [
    "#### 25. Build a program that solves a linear equation for x, considering different cases.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "9a3fbcf2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the coefficient 'a': 12\n",
      "Enter the coefficient 'b': 1\n",
      "The solution for x is: -0.08333333333333333\n"
     ]
    }
   ],
   "source": [
    "# Input coefficients\n",
    "a = float(input(\"Enter the coefficient 'a': \"))\n",
    "b = float(input(\"Enter the coefficient 'b': \"))\n",
    "\n",
    "if a == 0:\n",
    "    if b == 0:\n",
    "        print(\"Infinite solutions (line overlaps with the x-axis).\")\n",
    "    else:\n",
    "        print(\"No solution (line is parallel to the x-axis).\")\n",
    "else:\n",
    "    x = -b / a\n",
    "    print(f\"The solution for x is: {x}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d99a9faa",
   "metadata": {},
   "source": [
    "#### 26. Write a program that simulates a basic quiz game with multiple-choice questions and scoring.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "4b8236ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question 1: What is the capital of France?\n",
      "Options: a) Paris b) London c) Berlin\n",
      "Your answer (a, b, c): paris\n",
      "Correct!\n",
      "\n",
      "Question 2: Which planet is known as the Red Planet?\n",
      "Options: a) Venus b) Earth c) Mars\n",
      "Your answer (a, b, c): mars\n",
      "Correct!\n",
      "\n",
      "Question 3: What is the largest mammal in the world?\n",
      "Options: a) Elephant b) Giraffe c) Blue whale\n",
      "Your answer (a, b, c): whale\n",
      "Wrong. The correct answer is Blue whale\n",
      "\n",
      "Your score is 2/3\n"
     ]
    }
   ],
   "source": [
    "# Quiz questions and answers\n",
    "questions = [\"What is the capital of France?\",\n",
    "             \"Which planet is known as the Red Planet?\",\n",
    "             \"What is the largest mammal in the world?\"]\n",
    "answers = [\"Paris\", \"Mars\", \"Blue whale\"]\n",
    "options = [[\"a) Paris b) London c) Berlin\", \"a) Venus b) Earth c) Mars\", \"a) Elephant b) Giraffe c) Blue whale\"]]\n",
    "\n",
    "# Initialize score\n",
    "score = 0\n",
    "\n",
    "# Iterate through questions\n",
    "for i, question in enumerate(questions):\n",
    "    print(f\"Question {i + 1}: {question}\")\n",
    "    print(\"Options:\", options[0][i])\n",
    "    user_answer = input(\"Your answer (a, b, c): \").lower()\n",
    "    if user_answer == answers[i].lower():\n",
    "        score += 1\n",
    "        print(\"Correct!\\n\")\n",
    "    else:\n",
    "        print(f\"Wrong. The correct answer is {answers[i]}\\n\")\n",
    "\n",
    "print(f\"Your score is {score}/{len(questions)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7245bad6",
   "metadata": {},
   "source": [
    "#### 27. Develop a program that determines whether a given year is a prime number or not.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "c2b5c34e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a year: 13\n",
      "13 is a prime year.\n"
     ]
    }
   ],
   "source": [
    "# Input a year\n",
    "year = int(input(\"Enter a year: \"))\n",
    "\n",
    "if year > 1:\n",
    "    for i in range(2, int(year**0.5) + 1):\n",
    "        if (year % i) == 0:\n",
    "            print(f\"{year} is not a prime year.\")\n",
    "            break\n",
    "    else:\n",
    "        print(f\"{year} is a prime year.\")\n",
    "else:\n",
    "    print(f\"{year} is not a year .\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b844c313",
   "metadata": {},
   "source": [
    "#### 28. Create a program that sorts three numbers in ascending order using conditional statements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "4ece8006",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first number: 3\n",
      "Enter the second number: 2\n",
      "Enter the third number: 1\n",
      "The numbers in ascending order are: [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "# Input three numbers\n",
    "num1 = int(input(\"Enter the first number: \"))\n",
    "num2 = int(input(\"Enter the second number: \"))\n",
    "num3 = int(input(\"Enter the third number: \"))\n",
    "\n",
    "if num1 <= num2 <= num3:\n",
    "    sorted_numbers = [num1, num2, num3]\n",
    "elif num1 <= num3 <= num2:\n",
    "    sorted_numbers = [num1, num3, num2]\n",
    "elif num2 <= num1 <= num3:\n",
    "    sorted_numbers = [num2, num1, num3]\n",
    "elif num2 <= num3 <= num1:\n",
    "    sorted_numbers = [num2, num3, num1]\n",
    "elif num3 <= num1 <= num2:\n",
    "    sorted_numbers = [num3, num1, num2]\n",
    "else:\n",
    "    sorted_numbers = [num3, num2, num1]\n",
    "\n",
    "print(f\"The numbers in ascending order are: {sorted_numbers}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "317d23fe",
   "metadata": {},
   "source": [
    "#### 29. Build a program that determines the roots of a quartic equation using numerical methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "dbf743f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The roots of the quartic equation are: [-0.75 - 0.661437827766148*I, -0.75 + 0.661437827766148*I, 0.666666666666667 - 0.942809041582063*I, 0.666666666666667 + 0.942809041582063*I]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import sympy as sp\n",
    "\n",
    "b = 2\n",
    "c = 4\n",
    "d = 8\n",
    "e = 16\n",
    "\n",
    "x = sp.symbols('x')\n",
    "\n",
    "# Create the quartic equation\n",
    "quartic_equation = a * x**4 + b * x**3 + c * x**2 + d * x + e\n",
    "\n",
    "# Find the roots using sympy\n",
    "roots = sp.solve(quartic_equation, x)\n",
    "\n",
    "print(f\"The roots of the quartic equation are: {roots}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7598c29",
   "metadata": {},
   "source": [
    "#### 30. Write a program that calculates the BMI (Body Mass Index) and provides health recommendations based on the user's input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "88c8bb52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your weight (kg): 50\n",
      "Enter your height (m): 1.8\n",
      "Your BMI is 15.43, which falls into the category of Underweight. You should consider gaining weight.\n"
     ]
    }
   ],
   "source": [
    "# Input weight (kg) and height (m)\n",
    "weight = float(input(\"Enter your weight (kg): \"))\n",
    "height = float(input(\"Enter your height (m): \"))\n",
    "\n",
    "# Calculate BMI\n",
    "bmi = weight / (height ** 2)\n",
    "\n",
    "# Determine BMI category and provide recommendations\n",
    "if bmi < 18.5:\n",
    "    category = \"Underweight\"\n",
    "    recommendation = \"You should consider gaining weight.\"\n",
    "elif 18.5 <= bmi < 24.9:\n",
    "    category = \"Normal weight\"\n",
    "    recommendation = \"You have a healthy weight.\"\n",
    "elif 25 <= bmi < 29.9:\n",
    "    category = \"Overweight\"\n",
    "    recommendation = \"You should consider losing weight.\"\n",
    "else:\n",
    "    category = \"Obese\"\n",
    "    recommendation = \"You should consult a healthcare professional for weight management.\"\n",
    "\n",
    "print(f\"Your BMI is {bmi:.2f}, which falls into the category of {category}. {recommendation}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c11421f",
   "metadata": {},
   "source": [
    "# Challenge Level:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af73dde8",
   "metadata": {},
   "source": [
    "#### 31. Create a program that validates a password based on complexity rules (length, characters, etc.).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a49c5042",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "# Input a password\n",
    "password = input(\"Enter a password: \")\n",
    "\n",
    "# Define password complexity rules\n",
    "length_rule = len(password) >= 8\n",
    "uppercase_rule = bool(re.search(r'[A-Z]', password))\n",
    "lowercase_rule = bool(re.search(r'[a-z]', password))\n",
    "digit_rule = bool(re.search(r'\\d', password))\n",
    "special_char_rule = bool(re.search(r'[!@#$%^&*(),.?\":{}|<>]', password))\n",
    "\n",
    "# Validate the password\n",
    "if length_rule and uppercase_rule and lowercase_rule and digit_rule and special_char_rule:\n",
    "    print(\"Password is valid.\")\n",
    "else:\n",
    "    print(\"Password is invalid. Please follow the complexity rules.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00d05d07",
   "metadata": {},
   "source": [
    "#### 32. Develop a program that performs matrix addition and subtraction based on user input.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "571351d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number of rows: 2\n",
      "Enter the number of columns: 2\n",
      "Enter elements of matrix 1:\n",
      "Matrix 1[0][0]: 1\n",
      "Matrix 1[0][1]: 1\n",
      "Matrix 1[1][0]: 1\n",
      "Matrix 1[1][1]: 1\n",
      "Enter elements of matrix 2:\n",
      "Matrix 2[0][0]: 1\n",
      "Matrix 2[0][1]: 1\n",
      "Matrix 2[1][0]: 1\n",
      "Matrix 2[1][1]: 1\n",
      "Matrix Addition:\n",
      "[[2. 2.]\n",
      " [2. 2.]]\n",
      "Matrix Subtraction:\n",
      "[[0. 0.]\n",
      " [0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Input matrix dimensions\n",
    "rows = int(input(\"Enter the number of rows: \"))\n",
    "cols = int(input(\"Enter the number of columns: \"))\n",
    "\n",
    "# Input matrices\n",
    "matrix1 = np.zeros((rows, cols))\n",
    "matrix2 = np.zeros((rows, cols))\n",
    "\n",
    "print(\"Enter elements of matrix 1:\")\n",
    "for i in range(rows):\n",
    "    for j in range(cols):\n",
    "        matrix1[i][j] = float(input(f\"Matrix 1[{i}][{j}]: \"))\n",
    "\n",
    "print(\"Enter elements of matrix 2:\")\n",
    "for i in range(rows):\n",
    "    for j in range(cols):\n",
    "        matrix2[i][j] = float(input(f\"Matrix 2[{i}][{j}]: \"))\n",
    "\n",
    "# Perform addition and subtraction\n",
    "matrix_sum = matrix1 + matrix2\n",
    "matrix_diff = matrix1 - matrix2\n",
    "\n",
    "print(\"Matrix Addition:\")\n",
    "print(matrix_sum)\n",
    "\n",
    "print(\"Matrix Subtraction:\")\n",
    "print(matrix_diff)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2db1592c",
   "metadata": {},
   "source": [
    "#### 33. Write a program that calculates the greatest common divisor (GCD) of two numbers using the Euclidean algorithm.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "c99e7cf8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first number: 12\n",
      "Enter the second number: 13\n",
      "The GCD of 12 and 13 is: 1\n"
     ]
    }
   ],
   "source": [
    "def euclidean_gcd(a, b):\n",
    "    while b:\n",
    "        a, b = b, a % b\n",
    "    return a\n",
    "\n",
    "# Input two numbers\n",
    "num1 = int(input(\"Enter the first number: \"))\n",
    "num2 = int(input(\"Enter the second number: \"))\n",
    "\n",
    "gcd = euclidean_gcd(num1, num2)\n",
    "\n",
    "print(f\"The GCD of {num1} and {num2} is: {gcd}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1b44520",
   "metadata": {},
   "source": [
    "#### 34. Build a program that performs matrix multiplication using nested loops and conditional statements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "493388c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number of rows for matrix 1: 2\n",
      "Enter the number of columns for matrix 1: 2\n",
      "Enter the number of rows for matrix 2: 2\n",
      "Enter the number of columns for matrix 2: 2\n",
      "Enter elements of matrix 1:\n",
      "Matrix 1[0][0]: 2\n",
      "Matrix 1[0][1]: 2\n",
      "Matrix 1[1][0]: 2\n",
      "Matrix 1[1][1]: 2\n",
      "Enter elements of matrix 2:\n",
      "Matrix 2[0][0]: 2\n",
      "Matrix 2[0][1]: 2\n",
      "Matrix 2[1][0]: 2\n",
      "Matrix 2[1][1]: 2\n",
      "Matrix Multiplication Result:\n",
      "[8.0, 8.0]\n",
      "[8.0, 8.0]\n"
     ]
    }
   ],
   "source": [
    "# Input matrix dimensions\n",
    "rows1 = int(input(\"Enter the number of rows for matrix 1: \"))\n",
    "cols1 = int(input(\"Enter the number of columns for matrix 1: \"))\n",
    "rows2 = int(input(\"Enter the number of rows for matrix 2: \"))\n",
    "cols2 = int(input(\"Enter the number of columns for matrix 2: \"))\n",
    "\n",
    "if cols1 != rows2:\n",
    "    print(\"Matrix multiplication is not possible.\")\n",
    "else:\n",
    "    # Input matrices\n",
    "    matrix1 = []\n",
    "    matrix2 = []\n",
    "\n",
    "    print(\"Enter elements of matrix 1:\")\n",
    "    for i in range(rows1):\n",
    "        row = []\n",
    "        for j in range(cols1):\n",
    "            element = float(input(f\"Matrix 1[{i}][{j}]: \"))\n",
    "            row.append(element)\n",
    "        matrix1.append(row)\n",
    "\n",
    "    print(\"Enter elements of matrix 2:\")\n",
    "    for i in range(rows2):\n",
    "        row = []\n",
    "        for j in range(cols2):\n",
    "            element = float(input(f\"Matrix 2[{i}][{j}]: \"))\n",
    "            row.append(element)\n",
    "        matrix2.append(row)\n",
    "\n",
    "    # Perform matrix multiplication\n",
    "    result_matrix = []\n",
    "    for i in range(rows1):\n",
    "        row = []\n",
    "        for j in range(cols2):\n",
    "            sum = 0\n",
    "            for k in range(cols1):\n",
    "                sum += matrix1[i][k] * matrix2[k][j]\n",
    "            row.append(sum)\n",
    "        result_matrix.append(row)\n",
    "\n",
    "    print(\"Matrix Multiplication Result:\")\n",
    "    for row in result_matrix:\n",
    "        print(row)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d2a8cea",
   "metadata": {},
   "source": [
    "#### 35. Create a program that simulates a basic text-based tic-tac-toe game against the computer.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "21d3d99d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  |   |  \n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "  |   |  \n",
      "Enter your move (1-9): 1\n",
      "X | O |  \n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "  |   |  \n",
      "Enter your move (1-9): 2\n",
      "Invalid move. The cell is already occupied.\n",
      "Enter your move (1-9): 2\n",
      "Invalid move. The cell is already occupied.\n",
      "Enter your move (1-9): 2\n",
      "Invalid move. The cell is already occupied.\n",
      "Enter your move (1-9): 2\n",
      "Invalid move. The cell is already occupied.\n",
      "Enter your move (1-9): 1\n",
      "Invalid move. The cell is already occupied.\n",
      "Enter your move (1-9): 2\n",
      "Invalid move. The cell is already occupied.\n",
      "Enter your move (1-9): 3\n",
      "X | O | X\n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "  | O |  \n",
      "Enter your move (1-9): 4\n",
      "X | O | X\n",
      "---------\n",
      "X |   |  \n",
      "---------\n",
      "  | O | O\n",
      "Enter your move (1-9): 5\n",
      "X | O | X\n",
      "---------\n",
      "X | X |  \n",
      "---------\n",
      "O | O | O\n",
      "Computer wins. Better luck next time!\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "# Initialize the tic-tac-toe board\n",
    "board = [\" \" for _ in range(9)]\n",
    "\n",
    "# Function to print the board\n",
    "def print_board(board):\n",
    "    for i in range(0, 9, 3):\n",
    "        print(f\"{board[i]} | {board[i + 1]} | {board[i + 2]}\")\n",
    "        if i < 6:\n",
    "            print(\"---------\")\n",
    "\n",
    "# Function to check for a win\n",
    "def check_win(board, player):\n",
    "    win_combinations = [(0, 1, 2), (3, 4, 5), (6, 7, 8), (0, 3, 6), (1, 4, 7), (2, 5, 8), (0, 4, 8), (2, 4, 6)]\n",
    "    for combo in win_combinations:\n",
    "        if all(board[i] == player for i in combo):\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "# Main game loop\n",
    "while True:\n",
    "    print_board(board)\n",
    "\n",
    "    # Player's turn\n",
    "    while True:\n",
    "        try:\n",
    "            move = int(input(\"Enter your move (1-9): \")) - 1\n",
    "            if board[move] == \" \":\n",
    "                board[move] = \"X\"\n",
    "                break\n",
    "            else:\n",
    "                print(\"Invalid move. The cell is already occupied.\")\n",
    "        except (ValueError, IndexError):\n",
    "            print(\"Invalid input. Please enter a number between 1 and 9.\")\n",
    "\n",
    "    # Check if the player wins\n",
    "    if check_win(board, \"X\"):\n",
    "        print_board(board)\n",
    "        print(\"Congratulations! You win!\")\n",
    "        break\n",
    "\n",
    "    # Check for a tie\n",
    "    if \" \" not in board:\n",
    "        print_board(board)\n",
    "        print(\"It's a tie!\")\n",
    "        break\n",
    "\n",
    "    # Computer's turn\n",
    "    while True:\n",
    "        computer_move = random.randint(0, 8)\n",
    "        if board[computer_move] == \" \":\n",
    "            board[computer_move] = \"O\"\n",
    "            break\n",
    "\n",
    "    # Check if the computer wins\n",
    "    if check_win(board, \"O\"):\n",
    "        print_board(board)\n",
    "        print(\"Computer wins. Better luck next time!\")\n",
    "        break\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "187dc318",
   "metadata": {},
   "source": [
    "###### 36. Write a program that generates Fibonacci numbers up to a specified term using iterative methods.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "id": "e43e431e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number of Fibonacci terms: 12\n",
      "Fibonacci Sequence:\n",
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n",
      "55\n",
      "89\n"
     ]
    }
   ],
   "source": [
    "# Input the number of terms\n",
    "n = int(input(\"Enter the number of Fibonacci terms: \"))\n",
    "\n",
    "# Initialize the first two terms\n",
    "fibonacci = [0, 1]\n",
    "\n",
    "# Generate Fibonacci sequence\n",
    "for i in range(2, n):\n",
    "    next_term = fibonacci[i - 1] + fibonacci[i - 2]\n",
    "    fibonacci.append(next_term)\n",
    "\n",
    "# Print the Fibonacci sequence\n",
    "print(\"Fibonacci Sequence:\")\n",
    "for term in fibonacci:\n",
    "    print(term)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89879e2c",
   "metadata": {},
   "source": [
    "#### 37. Develop a program that calculates the nth term of the Fibonacci sequence using memoization.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "45798648",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the term number: 13\n",
      "The 13th Fibonacci term is: 233\n"
     ]
    }
   ],
   "source": [
    "# Define a dictionary to store Fibonacci numbers\n",
    "fibonacci_cache = {}\n",
    "\n",
    "# Function to calculate the nth Fibonacci term with memoization\n",
    "def fib(n):\n",
    "    if n in fibonacci_cache:\n",
    "        return fibonacci_cache[n]\n",
    "    if n <= 1:\n",
    "        return n\n",
    "    result = fib(n - 1) + fib(n - 2)\n",
    "    fibonacci_cache[n] = result\n",
    "    return result\n",
    "\n",
    "# Input the term number\n",
    "n = int(input(\"Enter the term number: \"))\n",
    "\n",
    "# Calculate and print the nth Fibonacci term\n",
    "result = fib(n)\n",
    "print(f\"The {n}th Fibonacci term is: {result}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "351a961f",
   "metadata": {},
   "source": [
    "#### 38. Create a program that generates a calendar for a given month and year using conditional statements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "id": "f8582537",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a year: 1\n",
      "Enter a month (1-12): 1\n",
      "\n",
      "------------------------------\n",
      "      January 1\n",
      "------------------------------\n",
      " Sun Mon Tue Wed Thu Fri Sat\n",
      "   1   2   3   4   5   6   7 \n",
      "  8   9  10  11  12  13  14 \n",
      " 15  16  17  18  19  20  21 \n",
      " 22  23  24  25  26  27  28 \n",
      " 29  30  31 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Input year and month\n",
    "import datetime\n",
    "year = int(input(\"Enter a year: \"))\n",
    "month = int(input(\"Enter a month (1-12): \"))\n",
    "\n",
    "# Define the number of days in each month (considering a non-leap year)\n",
    "days_in_month = {\n",
    "    1: 31, 2: 28, 3: 31, 4: 30, 5: 31, 6: 30,\n",
    "    7: 31, 8: 31, 9: 30, 10: 31, 11: 30, 12: 31\n",
    "}\n",
    "\n",
    "# Check for leap year\n",
    "if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):\n",
    "    days_in_month[2] = 29  # Update February's days for a leap year\n",
    "\n",
    "# Validate user input\n",
    "if month < 1 or month > 12:\n",
    "    print(\"Invalid month. Please enter a number between 1 and 12.\")\n",
    "else:\n",
    "    # Display the calendar header\n",
    "    print(f\"\\n{'-' * 30}\")\n",
    "    print(f\"      {calendar.month_name[month]} {year}\")\n",
    "    print(f\"{'-' * 30}\")\n",
    "    print(\" Sun Mon Tue Wed Thu Fri Sat\")\n",
    "\n",
    "    # Get the weekday of the first day in the month\n",
    "    first_day = datetime.date(year, month, 1).weekday()\n",
    "\n",
    "    # Print the calendar\n",
    "    print(\"     \" * first_day, end=\" \")\n",
    "    for day in range(1, days_in_month[month] + 1):\n",
    "        print(f\" {day:2}\", end=\" \")\n",
    "        if (day + first_day) % 7 == 0:\n",
    "            print()\n",
    "    print(\"\\n\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d4a1729",
   "metadata": {},
   "source": [
    "#### 39. Build a program that simulates a basic text-based blackjack game against the computer.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "id": "87daf32b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your hand: [4, 10] (Total Value: 14)\n",
      "Do you want to 'hit' or 'stand'? stand\n",
      "Your hand: [4, 10] (Total Value: 14)\n",
      "Computer's hand: [4, 3, 5, 11, 2, 7] (Total Value: 22)\n",
      "Computer busts! You win.\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "# Function to calculate the hand value\n",
    "def hand_value(hand):\n",
    "    value =0\n",
    "    for i in hand:\n",
    "        value = i + value\n",
    "    num_aces = hand.count(11)\n",
    "    while value > 21 and num_aces:\n",
    "        value -= 10\n",
    "        num_aces -= 1\n",
    "    return value\n",
    "\n",
    "# Initialize deck and hands\n",
    "deck = [2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10, 11] * 4\n",
    "player_hand = [random.choice(deck), random.choice(deck)]\n",
    "computer_hand = [random.choice(deck), random.choice(deck)]\n",
    "\n",
    "# Player's turn\n",
    "while True:\n",
    "    print(f\"Your hand: {player_hand} (Total Value: {hand_value(player_hand)})\")\n",
    "    player_action = input(\"Do you want to 'hit' or 'stand'? \").lower()\n",
    "\n",
    "    if player_action == 'hit':\n",
    "        player_hand.append(random.choice(deck))\n",
    "        if hand_value(player_hand) > 21:\n",
    "            print(f\"Your hand: {player_hand} (Total Value: {hand_value(player_hand)})\")\n",
    "            print(\"Bust! You lose.\")\n",
    "            break\n",
    "    elif player_action == 'stand':\n",
    "        break\n",
    "\n",
    "# Computer's turn\n",
    "while hand_value(computer_hand) < 17:\n",
    "    computer_hand.append(random.choice(deck))\n",
    "\n",
    "# Determine the winner\n",
    "player_value = hand_value(player_hand)\n",
    "computer_value = hand_value(computer_hand)\n",
    "\n",
    "print(f\"Your hand: {player_hand} (Total Value: {player_value})\")\n",
    "print(f\"Computer's hand: {computer_hand} (Total Value: {computer_value})\")\n",
    "\n",
    "if player_value > 21:\n",
    "    print(\"Bust! You lose.\")\n",
    "elif computer_value > 21:\n",
    "    print(\"Computer busts! You win.\")\n",
    "elif player_value > computer_value:\n",
    "    print(\"You win!\")\n",
    "elif player_value < computer_value:\n",
    "    print(\"Computer wins.\")\n",
    "else:\n",
    "    print(\"It's a tie!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea2b8e9f",
   "metadata": {},
   "source": [
    "#### 40. Write a program that generates the prime factors of a given number using trial division."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "id": "286883e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 123\n",
      "Prime factors of 123 are: [3, 41]\n"
     ]
    }
   ],
   "source": [
    "def prime_factors(n):\n",
    "    factors = []\n",
    "    divisor = 2\n",
    "    while divisor <= n:\n",
    "        if n % divisor == 0:\n",
    "            factors.append(divisor)\n",
    "            n //= divisor\n",
    "        else:\n",
    "            divisor += 1\n",
    "    return factors\n",
    "\n",
    "# Input a number\n",
    "number = int(input(\"Enter a number: \"))\n",
    "\n",
    "if number < 2:\n",
    "    print(\"Prime factors are not applicable for numbers less than 2.\")\n",
    "else:\n",
    "    factors = prime_factors(number)\n",
    "    print(f\"Prime factors of {number} are: {factors}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4581a3c",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}