3rd_Sept_Python_For_Loop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "994b0b41",
   "metadata": {},
   "source": [
    "# Basic Level:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bce1808",
   "metadata": {},
   "source": [
    "#### 1. Write a Python program to print the numbers from 1 to 10 using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e447c434",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 "
     ]
    }
   ],
   "source": [
    "for i in range(1,11):\n",
    "    print(i,end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83926511",
   "metadata": {},
   "source": [
    "#### 2. Create a program that calculates the sum of all numbers in a list using a `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7741ac4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "l1 = [1,2,3,4,5,6,7,8,9,10]\n",
    "\n",
    "numberSum = 0\n",
    "\n",
    "for i in range(1,11):\n",
    "    numberSum += i\n",
    "    \n",
    "print(numberSum)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c3e1d0f",
   "metadata": {},
   "source": [
    "#### 3. Write a program to print the characters of a string in reverse order using a `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "280ade5e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dlrow olleH\n"
     ]
    }
   ],
   "source": [
    "string = 'Hello world'\n",
    "revString = ''\n",
    "for i in range(len(string),0,-1):\n",
    "    revString = revString + string[i-1]\n",
    "\n",
    "print(revString)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2959f953",
   "metadata": {},
   "source": [
    "#### 4. Develop a program that finds the factorial of a given number using a `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "54481bc3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "fact = 1\n",
    "\n",
    "for i in range(1,n+1):\n",
    "    fact *= i\n",
    "    \n",
    "print(fact)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90af0789",
   "metadata": {},
   "source": [
    "#### 5. Create a program to print the multiplication table of a given number using a `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "b476cb8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 * 10 = 10\n",
      "2 * 10 = 20\n",
      "3 * 10 = 30\n",
      "4 * 10 = 40\n",
      "5 * 10 = 50\n",
      "6 * 10 = 60\n",
      "7 * 10 = 70\n",
      "8 * 10 = 80\n",
      "9 * 10 = 90\n",
      "10 * 10 = 100\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    "\n",
    "for i in range(1,n+1):\n",
    "    print('{} * {} = {}'.format(i,n,i*n))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5871a2e",
   "metadata": {},
   "source": [
    "#### 6. Write a program that counts the number of even and odd numbers in a list using a `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "e070a526",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Odd Count 25, Even Count 30\n"
     ]
    }
   ],
   "source": [
    "l1 = [1,2,3,4,5,6,7,8,9,10]\n",
    "CountEven = 0\n",
    "CountOdd = 0\n",
    "for i in l1:\n",
    "    if i%2 == 0:\n",
    "        CountEven += i\n",
    "    else:\n",
    "        CountOdd += i\n",
    "print('Odd Count {}, Even Count {}'.format(CountOdd,CountEven))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b15be62",
   "metadata": {},
   "source": [
    "#### 7. Develop a program that prints the squares of numbers from 1 to 5 using a `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "f1e2d47c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,6):\n",
    "    print(i*i)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3eb9d82",
   "metadata": {},
   "source": [
    "#### 8. Create a program to find the length of a string without using the `len()` function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "d5941f53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length  11\n"
     ]
    }
   ],
   "source": [
    "String = \"Hello World\"\n",
    "Length = 0\n",
    "for i in String:\n",
    "    Length += 1\n",
    "print('Length ',Length)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "416fe2e6",
   "metadata": {},
   "source": [
    "#### 9. Write a program that calculates the average of a list of numbers using a `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "45e0d8c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average 5.5\n"
     ]
    }
   ],
   "source": [
    "l1 = [1,2,3,4,5,6,7,8,9,10]\n",
    "\n",
    "numberSum = 0 \n",
    "\n",
    "for i in l1:\n",
    "    numberSum += i\n",
    "    \n",
    "print('Average',\n",
    "      numberSum/len(l1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f90acae",
   "metadata": {},
   "source": [
    "#### 10. Develop a program that prints the first `n` Fibonacci numbers using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "2a81a420",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n"
     ]
    }
   ],
   "source": [
    "Position = 10\n",
    "\n",
    "a = 0\n",
    "b = 1\n",
    "print(a)\n",
    "for i in range(1,Position):\n",
    "    print(b)\n",
    "    a, b = b,a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed98632c",
   "metadata": {},
   "source": [
    "# Intermediate Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17af4517",
   "metadata": {},
   "source": [
    "#### 11. Write a program to check if a given list contains any duplicates using a `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "45834937",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Contains Duplicate\n"
     ]
    }
   ],
   "source": [
    "l1 = [2,1,2,3,4,5,6,7,8,9,10]\n",
    "\n",
    "l1.sort()\n",
    "\n",
    "Flag = True\n",
    "\n",
    "for i in range(0,len(l1)-1):\n",
    "    if l1[i] == l1[i+1]:\n",
    "        Flag = False\n",
    "        break\n",
    "\n",
    "if Flag:\n",
    "    print('Does Not Contain Duplicate')\n",
    "else:\n",
    "    print('Contains Duplicate')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4fd05dd",
   "metadata": {},
   "source": [
    "#### 12. Create a program that prints the prime numbers in a given range using a `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9854c220",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the start of the range: 12\n",
      "Enter the end of the range: 50\n",
      "Prime numbers between 12 and 50:\n",
      "13\n",
      "17\n",
      "19\n",
      "23\n",
      "29\n",
      "31\n",
      "37\n",
      "41\n",
      "43\n",
      "47\n"
     ]
    }
   ],
   "source": [
    "# Input the range from the user\n",
    "start = int(input(\"Enter the start of the range: \"))\n",
    "end = int(input(\"Enter the end of the range: \"))\n",
    "\n",
    "print(f\"Prime numbers between {start} and {end}:\")\n",
    "          \n",
    "for num in range(start, end + 1):\n",
    "    if num > 1:\n",
    "        is_prime = True\n",
    "        for i in range(2, num//2):\n",
    "            if num % i == 0:\n",
    "                is_prime = False\n",
    "                break\n",
    "        if is_prime:\n",
    "            print(num)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8db4574e",
   "metadata": {},
   "source": [
    "#### 13. Develop a program that counts the number of vowels in a string using a `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "98c2d559",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Count Of Vowels is 3\n"
     ]
    }
   ],
   "source": [
    "my_string = 'Hello World'\n",
    "VowelCount = 0\n",
    "for i in my_string:\n",
    "    if i.lower() in ['a','e','i','o','u']:\n",
    "        VowelCount += 1\n",
    "\n",
    "print('Count Of Vowels is',VowelCount)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b52d4a8",
   "metadata": {},
   "source": [
    "#### 14. Write a program to find the maximum element in a 2D list using a nested `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4a951069",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "103\n"
     ]
    }
   ],
   "source": [
    "matrix = [\n",
    "    [23, 45, 12, 7],\n",
    "    [67, 8, 103, 56],\n",
    "    [34, 76, 10, 98]\n",
    "]\n",
    "\n",
    "max_element = matrix[0][0]\n",
    "\n",
    "for raw in matrix:\n",
    "    for element in raw:\n",
    "        if element > max_element:\n",
    "            max_element = element\n",
    "print(max_element)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a55f6f9",
   "metadata": {},
   "source": [
    "#### 15. Create a program that removes all occurrences of a specific element from a list using a `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "93bf4ed5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "my_list = [2, 3, 4, 3, 5, 6, 3]\n",
    "element_to_remove = 3\n",
    "\n",
    "new_list = [i for i in my_list if i != element_to_remove]\n",
    "\n",
    "print(new_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28e53603",
   "metadata": {},
   "source": [
    "#### 16. Develop a program that generates a multiplication table for numbers from 1 to 5 using a nested `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "16a5f2ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiplication table of 1 : 1 2 3 4 5 6 7 8 9 10 \n",
      "Multiplication table of 2 : 2 4 6 8 10 12 14 16 18 20 \n",
      "Multiplication table of 3 : 3 6 9 12 15 18 21 24 27 30 \n",
      "Multiplication table of 4 : 4 8 12 16 20 24 28 32 36 40 \n",
      "Multiplication table of 5 : 5 10 15 20 25 30 35 40 45 50 \n"
     ]
    }
   ],
   "source": [
    "First = 1\n",
    "Last = 5\n",
    "\n",
    "for i in range(First, Last + 1):\n",
    "    print('Multiplication table of', i,':',end=' ')\n",
    "    for j in range(1,11):\n",
    "        print(i*j,end=' ')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1321753",
   "metadata": {},
   "source": [
    "#### 17. Write a program that converts a list of Fahrenheit temperatures to Celsius using a `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a8b6684a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Celsius Temperatures: [0.0, 20.0, 36.7, 40.0, 50.0]\n"
     ]
    }
   ],
   "source": [
    "fahrenheit_temperatures = [32, 68, 98, 104, 122]\n",
    "\n",
    "celsius_temperatures = []\n",
    "\n",
    "for fahrenheit in fahrenheit_temperatures:\n",
    "    celsius = round((fahrenheit - 32) * 5/9,1)\n",
    "    celsius_temperatures.append(celsius)\n",
    "\n",
    "print(\"Celsius Temperatures:\", celsius_temperatures)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a28a783",
   "metadata": {},
   "source": [
    "#### 18. Create a program to print the common elements from two lists using a `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "cbb8b51e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Common Element: [3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "list1 = [1, 2, 3, 4, 5]\n",
    "list2 = [3, 4, 5, 6,3 ,7]\n",
    "\n",
    "common_elements = []\n",
    "\n",
    "for Element1 in list1:\n",
    "    for Element2 in list2:\n",
    "        if Element1 == Element2 and Element1 not in common_elements:\n",
    "            common_elements.append(Element1)\n",
    "\n",
    "print('Common Element:',common_elements)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e207532d",
   "metadata": {},
   "source": [
    "#### 19. Develop a program that prints the pattern of right-angled triangles using a `for` loop. Use ‘*’ to draw the pattern\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "3b026aad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*\n",
      "**\n",
      "***\n",
      "****\n",
      "*****\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 6):\n",
    "    for j in range(i):\n",
    "        print('*', end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0982d4f6",
   "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": 40,
   "id": "7f9330d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first number: 48 \n",
      "Enter the second number: 36\n",
      "The GCD of 48 and 36 is 12\n"
     ]
    }
   ],
   "source": [
    "num1 = int(input(\"Enter the first number: \"))\n",
    "num2 = int(input(\"Enter the second number: \"))\n",
    "\n",
    "# Ensure num1 is greater than or equal to num2\n",
    "if num1 < num2:\n",
    "    num1, num2 = num2, num1\n",
    "\n",
    "# Initialize GCD to 1\n",
    "gcd = 1\n",
    "\n",
    "for i in range(1, num2 + 1):\n",
    "    if num1 % i == 0 and num2 % i == 0:\n",
    "        gcd = i\n",
    "\n",
    "print(f\"The GCD of {num1} and {num2} is {gcd}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a22ea56",
   "metadata": {},
   "source": [
    "# Advanced Level:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f34ddeb2",
   "metadata": {},
   "source": [
    "#### 21. Create a program that calculates the sum of the digits of numbers in a list using a list comprehension.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "49a1597f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Number = 1234\n",
    "\n",
    "sum_digit = lambda n: n if n<10 else n%10 + sum_digit(n//10)\n",
    "\n",
    "\n",
    "sum_digit(1234)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8102199b",
   "metadata": {},
   "source": [
    "#### 22. Write a program to find the prime factors of a given number using a `for` loop and list comprehension.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "a5648956",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 8, 16, 32, 64, 128]\n"
     ]
    }
   ],
   "source": [
    "number = 256\n",
    "\n",
    "prime_factor = [i for i in range(2,number) if number%i == 0]\n",
    "\n",
    "print(prime_factor)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c04507c9",
   "metadata": {},
   "source": [
    "#### 23. Develop a program that extracts unique elements from a list and stores them in a new list using a list comprehension.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "42b56527",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = [1,2,3,4,5,6,6,7,8,8,9]\n",
    "\n",
    "New_List = [i for i in set(list1) ]\n",
    "#or \n",
    "New_List = [x for i, x in enumerate(list1) if x not in list1[:i] ]\n",
    "\n",
    "New_List"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5473cb4",
   "metadata": {},
   "source": [
    "#### 24. Create a program that generates a list of all palindromic numbers up to a specified limit using a list comprehension.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "9d0c8b3b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "limit = 121\n",
    "\n",
    "Palindrome_List = [i for i in range(1,limit+1) if str(i) == str(i)[::-1]]\n",
    "\n",
    "Palindrome_List"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55b90182",
   "metadata": {},
   "source": [
    "#### 25. Write a program to flatten a nested list using list comprehension.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "0cf98db6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "\n",
    "flattened_list = [item for sublist in nested_list for item in sublist]\n",
    "flattened_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f58c0a7",
   "metadata": {},
   "source": [
    "#### 26. Develop a program that computes the sum of even and odd numbers in a list separately using list comprehension.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "2cf8cac3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of Odd Number is 25 and sum of even number is 20\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "sum_of_odd = sum(i for i in numbers if i%2 == 1)\n",
    "sum_of_even = sum(i for i in numbers if i%2 == 0)\n",
    "\n",
    "print('Sum of Odd Number is {} and sum of even number is {}'.format(sum_of_odd,sum_of_even))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75dae0df",
   "metadata": {},
   "source": [
    "#### 27. Create a program that generates a list of squares of odd numbers between 1 and 10 using list comprehension.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "4c96b085",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 9, 25, 49, 81]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "listofSquare = [ i*i for i in range(1,11) if i%2 ==1]\n",
    "\n",
    "listofSquare"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca4199bb",
   "metadata": {},
   "source": [
    "#### 28. Write a program that combines two lists into a dictionary using list comprehension.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "9f45a53d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Combined Dictionary is  {'a': 1, 'b': 2, 'c': 3}\n"
     ]
    }
   ],
   "source": [
    "keys = [\"a\", \"b\", \"c\"]\n",
    "values = [1, 2, 3]\n",
    "\n",
    "combined_dict = {key: value for key,value in zip(keys,values)}\n",
    "\n",
    "print('Combined Dictionary is ',combined_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3280d31b",
   "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": 87,
   "id": "eab1c25b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vowels in the string: ['e', 'o', 'o']\n"
     ]
    }
   ],
   "source": [
    "text = \"Hello, World!\"\n",
    "vowels = [char for char in text if char.lower() in \"aeiou\"]\n",
    "print(\"Vowels in the string:\", vowels)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5aff0cf",
   "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": 91,
   "id": "5d3b8d8b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Strings with only numeric characters: ['123', '456', '789']\n"
     ]
    }
   ],
   "source": [
    "string_list = [\"abc123\", \"def456\", \"xyz789\"]\n",
    "\n",
    "numeric_strings = [''.join(char for char in string if char.isnumeric()) for string in string_list]\n",
    "\n",
    "print(\"Strings with only numeric characters:\", numeric_strings)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c143a970",
   "metadata": {},
   "source": [
    "# Challenge Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a76c0185",
   "metadata": {},
   "source": [
    "#### 31. Write a program to generate a list of prime numbers using the Sieve of Eratosthenes algorithm and list comprehension.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "6d757277",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a limit: 123\n",
      "Prime numbers up to the limit: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113]\n"
     ]
    }
   ],
   "source": [
    "limit = int(input(\"Enter a limit: \"))\n",
    "\n",
    "sieve = [True] * (limit + 1)\n",
    "sieve[0] = sieve[1] = False\n",
    "\n",
    "[sieve.__setitem__(i, False) for current in range(2, int(limit**0.5) + 1) if sieve[current] for i in range(current*current, limit+1, current)]\n",
    "\n",
    "primes = [num for num in range(2, limit + 1) if sieve[num]]\n",
    "\n",
    "print(\"Prime numbers up to the limit:\", primes)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88b0d4ad",
   "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": 94,
   "id": "551de517",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a limit: 10\n",
      "Pythagorean triplets up to the limit:\n",
      "(6, 8, 10)\n",
      "(3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "limit = int(input(\"Enter a limit: \"))\n",
    "\n",
    "pythagorean_triplets = [(a, b, c) for a in range(1, limit + 1)\n",
    "                                   for b in range(a, limit + 1)\n",
    "                                   for c in range(b, limit + 1)\n",
    "                                   if a**2 + b**2 == c**2]\n",
    "\n",
    "pythagorean_triplets = list(set(pythagorean_triplets))  # Remove duplicates if any\n",
    "\n",
    "print(\"Pythagorean triplets up to the limit:\")\n",
    "for triplet in pythagorean_triplets:\n",
    "    print(triplet)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7caaaa0d",
   "metadata": {},
   "source": [
    "#### 33. Develop a program that generates a list of all possible combinations of two lists using list comprehension.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "fd11591c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4] [1, 5] [1, 6] [1, 7] [2, 4] [2, 5] [2, 6] [2, 7] [3, 4] [3, 5] [3, 6] [3, 7] [4, 4] [4, 5] [4, 6] [4, 7] "
     ]
    }
   ],
   "source": [
    "l1 = [1,2,3,4]\n",
    "l2 = [4,5,6,7]\n",
    "\n",
    "UniqueComb = [[i,j] for i in l1 for j in l2] \n",
    "\n",
    "for i in UniqueComb:\n",
    "    print(i, end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64afa81f",
   "metadata": {},
   "source": [
    "#### 34. Write a program that calculates the mean, median, and mode of a list of numbers using list comprehension.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "a9fc295b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean: 17.625\n",
      "Median: 15.0\n",
      "Mode: [12]\n"
     ]
    }
   ],
   "source": [
    "# Sample list of numbers\n",
    "numbers = [12, 15, 12, 20, 25, 30, 12, 15]\n",
    "\n",
    "# Calculate the mean using list comprehension\n",
    "mean = sum(i for i in numbers)/len(numbers)\n",
    "\n",
    "#Mode\n",
    "mode = [key for key, value in counter.items() if value == max(counter.values())]\n",
    "\n",
    "#Median\n",
    "median = (sorted_numbers[mid] + sorted_numbers[~mid]) / 2 if len(sorted_numbers) % 2 == 0 else sorted_numbers[mid]\n",
    "\n",
    "\n",
    "print(f\"Mean: {mean}\")\n",
    "print(f\"Median: {median}\")\n",
    "print(f\"Mode: {mode}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b0eafbb",
   "metadata": {},
   "source": [
    "#### 35. Create a program that generates Pascal's triangle up to a specified number of rows using list comprehension.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "cc24247c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number of rows for Pascal's triangle: 12\n",
      "                 1                  \n",
      "                1 1                 \n",
      "               1 2 1                \n",
      "              1 3 3 1               \n",
      "             1 4 6 4 1              \n",
      "           1 5 10 10 5 1            \n",
      "          1 6 15 20 15 6 1          \n",
      "        1 7 21 35 35 21 7 1         \n",
      "       1 8 28 56 70 56 28 8 1       \n",
      "    1 9 36 84 126 126 84 36 9 1     \n",
      "1 10 45 120 210 252 210 120 45 10 1 \n",
      "1 11 55 165 330 462 462 330 165 55 11 1\n"
     ]
    }
   ],
   "source": [
    "def generate_pascals_triangle(rows):\n",
    "    if rows == 0:\n",
    "        return []\n",
    "\n",
    "    if rows == 1:\n",
    "        return [[1]]\n",
    "\n",
    "    previous_triangle = generate_pascals_triangle(rows - 1)\n",
    "    previous_row = previous_triangle[-1]\n",
    "\n",
    "    new_row = [1] + [previous_row[i - 1] + previous_row[i] for i in range(1, len(previous_row))] + [1]\n",
    "\n",
    "    return previous_triangle + [new_row]\n",
    "\n",
    "rows = int(input(\"Enter the number of rows for Pascal's triangle: \"))\n",
    "pascals_triangle = generate_pascals_triangle(rows)\n",
    "\n",
    "# Print Pascal's triangle\n",
    "for row in pascals_triangle:\n",
    "    print(\" \".join(map(str, row)).center(rows * 3))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57ad2600",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "3ccb8c76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of digits of 1 is 1\n",
      "Sum of digits of 2 is 2\n",
      "Sum of digits of 3 is 6\n",
      "Sum of digits of 4 is 6\n",
      "Sum of digits of 5 is 3\n"
     ]
    }
   ],
   "source": [
    "# Function to calculate the factorial of a number\n",
    "def factorial(n):\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return n * factorial(n - 1)\n",
    "\n",
    "# Calculate the sum of the digits of factorial for numbers from 1 to 5 using list comprehension\n",
    "results = [sum(int(digit) for digit in str(factorial(n))) for n in range(1, 6)]\n",
    "\n",
    "# Print the results\n",
    "for n, result in enumerate(results, start=1):\n",
    "    print(f\"Sum of digits of {n} is {result}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb6d5332",
   "metadata": {},
   "source": [
    "#### 37. Write a program that finds the longest word in a sentence using list comprehension.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "0ab2d752",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sentence: Hell world, welcome to programming\n",
      "The longest word in the sentence is: programming\n"
     ]
    }
   ],
   "source": [
    "sentence = input(\"Enter a sentence: \")\n",
    "\n",
    "words = sentence.split()\n",
    "longest_word = max(words, key=lambda word: len(word))\n",
    "\n",
    "print(f\"The longest word in the sentence is: {longest_word}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fdd9b2d",
   "metadata": {},
   "source": [
    "#### 38. Create a program that filters a list of stringsto include only those with more than three vowels using list comprehension.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "efde6595",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Strings with more than three vowels: ['example', 'programming', 'aii', 'elephant']\n"
     ]
    }
   ],
   "source": [
    "string_list = [\"hello\", \"world\", \"example\", \"programming\", \"python\", \"aii\", \"elephant\"]\n",
    "\n",
    "filtered_list = [string for string in string_list if sum(1 for char in string if char in \"aeiouAEIOU\") >= 3]\n",
    "\n",
    "print(\"Strings with more than three vowels:\", filtered_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b834f583",
   "metadata": {},
   "source": [
    "#### 39. Develop a program that calculates the sum of the digits of numbers from 1 to 1000 using list comprehension.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "5296ad67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of the digits of numbers from 1 to 1000 is: 13501\n"
     ]
    }
   ],
   "source": [
    "digit_sums = [sum(int(digit) for digit in str(number)) for number in range(1, 1001)]\n",
    "\n",
    "# Calculate and print the total sum of digit sums\n",
    "total_sum = sum(digit_sums)\n",
    "\n",
    "print(\"The sum of the digits of numbers from 1 to 1000 is:\", total_sum)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02b0f2ab",
   "metadata": {},
   "source": [
    "#### 40. Write a program that generates a list of prime palindromic numbers using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "b49ad4bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prime Palindromic Numbers: [2, 3, 5, 7, 11, 101, 131, 151, 181, 191, 313, 353, 373, 383, 727, 757, 787, 797, 919, 929]\n"
     ]
    }
   ],
   "source": [
    "def is_prime(num):\n",
    "    if num <= 1:\n",
    "        return False\n",
    "    for i in range(2, int(num**0.5) + 1):\n",
    "        if num % i == 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "prime_palindromic_numbers = [num for num in range(2, 1000) if is_prime(num) and str(num) == str(num)[::-1]]\n",
    "\n",
    "print(\"Prime Palindromic Numbers:\", prime_palindromic_numbers)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}