21_03_2024_Python For Loop Assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "78e23182-1ae1-42cb-bda1-f296ce9e9f51",
   "metadata": {},
   "source": [
    "# For loop : Basic Level"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc0f3734-f3a5-4332-9de5-0cb6c165280b",
   "metadata": {},
   "source": [
    "### 1) Write a Python program to print the numbers from 1 to 10 using a `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b28765e7-09e2-4354-9fb3-4f710f72fb33",
   "metadata": {},
   "source": [
    "### Ans 1)\n",
    "\n",
    "#### Steps:\n",
    "- Use range() function to generate a sequence of numbers from 1 to 10.\n",
    "- Iterate through it and print each number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "452f39f4-f046-4d89-9778-cf3803301cfe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numbers from 1 to 10 : \n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# Use range() function to generate a sequence of numbers from 1 to 10.\n",
    "# Iterate through it and print each number.\n",
    "print(\"Numbers from 1 to 10 : \")\n",
    "for i in range(1,11):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fd2e410-b323-406b-89c4-267f663b03f4",
   "metadata": {},
   "source": [
    "## 2) Create a program that calculates the sum of all numbers in a list using a `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20e3be15-0a2a-4a47-869b-8ab6e0639439",
   "metadata": {},
   "source": [
    "### Ans 2)\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a list of numbers/elements.\n",
    "- Initialise a variable \"list_sum\" by 0, to store the sum of all numbers.\n",
    "- Iterate through the list and add each number with list_sum.\n",
    "- Print the sum of all numbers i.e list_sum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9f19599b-24c6-4dcf-97ee-b73d207aa546",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [1, 2, 3, 4, 5]\n",
      "Sum of all numbers in a given list is : 15\n"
     ]
    }
   ],
   "source": [
    "# Create/take a list of numbers/elements.\n",
    "lis2 = [1,2,3,4,5]\n",
    "print(f\"Given list : {lis2}\")\n",
    "\n",
    "# Initialise a variable \"list_sum\" by 0, to store the sum of all numbers.\n",
    "list_sum = 0\n",
    "\n",
    "# Iterate through the list and add each number with list_sum.\n",
    "for num in lis2:\n",
    "    list_sum = list_sum + num\n",
    "    \n",
    "# Print the sum of all numbers i.e list_sum.\n",
    "print(f\"Sum of all numbers in a given list is : {list_sum}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5876a3b5-4915-460f-85ea-d068e2ab85cc",
   "metadata": {},
   "source": [
    "## 3) Write a program to print the characters of a string in reverse order using a `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6ee1ea7-00dd-4e0e-bb6e-f3957fb4679a",
   "metadata": {},
   "source": [
    "### Ans 3)\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a string of characters.\n",
    "- Using in-built function reverse a string, reversed() function returns an object.\n",
    "- Traverse through this objec to get the character of string in reverse order and print them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b3ed08b9-c1c7-4369-b615-f6b785917b6d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : noor\n",
      "Characters of given string in reverse order:\n",
      "r\n",
      "o\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "# Create/take a string of characters.\n",
    "s3 = 'noor'\n",
    "print(f\"Given string : {s3}\")\n",
    "\n",
    "# Using in-built function reverse a string, reversed() function returns an object.\n",
    "# Traverse through this objec to get the character of string in reverse order and print them.\n",
    "print(\"Characters of given string in reverse order:\")\n",
    "for char in reversed(s3):\n",
    "    print(char)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73ceff16-6459-43af-9079-da1158b5f465",
   "metadata": {},
   "source": [
    "## 4)  Develop a program that finds the factorial of a given number using a `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d288d4f1-211c-4af4-b3dd-6240fc5399a1",
   "metadata": {},
   "source": [
    "### Ans 4)\n",
    "\n",
    "#### Steps:\n",
    "- Take a number from user to find the factorial.\n",
    "- Initialise a varaible 'mult' by 1 that stores the calculated factorial.\n",
    "- Generate a sequence of numbers from 1 to till given number using range function and multiply this generated number with mult variable in each iteration.\n",
    "- Print the factorial i.e mult"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "90bcc9f1-c685-486f-8453-056fc23cc106",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number to find the factorial :  6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Factorial of number 6 is : 720\n"
     ]
    }
   ],
   "source": [
    "# Take a number from user to find the factorial.\n",
    "n = int(input(\"Enter a number to find the factorial : \"))\n",
    "\n",
    "# Initialise a varaible 'mult' by 1 that stores the calculated factorial.\n",
    "mult = 1\n",
    "\n",
    "# Generate a sequence of numbers from 1 to till given number using range function and multiply this generated number with mult variable in each iteration.\n",
    "for i in range(1,n+1):\n",
    "    mult *= i\n",
    "    \n",
    "# Print the factorial i.e mult\n",
    "print(f\"Factorial of number {n} is : {mult}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3066ab77-74aa-479e-8ec2-c161d5cc6bbc",
   "metadata": {},
   "source": [
    "## 5)  Create a program to print the multiplication table of a given number using a `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e705c5c-b813-4f63-9641-5985e255ad33",
   "metadata": {},
   "source": [
    "### Ans 5)\n",
    "\n",
    "#### Steps:\n",
    "- Take a number from user to find the table.\n",
    "- Generate a sequence of numbers from 1 to 10 and multiply each generated number with user given number to find its table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a928f62b-9f70-45ed-adc9-a61cba8bfb3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number to get it's multiplication table :   6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 x 1 = 6\n",
      "6 x 2 = 12\n",
      "6 x 3 = 18\n",
      "6 x 4 = 24\n",
      "6 x 5 = 30\n",
      "6 x 6 = 36\n",
      "6 x 7 = 42\n",
      "6 x 8 = 48\n",
      "6 x 9 = 54\n",
      "6 x 10 = 60\n"
     ]
    }
   ],
   "source": [
    "# Take a number from user to find the table.\n",
    "n = int(input(\"Enter a number to get it's multiplication table :  \"))\n",
    "\n",
    "# Generate a sequence of numbers from 1 to 10 and multiply each generated number with user given number to find its table.\n",
    "for i in range(1,11):\n",
    "    print(f\"{n} x {i} = {n*i}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0122580c-bd08-4db2-8c8f-cac3344ccf32",
   "metadata": {},
   "source": [
    "## 6)  Write a program that counts the number of even and odd numbers in a list using a `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2aaa2ef-3601-42b3-9c6c-8ef43acd40bf",
   "metadata": {},
   "source": [
    "### Ans 6)\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a list of even and odd numbers.\n",
    "- Initialise two varaibles even_count and odd_count to count even and odd numbers in a given list.\n",
    "- Traverse through the list and check whether elment is even or odd.\n",
    "- If element is even increase the count of even numbers by 1, If element is odd increase the count of odd numbers by 1,\n",
    "- Finally print count of even and odd numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a2a807d4-9087-4a29-b0fe-c18bb41a6532",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list is : [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 33, 32, 45, 76]\n",
      "Count of even numbers : 6\n",
      "Count of odd numbers : 8\n"
     ]
    }
   ],
   "source": [
    "# Create/take a list of even and odd numbers.\n",
    "lis6 = [1,2,3,4,5,6,7,8,9,11,33,32,45,76]\n",
    "print(f\"Given list is : {lis6}\")\n",
    "\n",
    "# Initialise two varaibles even_count and odd_count to count even and odd numbers in a given list.\n",
    "even_count = 0 \n",
    "odd_count = 0\n",
    "\n",
    "# Traverse through the list and check whether elment is even or odd.\n",
    "# If element is even increase the count of even numbers by 1, If element is odd increase the count of odd numbers by 1,\n",
    "for i in lis6:\n",
    "    if i%2 == 0:\n",
    "        even_count  += 1\n",
    "    else:\n",
    "        odd_count += 1\n",
    "        \n",
    "# Finally print count of even and odd numbers.\n",
    "print(f\"Count of even numbers : {even_count}\\nCount of odd numbers : {odd_count}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e249871-56da-46b2-a463-0af8bc4905f0",
   "metadata": {},
   "source": [
    "## 7) . Develop a program that prints the squares of numbers from 1 to 5 using a `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "043b7d49-647a-4e21-a961-e9d9c218d421",
   "metadata": {},
   "source": [
    "### Ans 7)\n",
    "\n",
    "#### Steps:\n",
    "- Generate a sequence of numbers from 1 to 5 and multiply each generated number with its own to find the square of number.\n",
    "- Print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a22c5c3d-0fe0-4369-a2ad-fcfde9368a44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Squares of numbers form 1 to 5 :\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "print(\"Squares of numbers form 1 to 5 :\")\n",
    "# Generate a sequence of numbers from 1 to 5 and multiply each generated number with its own to find the square of number.\n",
    "for i in range(1,6):\n",
    "    print(i*i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e931baa-aab9-4525-8847-2dd78baaf985",
   "metadata": {},
   "source": [
    "## 8) Create a program to find the length of a string without using the `len()` function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f06790a-48cb-4ca2-8d33-ed300b7b0baa",
   "metadata": {},
   "source": [
    "## Ans 8)\n",
    "\n",
    "#### Steps :\n",
    "- Take a string\n",
    "- Initialise a counter with 0, that will count the number of characters in string.\n",
    "- Traverse through the string.\n",
    "- Increase the counter by 1\n",
    "- Display the length i.e counter value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "de9d9106-048a-4547-89a3-392df703b735",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : Data Science\n",
      "The length of string is: 12 \n"
     ]
    }
   ],
   "source": [
    "## create a string\n",
    "s8 = 'Data Science'\n",
    "\n",
    "print(f\"Given string : {s8}\")\n",
    "## initialise counter\n",
    "char_count = 0\n",
    "\n",
    "## traverse though the string\n",
    "for char in s8:\n",
    "    char_count+=1\n",
    "    \n",
    "## print length of string\n",
    "print(f\"The length of string is: {char_count} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f58b7412-3a23-48db-bb31-3485e7664713",
   "metadata": {},
   "source": [
    "## 9) Write a program that calculates the average of a list of numbers using a `for` loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f0b371f-7f3d-45ad-a066-0b2150f94a7c",
   "metadata": {},
   "source": [
    "### Ans 9)\n",
    "\n",
    "1) Average of elements : sum of elements / total no. of elements\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a list of numbers/elements.\n",
    "- Initialise a variable \"list_sum\" by 0, to store the sum of all numbers.\n",
    "- Iterate through the list and add each number with list_sum.\n",
    "- find the total number of elements by using len() function.\n",
    "- find and print the avg of elements using formula."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "79be181d-9d6f-4674-aa77-41b97a1a6366",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [1, 2, 3, 4, 5]\n",
      "Avg of a list of numbers : 3\n"
     ]
    }
   ],
   "source": [
    "# Create/take a list of numbers/elements.\n",
    "lis9 = [1,2,3,4,5]\n",
    "print(f\"Given list : {lis9}\")\n",
    "\n",
    "# Initialise a variable \"list_sum\" by 0, to store the sum of all numbers.\n",
    "list_sum = 0\n",
    "\n",
    "# Iterate through the list and add each number with list_sum.\n",
    "for num in lis9:\n",
    "    list_sum = list_sum + num\n",
    "    \n",
    "# find the total number of elements in a list using len() function\n",
    "total_ele = len(lis9)\n",
    "\n",
    "# Print the avg of all numbers i.e list_sum.\n",
    "print(f\"Avg of a list of numbers : {list_sum//total_ele}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0806cdd-7a65-48e6-89e4-d686765c24a2",
   "metadata": {},
   "source": [
    "## 10)  Develop a program that prints the first `n` Fibonacci numbers using a `for` loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22944d76-0cf7-45ee-9e7e-85a71fa853d0",
   "metadata": {},
   "source": [
    "### Ans 10)\n",
    "\n",
    "1) Fibonacci number : F(n) = F(n-1) + F(n-2)\n",
    "\n",
    "#### Steps:\n",
    "- Take a number from user to print first n fibonacci numbers.\n",
    "- If number is 0 or 1 that is the base case then return number itself.\n",
    "- Else run the loop till n times to find the next number of fibonacci series using formula and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "6c891106-30bb-4fab-bf75-5a138eeff576",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a value of n to print first n fibonacci numbers :  6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# Take a number from user to print first n fibonacci numbers.\n",
    "n = int(input(\"Enter a value of n to print first n fibonacci numbers : \"))\n",
    "\n",
    "# If number is 0 or 1 that is the base case then return number itself.\n",
    "# Else run the loop till n times to find the next number of fibonacci series using formula and print it.\n",
    "if n <= 1:\n",
    "    print(n)\n",
    "else:\n",
    "    f0 , f1 = 0 , 1\n",
    "    print(f\"{f0}\\n{f1}\")\n",
    "    for i in range(2,n):\n",
    "        next_num = f0 + f1\n",
    "        print(next_num)\n",
    "        f0 = f1\n",
    "        f1 = next_num"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "106ac05e-f69d-4952-b825-b419202716ec",
   "metadata": {},
   "source": [
    "# For loop : Intermediate Level"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f6b5761-a889-4463-91e7-b1be42285555",
   "metadata": {},
   "source": [
    "## 11)  Write a program to check if a given list contains any duplicates using a `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dadc048a-9453-477a-8336-28a5b76e5dd1",
   "metadata": {},
   "source": [
    "### Ans 11)\n",
    "\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a list of numbers.\n",
    "- Traverse through the list using for loop.\n",
    "- Find the count of each element of the list.\n",
    "- If count of any element is greater than 1 that means there are duplicates else no."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "dd5791ef-9954-41db-bb87-e0c9e31cc58c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [2, 3, 1, 1, 4, 6, 7]\n",
      "Yes, list contains duplicates. \n"
     ]
    }
   ],
   "source": [
    "# Create/take a list of numbers.\n",
    "lis11 = [2,3,1,1,4,6,7]\n",
    "print(f\"Given list : {lis11}\")\n",
    "# Traverse through the list using for loop.\n",
    "# Find the count of each element of the list.\n",
    "# If count of any element is greater than 1 that means there are duplicates else no.\n",
    "for ele in lis11:\n",
    "    if lis11.count(ele) > 1:\n",
    "        print(\"Yes, list contains duplicates. \")\n",
    "        break\n",
    "else:\n",
    "    print(\"No, list doesn't contain duplicates. \")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91b8d6e6-ff0f-49a1-bdc3-4940a17ccd33",
   "metadata": {},
   "source": [
    "## 12)  Create a program that prints the prime numbers in a given range using a `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "423016c9-b9f5-45d8-a5c4-a8ea932799a4",
   "metadata": {},
   "source": [
    "### Ans 12)\n",
    "\n",
    "\n",
    "#### Steps:\n",
    "- Take a number from user.\n",
    "- Generate a sequence of numbers by using range() function.\n",
    "- Print if a generated number is prime else skip."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "54527330-fb87-4c24-83e4-0fbfc9e8707c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a range of numbers seperated by spaces to print the prime numbers: 1 20\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n",
      "13\n",
      "17\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "# take inputs/range from user, split it ,convert it into int and store it into variables.\n",
    "num = list(map(int, input(\"Enter a range of numbers seperated by spaces to print the prime numbers:\").split()))\n",
    "start = num[0]\n",
    "end = num[1]\n",
    "\n",
    "for i in range(start,end+1):\n",
    "    if i== 1 or i == 2:\n",
    "        print(i)\n",
    "    else:\n",
    "        for j in range(2,i):   # check whether number is prime or not.\n",
    "            if i%j == 0:\n",
    "                break\n",
    "        else:\n",
    "            print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9d8286f-d37a-4683-87e2-ac3704c561be",
   "metadata": {},
   "source": [
    "## 13) Develop a program that counts the number of vowels in a string using a `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24080db9-17e5-41c0-912e-15e4baed6bec",
   "metadata": {},
   "source": [
    "### Ans 13)\n",
    "\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a string of characters\n",
    "- Create a list of vowels\n",
    "- Initialise vowel count variable by 0\n",
    "- Search each character of string into list of vowels, if present then increase vowel count and print the final count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "4b5e10eb-1ab6-47fd-b9ca-2dd08e87057b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter any string to count number of vowels in it :  data science\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : data science\n",
      "Number of vowels in given string  : 5\n"
     ]
    }
   ],
   "source": [
    "# create/take a string of characters\n",
    "s13 = input(\"Enter any string to count number of vowels in it : \")\n",
    "print(f\"Given string : {s13}\")\n",
    "\n",
    "# create a list of vowels\n",
    "vowels = ['a','e','i','o','u']\n",
    "\n",
    "# initialise vowel count variable by 0\n",
    "vowel_count = 0\n",
    "\n",
    "# search each character of string into list of vowels, if present then increase vowel count and print the final count\n",
    "for char in s13:\n",
    "    if char in vowels:\n",
    "        vowel_count += 1\n",
    "        \n",
    "print(f\"Number of vowels in given string  : {vowel_count}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8912c2a3-8926-4bec-a10a-d780274a1e30",
   "metadata": {},
   "source": [
    "## 14)  Write a program to find the maximum element in a 2D list using a nested `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71c68d06-a64d-4295-bac0-f7c6e52b8017",
   "metadata": {},
   "source": [
    "### Ans 14)\n",
    "\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a 2D list of element.\n",
    "- Initialise max_val by 0\n",
    "- Traverse through each element row wise.\n",
    "- Print the maximum element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "8afcaa2e-2a8a-44cd-8469-17d34b78cac1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given 2D list : [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]\n",
      "Maximum value in given 2D list is : 12\n"
     ]
    }
   ],
   "source": [
    "# Create/take a 2D list of element.\n",
    "lis14 = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]\n",
    "print(f\"Given 2D list : {lis14}\")\n",
    "\n",
    "# Initialise max_val by 0\n",
    "max_val = 0\n",
    "\n",
    "# Traverse through each element row wise.\n",
    "# Print the maximum element.\n",
    "for i in range(len(lis14)):\n",
    "    for j in range(len(lis14[0])):\n",
    "        max_val = max(lis14[i][j], max_val)\n",
    "        \n",
    "print(f\"Maximum value in given 2D list is : {max_val}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cb78748-7d61-4f5c-8790-e08b45893a43",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 15)  Create a program that removes all occurrences of a specific element from a list using a `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c7afc3d-1bed-40fb-9a04-a6e5d997d8dc",
   "metadata": {},
   "source": [
    "### Ans 15)\n",
    "\n",
    "1) To remove all occurrences of an element from a list, frequency of that element should be known i.e how many times that specific element is repeated in the list.\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a list of elements.\n",
    "- Take an element from the user to remove that element from the list.\n",
    "- Find the count of that element in the list.\n",
    "- Run the loop count times to remove that element.\n",
    "- Print the updated list after removing that element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "89023e8f-7264-436c-939f-f896fd74374b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [1, 2, 3, 4, 1, 1, 5, 6]\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter an element to remove all occurrence of it from the list :  1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated list : [2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "# Create/take a list of elements.\n",
    "lis15 = [1,2,3,4,1,1,5,6]\n",
    "print(f\"Given list : {lis15}\")\n",
    "\n",
    "# Take an element from the user to remove that element from the list.\n",
    "ele = int(input(\"Enter an element to remove all occurrence of it from the list : \"))\n",
    "\n",
    "# Find the count of that element in the list.\n",
    "ele_count = lis15.count(ele)\n",
    "\n",
    "# Run the loop count times to remove that element.\n",
    "# Print the updated list after removing that element.\n",
    "for i in range(ele_count):\n",
    "    lis15.remove(ele)\n",
    "\n",
    "print(f\"Updated list : {lis15}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "007d3e57-7d4f-4b30-b157-6baaa8a4a88b",
   "metadata": {},
   "source": [
    "## 16)  Develop a program that generates a multiplication table for numbers from 1 to 5 using a nested `for` loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "800efdc0-ff77-46fc-ac2b-355497aa83fb",
   "metadata": {},
   "source": [
    "### Ans 16)\n",
    "\n",
    "#### Steps:\n",
    "- Generate a sequence of numbers from 1 to 10 by running outer loop.\n",
    "- Generate a sequence of numbers from 1 to 5 by running inner loop.\n",
    "- Multiplty outloop generated number with each inner loop generated number and print it.\n",
    "- Use end= '' parameter to print numbers in table format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "33835b6d-7a3f-4b81-8e0b-2e144f15c6ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Table from 1 to 5 : \n",
      "1 || 2 || 3 || 4 || 5 || \n",
      "2 || 4 || 6 || 8 || 10 || \n",
      "3 || 6 || 9 || 12 || 15 || \n",
      "4 || 8 || 12 || 16 || 20 || \n",
      "5 || 10 || 15 || 20 || 25 || \n",
      "6 || 12 || 18 || 24 || 30 || \n",
      "7 || 14 || 21 || 28 || 35 || \n",
      "8 || 16 || 24 || 32 || 40 || \n",
      "9 || 18 || 27 || 36 || 45 || \n",
      "10 || 20 || 30 || 40 || 50 || \n"
     ]
    }
   ],
   "source": [
    "print(\"Table from 1 to 5 : \")\n",
    "for i in range(1,11):\n",
    "    for j in range(1,6):\n",
    "        print(i*j,end=' || ')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4617c178-5ff4-4124-ba46-5ad9ff5ee60b",
   "metadata": {},
   "source": [
    "## 17) Write a program that converts a list of Fahrenheit temperatures to Celsius using a `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d65d19f-efed-44ae-ab0c-7b900b6f5277",
   "metadata": {},
   "source": [
    "### Ans 17)\n",
    "\n",
    "1) formula : C = 5/9 × (F-32) , where F = fahrenheit and C = Celsius\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a of Fahrenheit temperatures.\n",
    "- Create a new celsius list (empty list).\n",
    "- Traverse through each element of list.\n",
    "- Convert Fahrenheit temperatures into Celsius using formula and append it and print the final list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "efff30ee-f0fc-4ced-b7bb-980e8cb8310b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of Fahrenheit tmep : [32, 59, 98.24]\n",
      "List of celsius temp : [0.0, 15.0, 36.8]\n"
     ]
    }
   ],
   "source": [
    "# Create/take a of Fahrenheit temperatures.\n",
    "Fahrenheit_temp = [32,59,98.24]\n",
    "print(f\"List of Fahrenheit tmep : {Fahrenheit_temp}\")\n",
    "\n",
    "# Create a new celsius list (empty list).\n",
    "celsius_temp = []\n",
    "\n",
    "# Traverse through each element of list.\n",
    "# Convert Fahrenheit temperatures into Celsius using formula and append it and print the final list.\n",
    "for i in Fahrenheit_temp :\n",
    "    celsius_temp.append((i-32)*5/9)\n",
    "    \n",
    "print(f\"List of celsius temp : {celsius_temp}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d254ae18-255b-4611-9864-69d40d5fde85",
   "metadata": {},
   "source": [
    "## 18)  Create a program to print the common elements from two lists using a `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2eade2bd-44e2-463e-9316-a0833c0df111",
   "metadata": {},
   "source": [
    "### Ans 18)\n",
    "\n",
    "\n",
    "#### Steps:\n",
    "- Create/take two list of elements.\n",
    "- Traverse through first list of elements and by running nested loop search each element in 2nd list.\n",
    "- If any element is same print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e9a70df1-737b-421b-8c6a-5f2c08a70170",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given lists : \n",
      "List 1 : [1, 2, 3, 4, 5, 6]\n",
      "List 2 : [2, 4, 6, 7, 8, 9]\n",
      "Common element: 2\n",
      "Common element: 4\n",
      "Common element: 6\n"
     ]
    }
   ],
   "source": [
    "# Create/take two list of elements.\n",
    "lis18_1 = [1,2,3,4,5,6]\n",
    "lis18_2 = [2,4,6,7,8,9]\n",
    "print(f\"Given lists : \\nList 1 : {lis18_1}\\nList 2 : {lis18_2}\")\n",
    "\n",
    "# Traverse through first list of elements and by running nested loop search each element in 2nd list.\n",
    "# If any element is same print it.\n",
    "for i in lis18_1:\n",
    "    for j in lis18_2:\n",
    "        if j == i:\n",
    "            print('Common element:',j)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "838c1e4c-3327-4de7-90be-99e3c3f57104",
   "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": "markdown",
   "id": "4da9397c-da01-4332-b056-f3d83a5fe8f0",
   "metadata": {},
   "source": [
    "### Ans 19)\n",
    "\n",
    "\n",
    "#### Steps:\n",
    "- We can duplicate,triplicate a character by mutplying it that much times.\n",
    "- Use the same concept to print the stars.\n",
    "- To print the star only times multiply by 1.\n",
    "- To print the star two times multiply by 2.\n",
    "- To print the star three times multiply by 3.\n",
    "- To print the star four times multiply by 4.\n",
    "- To print the star five times multiply by 5.\n",
    "- Instead of writing repeatitive code use for loop and print the pattern. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "d2d04d7c-7862-40ce-8c08-ceb504a0b711",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*\n",
      "**\n",
      "***\n",
      "****\n",
      "*****\n"
     ]
    }
   ],
   "source": [
    "## concept\n",
    "print('*'*1)\n",
    "print('*'*2)\n",
    "print('*'*3)\n",
    "print('*'*4)\n",
    "print('*'*5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "e8bd02d8-3a19-4d72-baac-584f672f2fe1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pattern of Right angled trinagled using *\n",
      "*\n",
      "**\n",
      "***\n",
      "****\n",
      "*****\n"
     ]
    }
   ],
   "source": [
    "# using for loop\n",
    "print(\"Pattern of Right angled trinagled using *\")\n",
    "for i in range(1,6):\n",
    "    print('*'*i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c69f3c1-60d3-409f-af90-0485c7e692db",
   "metadata": {},
   "source": [
    "## 20)  Write a program to find the greatest common divisor (GCD) of two numbers using a `for` loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f226bfc0-fd3d-4515-9643-a3ba3ee884b9",
   "metadata": {},
   "source": [
    "### Ans 20)\n",
    "\n",
    "1) The GCD of two integers a and b is the largest number that divides both of a and b (without leaving a remainder or remainder is zero).\n",
    "\n",
    "#### Steps:\n",
    "- Take two numbers from user.\n",
    "- Find the min of both numbers.\n",
    "- Generate a sequence of numbers from that min value till 2.\n",
    "- Start dividing both given numbers from that min value continuously till 2.\n",
    "- Return the number as GCD that can divide both the numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b914e568-c256-4681-84e7-4ca0656f766a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter following values to find the GCD of two numbers\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter value of a :  12\n",
      "Enter value of b :  48\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Greatest common divisor of two given numbers is : 12\n"
     ]
    }
   ],
   "source": [
    "print(\"Enter following values to find the GCD of two numbers\")\n",
    "a = int(input(\"Enter value of a : \"))\n",
    "b = int(input(\"Enter value of b : \"))\n",
    "\n",
    "for i in reversed(range(2,min(a,b)+1)):\n",
    "    if a % i == 0 and b % i == 0:\n",
    "        print(f\"Greatest common divisor of two given numbers is : {i}\")\n",
    "        break\n",
    "else:\n",
    "    print(f\"Greatest common divisor of two given numbers is : {1}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8819f103-bfbe-4a43-934f-d1e29840139b",
   "metadata": {},
   "source": [
    "# For loop : Advanced Level"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d35a5d22-6786-4416-9897-01d7ef631ddb",
   "metadata": {},
   "source": [
    "## 21)  Create a program that calculates the sum of the digits of numbers in a list using a list comprehension."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a53428a8-165d-438c-b8d8-178e3928bbba",
   "metadata": {},
   "source": [
    "### Ans 21)\n",
    "\n",
    "#### Steps:\n",
    "- Create/Take a list of numbers.\n",
    "- Iterate through each number of list.\n",
    "- Convert number into string (iterable).\n",
    "- If length of number is 1 then return the number itself.\n",
    "- If length of number is greater than 1 then perform follwing task:\n",
    "- 1) Convert string of numbers into list of string using list() function.\n",
    "- 2) Convert list of string into list of integers using map() function.\n",
    "- 3) Convert the output of map funtion again into list and pass it to sum function.\n",
    "- 4) Add the sum to the list using list comprehention.\n",
    "- Note: Pack all these 4 steps into list comprehension.\n",
    "- Print the list of sum of numbers of given list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7da817d4-502d-429d-8440-866a9ea0104d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list :  [12, 230, 34, 451, 56, 76, 871]\n",
      "List of sum of numbers of given list :  [3, 5, 7, 10, 11, 13, 16]\n"
     ]
    }
   ],
   "source": [
    "lis21 = [12,230,34,451,56,76,871]\n",
    "print(\"Given list : \",lis21)\n",
    "\n",
    "output = [num if len(str(num))==1 else sum(list(map(int, list(str(num))))) for num in lis21 ]\n",
    "print(\"List of sum of numbers of given list : \",output)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a33a019-f767-4a3f-82ab-31ab778b908e",
   "metadata": {},
   "source": [
    "## 22) Write a program to find the prime factors of a given number using a `for` loop and list comprehension."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42344532-3965-4e5b-8ba3-ceb73e4d3022",
   "metadata": {},
   "source": [
    "### Ans 22)\n",
    "\n",
    "1) Create a list of factors which can divide a given number.\n",
    "2) From this list, find only prime factors and append into new list.\n",
    "\n",
    "\n",
    "#### Steps :\n",
    "- Create a list of factors which can divide a given number.\n",
    "- 1) Using list comprehension, create a list of numbers which can divide a given number.\n",
    "- From this list, find only prime factors and append into new list.\n",
    "- 1) Iterate through list of factors.\n",
    "- 2) Divide given number with factor, if number is divisble then append into new list of prime numbers.\n",
    "- 3) Then update the number with its quotient and repeat the step 2.\n",
    "- If number is not divisible by factor then skip that factor.\n",
    "- Print the list of prime factors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "43f9ae27-edb1-4c7a-b562-42694d8b1a38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter any number to find its prime factors :  99\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of prime factors :  [3, 3, 11]\n"
     ]
    }
   ],
   "source": [
    "def primeFactor1(num):\n",
    "    # Create a list of factors which can divide a given number.\n",
    "    # Using list comprehension, create a list of numbers which can divide a given number.\n",
    "    factors_list = [i for i in range(2, num) if num % i == 0]\n",
    "    \n",
    "    # From this list, find only prime factors and append into new list.\n",
    "    for factor in factors_list:\n",
    "        while num % factor == 0:\n",
    "            prime_lis.append(factor)\n",
    "            num //= factor\n",
    "    if num > 1:\n",
    "        prime_lis.append(num)\n",
    "        \n",
    "# Create a new global empty list to store prime factors\n",
    "prime_lis = []\n",
    "\n",
    "# call the function\n",
    "n = int(input(\"Enter any number to find its prime factors : \"))\n",
    "primeFactor1(n)\n",
    "\n",
    "# print the list of prime factors\n",
    "print('List of prime factors : ',prime_lis)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02295878-a9a7-4e90-807c-3481031a9a3f",
   "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": "markdown",
   "id": "37815192-fb3c-44c2-93d2-c6256e28c73a",
   "metadata": {},
   "source": [
    "### Ans 23)\n",
    "\n",
    "#### Steps:\n",
    "- Create a list of numbers.\n",
    "- Check unique values, If value is unique, its count will be 1.\n",
    "- Extract that unique value only form the list using indexing and append into list using list compreshension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "ec7bd552-e469-49ae-a7ce-5a7c346a0cbe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list :  [1, 2, 3, 2, 5, 6, 9, 3]\n",
      "List of unique values :  [1, 5, 6, 9]\n"
     ]
    }
   ],
   "source": [
    "# Create a list of numbers.\n",
    "lis23 = [1,2,3,2,5,6,9,3]\n",
    "print(\"Given list : \",lis23)\n",
    "\n",
    "# Check unique values, If value is unique, its count will be 1.\n",
    "# Extract that unique value only form the list using indexing and append into list using list compreshension.\n",
    "output = [lis23[i]  for i in range(len(lis23))  if lis23.count(lis23[i]) == 1]\n",
    "\n",
    "# print list of extracted values.\n",
    "print(\"List of unique values : \",output)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "014ad76d-acef-4431-ba16-6e88f2e05079",
   "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": "markdown",
   "id": "7c31a32b-e0c6-4936-8520-2f57c95c5876",
   "metadata": {},
   "source": [
    "### Ans 24)\n",
    "\n",
    "1. A number is called palindromic if number is same after reversing it. ex- 11, 101 etc\n",
    "2. Note: All single digit numbers are also palindromic numbers. Like : 0,1,2,3,...9 (after reversing they remain same.)\n",
    "\n",
    "#### Steps:\n",
    "- Generate a sequence of numbers from 0 to given number.\n",
    "- convert that number into string.\n",
    "- Check if number is same after reversing it.\n",
    "- If yes, add it to the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9fa11b4f-0a1e-4a95-87b7-5383aacb295c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter any number to generate all palindromic numbers up to that range: 200\n",
      "[0, 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": [
    "# write the above code using list comprehension.\n",
    "n = int(input(\"Enter any number to generate all palindromic numbers up to that range: \"))\n",
    "palin_lis = [num for num in range(0, n + 1) if str(num) == str(num)[::-1]]\n",
    "print(palin_lis)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24481882-7059-4a52-9420-748537a36d79",
   "metadata": {},
   "source": [
    "## 25)  Write a program to flatten a nested list using list comprehension."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17e8a1b8-55a8-4117-93b3-8251436a9784",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Ans 25)\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a nested list of elements.\n",
    "- Use list concatenation to flatten given nested list.\n",
    "- In first list append the elements of nested list by using nested loop.\n",
    "- In second list append the other elements.\n",
    "- Concatenate both the list to get final list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "133b1512-0fa3-424d-a9cd-23ae8ebb76a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 5, 6, 7, 1, 2, 3, 10]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lis25 = [1,2,3,[4,5],[6,7],10]\n",
    "flatten_lis = [sub_ele for ele in lis25 if type(ele)==list for sub_ele in ele] + [ele for ele in lis25 if type(ele)!=list]\n",
    "flatten_lis"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57d7f734-6299-495b-9467-ffca5019df46",
   "metadata": {},
   "source": [
    "## 26) Develop a program that computes the sum of even and odd numbers in a list separately using list comprehension."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63ce3539-00e5-454d-9016-e97fc286566f",
   "metadata": {},
   "source": [
    "### Ans 26)\n",
    "1) Task: ([sum of even numbers],[sum of odd numbers])\n",
    "2) list comprehension syntax : [output   collection    condition ]\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a list of elements.\n",
    "- Use list comprehension, create a list of even numbers.\n",
    "- Use list comprehension, and create another list of odd numbers.\n",
    "- Using sum() function, find the sum of all even numbers and odd number and print them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f6447e95-fb21-4a0f-955d-710abe87b30b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "Tuple of Sum of even numbers and odd numbers : \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(30, 25)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lis26 = [1,2,3,4,5,6,7,8,9,10]\n",
    "print(f\"Given list : {lis26}\")\n",
    "\n",
    "print(\"Tuple of Sum of even numbers and odd numbers : \")\n",
    "sum([i for i in lis26 if i%2==0]),sum([i for i in lis26 if i%2!=0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e4144f1-1859-4ff7-8143-def8440e5c70",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 27)  Create a program that generates a list of squares of odd numbers between 1 and 10 using list comprehension."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66cba131-a7ac-4b35-889f-97fc62848a49",
   "metadata": {},
   "source": [
    "### Ans 27)\n",
    "\n",
    "#### Steps:\n",
    "- First of all generate a sequence of numbers from 1 to 10.\n",
    "- Filter only odd numbers.\n",
    "- Square those odd numbers and append it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "74c52063-37b5-4253-8f1c-fa34fdfce388",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of squares of odd numbers between 1 and 10 :  [1, 9, 25, 49, 81]\n"
     ]
    }
   ],
   "source": [
    "# syntax: [output   collection   condition]\n",
    "output = [i*i for i in range(1,11) if i%2!=0]\n",
    "print(\"List of squares of odd numbers between 1 and 10 : \",output)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c20db82-2e97-46c4-a4cf-3f577a592934",
   "metadata": {},
   "source": [
    "## 28)  Write a program that combines two lists into a dictionary using list comprehension."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "181e92ee-ebd9-405c-b4fb-a1bb544167d2",
   "metadata": {},
   "source": [
    "### Ans 28)\n",
    "\n",
    "1) Task : for ex- if l1 = [1,2,3] , l2 = ['Python','SQL','ML'] ; output = {1:'Python',2:'SQL',3:'ML'}\n",
    "\n",
    "\n",
    "#### Steps:\n",
    "- Create/take two lists.\n",
    "- Using zip function traverse both the lists simultaneously.\n",
    "- Consider first list elements as keys and second list elements as values.\n",
    "- Use dictionary comprehension, create a dictionary by combining both lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b4fb5db1-9f1f-4498-b267-9b66ee1f8c8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given lists : \n",
      "List 1 : [1, 2, 3]\n",
      "List 2 : ['Python', 'SQL', 'ML']\n",
      "Created dictionary from both lists:  {1: 'Python', 2: 'SQL', 3: 'ML'}\n"
     ]
    }
   ],
   "source": [
    "lis28_1 = [1,2,3] \n",
    "lis28_2 = ['Python','SQL','ML']\n",
    "print(f\"Given lists : \\nList 1 : {lis28_1}\\nList 2 : {lis28_2}\")\n",
    "\n",
    "output = {key:value for key, value in zip(lis28_1,lis28_2)}\n",
    "print(\"Created dictionary from both lists: \",output)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea573413-66ec-4a5e-b45d-cad0b6853415",
   "metadata": {},
   "source": [
    "## 29)  Develop a program that extracts the vowels from a string and stores them in a list using list comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ee334ad-8182-4f06-847b-2e39d86ef699",
   "metadata": {},
   "source": [
    "### Ans 29)\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a string.\n",
    "- Create a list of vowels.\n",
    "- Traverse through string and if char is vowel then append it into list comprehension.\n",
    "- Print the list of extracted vowels from a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9a6e8b17-2db8-403a-912d-80fb9022668b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string: noorain raza\n",
      "List of extracted vowels:  ['o', 'o', 'a', 'i', 'a', 'a']\n"
     ]
    }
   ],
   "source": [
    "s29 = \"noorain raza\"\n",
    "print(\"Given string:\",s29)\n",
    "\n",
    "vowel = ['a','e','i','o','u']\n",
    "emptylist = [char for char in s29 if char in vowel]\n",
    "print(\"List of extracted vowels: \",emptylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "110688e1-3251-4f55-b7f3-befc07e3f12e",
   "metadata": {},
   "source": [
    "## 30)  Create a program that removes all non-numeric characters from a list of strings using list comprehension."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1099032-ea1f-47a5-be8a-83e5138bd336",
   "metadata": {},
   "source": [
    "### Ans 30)\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a list of string.\n",
    "- Using isnumeric() fucntion check whether element is numeric or not.\n",
    "- If element is numeric append into list using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "472f0e65-9a04-43f5-a22e-9019d2f87730",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list of string :  ['a', 'b', '1', '3', 'z', 'j']\n",
      "List after removing non-numeric characters :  ['1', '3']\n"
     ]
    }
   ],
   "source": [
    "lis = ['a','b','1','3','z','j']\n",
    "print(\"Given list of string : \",lis)\n",
    "\n",
    "lis30 = [char for char in lis if char.isnumeric()]\n",
    "print(\"List after removing non-numeric characters : \",lis30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c39ca5d5-372e-49fa-9f77-24c2664dc5b1",
   "metadata": {},
   "source": [
    "# For loop : Challenge Level"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09ca1b9d-e845-45ea-a85f-4af9fed67231",
   "metadata": {},
   "source": [
    "## 31)  Write a program to generate a list of prime numbers using the Sieve of Eratosthenes algorithm and list comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bcb29b5-e6d5-4792-9aba-1d0d62eb23fe",
   "metadata": {},
   "source": [
    "\n",
    "### Ans 31)\n",
    "\n",
    "1) Sieve of Eratosthenes is a simple and ancient algorithm used to find the prime numbers up to any given limit. It is one of the most efficient ways to find small prime numbers.\n",
    "\n",
    "2) For a given upper limit n the algorithm works by iteratively marking the multiples of primes as composite, starting from 2. Once all multiples of 2 have been marked composite, the muliples of next prime, ie 3 are marked composite. This process continues until p <= sqrt(n) or p*p <= n ; where p is a prime number.\n",
    "\n",
    "3) for ex- if n = 100 then loop will run 10 times to mark all the multiples of 2,3,4,5,6,7,8,9,10 by False. Rest of the numbers will be True.\n",
    "\n",
    "#### Steps :\n",
    "* create a list of n+1 length by True.\n",
    "* Run the while loop till p*p<=n    i.e p <= sqrt(n)\n",
    "* Now mark all the multiples of p(prime number) as False.How?\n",
    "* by first checking the condition inside while loop if list[p] is True\n",
    "* Then run the loop from p*p till n+1 with a jump of p (P*P,n+1,P)\n",
    "* and make all the multples to False.\n",
    "* Now run thee loop from 2 till end and print those which are only True. (those remaining numbers will be prime numbers.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "98f21643-aa1b-42dd-a5a4-0e5ef023ee13",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a value of n to generate prime numbers till n :  15\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of Prime numbers from 2 to 15 : [2, 3, 5, 7, 11, 13]\n"
     ]
    }
   ],
   "source": [
    "# take a number from user to generate primes numbers till n using Sieve of Erathosthenes algo\n",
    "n = int(input(\"Enter a value of n to generate prime numbers till n : \"))\n",
    "\n",
    "# create a list of n+1 length with True values.\n",
    "num_list = [True]*(n+1)\n",
    "\n",
    "# initialise a varaible p by first prime number i.e 2\n",
    "p = 2\n",
    "\n",
    "# Now start marking the multiples of prime numbers with False.\n",
    "while p*p <= n:\n",
    "    # check whether pth value of num_list is true or not.\n",
    "    if num_list[p] == True:\n",
    "        \n",
    "        for i in range(p*p,n+1,p):\n",
    "            num_list[i] = False\n",
    "        \n",
    "        # update value of p i.e prime number with next prime number to mark the mutples of next prime number as false\n",
    "        p+=1\n",
    "\n",
    "# create a list of all unmarked numbers i.e prime numbers.\n",
    "prime_list = [i for i in range(2,n+1) if num_list[i] == True]   \n",
    "print(f\"List of Prime numbers from 2 to {n} : {prime_list}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afed4411-c95d-48d0-9e2d-8d7156096af3",
   "metadata": {},
   "source": [
    "## 32)  Create a program that generates a list of all Pythagorean triplets up to a specified limit using list comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb20c025-3131-4f80-b8e7-a1dd3d4c54e5",
   "metadata": {},
   "source": [
    "### Ans 32)\n",
    "\n",
    "1) A Pythagorean triplet is a set of three positive integers a, b and c such that a2 + b2 = c2. \n",
    "2) Formula to generate Pythagorean triplets in terms of m and n : a = m2 - n2, \n",
    "       b = 2 * m * n, \n",
    "       c  = m2 + n2\n",
    "\n",
    "#### Steps:\n",
    "- First Write the code without using list comprehension, then pack it inside list comprehension.\n",
    "- Take in the upper limit from the user and store it in a variable.\n",
    "- Using a while loop and for loop, compute the Pythagorean triplets(a,b,c) using the formula in terms of m and n.\n",
    "- If the value of the c is greater than the upper limit or if any of the numbers is equal to 0, break from the loop(Don't add this triplet into list).\n",
    "- Append the triplets into empyt list.\n",
    "- Print it.\n",
    "- Note: Now pack the code inside list.\n",
    "- 1) Use list comprehension sysntax : [output  collection  condition]\n",
    "- 2) In place of output, return a tuple of a,b,c. Instead of writing their formaulas by using assignmnet operator(=), write them directly in terms of m and n.\n",
    "- 3) In place of collection , write two nested for loop. first loop generates numbers from 2 to given limit. And second loop generates number from 1 to till value generated from prev loop.\n",
    "- 4) In place of condition, write the conditions using all() function.\n",
    "- 5) Now store list of triplets into a variable and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2a42649d-38de-4484-976c-3885590fb71d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter upper limit: 20\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of generated Pythagorean Triplets up to 20 : [(3, 4, 5), (8, 6, 10), (5, 12, 13), (15, 8, 17), (12, 16, 20)]\n"
     ]
    }
   ],
   "source": [
    "# code without using list comprehension\n",
    "limit=int(input(\"Enter upper limit:\"))\n",
    "c=0\n",
    "m=2\n",
    "triplet_list = []\n",
    "while(c<limit):\n",
    "    for n in range(1,m+1):\n",
    "        a=m*m-n*n\n",
    "        b=2*m*n\n",
    "        c=m*m+n*n\n",
    "        if(c>limit):\n",
    "            break\n",
    "        if(a==0 or b==0 or c==0):\n",
    "            break\n",
    "        triplet_list.append((a,b,c))\n",
    "    m=m+1\n",
    "print(f\"List of generated Pythagorean Triplets up to {limit} : {triplet_list}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d596af0a-5626-414c-aa19-fd6d1b9848b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter upper limit: 20\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of generated Pythagorean Triplets up to 20 : [(3, 4, 5), (8, 6, 10), (5, 12, 13), (15, 8, 17), (12, 16, 20)]\n"
     ]
    }
   ],
   "source": [
    "# code by using list comprehension\n",
    "\n",
    "limit = int(input(\"Enter upper limit:\"))\n",
    "pythagorean_triplets = [(m * m - n * n, 2 * m * n, m * m + n * n) for m in range(2, limit) for n in range(1, m) if all(side > 0 for side in (m * m - n * n, 2 * m * n, m * m + n * n)) and m * m + n * n <= limit]\n",
    "print(f\"List of generated Pythagorean Triplets up to {limit} : {pythagorean_triplets}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a27d1390-b242-4c3d-8c4f-9a3c3f9ba383",
   "metadata": {},
   "source": [
    "## 33)  Develop a program that generates a list of all possible combinations of two lists using list comprehension."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2eba7a50-cc7c-471d-ac4d-89a796279da0",
   "metadata": {},
   "source": [
    "### Ans 33)\n",
    "\n",
    "#### Steps:\n",
    "- Create two lists of elements.\n",
    "- Using nested loop make each possible combination of list 1 elements with list 2 elements. \n",
    "- Store in tuple inside list using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "7e8cd6b8-4848-4381-824e-517e2646dea8",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given lists : \n",
      "List 1 : [1, 2, 3, 4]\n",
      "List 2 : ['A', 'B', 'C', 'D']\n",
      "List of all possible combinations of given two lists : [(1, 'A'), (1, 'B'), (1, 'C'), (1, 'D'), (2, 'A'), (2, 'B'), (2, 'C'), (2, 'D'), (3, 'A'), (3, 'B'), (3, 'C'), (3, 'D'), (4, 'A'), (4, 'B'), (4, 'C'), (4, 'D')]\n"
     ]
    }
   ],
   "source": [
    "lis33_1 = [1,2,3,4]\n",
    "lis33_2 = ['A','B','C','D']\n",
    "print(f\"Given lists : \\nList 1 : {lis33_1}\\nList 2 : {lis33_2}\")\n",
    "\n",
    "poss_combo = [(i,j) for i in lis33_1 for j in lis33_2]\n",
    "print(f\"List of all possible combinations of given two lists : {poss_combo}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61bf4899-6bdd-4d51-8c4f-24404fcebd57",
   "metadata": {},
   "source": [
    "## 34)  Write a program that calculates the mean, median, and mode of a list of numbers using list comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f6d2ede-f7a7-49e4-b400-59f26e2ca664",
   "metadata": {},
   "source": [
    "### Ans 34)\n",
    "\n",
    "#### Steps :\n",
    "- Create a list of elements.\n",
    "- 1) Mean : sum of elements / total number of elements\n",
    "- 2) median : sort the list, pick the middle one (in case of odd length)\n",
    "- 2) median : sort the list, pick the middle one and middle -1 , take the avg of both.(in case of even length)\n",
    "- 3) mode : most repetitve element.\n",
    "- -  1) Traverse through list and create list of tuple with element and their counts.\n",
    "- -  2) In list of tuple find the number which has max count."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "19e4a447-f266-4a88-8e97-ac5c85723a3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "lis34 = [1,2,3,4,5,6,7,8,4,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "0d023f7c-f51f-4f85-8e8b-6234d6d75484",
   "metadata": {},
   "outputs": [],
   "source": [
    "# mean = sum of elements / total number of elements\n",
    "mean = [round(sum(lis34)/len(lis34)) if lis34 else 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "0f8063a0-f9d7-4966-a02d-9eba24bce257",
   "metadata": {},
   "outputs": [],
   "source": [
    "# median : sort the list, pick the middle one (in case of odd length)\n",
    "# median : sort the list, pick the middle one and middle -1 , take the avg of both.(in case of even length)\n",
    "\n",
    "lis34.sort()\n",
    "lng = len(lis34)\n",
    "\n",
    "median = [(lis34[lng//2]+lis34[lng//2-1])/2 if lng%2!=0 else lis34[lng//2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d5a83509-64ed-44cc-802c-2e7f1cca1edf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# mode : most repetitve element.\n",
    "# 1) Traverse through list and create list of tuple with element and their counts.\n",
    "# 2) In list of tuple find the number which has max count.\n",
    "mode = max([(ele,lis34.count(ele)) for ele in lis34], key= lambda x : x[1])[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "670c5bf6-7ca6-4db5-b40c-f3f0a9b4ed6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean : 4\n",
      "Median : 4.0\n",
      "Mode : 4\n"
     ]
    }
   ],
   "source": [
    "print(f\"Mean : {mean[0]}\\nMedian : {median[0]}\\nMode : {mode}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cbb38f2-20f9-455d-b08c-f1b0cb59fc86",
   "metadata": {},
   "source": [
    "## 35)  Create a program that generates Pascal's triangle up to a specified number of rows using list comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cbb8679-47fe-4d07-aba8-80de6e713229",
   "metadata": {},
   "source": [
    "1) Pascal’s Triangle is a kind of number pattern. Pascal’s Triangle is the triangular arrangement of numbers that gives the coefficients in the expansion of any binomial expression.\n",
    "\n",
    "2) for ex - (x+y)**n for n = 0 ; coeff = 1, for n = 1 ; coeff = 1 1 and so on..\n",
    "\n",
    "3) Pascal’s Triangle Properties:\n",
    "- Each number is the sum of the two numbers above it.\n",
    "- The outside numbers are all 1.\n",
    "- The triangle is symmetric.\n",
    "- The first diagonal shows the counting numbers.\n",
    "- The sums of the rows give the powers of 2.\n",
    "- Each row gives the digits of the powers of 11.  (use this property to create Pascal's Triangle)\n",
    "- Each entry is an appropriate “choose number.”\n",
    "- And those are the “binomial coefficients.”\n",
    "- The Fibonacci numbers are there along diagonals.\n",
    "\n",
    "#### Steps:\n",
    "- Create a Pascal's triangle till n row by using the property that \"Each row gives the digits of the powers of 11.\"\n",
    "- Generate a sequence of numbers from 0 till n.\n",
    "- Find the 11 to the power from 0 till n and print it using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9d7aa2f0-63e7-421f-8e16-5b8dc148c5b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a value of n to Pascal's trinagle till n rows : 5\n",
      "Pascal's triangle : \n",
      "1\n",
      "11\n",
      "121\n",
      "1331\n",
      "14641\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Enter a value of n to Pascal's trinagle till n rows : \"))\n",
    "print(\"Pascal's triangle : \")\n",
    "pasTri = [11**i for i in range(n)]\n",
    "\n",
    "for i in pasTri:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "924916e7-acd6-4931-841b-e5705e834459",
   "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": "markdown",
   "id": "4a834803-0e18-4315-a97c-41f581b8f073",
   "metadata": {},
   "source": [
    "### Ans 36)\n",
    "\n",
    "#### Steps:\n",
    "- Create a fucntion that calculates the factorial of a number and return it.\n",
    "- Generate a sequence of numbers from 1 to 5 and call factorial fucntion to find the factorial of each number and store into list using list comprehension.\n",
    "- Then iterate through this list of factorials and find the sum of digits of each factorial numebers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "819241bb-07f8-4993-a091-75766a7c1a82",
   "metadata": {},
   "outputs": [],
   "source": [
    "# factorial function\n",
    "def fact(n):\n",
    "    mult = 1\n",
    "    for i in range(1,n+1):\n",
    "        mult = mult*i\n",
    "    \n",
    "    return mult"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "e457a83c-c2f6-4e25-bea8-5ce1447d237b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of sum of digits of factorial numbers [1, 2, 6, 6, 3]\n"
     ]
    }
   ],
   "source": [
    "# list comprehension \n",
    "list_sum_fact_digit = [sum(map(int,list(str(dig)))) for dig in [fact(num) for num in range(1,6)]]\n",
    "print(\"List of sum of digits of factorial numbers\",list_sum_fact_digit)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2c75a02-8a35-4d25-99e9-6570069e10d2",
   "metadata": {},
   "source": [
    "## 37)  Write a program that finds the longest word in a sentence using list comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e3060ba-c9f2-4eef-8677-514c9b9cce54",
   "metadata": {},
   "source": [
    "### Ans 37)\n",
    "\n",
    "#### Steps:\n",
    "- Take a sentence from user.\n",
    "- Convert sentence/string into list of strings by using split() function.\n",
    "- And store it into list, using list comprehension.\n",
    "- Pass entire list of words to max function to find the longest word by specifying key as len.\n",
    "- Print the longest word in sentence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "78950dc1-9a50-4e5a-9bbc-93942f237b57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a sentence to find the longest word in it :  full stack data science pro\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Longest word in given sentence is :\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'science'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence = input(\"Enter a sentence to find the longest word in it : \")\n",
    "print(\"Longest word in given sentence is :\")\n",
    "max([word for word in sentence.split()], key=len)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd9ee8a3-8bde-4c06-a05f-b02891b16d7a",
   "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": "markdown",
   "id": "65eb4396-a234-4262-ba82-93538ff8163f",
   "metadata": {},
   "source": [
    "### Ans 38)\n",
    "\n",
    "1) Appraoch : Write the code without using list comprehension then pack the code inside list comprehension.\n",
    "\n",
    "#### Steps:\n",
    "- Create an empty list to store filtered strings. \n",
    "- Traverse through list of strings.\n",
    "- If string contains more than 3 vowels then append string into empty list.\n",
    "- Pack all steps code inside list.\n",
    "- Note: In list comprehension we can't initialise variables like we do in general code. So use sum() function to add vowel counts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "53fa0c8e-9505-4ece-ade7-3afe06b16d48",
   "metadata": {},
   "outputs": [],
   "source": [
    "lis38 = ['noorain','data science','data','you','me']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "b4d81176-f345-45fd-8be1-f46edc3b5ddc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['noorain', 'data science']"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# code without list comprehension\n",
    "empyt_list = []\n",
    "for word in lis38:\n",
    "    vowel_count = 0\n",
    "    for char in word:\n",
    "        if char in ['a','e','i','o','u']:\n",
    "            vowel_count+=1\n",
    "\n",
    "    if vowel_count > 3:\n",
    "        empyt_list.append(word)\n",
    "empyt_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "954d4f46-9af1-4e95-8831-33e4a34244f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of strings with more than 3 vowels :  ['noorain', 'data science']\n"
     ]
    }
   ],
   "source": [
    "# code using list comprehension\n",
    "\n",
    "word_list = [word for word in lis38 if sum(1 for char in word if char in ['a','e','i','o','u'])>3]\n",
    "print(\"List of strings with more than 3 vowels : \",word_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c92f5cba-2b2c-4bd0-8665-e268e2f71046",
   "metadata": {},
   "source": [
    "## 39) Develop a program that calculates the sum of the digits of numbers from 1 to 1000 using list comprehension."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79005e13-528e-44b5-8236-0f58fa9934b5",
   "metadata": {},
   "source": [
    "### Ans 39)\n",
    "\n",
    "1) Appraoch : Write the code without using list comprehension then pack the code inside list comprehension.\n",
    "\n",
    "#### Steps:\n",
    "- Create an empty list to store all number's sum. \n",
    "- Generate a sequence of numbers from 1 to 1000.\n",
    "- If the length of generated number is 1 then append it directly.\n",
    "- Else, convert number into str > convert string into list of str > convert into list of integers using map function.\n",
    "- Pass the output of map function to sum() funtion to get the sum of numbers and append it into empty list.\n",
    "- Note: Now pack the above steps code inside list and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "007dab75-94ac-42a8-b29d-66f41d051b2c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# concpet : code without using list comprehension\n",
    "sum_list = []\n",
    "for num in range(1,1001):\n",
    "    if len(str(num)) > 1:\n",
    "        sum_list.append(sum(map(int ,list(str(num)))))\n",
    "    else:\n",
    "        sum_list.append(num)\n",
    "sum_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "2d1fb75b-0757-4662-bf09-06b7582e8ebb",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of sum of numbers from 1 to 1000 :  [1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 1]\n"
     ]
    }
   ],
   "source": [
    "# code using list comprehension\n",
    "List_sum = [sum(map(int ,list(str(num)))) if len(str(num)) > 1 else num for num in range(1,1001)]\n",
    "print(\"List of sum of numbers from 1 to 1000 : \",List_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b185553-5da5-4141-b3e6-137ed07d8af4",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 40)  Write a program that generates a list of prime palindromic numbers using list comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1eb6524-4e43-4476-bed5-babb344ec3a4",
   "metadata": {},
   "source": [
    "### Ans 40)\n",
    "\n",
    "1) Appraoch : Write the code without using list comprihension then pack the code inside list comprehension.\n",
    "\n",
    "#### Steps:\n",
    "- Take a value of n from user to generate prime palindromic numbers till n. \n",
    "- Generate a sequence of numbers from 11 to n.\n",
    "- First check, number is palindromic or not.\n",
    "- If number is palindromic then further check whether number is prime or not.\n",
    "- If number is prime then append into list else skip it.\n",
    "- Finally pack all the above steps inside list comprehension and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "97acdfbe-c254-49c3-be4f-c86c11341d46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter value of n greater than 11 to generate all prime palindromic numbers till n :  200\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[11, 101, 131, 151, 181, 191]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# code without using list comprehension.\n",
    "n = int(input(\"Enter value of n greater than 11 to generate all prime palindromic numbers till n : \"))\n",
    "palin_lis = []\n",
    "for num in range(11,n+1):\n",
    "    if str(num) == str(num)[::-1]:        \n",
    "        # check num is prime or not\n",
    "        for j in range(2,num):\n",
    "            if num%j==0:\n",
    "                break\n",
    "        else:\n",
    "            palin_lis.append(num)\n",
    "            \n",
    "        \n",
    "palin_lis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "bea7255f-fc7d-4573-881a-71958d81415a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter value of n greater than 11 to generate all palindromic numbers till n :  200\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of prime palindromic numbers from 11 to 200 : [11, 101, 131, 151, 181, 191]\n"
     ]
    }
   ],
   "source": [
    "# code by using list comprehension.\n",
    "# here all() function take an iterable and returns true if the given condition is true for all iterators. Else fasle\n",
    "n = int(input(\"Enter value of n greater than 11 to generate all palindromic numbers till n : \"))\n",
    "palin_lis = [num for num in range(11, n + 1) if str(num) == str(num)[::-1] and all(num % j != 0 for j in range(2, num))]\n",
    "\n",
    "print(f\"List of prime palindromic numbers from {11} to {n} : {palin_lis}\")\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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}