3rd_September_control_flow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4c836939",
   "metadata": {},
   "source": [
    "# Basic If-Else Statements:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49a24cb7",
   "metadata": {},
   "source": [
    "# 1. Write a Python program to check if a given number is positive or negative."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "4647d047",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number:-89\n",
      "-89 is negative\n"
     ]
    }
   ],
   "source": [
    "num=int(input(\"Enter the number:\"))\n",
    "if num>=0:\n",
    "    print(f\"{num} is positive\")\n",
    "else:\n",
    "    print(f\"{num} is negative\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a959b64",
   "metadata": {},
   "source": [
    "# 2. Create a program that determines if a person is eligible to vote based on their age."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4c18724c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your age:21\n",
      "You are eligible to vote\n"
     ]
    }
   ],
   "source": [
    "age=int(input(\"Enter your age:\"))\n",
    "if age >= 18:\n",
    "    print(\"You are eligible to vote\")\n",
    "else:\n",
    "    print(\"You are not eligible to vote\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "831b2c7c",
   "metadata": {},
   "source": [
    "# 3. Develop a program to find the maximum of two numbers using if-else statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a0743273",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number:78\n",
      "Enter another number:56\n",
      "maximum of 78 and 56 is 78\n"
     ]
    }
   ],
   "source": [
    "num1=int(input(\"Enter a number:\"))\n",
    "num2=int(input(\"Enter another number:\"))\n",
    "if num1>num2:\n",
    "    max=num1\n",
    "else:\n",
    "    max=num2\n",
    "print(f\"maximum of {num1} and {num2} is {max}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc08e11c",
   "metadata": {},
   "source": [
    "# 4. Write a Python script to classify a given year as a leap year or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "ee56c557",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the year:2100\n",
      "2100 is not a leap year\n"
     ]
    }
   ],
   "source": [
    "year=int(input(\"Enter the year:\"))\n",
    "if (year%400==0) or (year%4==0 and year%100!=0):\n",
    "    print(f\"{year} is a leap year\")\n",
    "else:\n",
    "    print(f\"{year} is not a leap year\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02096245",
   "metadata": {},
   "source": [
    "# 5. Create a program that checks whether a character is a vowel or a consonant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "e1e14b9a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a character:a\n",
      "'a' is a vowel\n"
     ]
    }
   ],
   "source": [
    "char=input(\"Enter a character:\")\n",
    "vowels=\"aeiouAEIOU\"\n",
    "if char in vowels:\n",
    "    print(f\"'{char}' is a vowel\")\n",
    "else:\n",
    "    print(f\"'{char}' is a consonant\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aac45686",
   "metadata": {},
   "source": [
    "# 6. Implement a program to determine whether a given number is even or odd."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "7b6da65e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number:84\n",
      "84 is even\n"
     ]
    }
   ],
   "source": [
    "num=int(input(\"Enter a number:\"))\n",
    "if num%2==0:\n",
    "    print(f\"{num} is even\")\n",
    "else:\n",
    "    print(f\"{num} is odd\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "764b2e37",
   "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": 42,
   "id": "e2a5db04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number:-54\n",
      "Absolute value of -54 is 54\n"
     ]
    }
   ],
   "source": [
    "def absolute_value(num):\n",
    "    if num>=0:\n",
    "        return num\n",
    "    else:\n",
    "        return num*-1\n",
    "\n",
    "num=int(input(\"Enter a number:\"))\n",
    "abs_value=absolute_value(num)\n",
    "print(f\"Absolute value of {num} is {abs_value}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1712ecad",
   "metadata": {},
   "source": [
    "# 8. Develop a program that determines the largest of three given numbers using if-else statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "4780b624",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first number: 45\n",
      "Enter the second number: 45\n",
      "Enter the third number: 21\n",
      "\n",
      "maximum of 45,45,21 is 45\n"
     ]
    }
   ],
   "source": [
    "a = int(input(\"Enter the first number: \"))\n",
    "b = int(input(\"Enter the second number: \"))\n",
    "c = int(input(\"Enter the third number: \"))\n",
    "\n",
    "if a>=b and a>=c:\n",
    "    max=a\n",
    "elif b>=c and b>=a:\n",
    "    max=b\n",
    "else:\n",
    "    max=c\n",
    "print(f\"\\nmaximum of {a},{b},{c} is {max}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01e38333",
   "metadata": {},
   "source": [
    "# 9. Create a program that checks if a given string is a palindrome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "368578ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string:madam\n",
      "'madam' is a palindrome string\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter a string:\")\n",
    "string=string.lower()\n",
    "if string==string[::-1]:\n",
    "    print(f\"'{string}' is a palindrome string\")\n",
    "else:\n",
    "    print(f\"'{string}' is a not palindrome string\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a4eb8e4",
   "metadata": {},
   "source": [
    "# 10. Write a Python program to calculate the grade based on a student's score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "b8150450",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your marks out of 100:90\n",
      "Your grade is: P\n"
     ]
    }
   ],
   "source": [
    "marks=float(input(\"Enter your marks out of 100:\"))\n",
    "if marks>=33:\n",
    "    grade='P'\n",
    "else:\n",
    "    grade='F'\n",
    "print(\"Your grade is:\",grade)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f08c0be",
   "metadata": {},
   "source": [
    "# Nested If-Else Statements:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5de99469",
   "metadata": {},
   "source": [
    "# 11. Write a program to find the largest among three numbers using nested if-else statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "2546ee6c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first number: 45\n",
      "Enter the second number: 47\n",
      "Enter the third number: 85\n",
      "\n",
      "maximum of 45,47,85 is 85\n"
     ]
    }
   ],
   "source": [
    "a = int(input(\"Enter the first number: \"))\n",
    "b = int(input(\"Enter the second number: \"))\n",
    "c = int(input(\"Enter the third number: \"))\n",
    "\n",
    "if a >= b:\n",
    "    if a >= c:\n",
    "        largest = a\n",
    "    else:\n",
    "        largest = c\n",
    "else:\n",
    "    if b >= c:\n",
    "        largest = b\n",
    "    else:\n",
    "        largest = c\n",
    "print(f\"\\nmaximum of {a},{b},{c} is {largest}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e36d87f0",
   "metadata": {},
   "source": [
    "# 12. Implement a program to determine if a triangle is equilateral, isosceles, or scalene."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7782094b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first side:10\n",
      "Enter the second side:12\n",
      "Enter the third side:15\n",
      "This is a scelene triangle\n"
     ]
    }
   ],
   "source": [
    "side1=float(input(\"Enter the first side:\"))\n",
    "side2=float(input(\"Enter the second side:\"))\n",
    "side3=float(input(\"Enter the third side:\"))\n",
    "\n",
    "if side1+side2>side3 and side1+side3>side2 and side2+side3>side1:\n",
    "    if side1==side2==side3:\n",
    "        print(\"This is an equilateral triangle\")\n",
    "    elif side1==side2 or side2==side3 or side3==side1:\n",
    "        print(\"This is an isosceles triangle\")\n",
    "    else:\n",
    "        print(\"This is a scelene triangle\")\n",
    "else:\n",
    "    print(\"The sides don't form a triangle\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab9ee89a",
   "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": 8,
   "id": "b661932c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the year:2000\n",
      "2000 is a leap year as well as century year\n"
     ]
    }
   ],
   "source": [
    "year=int(input(\"Enter the year:\"))\n",
    "if (year%400==0) or (year%4==0 and year%100!=0):\n",
    "    if year%100==0:\n",
    "        print(f\"{year} is a leap year as well as century year\")\n",
    "    else:\n",
    "        print(f\"{year} is a leap year but not a century year\")\n",
    "else:\n",
    "    print(f\"{year} is not a leap year\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69c734fa",
   "metadata": {},
   "source": [
    "# 14. Write a Python script to determine if a number is positive, negative, or zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "5af086ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number:13\n",
      "13 is positive\n"
     ]
    }
   ],
   "source": [
    "num=int(input(\"Enter the number:\"))\n",
    "if num>=0:\n",
    "    if num==0:\n",
    "        print(f\"{num} is zero\")\n",
    "    else:\n",
    "        print(f\"{num} is positive\")\n",
    "else:\n",
    "    print(f\"{num} is negative\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91196210",
   "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": 20,
   "id": "a2373b00",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your age:17\n",
      "You are a teenager\n"
     ]
    }
   ],
   "source": [
    "age=int(input(\"Enter your age:\"))\n",
    "\n",
    "if 13<=age<=19:\n",
    "    print(\"You are a teenager\")\n",
    "else:\n",
    "    print(\"You are not a teenager\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1593bde",
   "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": 33,
   "id": "40491de8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the angle:90\n",
      "90.0 is an right angle\n"
     ]
    }
   ],
   "source": [
    "angle=float(input(\"Enter the angle:\"))\n",
    "if 0<angle<90:\n",
    "    print(f\"{angle} is an acute angle\")\n",
    "elif angle==90:\n",
    "    print(f\"{angle} is an right angle\")\n",
    "elif 90<angle<=180:\n",
    "    print(f\"{angle} is an obtuse angle\")\n",
    "else:\n",
    "    print(f\"{angle} is invalid angle\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a7f0be8",
   "metadata": {},
   "source": [
    "# 17. Write a Python program to calculate the roots of a quadratic equation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "456cc96f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the coefficients 'a','b','c' of the quadratic equation of the form ax^2+bx+c.\n",
      "Enter a:1\n",
      "Enter b:-4\n",
      "Enter c:4\n",
      "Roots of the quadratic equation are real,equal and they are: 2.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print(\"Enter the coefficients 'a','b','c' of the quadratic equation of the form ax^2+bx+c.\")\n",
    "a=int(input(\"Enter a:\"))\n",
    "b=int(input(\"Enter b:\"))\n",
    "c=int(input(\"Enter c:\"))\n",
    "d=b**2-(4*a*c)\n",
    "if d>0:\n",
    "    root1=(-b+math.sqrt(d))/2*a\n",
    "    root2=(-b-math.sqrt(d))/2*a\n",
    "    print(f\"Roots of the quadratic equation are real,unique and they are: {root1} and {root2}\")\n",
    "elif d==0:\n",
    "    root=-b/(2*a)\n",
    "    print(f\"Roots of the quadratic equation are real,equal and they are: {root}\")\n",
    "else:\n",
    "    real_part = -b / (2*a)\n",
    "    imaginary_part = math.sqrt(abs(d)) / (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}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f0e40f0",
   "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.)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "56e31127",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number from 1 to 7:7\n",
      "The day of the week is Sunday\n"
     ]
    }
   ],
   "source": [
    "day_number=int(input(\"Enter a number from 1 to 7:\"))\n",
    "if 1<=day_number<=7:\n",
    "    week=[\"Monday\",\"Tuesday\",\"Wednesday\",\"Thursday\",\"Friday\",\"Saturday\",\"Sunday\"]\n",
    "    day=week[day_number-1]\n",
    "    print(f\"The day of the week is {day}\")\n",
    "else:\n",
    "    print(\"Invalid choice, enter number from 1 to 7\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6c9f1bb",
   "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": 52,
   "id": "2d1e6099",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the year:2000\n",
      "2000 is a leap year\n",
      "2000 is evenly divisible by 400\n"
     ]
    }
   ],
   "source": [
    "year=int(input(\"Enter the year:\"))\n",
    "\n",
    "if (year%400==0) or (year%4==0 and year%100!=0):\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 not evenly divisible by 400\")\n",
    "else:\n",
    "    print(f\"{year} is not a leap year\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60a39326",
   "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": 74,
   "id": "e22978e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 5\n",
      "5 is a prime number.\n"
     ]
    }
   ],
   "source": [
    "number = int(input(\"Enter a number: \"))\n",
    "\n",
    "if number > 1:\n",
    "    is_prime = True \n",
    "    for i in range(2, number):\n",
    "        if number % i == 0:\n",
    "            is_prime = False \n",
    "            break\n",
    "\n",
    "    if is_prime:\n",
    "        print(f\"{number} is a prime number.\")\n",
    "    else:\n",
    "        print(f\"{number} is not a prime number.\")\n",
    "else:\n",
    "    print(f\"{number} is not a prime number (prime numbers are greater than 1).\")\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30747301",
   "metadata": {},
   "source": [
    "# Elif Statements:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cfebcd9",
   "metadata": {},
   "source": [
    "# 21. Write a Python program to assign grades based on different ranges of scores using elif statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "1f6213d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your marks out of 100:94.65\n",
      "Your grade is: A+\n"
     ]
    }
   ],
   "source": [
    "marks=float(input(\"Enter your marks out of 100:\"))\n",
    "if marks>=90:\n",
    "    grade='A+'\n",
    "elif marks >=80:\n",
    "    grade='A'\n",
    "elif marks>=70:\n",
    "    grade='B'\n",
    "elif marks>=60:\n",
    "    grade='C'\n",
    "elif marks>=50:\n",
    "    grade='D'\n",
    "else:\n",
    "    grade='F'\n",
    "print(\"Your grade is:\",grade)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b751f1a",
   "metadata": {},
   "source": [
    "# 22. Implement a program to determine the type of a triangle based on its angles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "551efc08",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first angle of the triangle: 45\n",
      "Enter the second angle of the triangle: 45\n",
      "Enter the third angle of the triangle: 90\n",
      "The triangle is a Isosceles triangle.\n"
     ]
    }
   ],
   "source": [
    "angle1 = int(input(\"Enter the first angle of the triangle: \"))\n",
    "angle2 = int(input(\"Enter the second angle of the triangle: \"))\n",
    "angle3 = int(input(\"Enter the third angle of the triangle: \"))\n",
    "\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 = \"Not a valid triangle\"\n",
    "\n",
    "\n",
    "print(f\"The triangle is a {triangle_type} triangle.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63b2b254",
   "metadata": {},
   "source": [
    "# 23. Develop a program to categorize a given person's BMI into underweight, normal, overweight, or obese using elif statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "8e2da4f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your height in cm:165\n",
      "Enter your weight in kg:60\n",
      "Your BMI is: 22.03856749311295\n",
      "You are normal\n"
     ]
    }
   ],
   "source": [
    "height=float(input(\"Enter your height in cm:\"))\n",
    "weight=float(input(\"Enter your weight in kg:\"))\n",
    "bmi=weight/((height/100)**2)\n",
    "print(\"Your BMI is:\",bmi)\n",
    "if bmi<=18.5:\n",
    "    print(\"You are underweight\")\n",
    "elif 18.5<bmi<25:\n",
    "    print(\"You are normal\")\n",
    "elif 25<bmi<30:\n",
    "    print(\"You are overweight\")\n",
    "else:\n",
    "    print(\"You are obese\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e788316",
   "metadata": {},
   "source": [
    "# 24. Create a program that determines whether a given number is positive, negative, or zero using elif statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "f599854b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number:0\n",
      "0 is zero\n"
     ]
    }
   ],
   "source": [
    "num=int(input(\"Enter the number:\"))\n",
    "if num>0:\n",
    "    print(f\"{num} is positive\")\n",
    "elif num==0:\n",
    "    print(f\"{num} is zero\")\n",
    "else:\n",
    "    print(f\"{num} is negative\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95f87644",
   "metadata": {},
   "source": [
    "# 25. Write a Python script to determine the type of a character (uppercase, lowercase, or special) using elif statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "8e7ad0d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a character:*\n",
      "'*' is special\n"
     ]
    }
   ],
   "source": [
    "char=input(\"Enter a character:\")\n",
    "if char.isalpha():\n",
    "    if char.isupper():\n",
    "        print(f\"'{char}' is uppercase\")\n",
    "    elif char.islower():\n",
    "        print(f\"'{char}' is lowercase\")\n",
    "else:\n",
    "    print(f\"'{char}' is special\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6526b767",
   "metadata": {},
   "source": [
    "# 26. Implement a program to calculate the discounted price based on different purchase amounts using elif statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "ebf12a39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your purchase amount:15000\n",
      "Original Price: ₹15000.0\n",
      "You get 40.0% discount and Discounted Price: ₹9000.0\n"
     ]
    }
   ],
   "source": [
    "org_amount=float(input(\"Enter your purchase amount:\"))\n",
    "discount_rate=0\n",
    "discounted_price=org_amount\n",
    "\n",
    "if org_amount>=10000:\n",
    "    discount_rate=.4 #40% discount for purchase over 10000\n",
    "elif org_amount>=7000:\n",
    "    discount_rate=.3 #30% discount for purchase over 7000\n",
    "elif org_amount>=4000:\n",
    "    discount_rate=.2 #20% discount for purchase over 4000\n",
    "elif org_amount>=2000:\n",
    "    discount_rate=.1 #10% discount for purchase over 2000\n",
    "if discount_rate>0:\n",
    "    discounted_price=org_amount-(org_amount*discount_rate)\n",
    "    \n",
    "print(f\"Original Price: ₹{org_amount:}\")\n",
    "print(f\"You get {discount_rate*100}% discount and Discounted Price: ₹{discounted_price:}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baef526c",
   "metadata": {},
   "source": [
    "# 27. Develop a program to calculate the electricity bill based on different consumption slabs using elif statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "f9d9537a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your electricity consumption (in kWh): 154\n",
      "Electricity Consumption: 154.0 kWh\n",
      "Rate per kWh: ₹6.00\n",
      "Electricity Bill: ₹924.00\n"
     ]
    }
   ],
   "source": [
    "consumption = float(input(\"Enter your electricity consumption (in kWh): \"))\n",
    "\n",
    "bill_amount = 0.0\n",
    "rate_per_kwh = 0.0\n",
    "if consumption <= 50:\n",
    "    rate_per_kwh = 3.00 \n",
    "elif consumption <= 100:\n",
    "    rate_per_kwh = 4.50  \n",
    "elif consumption <= 200:\n",
    "    rate_per_kwh = 6.00 \n",
    "else:\n",
    "    rate_per_kwh = 7.50 \n",
    "\n",
    "bill_amount = consumption * rate_per_kwh\n",
    "\n",
    "print(f\"Electricity Consumption: {consumption} kWh\")\n",
    "print(f\"Rate per kWh: ₹{rate_per_kwh:.2f}\")  \n",
    "print(f\"Electricity Bill: ₹{bill_amount:.2f}\")  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aee728f9",
   "metadata": {},
   "source": [
    "# 28. Create a program to determine the type of quadrilateral based on its angles and sides using elif statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e79b85b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first angle (in degrees): 90\n",
      "Enter the second angle (in degrees): 90\n",
      "Enter the third angle (in degrees): 90\n",
      "Enter the fourth angle (in degrees): 90\n",
      "Enter the length of the first side: 10\n",
      "Enter the length of the second side: 15\n",
      "Enter the length of the third side: 10\n",
      "Enter the length of the fourth side: 15\n",
      "The quadrilateral is a Rectangle.\n"
     ]
    }
   ],
   "source": [
    "#input of angles\n",
    "\n",
    "angle1 = float(input(\"Enter the first angle (in degrees): \"))\n",
    "angle2 = float(input(\"Enter the second angle (in degrees): \"))\n",
    "angle3 = float(input(\"Enter the third angle (in degrees): \"))\n",
    "angle4 = float(input(\"Enter the fourth angle (in degrees): \"))\n",
    "\n",
    "#input of sides\n",
    "\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",
    "if angle1+angle2+angle3+angle4==360:\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",
    "    elif side1==side2==side3==side4:\n",
    "        if angle1 == angle3 and angle2 == angle4:\n",
    "            quadrilateral_type = \"Rhombus\"  \n",
    "    elif side1==side3 and side2==side4:\n",
    "        quadrilateral_type = \"Parallelogram\" \n",
    "    else:\n",
    "        quadrilateral_type = \"Quadrilateral\"  \n",
    "    print(f\"The quadrilateral is a {quadrilateral_type}.\")\n",
    "else:\n",
    "    print(\"The entered angles do not form a quadrilateral\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62685c68",
   "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": 9,
   "id": "6d78bf1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a month: july\n",
      "The season for July is Monsoon.\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "season           months\n",
    "Summer Season\tMarch to May\n",
    "Monsoon Season\tJune to September\n",
    "Autumn Season\tOctober to November\n",
    "Winter Season\tDecember to February\n",
    "'''\n",
    "\n",
    "month = input(\"Enter a month: \").lower()\n",
    "\n",
    "if month in [\"december\", \"january\", \"february\"]:\n",
    "    season = \"Winter\"\n",
    "elif month in [\"march\", \"april\", \"may\"]:\n",
    "    season = \"Summer\"\n",
    "elif month in [\"june\", \"july\", \"august\",\"september\"]:\n",
    "    season = \"Monsoon\"\n",
    "elif month in [\"october\", \"november\"]:\n",
    "    season = \"Autumn\"\n",
    "else:\n",
    "    season = \"Invalid Month\"\n",
    "    \n",
    "print(f\"The season for {month.capitalize()} is {season}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3adbac56",
   "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": 11,
   "id": "cbe26295",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a year: 2002\n",
      "Enter a month (1-12): 7\n",
      "2002 is a Common Year.\n",
      "Month 7 i.e July has 31 days.\n"
     ]
    }
   ],
   "source": [
    "year = int(input(\"Enter a year: \"))\n",
    "\n",
    "if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):\n",
    "    year_type = \"Leap Year\"\n",
    "else:\n",
    "    year_type = \"Common Year\"\n",
    "\n",
    "month = int(input(\"Enter a month (1-12): \"))\n",
    "\n",
    "if month == 2:\n",
    "    if year_type == \"Leap Year\":\n",
    "        days_in_month = 29\n",
    "    else:\n",
    "        days_in_month = 28\n",
    "elif month in [4, 6, 9, 11]:\n",
    "    days_in_month = 30\n",
    "else:\n",
    "    days_in_month = 31\n",
    "month_name=[\"January\", \"February\", \"March\", \"April\",\"May\", \"June\", \"July\",\"August\",\"September\", \"October\",\"November\",\"December\"]\n",
    "print(f\"{year} is a {year_type}.\")\n",
    "print(f\"Month {month} i.e {month_name[month-1]} has {days_in_month} days.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef39da45",
   "metadata": {},
   "source": [
    "# Basic Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "992e3ed8",
   "metadata": {},
   "source": [
    "# 1. Write a Python program that checks if a given number is positive, negative, or zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "cd817ff7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number:45\n",
      "45 is positive\n"
     ]
    }
   ],
   "source": [
    "num=int(input(\"Enter the number:\"))\n",
    "if num>0:\n",
    "    print(f\"{num} is positive\")\n",
    "elif num==0:\n",
    "    print(f\"{num} is zero\")\n",
    "else:\n",
    "    print(f\"{num} is negative\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df2e92cf",
   "metadata": {},
   "source": [
    "# 2. Create a program to determine if a person is eligible to vote based on their age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "fc88afbb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your age:21\n",
      "You are eligible to vote\n"
     ]
    }
   ],
   "source": [
    "age=int(input(\"Enter your age:\"))\n",
    "if age >= 18:\n",
    "    print(\"You are eligible to vote\")\n",
    "else:\n",
    "    print(\"You are not eligible to vote\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0740036",
   "metadata": {},
   "source": [
    "# 3. Write a program to find the maximum of two given numbers using conditional statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3da332cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number:12\n",
      "Enter another number:-78\n",
      "maximum of 12 and -78 is 12\n"
     ]
    }
   ],
   "source": [
    "num1=int(input(\"Enter a number:\"))\n",
    "num2=int(input(\"Enter another number:\"))\n",
    "if num1>num2:\n",
    "    max=num1\n",
    "else:\n",
    "    max=num2\n",
    "print(f\"maximum of {num1} and {num2} is {max}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "442e54e2",
   "metadata": {},
   "source": [
    "# 4. Develop a program that calculates the grade of a student based on their exam score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3741e434",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your marks out of 100:85\n",
      "Your grade is: A\n"
     ]
    }
   ],
   "source": [
    "marks=float(input(\"Enter your marks out of 100:\"))\n",
    "if marks>=90:\n",
    "    grade='A+'\n",
    "elif marks >=80:\n",
    "    grade='A'\n",
    "elif marks>=70:\n",
    "    grade='B'\n",
    "elif marks>=60:\n",
    "    grade='C'\n",
    "elif marks>=50:\n",
    "    grade='D'\n",
    "else:\n",
    "    grade='F'\n",
    "print(\"Your grade is:\",grade)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7898f161",
   "metadata": {},
   "source": [
    "# 5. Create a program that checks if a year is a leap year or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "bbc2a922",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the year:2004\n",
      "2004 is a leap year\n"
     ]
    }
   ],
   "source": [
    "year=int(input(\"Enter the year:\"))\n",
    "if (year%400==0) or (year%4==0 and year%100!=0):\n",
    "    print(f\"{year} is a leap year\")\n",
    "else:\n",
    "    print(f\"{year} is not a leap year\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4dcc709",
   "metadata": {},
   "source": [
    "# 6. Write a program to classify a triangle based on its sides' lengths."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "4fd39996",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first side:20\n",
      "Enter the second side:20\n",
      "Enter the third side:20\n",
      "This is an equilateral triangle\n"
     ]
    }
   ],
   "source": [
    "side1=float(input(\"Enter the first side:\"))\n",
    "side2=float(input(\"Enter the second side:\"))\n",
    "side3=float(input(\"Enter the third side:\"))\n",
    "\n",
    "if side1+side2>side3 and side1+side3>side2 and side2+side3>side1:\n",
    "    if side1==side2==side3:\n",
    "        print(\"This is an equilateral triangle\")\n",
    "    elif side1==side2 or side2==side3 or side3==side1:\n",
    "        print(\"This is an isosceles triangle\")\n",
    "    else:\n",
    "        print(\"This is a scelene triangle\")\n",
    "else:\n",
    "    print(\"The sides don't form a triangle\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a06fce1",
   "metadata": {},
   "source": [
    "# 7. Build a program that determines the largest of three given numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "200c7097",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first number: 15\n",
      "Enter the second number: 45\n",
      "Enter the third number: -85\n",
      "\n",
      "maximum of 15,45,-85 is 45\n"
     ]
    }
   ],
   "source": [
    "a = int(input(\"Enter the first number: \"))\n",
    "b = int(input(\"Enter the second number: \"))\n",
    "c = int(input(\"Enter the third number: \"))\n",
    "\n",
    "if a>=b and a>=c:\n",
    "    max=a\n",
    "elif b>=c and b>=a:\n",
    "    max=b\n",
    "else:\n",
    "    max=c\n",
    "print(f\"\\nmaximum of {a},{b},{c} is {max}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8975bfa8",
   "metadata": {},
   "source": [
    "# 8. Develop a program that checks whether a character is a vowel or a consonant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "abc706b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a character:b\n",
      "'b' is a consonant\n"
     ]
    }
   ],
   "source": [
    "char=input(\"Enter a character:\")\n",
    "vowels=\"aeiouAEIOU\"\n",
    "if char in vowels:\n",
    "    print(f\"'{char}' is a vowel\")\n",
    "else:\n",
    "    print(f\"'{char}' is a consonant\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "317406c0",
   "metadata": {},
   "source": [
    "# 9. Create a program to calculate the total cost of a shopping cart based on discounts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "87359b2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your purchase amount:15420\n",
      "Original Price: ₹15420.0\n",
      "You get 40.0% discount and Discounted Price: ₹9252.0\n"
     ]
    }
   ],
   "source": [
    "org_amount=float(input(\"Enter your purchase amount:\"))\n",
    "discount_rate=0\n",
    "discounted_price=org_amount\n",
    "\n",
    "if org_amount>=10000:\n",
    "    discount_rate=.4 #40% discount for purchase over 10000\n",
    "elif org_amount>=7000:\n",
    "    discount_rate=.3 #30% discount for purchase over 7000\n",
    "elif org_amount>=4000:\n",
    "    discount_rate=.2 #20% discount for purchase over 4000\n",
    "elif org_amount>=2000:\n",
    "    discount_rate=.1 #10% discount for purchase over 2000\n",
    "if discount_rate>0:\n",
    "    discounted_price=org_amount-(org_amount*discount_rate)\n",
    "    \n",
    "print(f\"Original Price: ₹{org_amount:}\")\n",
    "print(f\"You get {discount_rate*100}% discount and Discounted Price: ₹{discounted_price:}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4c5b3fa",
   "metadata": {},
   "source": [
    "# 10. Write a program that checks if a given number is even or odd."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "78c63db3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number:13\n",
      "13 is odd\n"
     ]
    }
   ],
   "source": [
    "num=int(input(\"Enter a number:\"))\n",
    "if num%2==0:\n",
    "    print(f\"{num} is even\")\n",
    "else:\n",
    "    print(f\"{num} is odd\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf7935af",
   "metadata": {},
   "source": [
    "# Intermediate Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39aca1b1",
   "metadata": {},
   "source": [
    "# 11. Write a program that calculates the roots of a quadratic equation ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "094a8329",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the coefficients 'a','b','c' of the quadratic equation of the form ax^2+bx+c.\n",
      "Enter a:1\n",
      "Enter b:4\n",
      "Enter c:2\n",
      "Roots of the quadratic equation are real,unique and they are: -0.586 and -3.414\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print(\"Enter the coefficients 'a','b','c' of the quadratic equation of the form ax^2+bx+c.\")\n",
    "a=int(input(\"Enter a:\"))\n",
    "b=int(input(\"Enter b:\"))\n",
    "c=int(input(\"Enter c:\"))\n",
    "d=b**2-(4*a*c)\n",
    "if d>0:\n",
    "    root1=(-b+math.sqrt(d))/2*a\n",
    "    root2=(-b-math.sqrt(d))/2*a\n",
    "    print(f\"Roots of the quadratic equation are real,unique and they are: { root1:.3f} and { root2:.3f}\")\n",
    "elif d==0:\n",
    "    root=-b/(2*a)\n",
    "    print(f\"Roots of the quadratic equation are real,equal and they are: {root:.3f}\")\n",
    "else:\n",
    "    real_part = -b / (2*a)\n",
    "    imaginary_part = math.sqrt(abs(d)) / (2*a)\n",
    "    root1 = complex(real_part, imaginary_part)\n",
    "    root2 = complex(real_part, -imaginary_part)\n",
    "    print(f\"The roots are complex: {root1:.3f} and {root2:.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "118ec0c3",
   "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": 44,
   "id": "e9dcc4ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number from 1 to 7:5\n",
      "The day of the week is Friday\n"
     ]
    }
   ],
   "source": [
    "day_number=int(input(\"Enter a number from 1 to 7:\"))\n",
    "if 1<=day_number<=7:\n",
    "    week=[\"Monday\",\"Tuesday\",\"Wednesday\",\"Thursday\",\"Friday\",\"Saturday\",\"Sunday\"]\n",
    "    day=week[day_number-1]\n",
    "    print(f\"The day of the week is {day}\")\n",
    "else:\n",
    "    print(\"Invalid choice, enter number from 1 to 7\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70849cea",
   "metadata": {},
   "source": [
    "# 13. Develop a program that calculates the factorial of a given number using recursion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bdb916a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number whose factorial is to be found:6\n",
      "factorial of 6 is: 720\n"
     ]
    }
   ],
   "source": [
    "def factorial(n):\n",
    "    if n == 0:\n",
    "        return 1 \n",
    "    else:\n",
    "        return n * factorial(n - 1)  \n",
    "num=int(input(\"Enter the number whose factorial is to be found:\"))\n",
    "if num>=0:\n",
    "    fact=factorial(num)\n",
    "    print(f\"factorial of {num} is: {fact}\")\n",
    "else:\n",
    "    print(\"Factorial can be found for numbers greater than or equal to 0\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5892d140",
   "metadata": {},
   "source": [
    "# 14. Write a program to find the largest among three numbers without using the `max()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ecfc8fdc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first number: 50\n",
      "Enter the second number: 12\n",
      "Enter the third number: 75\n",
      "\n",
      "maximum of 50,12,75 is 75\n"
     ]
    }
   ],
   "source": [
    "a = int(input(\"Enter the first number: \"))\n",
    "b = int(input(\"Enter the second number: \"))\n",
    "c = int(input(\"Enter the third number: \"))\n",
    "\n",
    "if a>=b and a>=c:\n",
    "    max=a\n",
    "elif b>=c and b>=a:\n",
    "    max=b\n",
    "else:\n",
    "    max=c\n",
    "print(f\"\\nmaximum of {a},{b},{c} is {max}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "511ee509",
   "metadata": {},
   "source": [
    "# 15. Create a program that simulates a basic ATM transaction menu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3cc83bfa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "********Welcome to ATM Service**************\n",
      "1. Check Balance\n",
      "2. Deposit\n",
      "3. Withdraw\n",
      "4. Exit\n",
      "***********************************************\n",
      "Enter your choice (1/2/3/4): 5\n",
      "Invalid choice. Please select a valid option (1/2/3/4).\n",
      "\n",
      "********Welcome to ATM Service**************\n",
      "1. Check Balance\n",
      "2. Deposit\n",
      "3. Withdraw\n",
      "4. Exit\n",
      "***********************************************\n",
      "Enter your choice (1/2/3/4): 1\n",
      "Your account balance is ₹10000.00\n",
      "\n",
      "********Welcome to ATM Service**************\n",
      "1. Check Balance\n",
      "2. Deposit\n",
      "3. Withdraw\n",
      "4. Exit\n",
      "***********************************************\n",
      "Enter your choice (1/2/3/4): 2\n",
      "Enter the amount to deposit: ₹502\n",
      "Successfully deposited ₹502.00\n",
      "Your account balance is ₹10502.00\n",
      "\n",
      "********Welcome to ATM Service**************\n",
      "1. Check Balance\n",
      "2. Deposit\n",
      "3. Withdraw\n",
      "4. Exit\n",
      "***********************************************\n",
      "Enter your choice (1/2/3/4): 3\n",
      "Enter the amount to withdraw: ₹1002\n",
      "Withdrew ₹1002.00\n",
      "Your account balance is ₹9500.00\n",
      "\n",
      "********Welcome to ATM Service**************\n",
      "1. Check Balance\n",
      "2. Deposit\n",
      "3. Withdraw\n",
      "4. Exit\n",
      "***********************************************\n",
      "Enter your choice (1/2/3/4): 1\n",
      "Your account balance is ₹9500.00\n",
      "\n",
      "********Welcome to ATM Service**************\n",
      "1. Check Balance\n",
      "2. Deposit\n",
      "3. Withdraw\n",
      "4. Exit\n",
      "***********************************************\n",
      "Enter your choice (1/2/3/4): 4\n",
      "Thank you for using the ATM. Goodbye!\n"
     ]
    }
   ],
   "source": [
    "account_balance = 10000\n",
    "\n",
    "# Function to display account balance\n",
    "def check_balance():\n",
    "    print(f\"Your account balance is ₹{account_balance:.2f}\")\n",
    "\n",
    "# Function to deposit money\n",
    "def deposit():\n",
    "    global account_balance\n",
    "    amount = float(input(\"Enter the amount to deposit: ₹\"))\n",
    "    if amount > 0:\n",
    "        account_balance += amount\n",
    "        print(f\"Successfully deposited ₹{amount:.2f}\")\n",
    "        check_balance()\n",
    "    else:\n",
    "        print(\"Invalid amount. Please enter a positive number.\")\n",
    "\n",
    "# Function to withdraw money\n",
    "def withdraw():\n",
    "    global account_balance\n",
    "    amount = float(input(\"Enter the amount to withdraw: ₹\"))\n",
    "    if amount > 0 and amount <= account_balance:\n",
    "        account_balance -= amount\n",
    "        print(f\"Withdrew ₹{amount:.2f}\")\n",
    "        check_balance()\n",
    "    elif amount > account_balance:\n",
    "        print(\"Insufficient funds.\")\n",
    "    else:\n",
    "        print(\"Invalid amount. Please enter a positive number.\")\n",
    "\n",
    "# Main ATM menu\n",
    "while True:\n",
    "    print(\"\\n********Welcome to ATM Service**************\")\n",
    "    print(\"1. Check Balance\")\n",
    "    print(\"2. Deposit\")\n",
    "    print(\"3. Withdraw\")\n",
    "    print(\"4. Exit\")\n",
    "    print(\"***********************************************\")\n",
    "    \n",
    "    choice = input(\"Enter your choice (1/2/3/4): \")\n",
    "    \n",
    "    if choice == \"1\":\n",
    "        check_balance()\n",
    "    elif choice == \"2\":\n",
    "        deposit()\n",
    "    elif choice == \"3\":\n",
    "        withdraw()\n",
    "    elif choice == \"4\":\n",
    "        print(\"Thank you for using the ATM. Goodbye!\")\n",
    "        break\n",
    "    else:\n",
    "        print(\"Invalid choice. Please select a valid option (1/2/3/4).\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6206950c",
   "metadata": {},
   "source": [
    "# 16. Build a program that checks if a given string is a palindrome or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "14e5e253",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string:madam\n",
      "'madam' is a palindrome string\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter a string:\")\n",
    "string=string.lower()\n",
    "if string==string[::-1]:\n",
    "    print(f\"'{string}' is a palindrome string\")\n",
    "else:\n",
    "    print(f\"'{string}' is a not palindrome string\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67890cdf",
   "metadata": {},
   "source": [
    "# 17. Write a program that calculates the average of a list of numbers, excluding the smallest and largest values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "1deb0116",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list:\n",
      " [22, 23, 45, 78, 95, 45, 12, 3, 5, 4]\n",
      "List excluding the smallest and largest values:\n",
      " [22, 23, 45, 78, 45, 12, 5, 4]\n",
      "Average of list of number excluding smallest and largest values: 29.25\n"
     ]
    }
   ],
   "source": [
    "sample_list=[22,23,45,78,95,45,12,3,5,4]\n",
    "print(\"Original list:\\n\",sample_list)\n",
    "if len(sample_list) < 3:\n",
    "    print(\"The list should have at least three numbers.\")\n",
    "sample_list.remove(min(sample_list))\n",
    "sample_list.remove(max(sample_list))\n",
    "average = sum(sample_list) / len(sample_list)\n",
    "print(\"List excluding the smallest and largest values:\\n\",sample_list)\n",
    "print(\"Average of list of number excluding smallest and largest values:\",average)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d58a2957",
   "metadata": {},
   "source": [
    "# 18. Develop a program that converts a given temperature from Celsius to Fahrenheit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "95a1a73b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the temperature in degree Celsius:95\n",
      "95.0°C = 203.0°F\n"
     ]
    }
   ],
   "source": [
    "celsius=float(input(\"Enter the temperature in degree Celsius:\"))\n",
    "fahrenheit=32+(9*celsius)/5\n",
    "print(f\"{celsius}°C = {fahrenheit}°F\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52c14093",
   "metadata": {},
   "source": [
    "# 19. Create a program that simulates a basic calculator for addition, subtraction, multiplication, and division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "7496de5a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first number:15\n",
      "Enter the second number:12\n",
      "\n",
      "Press 1 for addition\n",
      "Press 2 for subtraction\n",
      "Press 3 for multiplication\n",
      "Press 4 for division\n",
      "2\n",
      "15.0-12.0=3.0\n"
     ]
    }
   ],
   "source": [
    "num1=float(input(\"Enter the first number:\"))\n",
    "num2=float(input(\"Enter the second number:\"))\n",
    "print(\"\\nPress 1 for addition\")\n",
    "print(\"Press 2 for subtraction\")\n",
    "print(\"Press 3 for multiplication\")\n",
    "print(\"Press 4 for division\")\n",
    "choice=int(input())\n",
    "if choice==1:\n",
    "    print(f\"{num1}+{num2}={num1+num2}\")\n",
    "elif choice==2:\n",
    "    print(f\"{num1}-{num2}={num1-num2}\")\n",
    "elif choice==3:\n",
    "    print(f\"{num1}*{num2}={num1*num2}\")\n",
    "elif choice==4:\n",
    "    if num2==0:\n",
    "        print(\"Can't divide by 0\")\n",
    "    else:\n",
    "        print(f\"{num1}/{num2}={num1/num2}\")\n",
    "else:\n",
    "    print(\"Invalid choice\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06476928",
   "metadata": {},
   "source": [
    "# 20. Write a program that determines the roots of a cubic equation using the Cardano formula"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "1fd99336",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the coefficient of x^3 (a): 1\n",
      "Enter the coefficient of x^2 (b): -23\n",
      "Enter the coefficient of x (c): 142\n",
      "Enter the constant term (d): -120\n",
      "Roots of the cubic equation:\n",
      "Root 1: 12.000000\n",
      "Root 2: 1.000000\n",
      "Root 3: 10.000000\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "def cubic_roots(a, b, c, d):\n",
    "    if a == 0:\n",
    "        return \"Coefficient 'a' cannot be zero.\"\n",
    "\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",
    "\n",
    "    discriminant = (q**2 / 4) + (p**3 / 27)\n",
    "\n",
    "    if discriminant > 0:\n",
    "        u = (-q / 2 + math.sqrt(discriminant))**(1/3)\n",
    "        v = (-q / 2 - math.sqrt(discriminant))**(1/3)\n",
    "        root1 = u + v - b / (3 * a)\n",
    "        return [root1]\n",
    "\n",
    "    elif discriminant == 0:\n",
    "        root1 = (-q / 2)**(1/3) - b / (3 * a)\n",
    "        root2 = (-q / 2)**(1/3) - b / (3 * a)\n",
    "        return [root1, root2]\n",
    "\n",
    "    else:  # Discriminant is less than zero\n",
    "        r = math.sqrt(-(p**3) / 27)\n",
    "        theta = math.acos(-q / (2 * r))\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 - 2 * math.pi) / 3) - b / (3 * a)\n",
    "        return [root1, root2, root3]\n",
    "\n",
    "try:\n",
    "    a = float(input(\"Enter the coefficient of x^3 (a): \"))\n",
    "    b = float(input(\"Enter the coefficient of x^2 (b): \"))\n",
    "    c = float(input(\"Enter the coefficient of x (c): \"))\n",
    "    d = float(input(\"Enter the constant term (d): \"))\n",
    "\n",
    "    roots = cubic_roots(a, b, c, d)\n",
    "\n",
    "    print(\"Roots of the cubic equation:\")\n",
    "    for i, root in enumerate(roots):\n",
    "        print(f\"Root {i+1}: {root:.6f}\")\n",
    "\n",
    "except ValueError:\n",
    "    print(\"Invalid input. Please enter valid numerical coefficients.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8733642",
   "metadata": {},
   "source": [
    "# Advanced Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a07a6900",
   "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": 4,
   "id": "9b8ca657",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your annual income:₹720000\n",
      "You need to pay ₹34500.000 on your annual income of ₹720000.000\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "AMOUNT                             INCOME TAX RATE\n",
    "Up to ₹2,50,000                     0%\n",
    "₹2,50,001 – ₹5,00,000           5% above ₹2,50,000\n",
    "₹5,00,001 – ₹7,50,000           10% above ₹5,00,000 + ₹12,500\n",
    "₹7,50,001 – ₹10,00,000         15% above ₹7,50,000 + ₹37,500\n",
    "₹10,00,001 – ₹12,50,000       20% above ₹10,00,000 + ₹75,000\n",
    "₹12,50,001 – ₹15,00,000       25% above ₹12,50,000 + ₹1,25,000\n",
    "Above ₹15,00,001                  30% above ₹15,00,000 + ₹1,87,500\n",
    "'''\n",
    "\n",
    "\n",
    "def income_tax(income):\n",
    "    if income<=250000:\n",
    "        tax=0\n",
    "    elif income<=500000:\n",
    "        tax=(income-250000)*.05\n",
    "    elif income<=750000:\n",
    "        tax=(income-500000)*.1+12500\n",
    "    elif income<=1000000:\n",
    "        tax=(income-750000)*.15+37500\n",
    "    elif income<=1250000:\n",
    "        tax=(income-1000000)*.2+75000\n",
    "    elif income<=1500000:\n",
    "        tax=(income-1250000)*.25+125000\n",
    "    else:\n",
    "        tax=(income-1500000)*.3+187500\n",
    "    return tax\n",
    "\n",
    "income=float(input(\"Enter your annual income:₹\"))\n",
    "tax=income_tax(income)\n",
    "print(f\"You need to pay ₹{tax:.3f} on your annual income of ₹{income:.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "906b5add",
   "metadata": {},
   "source": [
    "# 22. Write a program that simulates a rock-paper-scissors game against the computer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d5415449",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your choice (rock, paper, or scissors): rock\n",
      "You chose 'rock'.\n",
      "The computer chose 'scissors'.\n",
      "Rock smashes scissors!,You win!\n",
      "Do you want to play again? (yes/no): no\n",
      "Thanks for playing!\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "def get_user_choice():\n",
    "    while True:\n",
    "        user_choice = input(\"Enter your choice (rock, paper, or scissors): \").lower()\n",
    "        if user_choice in [\"rock\", \"paper\", \"scissors\"]:\n",
    "            return user_choice\n",
    "        else:\n",
    "            print(\"Invalid choice. Please choose rock, paper, or scissors.\")\n",
    "\n",
    "def get_computer_choice():\n",
    "    choices = [\"rock\", \"paper\", \"scissors\"]\n",
    "    return random.choice(choices)\n",
    "\n",
    "def determine_winner(user_choice, computer_choice):\n",
    "    if user_choice == computer_choice:\n",
    "        return \"It's a tie!\"\n",
    "    elif user_choice == \"rock\" and computer_choice == \"scissors\":\n",
    "        return \"Rock smashes scissors!,You win!\"\n",
    "    elif user_choice == \"paper\" and computer_choice == \"rock\":\n",
    "        return \"Paper covers rock! You win!\"\n",
    "    elif user_choice == \"scissors\" and computer_choice == \"paper\":\n",
    "        return \"Scissors cuts paper! You win!\"\n",
    "    else:\n",
    "        return \"Computer wins!\"\n",
    "\n",
    "while True:\n",
    "    user_choice = get_user_choice()\n",
    "    computer_choice = get_computer_choice()\n",
    "    print(f\"You chose '{user_choice}'.\")\n",
    "    print(f\"The computer chose '{computer_choice}'.\")\n",
    "    \n",
    "    result = determine_winner(user_choice, computer_choice)\n",
    "    print(result)\n",
    "\n",
    "    play_again = input(\"Do you want to play again? (yes/no): \").lower()\n",
    "    if play_again != \"yes\":\n",
    "        break\n",
    "\n",
    "print(\"Thanks for playing!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fbaddcc",
   "metadata": {},
   "source": [
    "# 23. Develop a program that generates a random password based on user preferences (length, complexity)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e52c3a32",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*******************Welcome to the Random Password Generator!**************************\n",
      "Enter the desired password length: 12\n",
      "Include lowercase letters? (y/n): y\n",
      "Include uppercase letters? (y/n): y\n",
      "Include digits? (y/n): y\n",
      "Include special characters? (y/n): y\n",
      "\n",
      "Generated Password: OV!06x[\"$l<i\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import string\n",
    "\n",
    "print(\"*******************Welcome to the Random Password Generator!**************************\")\n",
    "\n",
    "length = int(input(\"Enter the desired password length: \"))\n",
    "use_lowercase = input(\"Include lowercase letters? (y/n): \").lower() == 'y'\n",
    "use_uppercase = input(\"Include uppercase letters? (y/n): \").lower() == 'y'\n",
    "use_digits = input(\"Include digits? (y/n): \").lower() == 'y'\n",
    "use_special_chars = input(\"Include special characters? (y/n): \").lower() == 'y'\n",
    "\n",
    "characters = ''\n",
    "\n",
    "if use_lowercase:\n",
    "    characters += string.ascii_lowercase\n",
    "if use_uppercase:\n",
    "    characters += string.ascii_uppercase\n",
    "if use_digits:\n",
    "    characters += string.digits\n",
    "if use_special_chars:\n",
    "    characters += string.punctuation\n",
    "\n",
    "if len(characters) == 0:\n",
    "    print(\"Please select at least one character type.\")\n",
    "else:\n",
    "    password = ''.join(random.choice(characters) for _ in range(length))\n",
    "    print(f\"\\nGenerated Password: {password}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2288b5ac",
   "metadata": {},
   "source": [
    "# 24. Create a program that implements a simple text-based adventure game with branching scenarios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1ffa7096",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "WELCOME! LET'S START THE ADVENTURE\n",
      "\n",
      "You are standing outside of your house and you see a man running towards you and asking for urgent shelter.\n",
      "\n",
      "Will you provide shelter to him. (Yes / No)\n",
      "\n",
      ">>no\n",
      "\n",
      "Now, he is trying to kill you. Will, you knock him down? (Yes / No)\n",
      "\n",
      ">>yes\n",
      "\n",
      "Congrats! He was a thief & You helped the police to catch him with your bravery.\n"
     ]
    }
   ],
   "source": [
    "answer_yes = [\"Yes\", \"Y\", \"yes\", \"y\"]\n",
    "answer_no = [\"No\", \"N\", \"no\", \"n\"]\n",
    "\n",
    "print(\"\"\"\n",
    "WELCOME! LET'S START THE ADVENTURE\n",
    "\n",
    "You are standing outside of your house and you see a man running towards you and asking for urgent shelter.\n",
    "\n",
    "Will you provide shelter to him. (Yes / No)\n",
    "\"\"\")\n",
    "\n",
    "ans1 = input(\">>\")\n",
    "\n",
    "if ans1 in answer_yes:\n",
    "    print(\"\\nAfter 2 minutes, the Police came to your house, and ask you that whether the thief is in your house or not. Will you say (Yes / No)\\n\")\n",
    "\n",
    "    ans2 = input(\">>\")\n",
    "\n",
    "    if ans2 in answer_yes:\n",
    "        print(\"\\nYou are an honest person. He was a thief & You won the Game\")\n",
    "\n",
    "    elif ans2 in answer_no:\n",
    "        print(\"\\nYou helped a thief. Now, go to Jail. GAME OVER\")\n",
    "\n",
    "    else:\n",
    "        print(\"\\nYou typed the wrong input. GOODBYE!\")\n",
    "\n",
    "elif ans1 in answer_no:\n",
    "    print(\"\\nNow, he is trying to kill you. Will, you knock him down? (Yes / No)\\n\")\n",
    "\n",
    "    ans3 = input(\">>\")\n",
    "\n",
    "    if ans3 in answer_yes:\n",
    "        print(\"\\nCongrats! He was a thief & You helped the police to catch him with your bravery.\")\n",
    "\n",
    "    elif ans3 in answer_no:\n",
    "        print(\"\\nSorry! You are dead. He was a thief & He killed you. GAME OVER\")\n",
    "\n",
    "    else:\n",
    "        print(\"\\nYou typed the wrong input. GOODBYE!\")\n",
    "\n",
    "else:\n",
    "    print(\"\\nYou typed the wrong input. GOODBYE!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dff2294",
   "metadata": {},
   "source": [
    "# 25. Build a program that solves a linear equation  for x, considering different cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "7b4ecbc8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***********************Linear Equation solver***********************\n",
      "Enter the coefficients'a' and 'b' in the equation of form ax+b=0\n",
      "a>>25\n",
      "b>>2\n",
      "The solution of the equation 25.0x + 2.0 = 0 is x=-0.08\n"
     ]
    }
   ],
   "source": [
    "print(\"***********************Linear Equation solver***********************\")\n",
    "print(\"Enter the coefficients'a' and 'b' in the equation of form ax+b=0\")\n",
    "a=float(input(\"a>>\"))\n",
    "b=float(input(\"b>>\"))\n",
    "if a==0:\n",
    "    if b==0:\n",
    "        print(f\"The equation {a}x + {b} = 0 has infinitely many solutions.\")\n",
    "    else:\n",
    "        print(f\"The equation {a}x + {b} = 0 has no solution.\")\n",
    "else:\n",
    "    x=-b/a\n",
    "    print(f\"The solution of the equation {a}x + {b} = 0 is x={x}\")\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ae78411",
   "metadata": {},
   "source": [
    "# 26. Write a program that simulates a basic quiz game with multiple-choice questions and scoring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "4d9d9824",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "****************Welcome to the Quiz game********************\n",
      "\n",
      "\n",
      "There will be 4 options a,b,c,d, you have to select the correct option.\n",
      "\n",
      "1._______ is the smallest unit of data in a computer ?\n",
      "\n",
      "a)Gigabyte \n",
      "b)Bit \n",
      "c)Byte \n",
      "d)Terabyte\n",
      "\n",
      "your choice>>b\n",
      "Correct answer!\n",
      "\n",
      "2.Which of the following is NOT an anti-virus software ?\n",
      "\n",
      "a)Avast \n",
      "b)Linux \n",
      "c)Norton \n",
      "d)Kaspersky \n",
      "\n",
      "your choice>>b\n",
      "Correct answer!\n",
      "\n",
      "3.In the context of digital computer, which of the following pairs of digits is referred to as binary code ?\n",
      "\n",
      "a)3 and 4 \n",
      "b)0 and 1 \n",
      "c)2 and 3 \n",
      "d)1 and 2 \n",
      "\n",
      "your choice>>b\n",
      "Correct answer!\n",
      "\n",
      "4.Which unit of the computer is considered as the brain of the computer ?\n",
      "\n",
      "a)Memory unit \n",
      "b)Input unit \n",
      "c)CPU \n",
      "d)Output unit \n",
      "\n",
      "your choice>>c\n",
      "Correct answer!\n",
      "\n",
      "5.What is the full form of PROM ?\n",
      "\n",
      "a)Program read-only memory \n",
      "b)Primary read-only memory \n",
      "c)Programmable read-only memory \n",
      "d)Program read-output memory \n",
      "\n",
      "\n",
      "your choice>>c\n",
      "Correct answer!\n",
      "\n",
      "6.In the context of computing, what is the full form of URL ?\n",
      "\n",
      "a)Undistributed Resource Locator \n",
      "b)Unified Resource Locator \n",
      "c)Uniform Resource Locator \n",
      "d)Uniform Region Locator \n",
      "\n",
      "\n",
      "your choice>>c\n",
      "Correct answer!\n",
      "\n",
      "7.Which of the following is an input device used to enter motion data in computers or other electronic devices ?\n",
      "\n",
      "a)Monitor \n",
      "b)Trackball \n",
      "c)Plotter \n",
      "d)Joystick \n",
      "\n",
      "\n",
      "your choice>>a\n",
      "Wrong answer!\n",
      "\n",
      "8.In the context of computing, a byte is equal to _____ bits ?\n",
      "\n",
      "a)4 \n",
      "b)16 \n",
      "c)24 \n",
      "d)8 \n",
      "\n",
      "your choice>>d\n",
      "Correct answer!\n",
      "\n",
      "9._____ is a small, portable flash memory card that plugs into a computer’s USB port and functions as a portable hard drive ?\n",
      "\n",
      "a)Flash drive \n",
      "b)CD-RW \n",
      "c)DVD-ROM \n",
      "d)CD-ROM \n",
      "\n",
      "your choice>>d\n",
      "Wrong answer!\n",
      "\n",
      "10.Which of the following devices is NOT used to enter data into a computer ?\n",
      "\n",
      "a)Mouse \n",
      "b)Keyboard \n",
      "c)Scanner \n",
      "d)Monitor\n",
      "\n",
      "your choice>>da\n",
      "Wrong answer!\n",
      "\n",
      "Your score is 7/10\n"
     ]
    }
   ],
   "source": [
    "print(\"****************Welcome to the Quiz game********************\")\n",
    "print(\"\\n\\nThere will be 4 options a,b,c,d, you have to select the correct option.\")\n",
    "options={1:'b',2:'b',3:'b',4:'c',5:'c',6:'c',7:'b',8:'d',9:'a',10:'d'}\n",
    "score=0\n",
    "def check(q,choice):\n",
    "    global score\n",
    "    if choice==options[q]:\n",
    "        score+=1\n",
    "        print(\"Correct answer!\")\n",
    "    else:\n",
    "        print(\"Wrong answer!\")\n",
    "\n",
    "        \n",
    "print(\"\"\"\n",
    "1._______ is the smallest unit of data in a computer ?\n",
    "\n",
    "a)Gigabyte \n",
    "b)Bit \n",
    "c)Byte \n",
    "d)Terabyte\n",
    "\"\"\")\n",
    "choice=input(\"your choice>>\").lower()\n",
    "check(1,choice)\n",
    "\n",
    "print(\"\"\"\n",
    "2.Which of the following is NOT an anti-virus software ?\n",
    "\n",
    "a)Avast \n",
    "b)Linux \n",
    "c)Norton \n",
    "d)Kaspersky \n",
    "\"\"\")\n",
    "choice=input(\"your choice>>\").lower()\n",
    "check(2,choice)\n",
    "\n",
    "print(\"\"\"\n",
    "3.In the context of digital computer, which of the following pairs of digits is referred to as binary code ?\n",
    "\n",
    "a)3 and 4 \n",
    "b)0 and 1 \n",
    "c)2 and 3 \n",
    "d)1 and 2 \n",
    "\"\"\")\n",
    "choice=input(\"your choice>>\").lower()\n",
    "check(3,choice)\n",
    "\n",
    "print(\"\"\"\n",
    "4.Which unit of the computer is considered as the brain of the computer ?\n",
    "\n",
    "a)Memory unit \n",
    "b)Input unit \n",
    "c)CPU \n",
    "d)Output unit \n",
    "\"\"\")\n",
    "choice=input(\"your choice>>\").lower()\n",
    "check(4,choice)\n",
    "\n",
    "print(\"\"\"\n",
    "5.What is the full form of PROM ?\n",
    "\n",
    "a)Program read-only memory \n",
    "b)Primary read-only memory \n",
    "c)Programmable read-only memory \n",
    "d)Program read-output memory \n",
    "\n",
    "\"\"\")\n",
    "choice=input(\"your choice>>\").lower()\n",
    "check(5,choice)\n",
    "\n",
    "print(\"\"\"\n",
    "6.In the context of computing, what is the full form of URL ?\n",
    "\n",
    "a)Undistributed Resource Locator \n",
    "b)Unified Resource Locator \n",
    "c)Uniform Resource Locator \n",
    "d)Uniform Region Locator \n",
    "\n",
    "\"\"\")\n",
    "choice=input(\"your choice>>\").lower()\n",
    "check(6,choice)\n",
    "\n",
    "print(\"\"\"\n",
    "7.Which of the following is an input device used to enter motion data in computers or other electronic devices ?\n",
    "\n",
    "a)Monitor \n",
    "b)Trackball \n",
    "c)Plotter \n",
    "d)Joystick \n",
    "\n",
    "\"\"\")\n",
    "choice=input(\"your choice>>\").lower()\n",
    "check(7,choice)\n",
    "\n",
    "print(\"\"\"\n",
    "8.In the context of computing, a byte is equal to _____ bits ?\n",
    "\n",
    "a)4 \n",
    "b)16 \n",
    "c)24 \n",
    "d)8 \n",
    "\"\"\")\n",
    "choice=input(\"your choice>>\").lower()\n",
    "check(8,choice)\n",
    "\n",
    "print(\"\"\"\n",
    "9._____ is a small, portable flash memory card that plugs into a computer’s USB port and functions as a portable hard drive ?\n",
    "\n",
    "a)Flash drive \n",
    "b)CD-RW \n",
    "c)DVD-ROM \n",
    "d)CD-ROM \n",
    "\"\"\")\n",
    "choice=input(\"your choice>>\").lower()\n",
    "check(9,choice)\n",
    "\n",
    "print(\"\"\"\n",
    "10.Which of the following devices is NOT used to enter data into a computer ?\n",
    "\n",
    "a)Mouse \n",
    "b)Keyboard \n",
    "c)Scanner \n",
    "d)Monitor\n",
    "\"\"\")\n",
    "choice=input(\"your choice>>\").lower()\n",
    "check(10,choice)\n",
    "print(f\"\\nYour score is {score}/10\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccf2bddf",
   "metadata": {},
   "source": [
    "# 27. Develop a program that determines whether a given year is a prime number or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "d43299ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the year>>2113\n",
      "2113 is a prime number\n"
     ]
    }
   ],
   "source": [
    "year=int(input(\"Enter the year>>\"))\n",
    "count=0\n",
    "for i in range(1,int(year/2)):\n",
    "    if year%i==0:\n",
    "        count+=1\n",
    "if count==1:\n",
    "    print(f\"{year} is a prime number\")\n",
    "else:\n",
    "    print(f\"{year} is not a prime number\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9795605a",
   "metadata": {},
   "source": [
    "# 28. Create a program that sorts three numbers in ascending order using conditional statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "e5dcf36e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter first number>>45\n",
      "Enter second number>>2\n",
      "Enter third number>>89\n",
      "Sorted numbers in ascending order: 2 < 45 < 89\n"
     ]
    }
   ],
   "source": [
    "num1=int(input(\"Enter first number>>\"))\n",
    "num2=int(input(\"Enter second number>>\"))\n",
    "num3=int(input(\"Enter third number>>\"))\n",
    "if num1 <= num2 <= num3:\n",
    "    smallest = num1\n",
    "    middle = num2\n",
    "    largest = num3\n",
    "elif num1 <= num3 <= num2:\n",
    "    smallest = num1\n",
    "    middle = num3\n",
    "    largest = num2\n",
    "elif num2 <= num1 <= num3:\n",
    "    smallest = num2\n",
    "    middle = num1\n",
    "    largest = num3\n",
    "elif num2 <= num3 <= num1:\n",
    "    smallest = num2\n",
    "    middle = num3\n",
    "    largest = num1\n",
    "elif num3 <= num1 <= num2:\n",
    "    smallest = num3\n",
    "    middle = num1\n",
    "    largest = num2\n",
    "else:\n",
    "    smallest = num3\n",
    "    middle = num2\n",
    "    largest = num1\n",
    "print(f\"Sorted numbers in ascending order: {smallest} < {middle} < {largest}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84c579c8",
   "metadata": {},
   "source": [
    "# 29. Build a program that determines the roots of a quartic equation using numerical methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "57d07775",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the coefficients 'a','b','c' of the quadratic equation of the form ax^2+bx+c.\n",
      "Enter a:1\n",
      "Enter b:-7\n",
      "Enter c:12\n",
      "Roots of the quadratic equation are real,unique and they are: 4.0 and 3.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print(\"Enter the coefficients 'a','b','c' of the quadratic equation of the form ax^2+bx+c.\")\n",
    "a=int(input(\"Enter a:\"))\n",
    "b=int(input(\"Enter b:\"))\n",
    "c=int(input(\"Enter c:\"))\n",
    "d=b**2-(4*a*c)\n",
    "if d>0:\n",
    "    root1=(-b+math.sqrt(d))/2*a\n",
    "    root2=(-b-math.sqrt(d))/2*a\n",
    "    print(f\"Roots of the quadratic equation are real,unique and they are: {root1} and {root2}\")\n",
    "elif d==0:\n",
    "    root=-b/(2*a)\n",
    "    print(f\"Roots of the quadratic equation are real,equal and they are: {root}\")\n",
    "else:\n",
    "    real_part = -b / (2*a)\n",
    "    imaginary_part = math.sqrt(abs(d)) / (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}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5410d0c2",
   "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": 38,
   "id": "36ba02bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your height in cm:165\n",
      "Enter your weight in kg:60\n",
      "Your BMI is: 22.03856749311295\n",
      "You are normal,You have a healthy weight. Keep up the good work with a balanced diet and regular exercise.\n"
     ]
    }
   ],
   "source": [
    "height=float(input(\"Enter your height in cm:\"))\n",
    "weight=float(input(\"Enter your weight in kg:\"))\n",
    "bmi=weight/((height/100)**2)\n",
    "print(\"Your BMI is:\",bmi)\n",
    "if bmi<=18.5:\n",
    "    print(\"You are underweight.It's important to maintain a balanced diet and consider consulting a nutritionist.\")\n",
    "elif 18.5<bmi<25:\n",
    "    print(\"You are normal,You have a healthy weight. Keep up the good work with a balanced diet and regular exercise.\")\n",
    "elif 25<bmi<30:\n",
    "    print(\"You are overweight.Consider adopting a healthier lifestyle with more physical activity and a balanced diet.\")\n",
    "else:\n",
    "    print(\"You are obese.It's crucial to consult a healthcare professional for a personalized weight management plan.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3382ef25",
   "metadata": {},
   "source": [
    "# Challenge Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fd2fc89",
   "metadata": {},
   "source": [
    "# 31. Create a program that validates a password based on complexity rules (length, characters, etc.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "a83b48ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a password: JB98U5jJHIK&^%&*\n",
      "Password is valid.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "def validate_password(password):\n",
    "\n",
    "    if len(password) < 8:\n",
    "        return \"Password must be at least 8 characters long.\"\n",
    "\n",
    "\n",
    "    if not re.search(r'[A-Z]', password):\n",
    "        return \"Password must contain at least one uppercase letter.\"\n",
    "\n",
    "\n",
    "    if not re.search(r'[a-z]', password):\n",
    "        return \"Password must contain at least one lowercase letter.\"\n",
    "\n",
    "    if not re.search(r'[0-9]', password):\n",
    "        return \"Password must contain at least one digit.\"\n",
    "\n",
    "    if not re.search(r'[!@#$%^&*]', password):\n",
    "        return \"Password must contain at least one special character (!@#$%^&*).\"\n",
    "\n",
    "    return \"Password is valid.\"\n",
    "\n",
    "\n",
    "password = input(\"Enter a password: \")\n",
    "\n",
    "\n",
    "validation_result = validate_password(password)\n",
    "print(validation_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc91d312",
   "metadata": {},
   "source": [
    "# 32. Develop a program that performs matrix addition and subtraction based on user input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "c646474b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number of rows for first matrix: 2\n",
      "Enter the number of columns for second matrix: 2\n",
      "Enter the number of rows for second matrix: 2\n",
      "Enter the number of columns for second matrix: 2\n",
      "Enter the elements of the first matrix:\n",
      "Enter element at row 1, column 1: 5\n",
      "Enter element at row 1, column 2: 6\n",
      "Enter element at row 2, column 1: 2\n",
      "Enter element at row 2, column 2: 3\n",
      "matrix 1:\n",
      "5  6  \n",
      "2  3  \n",
      "\n",
      "Enter the elements of the second matrix:\n",
      "Enter element at row 1, column 1: 4\n",
      "Enter element at row 1, column 2: 5\n",
      "Enter element at row 2, column 1: 2\n",
      "Enter element at row 2, column 2: 3\n",
      "matrix 2:\n",
      "4  5  \n",
      "2  3  \n",
      "\n",
      "\n",
      "Matrix Addition:\n",
      "9  11  \n",
      "4  6  \n",
      "\n",
      "Matrix Subtraction:\n",
      "1  1  \n",
      "0  0  \n"
     ]
    }
   ],
   "source": [
    "def matrix_addition(matrix1, matrix2):\n",
    "    if len(matrix1) != len(matrix2) or len(matrix1[0]) != len(matrix2[0]):\n",
    "        return None \n",
    "    \n",
    "    result = []\n",
    "    for i in range(len(matrix1)):\n",
    "        row = []\n",
    "        for j in range(len(matrix1[0])):\n",
    "            row.append(matrix1[i][j] + matrix2[i][j])\n",
    "        result.append(row)\n",
    "    return result\n",
    "\n",
    "def matrix_subtraction(matrix1, matrix2):\n",
    "    if len(matrix1) != len(matrix2) or len(matrix1[0]) != len(matrix2[0]):\n",
    "        return None \n",
    "    \n",
    "    result = []\n",
    "    for i in range(len(matrix1)):\n",
    "        row = []\n",
    "        for j in range(len(matrix1[0])):\n",
    "            row.append(matrix1[i][j] - matrix2[i][j])\n",
    "        result.append(row)\n",
    "    return result\n",
    "\n",
    "def display_matrix(matrix):\n",
    "    for row in matrix:\n",
    "        row_str = \"\"\n",
    "        for element in row:\n",
    "            row_str += str(element) + \"  \"\n",
    "        print(row_str)\n",
    "\n",
    "rows1 = int(input(\"Enter the number of rows for first matrix: \"))\n",
    "cols1 = int(input(\"Enter the number of columns for second matrix: \"))\n",
    "rows2 = int(input(\"Enter the number of rows for second matrix: \"))\n",
    "cols2 = int(input(\"Enter the number of columns for second matrix: \"))\n",
    "if rows1!=rows2 and cols1!=cols2:\n",
    "    print(\"Matrix addition and subtraction is not possible due to incomparable order!\")\n",
    "else:\n",
    "    print(\"Enter the elements of the first matrix:\")\n",
    "    matrix1 = []\n",
    "    for i in range(rows1):\n",
    "        row = []\n",
    "        for j in range(cols1):\n",
    "            element = int(input(f\"Enter element at row {i + 1}, column {j + 1}: \"))\n",
    "            row.append(element)\n",
    "        matrix1.append(row)\n",
    "    print(\"matrix 1:\")\n",
    "    display_matrix(matrix1)\n",
    "    print()\n",
    "    \n",
    "    print(\"Enter the elements of the second matrix:\")\n",
    "    matrix2 = []\n",
    "    for i in range(rows2):\n",
    "        row = []\n",
    "        for j in range(cols2):\n",
    "            element = int(input(f\"Enter element at row {i + 1}, column {j + 1}: \"))\n",
    "            row.append(element)\n",
    "        matrix2.append(row)\n",
    "    print(\"matrix 2:\")\n",
    "    display_matrix(matrix2)\n",
    "    print()\n",
    "    result_addition = matrix_addition(matrix1, matrix2)\n",
    "    if result_addition is not None:\n",
    "        print(\"\\nMatrix Addition:\")\n",
    "        display_matrix(result_addition)\n",
    "    else:\n",
    "        print(\"\\nMatrix addition is not possible due to different dimensions.\")\n",
    "    \n",
    "    result_subtraction = matrix_subtraction(matrix1, matrix2)\n",
    "    if result_subtraction is not None:\n",
    "        print(\"\\nMatrix Subtraction:\")\n",
    "        display_matrix(result_subtraction)\n",
    "    else:\n",
    "        print(\"\\nMatrix subtraction is not possible due to different dimensions.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de52f440",
   "metadata": {},
   "source": [
    "# 33. Write a program that calculates the greatest common divisor (GCD) of two numbers using the Euclidean algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "a2f0ea59",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first number:25\n",
      "Enter the second number:555\n",
      "The greatest common divisor (GCD) of 25 and 555 is 5.\n"
     ]
    }
   ],
   "source": [
    "num1=int(input(\"Enter the first number:\"))\n",
    "num2=int(input(\"Enter the second number:\"))\n",
    "\n",
    "def euclidean_gcd(a, b):\n",
    "    while b:\n",
    "        a, b = b, a % b\n",
    "    return a\n",
    "\n",
    "gcd = euclidean_gcd(num1, num2)\n",
    "\n",
    "print(f\"The greatest common divisor (GCD) of {num1} and {num2} is {gcd}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c433674",
   "metadata": {},
   "source": [
    "# 34. Build a program that performs matrix multiplication using nested loops and conditional statements\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "a1a40c27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number of rows for the first matrix: 2\n",
      "Enter the number of columns for the first matrix: 3\n",
      "Enter the number of rows for the second matrix: 3\n",
      "Enter the number of columns for the second matrix: 2\n",
      "Enter the elements of the first matrix:\n",
      "Enter element at row 1, column 1: 5\n",
      "Enter element at row 1, column 2: 6\n",
      "Enter element at row 1, column 3: 4\n",
      "Enter element at row 2, column 1: 2\n",
      "Enter element at row 2, column 2: 3\n",
      "Enter element at row 2, column 3: 5\n",
      "Matrix 1:\n",
      "5   6   4   \n",
      "2   3   5   \n",
      "\n",
      "Enter the elements of the second matrix:\n",
      "Enter element at row 1, column 1: 6\n",
      "Enter element at row 1, column 2: 2\n",
      "Enter element at row 2, column 1: 3\n",
      "Enter element at row 2, column 2: 5\n",
      "Enter element at row 3, column 1: 6\n",
      "Enter element at row 3, column 2: 5\n",
      "Matrix 2:\n",
      "6   2   \n",
      "3   5   \n",
      "6   5   \n",
      "\n",
      "Matrix Multiplication:\n",
      "72   60   \n",
      "51   44   \n"
     ]
    }
   ],
   "source": [
    "def matrix_multiplication(matrix1, matrix2):\n",
    "    if len(matrix1[0]) != len(matrix2):\n",
    "        return None\n",
    "    result = []\n",
    "    for i in range(len(matrix1)):\n",
    "        row = []\n",
    "        for j in range(len(matrix2[0])):\n",
    "            element = 0\n",
    "            for k in range(len(matrix2)):\n",
    "                element += matrix1[i][k] * matrix2[k][j]\n",
    "            row.append(element)\n",
    "        result.append(row)\n",
    "    return result\n",
    "\n",
    "\n",
    "def display_matrix(matrix):\n",
    "    for row in matrix:\n",
    "        row_str = \"\"\n",
    "        for element in row:\n",
    "            row_str += str(element) + \"   \"\n",
    "        print(row_str)\n",
    "\n",
    "\n",
    "rows1 = int(input(\"Enter the number of rows for the first matrix: \"))\n",
    "cols1 = int(input(\"Enter the number of columns for the first matrix: \"))\n",
    "rows2 = int(input(\"Enter the number of rows for the second matrix: \"))\n",
    "cols2 = int(input(\"Enter the number of columns for the second matrix: \"))\n",
    "\n",
    "if cols1 != rows2:\n",
    "    print(\"Matrix multiplication is not possible due to incompatible dimensions.\")\n",
    "else:\n",
    "    print(\"Enter the elements of the first matrix:\")\n",
    "    matrix1 = []\n",
    "    for i in range(rows1):\n",
    "        row = []\n",
    "        for j in range(cols1):\n",
    "            element = int(input(f\"Enter element at row {i + 1}, column {j + 1}: \"))\n",
    "            row.append(element)\n",
    "        matrix1.append(row)\n",
    "    print(\"Matrix 1:\")\n",
    "    display_matrix(matrix1)\n",
    "    print(\"\\nEnter the elements of the second matrix:\")\n",
    "    matrix2 = []\n",
    "    for i in range(rows2):\n",
    "        row = []\n",
    "        for j in range(cols2):\n",
    "            element = int(input(f\"Enter element at row {i + 1}, column {j + 1}: \"))\n",
    "            row.append(element)\n",
    "        matrix2.append(row)\n",
    "    print(\"Matrix 2:\")\n",
    "    display_matrix(matrix2)\n",
    "\n",
    "    result = matrix_multiplication(matrix1, matrix2)\n",
    "    \n",
    "    if result is not None:\n",
    "        print(\"\\nMatrix Multiplication:\")\n",
    "        display_matrix(result)\n",
    "    else:\n",
    "        print(\"\\nMatrix multiplication is not possible due to incompatible dimensions.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71d9fae7",
   "metadata": {},
   "source": [
    "# 35. Create a program that simulates a basic text-based tic-tac-toe game against the computer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "68204208",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Tic-Tac-Toe!\n",
      "  |   |  \n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "Enter row and column (e.g., 1 2): 2 2\n",
      "  |   |  \n",
      "---------\n",
      "  | X |  \n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "Computer's Move:\n",
      "  |   | O\n",
      "---------\n",
      "  | X |  \n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "Enter row and column (e.g., 1 2): 1 2\n",
      "  | X | O\n",
      "---------\n",
      "  | X |  \n",
      "---------\n",
      "  |   |  \n",
      "---------\n",
      "Computer's Move:\n",
      "  | X | O\n",
      "---------\n",
      "  | X |  \n",
      "---------\n",
      "O |   |  \n",
      "---------\n",
      "Enter row and column (e.g., 1 2): 2 2\n",
      "Invalid move. Try again.\n",
      "Enter row and column (e.g., 1 2): 1 3\n",
      "Invalid move. Try again.\n",
      "Enter row and column (e.g., 1 2): 2 3\n",
      "  | X | O\n",
      "---------\n",
      "  | X | X\n",
      "---------\n",
      "O |   |  \n",
      "---------\n",
      "Computer's Move:\n",
      "  | X | O\n",
      "---------\n",
      "  | X | X\n",
      "---------\n",
      "O | O |  \n",
      "---------\n",
      "Enter row and column (e.g., 1 2): 1 1\n",
      "X | X | O\n",
      "---------\n",
      "  | X | X\n",
      "---------\n",
      "O | O |  \n",
      "---------\n",
      "Computer's Move:\n",
      "X | X | O\n",
      "---------\n",
      "  | X | X\n",
      "---------\n",
      "O | O | O\n",
      "---------\n",
      "Computer wins! Better luck next time.\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "def print_board(board):\n",
    "    for row in board:\n",
    "        print(\" | \".join(row))\n",
    "        print(\"-\" * 9)\n",
    "\n",
    "\n",
    "def check_winner(board, player):\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",
    "# Function to make a computer move\n",
    "def computer_move(board, computer_char):\n",
    "    empty_cells = [(i, j) for i in range(3) for j in range(3) if board[i][j] == \" \"]\n",
    "    if empty_cells:\n",
    "        return random.choice(empty_cells)\n",
    "    else:\n",
    "        return None\n",
    "\n",
    "# Initialize the Tic-Tac-Toe board\n",
    "board = [[\" \" for _ in range(3)] for _ in range(3)]\n",
    "\n",
    "# Print the initial board\n",
    "print(\"Welcome to Tic-Tac-Toe!\")\n",
    "print_board(board)\n",
    "\n",
    "# Main game loop\n",
    "player_char = \"X\"\n",
    "computer_char = \"O\"\n",
    "while True:\n",
    "    # Player's move\n",
    "    while True:\n",
    "        try:\n",
    "            row, col = map(int, input(\"Enter row and column (e.g., 1 2): \").split())\n",
    "            if 1 <= row <= 3 and 1 <= col <= 3 and board[row - 1][col - 1] == \" \":\n",
    "                board[row - 1][col - 1] = player_char\n",
    "                break\n",
    "            else:\n",
    "                print(\"Invalid move. Try again.\")\n",
    "        except (ValueError, IndexError):\n",
    "            print(\"Invalid input. Enter row and column as numbers, e.g., '1 2'.\")\n",
    "\n",
    "    # Print the updated board\n",
    "    print_board(board)\n",
    "\n",
    "    # Check if the player has won\n",
    "    if check_winner(board, player_char):\n",
    "        print(\"Congratulations! You win!\")\n",
    "        break\n",
    "\n",
    "    # Check for a tie\n",
    "    if all(cell != \" \" for row in board for cell in row):\n",
    "        print(\"It's a tie!\")\n",
    "        break\n",
    "\n",
    "    # Computer's move\n",
    "    computer_row, computer_col = computer_move(board, computer_char)\n",
    "    if computer_row is not None:\n",
    "        board[computer_row][computer_col] = computer_char\n",
    "\n",
    "        # Print the updated board\n",
    "        print(\"Computer's Move:\")\n",
    "        print_board(board)\n",
    "\n",
    "        # Check if the computer has won\n",
    "        if check_winner(board, computer_char):\n",
    "            print(\"Computer wins! Better luck next time.\")\n",
    "            break\n",
    "    else:\n",
    "        print(\"It's a tie!\")\n",
    "        break\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6eb6589c",
   "metadata": {},
   "source": [
    "# 36. Write a program that generates Fibonacci numbers up to a specified term using iterative methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "e024683b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value of n:15\n",
      "First 15 fibonacci numbers are:\n",
      "0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 "
     ]
    }
   ],
   "source": [
    "n=int(input(\"Enter the value of n:\"))\n",
    "a=0\n",
    "b=1\n",
    "print(\"First\",n,\"fibonacci numbers are:\")\n",
    "print(a,b,end=\" \")\n",
    "for i in range(n-2):\n",
    "    c=a+b\n",
    "    a=b\n",
    "    b=c\n",
    "    print(c,end=\" \")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ce44e61",
   "metadata": {},
   "source": [
    "# 37. Develop a program that calculates the nth term of the Fibonacci sequence using memoization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "def2ffb7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the term (n) to calculate the Fibonacci number for: 14\n",
      "The Fibonacci number at term 14 is: 377\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def fibonacci(n, memo={}):\n",
    "    if n in memo:\n",
    "        return memo[n]\n",
    "    if n <= 1:\n",
    "        return n\n",
    "    memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)\n",
    "    return memo[n]\n",
    "\n",
    "\n",
    "term = int(input(\"Enter the term (n) to calculate the Fibonacci number for: \"))\n",
    "\n",
    "if term < 0:\n",
    "    print(\"Please enter a non-negative integer.\")\n",
    "else:\n",
    "\n",
    "    result = fibonacci(term)\n",
    "\n",
    "    print(f\"The Fibonacci number at term {term} is: {result}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d537a9a2",
   "metadata": {},
   "source": [
    "# 38. Create a program that generates a calendar for a given month and year using conditional statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "889d7799",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the year: 2002\n",
      "Enter the month (1-12): 7\n",
      "\n",
      "Calendar for 7/2002:\n",
      "\n",
      "     July 2002\n",
      "Mo Tu We Th Fr Sa Su\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": [
    "import calendar\n",
    "\n",
    "def generate_calendar(year, month):\n",
    "    cal = calendar.month(year, month)\n",
    "    return cal\n",
    "\n",
    "\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",
    "    print(\"Invalid month. Please enter a number between 1 and 12.\")\n",
    "else:\n",
    "    print(f\"\\nCalendar for {month}/{year}:\\n\")\n",
    "    calendar_text = generate_calendar(year, month)\n",
    "    print(calendar_text)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a32b71d9",
   "metadata": {},
   "source": [
    "# 39. Build a program that simulates a basic text-based blackjack game against the computer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a37f96ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cards Player Has: [('6', 'Hearts'), ('9', 'Diamonds')]\n",
      "Score Of The Player: 15\n",
      "\n",
      "\n",
      "What do you want? [\"play\" to request another card, \"stop\" to stop]: play\n",
      "Cards Player Has: [('6', 'Hearts'), ('9', 'Diamonds'), ('7', 'Spades')]\n",
      "Score Of The Player: 22\n",
      "\n",
      "\n",
      "What do you want? [\"play\" to request another card, \"stop\" to stop]: play\n",
      "Cards Dealer Has: [('8', 'Spades'), ('Jack', 'Spades')]\n",
      "Score Of The Dealer: 18\n",
      "Cards Player Has: [('6', 'Hearts'), ('9', 'Diamonds'), ('7', 'Spades'), ('5', 'Diamonds')]\n",
      "Score Of The Player: 22\n",
      "Dealer wins (Player Loss Because Player Score is exceeding 21)\n",
      "Cards Dealer Has: [('8', 'Spades'), ('Jack', 'Spades')]\n",
      "Score Of The Dealer: 18\n",
      "\n",
      "\n",
      "Cards Dealer Has: [('8', 'Spades'), ('Jack', 'Spades')]\n",
      "Score Of The Dealer: 18\n",
      "Cards Player Has: [('6', 'Hearts'), ('9', 'Diamonds'), ('7', 'Spades'), ('5', 'Diamonds')]\n",
      "Score Of The Player: 22\n",
      "Player wins (Player Has High Score than Dealer)\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "card_categories = ['Hearts', 'Diamonds', 'Clubs', 'Spades']\n",
    "cards_list = ['Ace', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'Jack', 'Queen', 'King']\n",
    "deck = [(card, category) for category in card_categories for card in cards_list]\n",
    "\n",
    "def card_value(card):\n",
    "\tif card[0] in ['Jack', 'Queen', 'King']:\n",
    "\t\treturn 10\n",
    "\telif card[0] == 'Ace':\n",
    "\t\treturn 11\n",
    "\telse:\n",
    "\t\treturn int(card[0])\n",
    "\n",
    "random.shuffle(deck)\n",
    "player_card = [deck.pop(), deck.pop()]\n",
    "dealer_card = [deck.pop(), deck.pop()]\n",
    "\n",
    "while True:\n",
    "\tplayer_score = sum(card_value(card) for card in player_card)\n",
    "\tdealer_score = sum(card_value(card) for card in dealer_card)\n",
    "\tprint(\"Cards Player Has:\", player_card)\n",
    "\tprint(\"Score Of The Player:\", player_score)\n",
    "\tprint(\"\\n\")\n",
    "\tchoice = input('What do you want? [\"play\" to request another card, \"stop\" to stop]: ').lower()\n",
    "\tif choice == \"play\":\n",
    "\t\tnew_card = deck.pop()\n",
    "\t\tplayer_card.append(new_card)\n",
    "\telif choice == \"stop\":\n",
    "\t\tbreak\n",
    "\telse:\n",
    "\t\tprint(\"Invalid choice. Please try again.\")\n",
    "\t\tcontinue\n",
    "\n",
    "\tif player_score > 21:\n",
    "\t\tprint(\"Cards Dealer Has:\", dealer_card)\n",
    "\t\tprint(\"Score Of The Dealer:\", dealer_score)\n",
    "\t\tprint(\"Cards Player Has:\", player_card)\n",
    "\t\tprint(\"Score Of The Player:\", player_score)\n",
    "\t\tprint(\"Dealer wins (Player Loss Because Player Score is exceeding 21)\")\n",
    "\t\tbreak\n",
    "\n",
    "while dealer_score < 17:\n",
    "\tnew_card = deck.pop()\n",
    "\tdealer_card.append(new_card)\n",
    "\tdealer_score += card_value(new_card)\n",
    "\n",
    "print(\"Cards Dealer Has:\", dealer_card)\n",
    "print(\"Score Of The Dealer:\", dealer_score)\n",
    "print(\"\\n\")\n",
    "\n",
    "if dealer_score > 21:\n",
    "\tprint(\"Cards Dealer Has:\", dealer_card)\n",
    "\tprint(\"Score Of The Dealer:\", dealer_score)\n",
    "\tprint(\"Cards Player Has:\", player_card)\n",
    "\tprint(\"Score Of The Player:\", player_score)\n",
    "\tprint(\"Player wins (Dealer Loss Because Dealer Score is exceeding 21)\")\n",
    "elif player_score > dealer_score:\n",
    "\tprint(\"Cards Dealer Has:\", dealer_card)\n",
    "\tprint(\"Score Of The Dealer:\", dealer_score)\n",
    "\tprint(\"Cards Player Has:\", player_card)\n",
    "\tprint(\"Score Of The Player:\", player_score)\n",
    "\tprint(\"Player wins (Player Has High Score than Dealer)\")\n",
    "elif dealer_score > player_score:\n",
    "\tprint(\"Cards Dealer Has:\", dealer_card)\n",
    "\tprint(\"Score Of The Dealer:\", dealer_score)\n",
    "\tprint(\"Cards Player Has:\", player_card)\n",
    "\tprint(\"Score Of The Player:\", player_score)\n",
    "\tprint(\"Dealer wins (Dealer Has High Score than Player)\")\n",
    "else:\n",
    "\tprint(\"Cards Dealer Has:\", dealer_card)\n",
    "\tprint(\"Score Of The Dealer:\", dealer_score)\n",
    "\tprint(\"Cards Player Has:\", player_card)\n",
    "\tprint(\"Score Of The Player:\", player_score)\n",
    "\tprint(\"It's a tie.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d903ce40",
   "metadata": {},
   "source": [
    "# 40. Write a program that generates the prime factors of a given number using trial division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "780f3c43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number to find its prime factors: 144\n",
      "The prime factors of 144 are: 2, 2, 2, 2, 3, 3\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 = n // divisor  # Update n by dividing it by the divisor\n",
    "        else:\n",
    "            divisor += 1\n",
    "\n",
    "    return factors\n",
    "\n",
    "num = int(input(\"Enter a number to find its prime factors: \"))\n",
    "\n",
    "if num <= 1:\n",
    "    print(\"Please enter a positive integer greater than 1.\")\n",
    "else:\n",
    "    factors = prime_factors(num)\n",
    "    \n",
    "    if len(factors) == 0:\n",
    "        print(f\"{num} is a prime number, and it has no prime factors other than itself.\")\n",
    "    else:\n",
    "        print(\"The prime factors of\", num, \"are:\", end=\" \")\n",
    "        for i in range(len(factors)):\n",
    "            if i < len(factors) - 1:\n",
    "                print(factors[i], end=\", \")\n",
    "            else:\n",
    "                print(factors[i])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7dbc37d",
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}