3rd_September_for_loop_assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "faf622f3",
   "metadata": {},
   "source": [
    "# Basic Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f8e8b5a",
   "metadata": {},
   "source": [
    "# 1. Write a Python program to print the numbers from 1 to 10 using a `for` loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ae9f8e7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,11):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d8a62a9",
   "metadata": {},
   "source": [
    "# 2. Create a program that calculates the sum of all numbers in a list using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "92aa3b96",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of all numbers in a list is  55\n"
     ]
    }
   ],
   "source": [
    "my_list=[1,2,3,4,5,6,7,8,9,10]\n",
    "list_sum=0\n",
    "for i in my_list:\n",
    "    list_sum+=i\n",
    "print(\"Sum of all numbers in a list is \",list_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef7bd805",
   "metadata": {},
   "source": [
    "# 3. Write a program to print the characters of a string in reverse order using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "abb1c9fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tnemngissA"
     ]
    }
   ],
   "source": [
    "my_string=\"Assignment\"\n",
    "rev=\"\"\n",
    "for char in my_string:\n",
    "    rev=char+rev\n",
    "print(rev,end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98a5895f",
   "metadata": {},
   "source": [
    "# 4. Develop a program that finds the factorial of a given number using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "ff1309f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number whose factorial is to be found:5\n",
      "The factorial of 5  is: 120\n"
     ]
    }
   ],
   "source": [
    "n=int(input(\"Enter a number whose factorial is to be found:\"))\n",
    "p=1\n",
    "for i in range(1,n+1):\n",
    "    p=p*i\n",
    "print(\"The factorial of\",n,\" is:\",p)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20d86604",
   "metadata": {},
   "source": [
    "# 5. Create a program to print the multiplication table of a given number using a `for` loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "1b1d23fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number whose multiplication table is to be calculated:7\n",
      "7 * 1 = 7\n",
      "7 * 2 = 14\n",
      "7 * 3 = 21\n",
      "7 * 4 = 28\n",
      "7 * 5 = 35\n",
      "7 * 6 = 42\n",
      "7 * 7 = 49\n",
      "7 * 8 = 56\n",
      "7 * 9 = 63\n",
      "7 * 10 = 70\n"
     ]
    }
   ],
   "source": [
    "n=int(input(\"Enter the number whose multiplication table is to be calculated:\"))\n",
    "for i in range(1,11):\n",
    "    print(n,\"*\",i,\"=\",n*i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03bc1db2",
   "metadata": {},
   "source": [
    "# 6. Write a program that counts the number of even and odd numbers in a list using a `for` loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "365f45e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of even elements in the list: 5\n",
      "Number of odd elements in the list: 6\n"
     ]
    }
   ],
   "source": [
    "my_list=[1,2,3,4,5,6,7,8,9,10,55]\n",
    "c_even=0\n",
    "c_odd=0\n",
    "for i in my_list:\n",
    "    if i%2==0:\n",
    "        c_even+=1\n",
    "    elif i%2!=0:\n",
    "        c_odd+=1\n",
    "print(\"Number of even elements in the list:\",c_even)\n",
    "print(\"Number of odd elements in the list:\",c_odd)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "097b8dc3",
   "metadata": {},
   "source": [
    "# 7. Develop a program that prints the squares of numbers from 1 to 5 using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "e7fc166d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Squares of numbers from 1 to 5:\n",
      "1  4  9  16  25  "
     ]
    }
   ],
   "source": [
    "print(\"Squares of numbers from 1 to 5:\")\n",
    "for i in range(1,6):\n",
    "    print(i**2,end=\"  \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17f037eb",
   "metadata": {},
   "source": [
    "# 8. Create a program to find the length of a string without using the `len()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "1c468586",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string:assignment\n",
      "Length of the given string is: 10\n"
     ]
    }
   ],
   "source": [
    "my_string=input(\"Enter a string:\")\n",
    "count=0\n",
    "for char in my_string:\n",
    "    count+=1\n",
    "print(\"Length of the given string is:\",count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5f470e1",
   "metadata": {},
   "source": [
    "# 9. Write a program that calculates the average of a list of numbers using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "59994a3e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average of the list is: 5.5\n"
     ]
    }
   ],
   "source": [
    "my_list=[1,2,3,4,5,6,7,8,9,10]\n",
    "n=len(my_list)\n",
    "sum_list=0\n",
    "for i in my_list:\n",
    "    sum_list+=i\n",
    "#calculating the average of the list\n",
    "avg=sum_list/n\n",
    "print(\"Average of the list is:\",avg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bdf93a8",
   "metadata": {},
   "source": [
    "# 10. Develop a program that prints the first `n` Fibonacci numbers using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "571c474f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value of n:10\n",
      "First 10 fibonacci numbers are:\n",
      "0 1 1 2 3 5 8 13 21 34 "
     ]
    }
   ],
   "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": "fa338c73",
   "metadata": {},
   "source": [
    "# Intermediate Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3141ae03",
   "metadata": {},
   "source": [
    "# 11. Write a program to check if a given list contains any duplicates using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "60bbac24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The list contains duplicate elements\n"
     ]
    }
   ],
   "source": [
    "my_list=[1,5,6,8,7,9,0,2,1]\n",
    "flag=-1\n",
    "for i in range(0,len(my_list)):\n",
    "    for j in range(i+1,len(my_list)):\n",
    "        if my_list[i]==my_list[j]:\n",
    "            flag=1\n",
    "            break\n",
    "if flag==1:\n",
    "    print(\"The list contains duplicate elements\")\n",
    "else:\n",
    "    print(\"The list does not contain duplicate elements\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ff42323",
   "metadata": {},
   "source": [
    "# 12. Create a program that prints the prime numbers in a given range using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "fe5ba136",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first value of the range:1\n",
      "Enter the last value of the range:50\n",
      "\n",
      "Prime numbers between 1 & 50  are:\n",
      "\n",
      "2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, "
     ]
    }
   ],
   "source": [
    "a=int(input(\"Enter the first value of the range:\"))\n",
    "b=int(input(\"Enter the last value of the range:\"))\n",
    "print(\"\\nPrime numbers between\",a,\"&\",b,\" are:\\n\")\n",
    "for i in range(a,b+1):\n",
    "    count=0\n",
    "    for j in range(1,i+1):\n",
    "        if i%j==0:\n",
    "            count+=1\n",
    "    if count==2:\n",
    "        print(i,end=\", \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9370339e",
   "metadata": {},
   "source": [
    "# 13. Develop a program that counts the number of vowels in a string using a `for` loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "bd8d37bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:cauliflower\n",
      "Number of vowels in the string 'cauliflower' is: 5\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "string=string.lower()\n",
    "vowels=\"aeiou\"\n",
    "count=0\n",
    "for char in string:\n",
    "    if char in vowels:\n",
    "        count+=1\n",
    "print(f\"Number of vowels in the string '{string}' is:\",count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cb7ca5d",
   "metadata": {},
   "source": [
    "# 14. Write a program to find the maximum element in a 2D list using a nested `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cf795840",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The maximum element in the matrix is: 111\n"
     ]
    }
   ],
   "source": [
    "def find_max_element(matrix):\n",
    "    if not matrix:\n",
    "        return None\n",
    "    max_element = matrix[0][0] \n",
    "    for row in matrix:\n",
    "        for element in row:\n",
    "            if element > max_element:\n",
    "                max_element = element \n",
    "    return max_element\n",
    "\n",
    "list2d=[[1,2,3,4,5],[1,33,111,56,7],[-11,-2,3,-8,57]]\n",
    "max_ele=find_max_element(list2d)\n",
    "print(\"The maximum element in the matrix is:\",max_ele)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a76c8bd6",
   "metadata": {},
   "source": [
    "# 15. Create a program that removes all occurrences of a specific element from a list using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a3c6f9bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the element you want to remove:45\n",
      "Original list:\n",
      " [1, 2, 3, 4, 5, 8, 7, 9, 5, 45, 12, 45, 78, 45, 2, 5]\n",
      "After removing the element 45,the modified list\n",
      " [1, 2, 3, 4, 5, 8, 7, 9, 5, 12, 78, 2, 5]\n"
     ]
    }
   ],
   "source": [
    "sample_list=[1,2,3,4,5,8,7,9,5,45,12,45,78,45,2,5]\n",
    "n=int(input(\"Enter the element you want to remove:\"))\n",
    "print(\"Original list:\\n\",sample_list)\n",
    "for i in sample_list:\n",
    "    if i==n:\n",
    "        sample_list.remove(n)\n",
    "print(f\"After removing the element {n},the modified list\\n\",sample_list)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e969f983",
   "metadata": {},
   "source": [
    "# 16. Develop a program that generates a multiplication table for numbers from 1 to 5 using a nested `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2d05ef00",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiplication table for 1\n",
      "\n",
      "1 * 1 = 1\n",
      "1 * 2 = 2\n",
      "1 * 3 = 3\n",
      "1 * 4 = 4\n",
      "1 * 5 = 5\n",
      "1 * 6 = 6\n",
      "1 * 7 = 7\n",
      "1 * 8 = 8\n",
      "1 * 9 = 9\n",
      "1 * 10 = 10\n",
      "\n",
      "Multiplication table for 2\n",
      "\n",
      "2 * 1 = 2\n",
      "2 * 2 = 4\n",
      "2 * 3 = 6\n",
      "2 * 4 = 8\n",
      "2 * 5 = 10\n",
      "2 * 6 = 12\n",
      "2 * 7 = 14\n",
      "2 * 8 = 16\n",
      "2 * 9 = 18\n",
      "2 * 10 = 20\n",
      "\n",
      "Multiplication table for 3\n",
      "\n",
      "3 * 1 = 3\n",
      "3 * 2 = 6\n",
      "3 * 3 = 9\n",
      "3 * 4 = 12\n",
      "3 * 5 = 15\n",
      "3 * 6 = 18\n",
      "3 * 7 = 21\n",
      "3 * 8 = 24\n",
      "3 * 9 = 27\n",
      "3 * 10 = 30\n",
      "\n",
      "Multiplication table for 4\n",
      "\n",
      "4 * 1 = 4\n",
      "4 * 2 = 8\n",
      "4 * 3 = 12\n",
      "4 * 4 = 16\n",
      "4 * 5 = 20\n",
      "4 * 6 = 24\n",
      "4 * 7 = 28\n",
      "4 * 8 = 32\n",
      "4 * 9 = 36\n",
      "4 * 10 = 40\n",
      "\n",
      "Multiplication table for 5\n",
      "\n",
      "5 * 1 = 5\n",
      "5 * 2 = 10\n",
      "5 * 3 = 15\n",
      "5 * 4 = 20\n",
      "5 * 5 = 25\n",
      "5 * 6 = 30\n",
      "5 * 7 = 35\n",
      "5 * 8 = 40\n",
      "5 * 9 = 45\n",
      "5 * 10 = 50\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,6):\n",
    "    print(f\"Multiplication table for {i}\\n\")\n",
    "    for j in range(1,11):\n",
    "        print(i,\"*\",j,\"=\",i*j)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1907454",
   "metadata": {},
   "source": [
    "# 17. Write a program that converts a list of Fahrenheit temperatures to Celsius using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "4edf71c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of fahrenheit temperature:\n",
      " [32, 212, 45, 78, 52, 45, 12, 63]\n",
      "List of celsius temperature:\n",
      " [0.0, 100.0, 7.222, 25.556, 11.111, 7.222, -11.111, 17.222]\n"
     ]
    }
   ],
   "source": [
    "fahrenheit_list=[32,212,45,78,52,45,12,63]\n",
    "celsius_list=[]\n",
    "for i in fahrenheit_list:\n",
    "    c=5*(i-32)/9\n",
    "    c=round(c,3)\n",
    "    celsius_list.append(c)\n",
    "print(\"List of fahrenheit temperature:\\n\",fahrenheit_list)\n",
    "print(\"List of celsius temperature:\\n\",celsius_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2f939fa",
   "metadata": {},
   "source": [
    "# 18. Create a program to print the common elements from two lists using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "fe54e1f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list1: [2, 4, 6, 8, 10]\n",
      "List2: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "Common elements in both lists:\n",
      "2  4  6  8  10  "
     ]
    }
   ],
   "source": [
    "list1=[2,4,6,8,10]\n",
    "list2=[1,2,3,4,5,6,7,8,9,10]\n",
    "print(\"list1:\",list1)\n",
    "print(\"List2:\",list2)\n",
    "print(\"Common elements in both lists:\")\n",
    "for i in list1:\n",
    "    if i in list2:\n",
    "        print(i,end=\"  \")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9172d75",
   "metadata": {},
   "source": [
    "# 19. Develop a program that prints the pattern of right-angled triangles using a `for` loop. Use ‘*’ to draw the pattern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "6391238b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n",
      "* * * * * * \n",
      "* * * * * * * \n",
      "* * * * * * * * \n",
      "* * * * * * * * * \n",
      "* * * * * * * * * * \n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(\"* \"*(i+1))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d6e3de1",
   "metadata": {},
   "source": [
    "# 20. Write a program to find the greatest common divisor (GCD) of two numbers using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "3de4297e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first number:56\n",
      "Enter the second number:21\n",
      "\n",
      "GCD of 56 and 21 is 7\n"
     ]
    }
   ],
   "source": [
    "num1=int(input(\"Enter the first number:\"))\n",
    "num2=int(input(\"Enter the second number:\"))\n",
    "min_ele=min(num1,num2)\n",
    "for i in range(1,min_ele+1):\n",
    "    if (num1%i==0) and (num2%i==0):\n",
    "        gcd=i\n",
    "print(f\"\\nGCD of {num1} and {num2} is {gcd}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9eb0b57",
   "metadata": {},
   "source": [
    "# Advanced Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5cbc135",
   "metadata": {},
   "source": [
    "# 21. Create a program that calculates the sum of the digits of numbers in a list using a list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d2a61e54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of digit sums: 48\n"
     ]
    }
   ],
   "source": [
    "def digit_sum(number):\n",
    "    return sum(int(digit) for digit in str(number))\n",
    "\n",
    "def sum_of_digit_sums(numbers):\n",
    "    return sum(digit_sum(number) for number in numbers)\n",
    "\n",
    "numbers = [123, 45, 6789, 12]\n",
    "\n",
    "result = sum_of_digit_sums(numbers)\n",
    "print(\"Sum of digit sums:\", result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2982bc0c",
   "metadata": {},
   "source": [
    "# 22. Write a program to find the prime factors of a given number using a `for` loop and list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5e22a9a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number whose prime factors are to be found:120\n",
      "Prime factors of 120 are [2, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "def find_prime_factors(number):\n",
    "    factors=[i for i in range(2,number+1) if num%i==0]\n",
    "    prime_factor=[]\n",
    "    for factor in factors:\n",
    "        is_prime=True\n",
    "        for i in range(2,int(factor**0.5)+1):\n",
    "            if factor%i==0:\n",
    "                is_prime=False\n",
    "                break\n",
    "        if is_prime:\n",
    "            prime_factor.append(factor)\n",
    "    return prime_factor\n",
    "\n",
    "num=int(input(\"Enter the number whose prime factors are to be found:\"))\n",
    "if num<=1:\n",
    "    print(f\"Prime factors of {num} does not exists\")\n",
    "else:\n",
    "    k=find_prime_factors(num)\n",
    "    print(f\"Prime factors of {num} are {k}\")\n",
    "            \n",
    "                    \n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fd1cc90",
   "metadata": {},
   "source": [
    "# 23. Develop a program that extracts unique elements from a list and stores them in a new list using a list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c4645148",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original list: [1, 2, 1, 3, 4, 5, 1, 3, 2, 4, 5, 6, 8, 7, 1, 2, 5, 87, 61, 2, 5]\n",
      "List with Unique elements: [6, 8, 7, 87, 61]\n"
     ]
    }
   ],
   "source": [
    "my_list=[1,2,1,3,4,5,1,3,2,4,5,6,8,7,1,2,5,87,61,2,5]\n",
    "new_list=[i for i in my_list if my_list.count(i)==1]\n",
    "print(\"original list:\",my_list)\n",
    "print(\"List with Unique elements:\",new_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b9e30a1",
   "metadata": {},
   "source": [
    "# 24. Create a program that generates a list of all palindromic numbers up to a specified limit using a list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "e19bb110",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value of n:200\n",
      "List of palindromic numbers upto 200 is:\n",
      " [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191]\n"
     ]
    }
   ],
   "source": [
    "n=int(input(\"Enter the value of n:\"))\n",
    "palindrome=[i for i in range(1,n+1) if str(i)==str(i)[::-1]]\n",
    "print(f\"List of palindromic numbers upto {n} is:\\n\",palindrome)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43731787",
   "metadata": {},
   "source": [
    "# 25. Write a program to flatten a nested list using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "b1ce6175",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nested list [[1, 2, 3, 4, 5], [1, 33, 111, 56, 7], [-11, -2, 3, -8, 57]]\n",
      "Flatten list: [1, 2, 3, 4, 5, 1, 33, 111, 56, 7, -11, -2, 3, -8, 57]\n"
     ]
    }
   ],
   "source": [
    "nested_list=[[1,2,3,4,5],[1,33,111,56,7],[-11,-2,3,-8,57]]\n",
    "flatten_list=[num for rows in nested_list for num in rows ]\n",
    "print(\"Nested list\",nested_list)\n",
    "print(\"Flatten list:\",flatten_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b2a4a20",
   "metadata": {},
   "source": [
    "# 26. Develop a program that computes the sum of even and odd numbers in a list separately using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "6e8de69a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of the even elements: 30\n",
      "Sum of the odd elements: 25\n"
     ]
    }
   ],
   "source": [
    "my_list=[1,2,3,4,5,6,7,8,9,10]\n",
    "even_sum=sum([i for i in my_list if i%2==0])\n",
    "odd_sum=sum([i for i in my_list if i%2!=0])\n",
    "print(\"Sum of the even elements:\",even_sum)\n",
    "print(\"Sum of the odd elements:\",odd_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f230d939",
   "metadata": {},
   "source": [
    "# 27. Create a program that generates a list of squares of odd numbers between 1 and 10 using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "7c6ec008",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list of squares of odd numbers between 1 and 10:\n",
      " [1, 9, 25, 49, 81]\n"
     ]
    }
   ],
   "source": [
    "square_list=[i**2 for i in range(1,11) if i%2!=0]\n",
    "print(\"list of squares of odd numbers between 1 and 10:\\n\",square_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3937af26",
   "metadata": {},
   "source": [
    "# 28. Write a program that combines two lists into a dictionary using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "de692531",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Combinition of 2 list into dictionary: {'name': 'Thalaiva', 'age': 71, 'grade': 'A'}\n"
     ]
    }
   ],
   "source": [
    "key_list=[\"name\",\"age\",\"grade\"]\n",
    "value_list=[\"Thalaiva\",71,\"A\"]\n",
    "dictionary={key_list[i]: value_list[i] for i in range(min(len(key_list), len(value_list)))}\n",
    "print(\"Combinition of 2 list into dictionary:\",dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a158b4f",
   "metadata": {},
   "source": [
    "# 29. Develop a program that extracts the vowels from a string and stores them in a list using list comprehension.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "8b1e0553",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:This is an assignment on for loops\n",
      "List of vowels from the string: ['i', 'i', 'a', 'a', 'i', 'e', 'o', 'o', 'o', 'o']\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "string=string.lower()\n",
    "vowels=\"aeiou\"\n",
    "vowels_list=[char for char in string if char in vowels]\n",
    "print(\"List of vowels from the string:\",vowels_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edaaa1a0",
   "metadata": {},
   "source": [
    "# 30. Create a program that removes all non-numeric characters from a list of strings using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "9334d75e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original List: ['crazy123', 'apple', 'nokia334', 'sam456', 'dig345']\n",
      "Numeric List: ['123', '', '334', '456', '345']\n"
     ]
    }
   ],
   "source": [
    "sample_list=[\"crazy123\",\"apple\",\"nokia334\",\"sam456\",\"dig345\"]\n",
    "numeric_list=[''.join(filter(str.isdigit, string)) for string in sample_list]\n",
    "print(\"Original List:\", sample_list)\n",
    "print(\"Numeric List:\", numeric_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "743ef743",
   "metadata": {},
   "source": [
    "# Challenge Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5037868",
   "metadata": {},
   "source": [
    "# 31. Write a program to generate a list of prime numbers using the Sieve of Eratosthenes algorithm and list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "435bfbfe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter an upper limit for prime number generation: 55\n",
      "Prime numbers up to 55:\n",
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53]\n"
     ]
    }
   ],
   "source": [
    "def sieve_eratosthenes(n):\n",
    "    # Create a boolean list \"is_prime\" and initialize all entries as True\n",
    "    is_prime = [True] * (n + 1)\n",
    "    is_prime[0] = is_prime[1] = False  # 0 and 1 are not prime numbers\n",
    "    \n",
    "    # Mark the multiples of all prime numbers as False\n",
    "    for p in range(2, int(n**0.5) + 1):\n",
    "        if is_prime[p]:\n",
    "            for i in range(p * p, n + 1, p):\n",
    "                is_prime[i] = False\n",
    "    \n",
    "    # Use list comprehension to extract prime numbers from the boolean list\n",
    "    prime_numbers = [i for i in range(2, n + 1) if is_prime[i]]\n",
    "    \n",
    "    return prime_numbers\n",
    "\n",
    "n = int(input(\"Enter an upper limit for prime number generation: \"))\n",
    "\n",
    "if n < 2:\n",
    "    print(\"No prime numbers in the given range.\")\n",
    "else:\n",
    "    primes = sieve_eratosthenes(n)\n",
    "    print(f\"Prime numbers up to {n}:\")\n",
    "    print(primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90b99251",
   "metadata": {},
   "source": [
    "# 32. Create a program that generates a list of all Pythagorean triplets up to a specified limit using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "f9b2005c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the upper limit:15\n",
      "Pythagorean triplets up to 15:\n",
      " [(3, 4, 5), (5, 12, 13), (6, 8, 10), (9, 12, 15)]\n"
     ]
    }
   ],
   "source": [
    "n=int(input(\"Enter the upper limit:\"))\n",
    "triplets=[(i,j,k) for i in range(1,n+1)\n",
    "                  for j in range(i,n+1)\n",
    "                  for k in range(j,n+1)\n",
    "                    if i**2+j**2==k**2]\n",
    "\n",
    "print(f\"Pythagorean triplets up to {n}:\\n\",triplets)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5ebc4ce",
   "metadata": {},
   "source": [
    "# 33. Develop a program that generates a list of all possible combinations of two lists using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "eced2324",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Combinition of 2 lists:\n",
      " [(1, 3), (1, 7), (1, 5), (2, 3), (2, 7), (2, 5), (3, 3), (3, 7), (3, 5), (5, 3), (5, 7), (5, 5)]\n"
     ]
    }
   ],
   "source": [
    "list1=[1,2,3,5]\n",
    "list2=[3,7,5]\n",
    "comb_list=[(i,j) for i in list1 for j in list2]\n",
    "print(\"Combinition of 2 lists:\\n\",comb_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5ceeb02",
   "metadata": {},
   "source": [
    "# 34. Write a program that calculates the mean, median, and mode of a list of numbers using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "ddef5902",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean: 40.214285714285715\n",
      "Median: 46.0\n",
      "Mode: 2\n"
     ]
    }
   ],
   "source": [
    "import statistics\n",
    "sample_list=[56,85,1,2,45,65,2,47,56,89,2,0,45,68]\n",
    "mean=statistics.mean([i for i in sample_list])\n",
    "median=statistics.median([i for i in sample_list])\n",
    "mode=statistics.mode([i for i in sample_list])\n",
    "print(\"Mean:\",mean)\n",
    "print(\"Median:\",median)\n",
    "print(\"Mode:\",mode)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1b12709",
   "metadata": {},
   "source": [
    "# 35. Create a program that generates Pascal's triangle up to a specified number of rows using list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "13cb60f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number of rows for Pascal's triangle: 5\n",
      "[1]\n",
      "[1, 1]\n",
      "[1, 2, 1]\n",
      "[1, 3, 3, 1]\n",
      "[1, 4, 6, 4, 1]\n"
     ]
    }
   ],
   "source": [
    "def generate_pascals_triangle(n):\n",
    "    triangle = []\n",
    "    for i in range(n):\n",
    "        row = [1 if j == 0 or j == i else row[j - 1] + row[j] for j in range(i + 1)]\n",
    "        triangle.append(row)\n",
    "\n",
    "    return triangle\n",
    "\n",
    "\n",
    "n = int(input(\"Enter the number of rows for Pascal's triangle: \"))\n",
    "pascals_triangle = generate_pascals_triangle(n)\n",
    "for row in pascals_triangle:\n",
    "    print(row)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc0f60f2",
   "metadata": {},
   "source": [
    "# 36. Develop a program that calculates the sum of the digits of a factorial of numbers from 1 to 5 using list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "a81be6c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of factorial of numbers from 1 to 5: [1, 2, 6, 24, 120]\n",
      "Sum of digits of factorial of number: 18\n"
     ]
    }
   ],
   "source": [
    "factorial=[]\n",
    "\n",
    "for i in range(1,6):\n",
    "    p=1\n",
    "    for j in range(1,i+1):\n",
    "        p=p*j\n",
    "    factorial.append(p)\n",
    "    \n",
    "def digit_sum(numbers):\n",
    "    return sum(int(digit) for digit in str(numbers))\n",
    "\n",
    "def sum_of_digit_sums(numbers):\n",
    "    return sum(digit_sum(number) for number in numbers)\n",
    "fact_sum=sum_of_digit_sums(factorial)\n",
    "    \n",
    "print(\"List of factorial of numbers from 1 to 5:\",factorial)\n",
    "print(\"Sum of digits of factorial of number:\",fact_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e60181d4",
   "metadata": {},
   "source": [
    "# 37. Write a program that finds the longest word in a sentence using list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "14d4f03e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string:This is my assignment on for loops\n",
      "Longest word in the sentence is: assignment\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter a string:\")\n",
    "longest_word=max([i for i in string.split()],key=len)\n",
    "print(\"Longest word in the sentence is:\",longest_word)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a16f804",
   "metadata": {},
   "source": [
    "# 38. Create a program that filters a list of strings to include only those with more than three vowels using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "6ae62fbe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original List: ['Tree', 'samsung', 'cauliflower', 'shy', 'high', 'elephant', 'assignment', 'programming', 'aeio', 'ueai']\n",
      "Filtered List with more than three vowels: ['cauliflower', 'aeio', 'ueai']\n"
     ]
    }
   ],
   "source": [
    "sample_list=[\"Tree\",\"samsung\",\"cauliflower\",\"shy\",\"high\",\"elephant\",\"assignment\",\"programming\",\"aeio\",\"ueai\"]\n",
    "\n",
    "def count_vowels(word):\n",
    "    vowels = \"AEIOUaeiou\"\n",
    "    return sum(1 for char in word if char in vowels)\n",
    "\n",
    "filtered_list = [word for word in sample_list if count_vowels(word) > 3]\n",
    "print(\"Original List:\", sample_list)\n",
    "print(\"Filtered List with more than three vowels:\", filtered_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a8cf8df",
   "metadata": {},
   "source": [
    "# 39. Develop a program that calculates the sum of the digits of numbers from 1 to 1000 using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "fb84a317",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Sum of Digits from 1 to 1000: 13501\n"
     ]
    }
   ],
   "source": [
    "def sum_of_digits(number):\n",
    "    return sum(int(digit) for digit in str(number))\n",
    "\n",
    "digit_sums = [sum_of_digits(i) for i in range(1, 1001)]\n",
    "total_sum = sum(digit_sums)\n",
    "print(\"Total Sum of Digits from 1 to 1000:\", total_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc46ec85",
   "metadata": {},
   "source": [
    "# 40. Write a program that generates a list of prime palindromic numbers using list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "b75d4c4e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value of n:200\n",
      "[2, 3, 5, 7, 11, 101, 131, 151, 181, 191]\n"
     ]
    }
   ],
   "source": [
    "def is_prime(num):\n",
    "        c=0\n",
    "        for j in range(1,num+1):\n",
    "            if num%j==0:\n",
    "                c+=1\n",
    "        if c==2:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "n=int(input(\"Enter the value of n:\"))\n",
    "prime_palindromic=[i for i in range(1,n+1) if str(i)==str(i)[::-1] and is_prime(i)]\n",
    "print(prime_palindromic)"
   ]
  }
 ],
 "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
}