3rd _ Sep_For_Loop_Assignment_Questions (1).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "faa269a5-51c0-4226-b77a-b903398ad6ad",
   "metadata": {},
   "source": [
    "                                      For Loop Assignment Questions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d1d0755-b18a-4349-9c88-1b4d4a058a26",
   "metadata": {},
   "source": [
    "BASIC LAVEL:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "637e3c8d-3927-40ed-85a9-c4e56acc3027",
   "metadata": {},
   "source": [
    "1. Write a Python program to print the numbers from 1 to 10 using a `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c3a6c949-7c0c-4138-9735-ca685ad56607",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for num in range(1, 11):\n",
    "    print(num)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93b33396-ce43-42ac-9bb2-aeb2e0bfe34b",
   "metadata": {},
   "source": [
    "2. Create a program that calculates the sum of all numbers in a list using a `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d9c6e33-93c0-4484-9b70-51f6ba5b580d",
   "metadata": {},
   "source": [
    "numbers = [10, 20, 30, 40, 50]\n",
    "sum_numbers = 0\n",
    "for num in numbers:\n",
    "    sum_numbers += num   \n",
    "\n",
    "print(\"Sum of numbers:\", sum_numbers)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02b29e95-73c4-42f3-a913-553c4b6d19ac",
   "metadata": {},
   "source": [
    "3. Write a program to print the characters of a string in reverse order using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b819a8d7-9d09-4ab0-97bd-ff7108b1b1b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original string: Hello, World!\n",
      "Reversed string: !dlroW ,olleH\n"
     ]
    }
   ],
   "source": [
    " input_string = \"Hello, World!\"\n",
    " reversed_string = \"\"\n",
    " for char in reversed(input_string):\n",
    "    reversed_string += char\n",
    " \n",
    "print(\"Original string:\", input_string)\n",
    "print(\"Reversed string:\", reversed_string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a49585d5-b5cd-4ab4-af41-370661f062b1",
   "metadata": {},
   "source": [
    "4. Develop a program that finds the factorial of a given number using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3c85a7a2-026b-4d3b-8850-3ac3360f8c25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The factorial of 5 is: 120\n"
     ]
    }
   ],
   "source": [
    "def factorial(n):\n",
    "    fact = 1\n",
    "    for i in range(1, n + 1):\n",
    "        fact *= i  \n",
    "    \n",
    "    return fact\n",
    "num = 5\n",
    "print(f\"The factorial of {num} is:\", factorial(num))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cdc3112-b4ca-4d7c-bccd-3bb73f4f32c9",
   "metadata": {},
   "source": [
    "5. Create a program to print the multiplication table of a given number using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1e2095bc-ae82-4dd0-b066-7ec18bfce6a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiplication table for 7:\n",
      "7 * 1 = 7\n",
      "7 * 2 = 14\n",
      "7 * 3 = 21\n",
      "7 * 4 = 28\n",
      "7 * 5 = 35\n",
      "7 * 6 = 42\n",
      "7 * 7 = 49\n",
      "7 * 8 = 56\n",
      "7 * 9 = 63\n",
      "7 * 10 = 70\n"
     ]
    }
   ],
   "source": [
    "def multiplication_table(num):\n",
    "    print(f\"Multiplication table for {num}:\")\n",
    "    for i in range(1, 11): \n",
    "        print(f\"{num} * {i} = {num * i}\")\n",
    "number = 7\n",
    "multiplication_table(number)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdbf033e-5847-4ddc-b8a4-cc975142381c",
   "metadata": {},
   "source": [
    "6. Write a program that counts the number of even and odd numbers in a list using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "38dc57d7-5aa0-4645-959e-f9a40666bee0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of even numbers: 5\n",
      "Number of odd numbers: 5\n"
     ]
    }
   ],
   "source": [
    " def count_even_odd(numbers):\n",
    "    even_count = 0\n",
    "    odd_count = 0\n",
    "    \n",
    "    for num in numbers:\n",
    "        if num % 2 == 0:\n",
    "            even_count += 1\n",
    "        else:\n",
    "            odd_count += 1\n",
    "    \n",
    "    return even_count, odd_count\n",
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "even_count, odd_count = count_even_odd(numbers)\n",
    " print(\"Number of even numbers:\", even_count)\n",
    "print(\"Number of odd numbers:\", odd_count)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3d24e0c-3622-4e21-9db2-37e080214d90",
   "metadata": {},
   "source": [
    "7. Develop a program that prints the squares of numbers from 1 to 5 using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2014cab0-a133-4fe1-ad75-207849b496e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The square of 1 is: 1\n",
      "The square of 2 is: 4\n",
      "The square of 3 is: 9\n",
      "The square of 4 is: 16\n",
      "The square of 5 is: 25\n"
     ]
    }
   ],
   "source": [
    "for num in range(1, 6):\n",
    "    square = num ** 2 \n",
    "    print(f\"The square of {num} is:\", square)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e774f46-08a5-4388-94fb-f52b79586ff4",
   "metadata": {},
   "source": [
    "8. Create a program to find the length of a string without using the `len()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "17d8dcce-baaf-45d3-93f7-67800146bdaf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of the string: 13\n"
     ]
    }
   ],
   "source": [
    "def string_length(s):\n",
    "    count = 0\n",
    "    for char in s:\n",
    "        count += 1\n",
    "    return count\n",
    "input_string = \"Hello, World!\"\n",
    " \n",
    "print(\"Length of the string:\", string_length(input_string))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e960b34b-26fb-4124-ab8d-5d3b47430332",
   "metadata": {},
   "source": [
    "9. Write a program that calculates the average of a list of numbers using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1f9bfae8-2ed6-448d-9b6b-e5149d3f30c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average of the numbers: 30.0\n"
     ]
    }
   ],
   "source": [
    "def calculate_average(numbers):\n",
    "    sum_numbers = 0\n",
    "    count = 0\n",
    "    \n",
    "    for num in numbers:\n",
    "        sum_numbers += num\n",
    "        count += 1\n",
    "    \n",
    "    if count == 0:\n",
    "        return 0 \n",
    "    else:\n",
    "        average = sum_numbers / count\n",
    "        return average\n",
    "numbers = [10, 20, 30, 40, 50]\n",
    "average = calculate_average(numbers)\n",
    "print(\"Average of the numbers:\", average)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a914928e-1e35-495e-9d15-9b2ec4be6644",
   "metadata": {},
   "source": [
    "10. Develop a program that prints the first `n` Fibonacci numbers using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5ebb467c-4331-4a95-bd1c-af3f58ca6ab3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 1 2 3 5 8 13 21 34 \n"
     ]
    }
   ],
   "source": [
    "def print_fibonacci(n):\n",
    "    a, b = 0, 1\n",
    "    for _ in range(n):\n",
    "        print(a, end=' ')\n",
    "        a, b = b, a + b\n",
    "    print()  \n",
    " \n",
    "n = 10   \n",
    "print_fibonacci(n)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff0a465b-f6d6-4f29-82d9-40735b4424b4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "aa42472f-9fdb-44a4-bb9c-0fbe17c561ca",
   "metadata": {},
   "source": [
    "                                          Intermediate Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "688cd842-e971-470b-babb-e12502d84352",
   "metadata": {},
   "source": [
    "11. Write a program to check if a given list contains any duplicates using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "7499fe38-c480-4c7a-91d3-ff45e4838691",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "def contains_duplicates(input_list):\n",
    "    seen = set()\n",
    " \n",
    "    for element in input_list:\n",
    "         if element in seen:\n",
    "            return True\n",
    "         seen.add(element)\n",
    "    return False \n",
    "example_list = [1, 2, 3, 4, 5, 6, 3]  \n",
    "print(contains_duplicates(example_list))  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89f6e8f1-951c-4abe-8dae-e3e207a02a8d",
   "metadata": {},
   "source": [
    "12. Create a program that prints the prime numbers in a given range using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "55e0b1e4-cc21-418f-bb4a-26096c8fb689",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11 13 17 19 23 29 31 37 41 43 47 \n"
     ]
    }
   ],
   "source": [
    "def is_prime(num):\n",
    "    \"\"\"Helper function to check if a number is prime.\"\"\"\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",
    "def print_primes_in_range(start, end):\n",
    "    \"\"\"Function to print prime numbers in a given range.\"\"\"\n",
    "    for num in range(start, end + 1):\n",
    "        if is_prime(num):\n",
    "            print(num, end=' ')\n",
    "    print() \n",
    " \n",
    "start = 10  \n",
    "end = 50   \n",
    "print_primes_in_range(start, end)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fec8416-d0b0-4893-abe9-a8af6474d6fd",
   "metadata": {},
   "source": [
    "13. Develop a program that counts the number of vowels in a string using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "0a3776fc-faaa-425f-b469-f7217386cfab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of vowels in 'Hello, World!': 3\n"
     ]
    }
   ],
   "source": [
    "def count_vowels(input_string):\n",
    "    vowels = 'aeiouAEIOU'\n",
    "    count = 0\n",
    "    for char in input_string:\n",
    "        if char in vowels:\n",
    "            count += 1\n",
    "    \n",
    "    return count\n",
    "example_string = \"Hello, World!\"  \n",
    "print(f\"Number of vowels in '{example_string}': {count_vowels(example_string)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efde4b5a-b0c6-492d-b0e0-d67bcfda8f95",
   "metadata": {},
   "source": [
    "14. Write a program to find the maximum element in a 2D list using a nested `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "c0d742df-a08a-423e-b8a0-4cf0b0cff0be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The maximum element in the matrix is: 9\n"
     ]
    }
   ],
   "source": [
    "def find_max_in_2d_list(matrix):\n",
    "    max_element = float('-inf')\n",
    "    for row in matrix:\n",
    "        for element in row:\n",
    "            if element > max_element:\n",
    "                max_element = element\n",
    "    \n",
    "    return max_element\n",
    "matrix = [\n",
    "    [3, 5, 9],\n",
    "    [7, 1, 8],\n",
    "    [2, 6, 4]\n",
    "] \n",
    "\n",
    "print(f\"The maximum element in the matrix is: {find_max_in_2d_list(matrix)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e88a5c1-6dd6-4c14-8d50-0d660efbe21e",
   "metadata": {},
   "source": [
    "15. Create a program that removes all occurrences of a specific element from a list using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "becbaa6b-aaa1-4c5f-bd39-b7677c3bdcfb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list: [1, 2, 3, 4, 3, 5, 3, 6]\n",
      "List after removing 3: [1, 2, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "def remove_element(input_list, element_to_remove): \n",
    "    result_list = [] \n",
    "    for element in input_list: \n",
    "        if element != element_to_remove:\n",
    "            result_list.append(element)\n",
    "    \n",
    "    return result_list \n",
    "example_list = [1, 2, 3, 4, 3, 5, 3, 6]  \n",
    "element_to_remove = 3 \n",
    "print(f\"Original list: {example_list}\")\n",
    "print(f\"List after removing {element_to_remove}: {remove_element(example_list, element_to_remove)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aab654f8-80bc-4d03-879b-1c37469cd813",
   "metadata": {},
   "source": [
    "16. Develop a program that generates a multiplication table for numbers from 1 to 5 using a nested `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "62ca50d7-1260-46c4-87ca-107b8ffa17d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       1   2   3   4   5\n",
      "   1   1   2   3   4   5\n",
      "   2   2   4   6   8  10\n",
      "   3   3   6   9  12  15\n",
      "   4   4   8  12  16  20\n",
      "   5   5  10  15  20  25\n"
     ]
    }
   ],
   "source": [
    "def generate_multiplication_table(): \n",
    "    start = 1\n",
    "    end = 5 \n",
    "    print(\"    \", end='')\n",
    "    for i in range(start, end + 1):\n",
    "        print(f\"{i:4}\", end='')\n",
    "    print() \n",
    "    for i in range(start, end + 1):\n",
    "        print(f\"{i:4}\", end='')  \n",
    "        for j in range(start, end + 1):\n",
    "            print(f\"{i * j:4}\", end='')\n",
    "        print()  \n",
    "generate_multiplication_table()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "474e0139-53c8-450e-bcfc-05cad8de88f5",
   "metadata": {},
   "source": [
    "17. Write a program that converts a list of Fahrenheit temperatures to Celsius using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "1d988df4-1788-4366-8592-9365ce70cc4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fahrenheit temperatures: [32, 68, 104, 212]\n",
      "Celsius temperatures: [0.0, 20.0, 40.0, 100.0]\n"
     ]
    }
   ],
   "source": [
    "def fahrenheit_to_celsius(fahrenheit_temps): \n",
    "    celsius_temps = [] \n",
    "    for temp in fahrenheit_temps: \n",
    "        celsius_temp = (temp - 32) * 5.0/9.0\n",
    "        celsius_temps.append(celsius_temp)\n",
    "    \n",
    "    return celsius_temps \n",
    "fahrenheit_temps = [32, 68, 104, 212] \n",
    "celsius_temps = fahrenheit_to_celsius(fahrenheit_temps)\n",
    "print(f\"Fahrenheit temperatures: {fahrenheit_temps}\")\n",
    "print(f\"Celsius temperatures: {celsius_temps}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7993a52-2681-4a04-b0a5-f615b906edea",
   "metadata": {},
   "source": [
    "18. Create a program to print the common elements from two lists using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "5ef8bfc3-caa8-4f15-be80-e92882b2f105",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Common elements: [4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "def find_common_elements(list1, list2): \n",
    "    common_elements = [] \n",
    "    for element in list1: \n",
    "        if element in list2 and element not in common_elements:\n",
    "            common_elements.append(element)\n",
    "    \n",
    "    return common_elements \n",
    "list1 = [1, 2, 3, 4, 5, 6]\n",
    "list2 = [4, 5, 6, 7, 8, 9]\n",
    "\n",
    "common_elements = find_common_elements(list1, list2)\n",
    "print(f\"Common elements: {common_elements}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d9cb042-8a93-4dd0-8a95-a82a768142c8",
   "metadata": {},
   "source": [
    "19. Develop a program that prints the pattern of right-angled triangles using a `for` loop. Use ‘*’ to draw the"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "3794ad90-28c3-4dc9-8c62-e6ddcf3c8fc8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*\n",
      "**\n",
      "***\n",
      "****\n",
      "*****\n"
     ]
    }
   ],
   "source": [
    "def print_right_angled_triangle(rows): \n",
    "    for i in range(1, rows + 1): \n",
    "        print('*' * i) \n",
    "rows = 5 \n",
    "print_right_angled_triangle(rows)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "beda5588-2829-4e65-8659-c822cbc90e93",
   "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": "b86c8d64-6bfc-45ca-bf92-0d3695280c1b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The GCD of 56 and 98 is: 14\n"
     ]
    }
   ],
   "source": [
    "def find_gcd(a, b):   \n",
    "    gcd = 1 \n",
    "    min_number = min(a, b) \n",
    "    for i in range(1, min_number + 1): \n",
    "        if a % i == 0 and b % i == 0:\n",
    "            gcd = i\n",
    "    \n",
    "    return gcd \n",
    "num1 = 56\n",
    "num2 = 98\n",
    "print(f\"The GCD of {num1} and {num2} is: {find_gcd(num1, num2)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f02b3260-4a64-49e8-84e5-febb93dfcc0e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b74840d5-7dd7-4dfb-8038-a70822d9d391",
   "metadata": {},
   "source": [
    "                                                Advanced Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0f677ef-a61c-41d0-93d9-5bf518b5cea5",
   "metadata": {},
   "source": [
    "21. Create a program that calculates the sum of the digits of numbers in a list using a list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "c350d112-e686-440d-96ec-50dd4898e530",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original numbers: [123, 456, 789]\n",
      "Sum of digits for each number: [6, 15, 24]\n"
     ]
    }
   ],
   "source": [
    "def sum_of_digits(numbers): \n",
    "    def sum_digits(n):\n",
    "        return sum(int(digit) for digit in str(n) if digit.isdigit()) \n",
    "    digit_sums = [sum_digits(num) for num in numbers]\n",
    "    \n",
    "    return digit_sums \n",
    "numbers = [123, 456, 789]\n",
    "digit_sums = sum_of_digits(numbers)\n",
    "print(f\"Original numbers: {numbers}\")\n",
    "print(f\"Sum of digits for each number: {digit_sums}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93e3ae4e-8f20-4580-beaa-6bbc3c852fa1",
   "metadata": {},
   "source": [
    "22. Write a program to find the prime factors of a given number using a `for` loop and list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "15a0ff15-dc1e-4ceb-bd0a-677a46e99ca7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prime factors of 84: [2, 3, 7]\n"
     ]
    }
   ],
   "source": [
    "def is_prime(num):\n",
    "    \"\"\" Helper function to check if a number is prime \"\"\"\n",
    "    if num <= 1:\n",
    "        return False\n",
    "    if num <= 3:\n",
    "        return True\n",
    "    if num % 2 == 0 or num % 3 == 0:\n",
    "        return False\n",
    "    i = 5\n",
    "    while i * i <= num:\n",
    "        if num % i == 0 or num % (i + 2) == 0:\n",
    "            return False\n",
    "        i += 6\n",
    "    return True\n",
    "\n",
    "def prime_factors(n):\n",
    "    \"\"\" Function to find prime factors of a given number \"\"\"\n",
    "    factors = [] \n",
    "    for i in range(2, int(n**0.5) + 1):\n",
    "        if n % i == 0: \n",
    "            if is_prime(i):\n",
    "                factors.append(i) \n",
    "            if is_prime(n // i):\n",
    "                factors.append(n // i) \n",
    "    if is_prime(n) and n > 1:\n",
    "        factors.append(n)\n",
    "    return factors \n",
    "number = 84  \n",
    "print(f\"Prime factors of {number}: {prime_factors(number)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f15c9e0-ad06-4df0-adfa-ac91b0204471",
   "metadata": {},
   "source": [
    "23. Develop a program that extracts unique elements from a list and stores them in a new list using a list\n",
    "comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "47112554-4fe4-4528-9cf2-6e3a1f281bd9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list: [1, 2, 3, 2, 4, 5, 6, 4, 7, 8]\n",
      "Unique elements: [1, 3, 5, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "def extract_unique_elements(input_list): \n",
    "    unique_elements = [element for element in input_list if input_list.count(element) == 1]\n",
    "    return unique_elements \n",
    "original_list = [1, 2, 3, 2, 4, 5, 6, 4, 7, 8]\n",
    "unique_elements = extract_unique_elements(original_list)\n",
    "print(f\"Original list: {original_list}\")\n",
    "print(f\"Unique elements: {unique_elements}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb26739f-309b-49a2-98ad-60107af40462",
   "metadata": {},
   "source": [
    "24. Create a program that generates a list of all palindromic numbers up to a specified limit using a list\n",
    "comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "1af79bf0-252a-4b8e-88ac-75e622218f88",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Palindromic numbers up to 100: [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99]\n"
     ]
    }
   ],
   "source": [
    "def is_palindrome(number):\n",
    "    \"\"\" Helper function to check if a number is palindrome \"\"\"\n",
    "    return str(number) == str(number)[::-1]\n",
    "\n",
    "def generate_palindromic_numbers(limit):\n",
    "    \"\"\" Function to generate palindromic numbers up to a specified limit \"\"\"\n",
    "    palindromic_numbers = [num for num in range(1, limit + 1) if is_palindrome(num)]\n",
    "    return palindromic_numbers \n",
    "limit = 100  \n",
    "palindromic_numbers = generate_palindromic_numbers(limit)\n",
    "print(f\"Palindromic numbers up to {limit}: {palindromic_numbers}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4f0abec-f1f6-4d6f-ac8f-3d167c261095",
   "metadata": {},
   "source": [
    "25. Write a program to flatten a nested list using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "2057ae06-1b31-4530-a9a1-b33f37b1ecb6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original nested list: [[1, 2, [3]], [4, [5]], [6, 7, 8]]\n",
      "Flattened list: [1, 2, 3, 4, 5, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "def flatten_list(nested_list): \n",
    "    if not isinstance(nested_list, list):\n",
    "        return [nested_list] \n",
    "    flattened_list = [item for sublist in nested_list for item in flatten_list(sublist)]\n",
    "    \n",
    "    return flattened_list \n",
    "\n",
    "nested_list = [[1, 2, [3]], [4, [5]], [6, 7, 8]]\n",
    "flattened_list = flatten_list(nested_list)\n",
    "print(f\"Original nested list: {nested_list}\")\n",
    "print(f\"Flattened list: {flattened_list}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29f98bbd-61c5-459d-a7c7-1c1129943811",
   "metadata": {},
   "source": [
    "26. Develop a program that computes the sum of even and odd numbers in a list separately using list\n",
    "comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "df2e55bc-3494-4a7a-af1a-7a74f5057610",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Sum of even numbers: 20\n",
      "Sum of odd numbers: 25\n"
     ]
    }
   ],
   "source": [
    "def sum_even_odd(numbers): \n",
    "    sum_even = sum([num for num in numbers if num % 2 == 0])\n",
    "    sum_odd = sum([num for num in numbers if num % 2 != 0])\n",
    "    return sum_even, sum_odd \n",
    "\n",
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "sum_even, sum_odd = sum_even_odd(numbers)\n",
    "print(f\"Original numbers: {numbers}\")\n",
    "print(f\"Sum of even numbers: {sum_even}\")\n",
    "print(f\"Sum of odd numbers: {sum_odd}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d222bcc2-737f-40f5-b7c7-86cd03254459",
   "metadata": {},
   "source": [
    "27. Create a program that generates a list of squares of odd numbers between 1 and 10 using list\n",
    "comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "94ca1bb8-2112-4084-85b6-94795eefe5cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Squares of odd numbers between 1 and 10:\n",
      "[1, 9, 25, 49, 81]\n"
     ]
    }
   ],
   "source": [
    "squares_of_odd = [num**2 for num in range(1, 11) if num % 2 != 0]\n",
    "\n",
    "print(\"Squares of odd numbers between 1 and 10:\")\n",
    "print(squares_of_odd)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0b4abb5-4dac-4807-87e8-7bc68078018b",
   "metadata": {},
   "source": [
    "28. Write a program that combines two lists into a dictionary using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "f99f23dd-6f58-4bdc-9a52-2b98fb0c09b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Combined dictionary: {'a': 1, 'b': 2, 'c': 3}\n"
     ]
    }
   ],
   "source": [
    "def lists_to_dict(keys, values): \n",
    "    combined_dict = {keys[i]: values[i] for i in range(min(len(keys), len(values)))}\n",
    "    return combined_dict\n",
    " \n",
    "keys = ['a', 'b', 'c']\n",
    "values = [1, 2, 3, 4]  \n",
    "combined_dict = lists_to_dict(keys, values)\n",
    "print(f\"Combined dictionary: {combined_dict}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42ef8dbb-0dab-475e-bb13-e7bcb9d199e9",
   "metadata": {},
   "source": [
    "29. Develop a program that extracts the vowels from a string and stores them in a list using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "bbd254eb-3a13-4ece-864e-8c2614c4a8a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input string: Hello, World! This is a test string.\n",
      "Vowels extracted: ['e', 'o', 'o', 'i', 'i', 'a', 'e', 'i']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def extract_vowels(input_string): \n",
    "    vowels = \"aeiouAEIOU\"\n",
    "     \n",
    "    vowel_list = [char for char in input_string if char in vowels] \n",
    "    return vowel_list \n",
    "\n",
    "input_string = \"Hello, World! This is a test string.\"\n",
    "vowels = extract_vowels(input_string)\n",
    "print(f\"Input string: {input_string}\")\n",
    "print(f\"Vowels extracted: {vowels}\")\n",
    "/"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59f4068d-230a-4c11-bc4f-0a5e11b8c5d6",
   "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": 54,
   "id": "78829618-0e44-46ee-b92c-dac8c090f3f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original strings: ['abc123', '45def', '6ghi78', 'jklmno']\n",
      "Cleaned strings (numeric only): ['123', '45', '678', '']\n"
     ]
    }
   ],
   "source": [
    "def remove_non_numeric(strings): \n",
    "    cleaned_strings = [''.join(char for char in string if char.isdigit()) for string in strings]\n",
    "    return cleaned_strings \n",
    "\n",
    "strings = ['abc123', '45def', '6ghi78', 'jklmno']\n",
    "cleaned_strings = remove_non_numeric(strings)\n",
    "print(f\"Original strings: {strings}\")\n",
    "print(f\"Cleaned strings (numeric only): {cleaned_strings}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86fe80d6-74a3-4e5b-b77a-477180e6847d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5a087d0c-e3fa-4a0a-8acb-c5db9bb2d8d5",
   "metadata": {},
   "source": [
    "                                             Challenge Level:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5faad4a7-7d85-42b9-bf1b-8cff7c53258a",
   "metadata": {},
   "source": [
    "31. Write a program to generate a list of prime numbers using the Sieve of Eratosthenes algorithm and list\n",
    "comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "b8cd1d53-8da2-48fd-8cc9-4bca3e310423",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prime numbers up to 50:\n",
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]\n"
     ]
    }
   ],
   "source": [
    "def sieve_of_eratosthenes(n): \n",
    "    prime = [True] * (n + 1)\n",
    "    p = 2\n",
    "    while (p * p <= n): \n",
    "        if prime[p] == True: \n",
    "            for i in range(p * p, n + 1, p):\n",
    "                prime[i] = False\n",
    "        p += 1 \n",
    "    prime_numbers = [p for p in range(2, n + 1) if prime[p]]\n",
    "    return prime_numbers \n",
    "\n",
    "n = 50  \n",
    "primes = sieve_of_eratosthenes(n)\n",
    "print(f\"Prime numbers up to {n}:\")\n",
    "print(primes)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e291496-7d0d-4a95-bb9b-f7986ace0c69",
   "metadata": {},
   "source": [
    "32. Create a program that generates a list of all Pythagorean triplets up to a specified limit using list\n",
    "comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "76b5af4b-175c-4b53-89eb-24d2879388af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pythagorean triplets up to 20:\n",
      "[(3, 4, 5), (6, 8, 10), (5, 12, 13), (9, 12, 15), (8, 15, 17), (12, 16, 20)]\n"
     ]
    }
   ],
   "source": [
    "def generate_pythagorean_triplets(limit):\n",
    "    triplets = [(a, b, c) for c in range(1, limit + 1) \n",
    "                        for b in range(1, c) \n",
    "                        for a in range(1, b) \n",
    "                        if a**2 + b**2 == c**2]\n",
    "    return triplets \n",
    "limit = 20   \n",
    "triplets = generate_pythagorean_triplets(limit)\n",
    "print(f\"Pythagorean triplets up to {limit}:\")\n",
    "print(triplets)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "617afae6-d793-4a50-a6e9-f2bfaa52fa59",
   "metadata": {},
   "source": [
    "33. Develop a program that generates a list of all possible combinations of two lists using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "9b392c24-1e01-4951-b36e-a14f90ccd4b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All possible combinations of ['a', 'b', 'c'] and [1, 2, 3]:\n",
      "[('a', 1), ('a', 2), ('a', 3), ('b', 1), ('b', 2), ('b', 3), ('c', 1), ('c', 2), ('c', 3)]\n"
     ]
    }
   ],
   "source": [
    "def generate_combinations(list1, list2): \n",
    "    combinations = [(x, y) for x in list1 for y in list2]\n",
    "    return combinations \n",
    "\n",
    "list1 = ['a', 'b', 'c']\n",
    "list2 = [1, 2, 3]\n",
    "combinations = generate_combinations(list1, list2)\n",
    "print(f\"All possible combinations of {list1} and {list2}:\")\n",
    "print(combinations)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0050c2fa-a968-4981-9ec7-752862bc70d4",
   "metadata": {},
   "source": [
    "34. Write a program that calculates the mean, median, and mode of a list of numbers using list\n",
    "comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "c480c6aa-96ed-489e-873d-e4e10bd5158e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of numbers: [1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9, 9, 10]\n",
      "Mean: 6.0\n",
      "Median: 6\n",
      "Mode: [9]\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "import statistics\n",
    "\n",
    "def calculate_mean(numbers): \n",
    "    mean = sum(numbers) / len(numbers) if numbers else 0\n",
    "    return mean\n",
    "\n",
    "def calculate_median(numbers): \n",
    "    numbers.sort()\n",
    "    n = len(numbers)\n",
    "    median = (numbers[n//2] + numbers[(n-1)//2]) / 2 if n % 2 == 0 else numbers[n//2]\n",
    "    return median\n",
    "\n",
    "def calculate_mode(numbers): \n",
    "    counts = Counter(numbers)\n",
    "    mode = [k for k, v in counts.items() if v == max(counts.values())]\n",
    "    return mode\n",
    " \n",
    "numbers = [1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9, 9, 10]\n",
    "mean = calculate_mean(numbers)\n",
    "median = calculate_median(numbers)\n",
    "mode = calculate_mode(numbers)\n",
    "print(f\"List of numbers: {numbers}\")\n",
    "print(f\"Mean: {mean}\")\n",
    "print(f\"Median: {median}\")\n",
    "print(f\"Mode: {mode}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "922038d6-ad8f-46ea-9695-99360d74cb1e",
   "metadata": {},
   "source": [
    "35. Create a program that generates Pascal's triangle up to a specified number of rows using list\n",
    "comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "7914be33-963c-4c0b-b87c-61a8731ca1de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pascal's Triangle up to 6 rows:\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"
     ]
    }
   ],
   "source": [
    "def generate_pascals_triangle(num_rows):\n",
    "    triangle = [[1] * (i + 1) for i in range(num_rows)]\n",
    "    for i in range(2, num_rows):\n",
    "        for j in range(1, i):\n",
    "            triangle[i][j] = triangle[i-1][j-1] + triangle[i-1][j]\n",
    "    return triangle\n",
    "\n",
    "def print_pascals_triangle(triangle):\n",
    "    for row in triangle:\n",
    "        print(\" \".join(map(str, row)).center(len(triangle[-1]) * 5))\n",
    " \n",
    "num_rows = 6   \n",
    "triangle = generate_pascals_triangle(num_rows)\n",
    "print(f\"Pascal's Triangle up to {num_rows} rows:\")\n",
    "print_pascals_triangle(triangle)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54a3b028-d2e3-47db-8265-a7937a311364",
   "metadata": {},
   "source": [
    "36. Develop a program that calculates the sum of the digits of a factorial of numbers from 1 to 5 using list\n",
    "comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "1f774831-5047-4d4c-b679-a8abcc9c63c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Factorial of 1: 1\n",
      "Sum of digits: 1\n",
      "\n",
      "Factorial of 2: 2\n",
      "Sum of digits: 2\n",
      "\n",
      "Factorial of 3: 6\n",
      "Sum of digits: 6\n",
      "\n",
      "Factorial of 4: 24\n",
      "Sum of digits: 6\n",
      "\n",
      "Factorial of 5: 120\n",
      "Sum of digits: 3\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "def factorial(n):\n",
    "    return math.factorial(n)\n",
    "\n",
    "def sum_of_digits(number):\n",
    "    return sum(int(digit) for digit in str(number)) \n",
    "results = [sum_of_digits(factorial(i)) for i in range(1, 6)] \n",
    "for i in range(1, 6):\n",
    "    print(f\"Factorial of {i}:\", factorial(i))\n",
    "    print(f\"Sum of digits:\", results[i-1])\n",
    "    print()\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c44ccc58-e090-4bdd-af2c-117bf7dfd91c",
   "metadata": {},
   "source": [
    "37. Write a program that finds the longest word in a sentence using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "179cd953-c77e-4bc0-91eb-29927801f317",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sentence: Hello world, this is a sentence to find the longest word.\n",
      "Longest word: sentence\n"
     ]
    }
   ],
   "source": [
    "def find_longest_word(sentence): \n",
    "    words = sentence.split() \n",
    "    longest_word = max(words, key=len)\n",
    "    \n",
    "    return longest_word \n",
    "sentence = \"Hello world, this is a sentence to find the longest word.\"\n",
    "longest_word = find_longest_word(sentence)\n",
    "print(f\"Sentence: {sentence}\")\n",
    "print(f\"Longest word: {longest_word}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "643c017b-e7fb-49fd-848d-a871f6b7aded",
   "metadata": {},
   "source": [
    "38. Create a program that filters a list of strings to include only those with more than three vowels using list\n",
    "comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "315c26ca-81fa-4e64-9ba9-0f12c52a8c38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original strings: ['hello', 'world', 'python', 'programming', 'education', 'algorithm', 'openai']\n",
      "Filtered strings with more than three vowels: ['education', 'openai']\n"
     ]
    }
   ],
   "source": [
    "def count_vowels(string):\n",
    "    vowels = \"aeiouAEIOU\"\n",
    "    return sum(1 for char in string if char in vowels)\n",
    "\n",
    "def filter_strings_with_more_than_three_vowels(strings):\n",
    "    filtered_strings = [string for string in strings if count_vowels(string) > 3]\n",
    "    return filtered_strings \n",
    "\n",
    "strings = [\n",
    "    \"hello\",\n",
    "    \"world\",\n",
    "    \"python\",\n",
    "    \"programming\",\n",
    "    \"education\",\n",
    "    \"algorithm\",\n",
    "    \"openai\"\n",
    "]\n",
    "\n",
    "filtered_strings = filter_strings_with_more_than_three_vowels(strings)\n",
    "print(\"Original strings:\", strings)\n",
    "print(\"Filtered strings with more than three vowels:\", filtered_strings)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c66757b-60a0-4919-ac26-bd96d6dee6ac",
   "metadata": {},
   "source": [
    "39. Develop a program that calculates the sum of the digits of numbers from 1 to 1000 using list\n",
    "comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "4d21838d-4044-4e2d-8c3a-53523e3e54a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of digits from 1 to 1000: 13501\n"
     ]
    }
   ],
   "source": [
    "def sum_of_digits(number):\n",
    "    return sum(int(digit) for digit in str(number)) \n",
    "sum_of_digits_1_to_1000 = sum(sum_of_digits(i) for i in range(1, 1001))\n",
    " \n",
    "print(f\"Sum of digits from 1 to 1000: {sum_of_digits_1_to_1000}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e64099aa-e12c-4bc4-8a50-b824a33c6bba",
   "metadata": {},
   "source": [
    "40. Write a program that generates a list of prime palindromic numbers using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "3fdd3236-fc36-4efe-a550-a7d99965e239",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prime palindromic numbers up to 1000:\n",
      "[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(number):\n",
    "    if number <= 1:\n",
    "        return False\n",
    "    if number == 2:\n",
    "        return True   \n",
    "    if number % 2 == 0:\n",
    "        return False  \n",
    "    for i in range(3, int(number**0.5) + 1, 2):\n",
    "        if number % i == 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "def is_palindrome(number):\n",
    "    return str(number) == str(number)[::-1] \n",
    "prime_palindromes = [num for num in range(1, 1000) if is_prime(num) and is_palindrome(num)] \n",
    "print(\"Prime palindromic numbers up to 1000:\")\n",
    "print(prime_palindromes)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "409d4918-3313-4575-9bab-47edb771db11",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}