loops assignment (1) (1).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ideal-bryan",
   "metadata": {},
   "source": [
    "## [10 Questions] QUIZ - Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "certified-catalyst",
   "metadata": {},
   "source": [
    "**Q 1:**\n",
    "\n",
    "Define a function that draw a square of stars on the screen.\n",
    "\n",
    "The function name will be **sqaure_of_stars_with_while**.\n",
    "\n",
    "The parameter will be number of stars in one side of square.\n",
    "\n",
    "Hints:\n",
    "* ask for number of stars from the user\n",
    "* use while loop\n",
    "\n",
    "<pre>\n",
    "Expected output for 5 stars:\n",
    "\n",
    "* * * * * \n",
    "* * * * * \n",
    "* * * * * \n",
    "* * * * * \n",
    "* * * * * \n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "occupied-cheat",
   "metadata": {},
   "outputs": [],
   "source": [
    "# S 1:\n",
    "\n",
    "def sqaure_of_stars_with_for(n):\n",
    "    \n",
    "    # Loop through rows\n",
    "    for i in range(n):\n",
    "    \n",
    "    # Loop to print pattern\n",
    "        for j in range(n):\n",
    "            print(\"*\", end=' ')\n",
    "        print()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "5411f822-858b-438f-b917-1fe7f3f60842",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the number of stars:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* * * * * \n",
      "* * * * * \n",
      "* * * * * \n",
      "* * * * * \n",
      "* * * * * \n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Enter the number of stars: \"))\n",
    "sqaure_of_stars_with_for(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "chronic-shakespeare",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sqaure_of_stars_with_while(n):\n",
    "    \n",
    "    i = 0\n",
    "# rows\n",
    "    while i < n:\n",
    "        stars = \"\"  \n",
    "# columns\n",
    "        j = 0\n",
    "        while j < n:\n",
    "            stars += \"* \"\n",
    "            j += 1       \n",
    "# print the row stars\n",
    "        print(stars)\n",
    "        i += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "68dd400a-b55e-4fcf-bc31-377082122411",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the number of stars:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* * * * * \n",
      "* * * * * \n",
      "* * * * * \n",
      "* * * * * \n",
      "* * * * * \n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Enter the number of stars: \"))\n",
    "sqaure_of_stars_with_while(n) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "logical-embassy",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc55a966-2514-4dad-94fe-6a8e9b167091",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "every-removal",
   "metadata": {},
   "source": [
    "**Q 2:**\n",
    "\n",
    "Define a function that draw a square of stars on the screen.\n",
    "\n",
    "The function name will be **sqaure_of_stars_with_for**.\n",
    "\n",
    "The parameter will be number of stars in one side of square.\n",
    "\n",
    "Hints:\n",
    "* ask for number of stars from the user\n",
    "* use for loop\n",
    "\n",
    "<pre>\n",
    "Expected output for 5 stars:\n",
    "\n",
    "* * * * * \n",
    "* * * * * \n",
    "* * * * * \n",
    "* * * * * \n",
    "* * * * * \n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "careful-astronomy",
   "metadata": {},
   "outputs": [],
   "source": [
    "# S 2:\n",
    "\n",
    "def sqaure_of_stars_with_for(n):\n",
    "    \n",
    "    # Loop through rows\n",
    "    for i in range(n):\n",
    "    \n",
    "    # Loop to print pattern\n",
    "        for j in range(n):\n",
    "            print(\"*\", end=' ')\n",
    "        print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "finite-julian",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the number of stars:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* * * * * \n",
      "* * * * * \n",
      "* * * * * \n",
      "* * * * * \n",
      "* * * * * \n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Enter the number of stars: \"))\n",
    "sqaure_of_stars_with_for(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "wound-bible",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "present-oxide",
   "metadata": {},
   "source": [
    "**Q 3:**\n",
    "\n",
    "Define a function that draw a right triangle (lower triangle) of stars on the screen.\n",
    "\n",
    "The function name will be **lower_triangle_with_while**.\n",
    "\n",
    "The parameter will be number of stars in one side of triangle.\n",
    "\n",
    "Hints:\n",
    "* ask for number of stars from the user\n",
    "* use while loop\n",
    "\n",
    "<pre>\n",
    "Expected output for 5 stars:\n",
    "(lower triangle)\n",
    "\n",
    "*\n",
    "* *\n",
    "* * *\n",
    "* * * * \n",
    "* * * * *\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "desirable-glory",
   "metadata": {},
   "outputs": [],
   "source": [
    "# S 3:\n",
    "def lower_triangle_with_while(n):\n",
    "    i = 1\n",
    "    while i <= n :\n",
    "        j = 1\n",
    "        while j <= i:\n",
    "            print(\"*\", end=\" \")\n",
    "            j += 1\n",
    "        print()\n",
    "        i += 1\n",
    "\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "f894de80-7b02-4708-9d79-570115b64f8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n"
     ]
    }
   ],
   "source": [
    "lower_triangle_with_while(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "b55c1e78-4729-4773-8db0-ba7c98051e14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n",
      "* * * * * * \n",
      "* * * * * * * \n",
      "* * * * * * * * \n",
      "* * * * * * * * * \n",
      "* * * * * * * * * * \n",
      "* * * * * * * * * * * \n",
      "* * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * * * * \n"
     ]
    }
   ],
   "source": [
    "lower_triangle_with_while(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "collaborative-magnitude",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n"
     ]
    }
   ],
   "source": [
    "lower_triangle_with_while(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "settled-valuable",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n",
      "* * * * * * \n",
      "* * * * * * * \n",
      "* * * * * * * * \n",
      "* * * * * * * * * \n",
      "* * * * * * * * * * \n",
      "* * * * * * * * * * * \n",
      "* * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * * * * \n"
     ]
    }
   ],
   "source": [
    "lower_triangle_with_while(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e4a3a27-735b-4404-89d4-da633b0aa9e8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "american-shooting",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "driven-fortune",
   "metadata": {},
   "source": [
    "**Q 4:**\n",
    "\n",
    "Define a function that draw a right triangle (lower triangle) of stars on the screen.\n",
    "\n",
    "The function name will be **lower_triangle_with_for**.\n",
    "\n",
    "The parameter will be number of stars in one side of triangle.\n",
    "\n",
    "Hints:\n",
    "* ask for number of stars from the user\n",
    "* use for loop\n",
    "\n",
    "<pre>\n",
    "Expected output for 5 stars:\n",
    "(lower triangle)\n",
    "\n",
    "*\n",
    "* *\n",
    "* * *\n",
    "* * * * \n",
    "* * * * *\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "funny-choice",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n"
     ]
    }
   ],
   "source": [
    "# S 4:\n",
    "def lower_triangle_with_for(n):\n",
    "    \n",
    "    # Loop through rows\n",
    "    for i in range(n+1):\n",
    "    \n",
    "    # Loop to print pattern\n",
    "        for j in range(i):\n",
    "            print(\"*\", end=' ')\n",
    "        print()\n",
    "\n",
    "lower_triangle_with_for(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "f8639c12-153e-4ae4-8b41-2ef5ee716182",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n",
      "* * * * * * \n",
      "* * * * * * * \n",
      "* * * * * * * * \n",
      "* * * * * * * * * \n",
      "* * * * * * * * * * \n",
      "* * * * * * * * * * * \n",
      "* * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * * * * \n"
     ]
    }
   ],
   "source": [
    "lower_triangle_with_for(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "professional-sending",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n"
     ]
    }
   ],
   "source": [
    "lower_triangle_with_for(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "modern-slovakia",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n",
      "* * * * * * \n",
      "* * * * * * * \n",
      "* * * * * * * * \n",
      "* * * * * * * * * \n",
      "* * * * * * * * * * \n",
      "* * * * * * * * * * * \n",
      "* * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * * * * \n"
     ]
    }
   ],
   "source": [
    "lower_triangle_with_for(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "present-killing",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "turkish-crowd",
   "metadata": {},
   "source": [
    "**Q 5:**\n",
    "\n",
    "Define a function that draw a right triangle (upper triangle) of stars on the screen.\n",
    "\n",
    "The function name will be **upper_triangle_with_for**.\n",
    "\n",
    "The parameter will be number of stars in one side of triangle.\n",
    "\n",
    "Hints:\n",
    "* ask for number of stars from the user\n",
    "* use for loop\n",
    "\n",
    "<pre>\n",
    "Expected output for 5 stars:\n",
    "(upper triangle)\n",
    "\n",
    "* * * * * \n",
    "* * * * \n",
    "* * * \n",
    "* * \n",
    "* \n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "under-craps",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* * * * * \n",
      "* * * * \n",
      "* * * \n",
      "* * \n",
      "* \n"
     ]
    }
   ],
   "source": [
    "# S 5:\n",
    "def upper_triangle_with_for(n):\n",
    "    \n",
    "    # Loop through rows\n",
    "    for i in range(n,0,-1):\n",
    "    \n",
    "    # Loop to print pattern\n",
    "        for j in range(i):\n",
    "            print(\"*\", end=' ')\n",
    "        print()\n",
    "\n",
    "upper_triangle_with_for(5)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "subject-insulation",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* * * * * \n",
      "* * * * \n",
      "* * * \n",
      "* * \n",
      "* \n"
     ]
    }
   ],
   "source": [
    "upper_triangle_with_for(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abandoned-medium",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "photographic-charm",
   "metadata": {},
   "source": [
    "**Q 6:**\n",
    "\n",
    "Define a function that draw an isosceles triangle of stars on the screen.\n",
    "\n",
    "The function name will be **isosceles_triangle_with_for**.\n",
    "\n",
    "The parameter will be number of stars in half of the long side of triangle.\n",
    "\n",
    "Hints:\n",
    "* ask for number of stars from the user\n",
    "* call previous functions for drawing\n",
    "\n",
    "<pre>\n",
    "Expected output for 5 stars:\n",
    "(upper triangle)\n",
    "\n",
    "* \n",
    "* * \n",
    "* * * \n",
    "* * * * \n",
    "* * * * * \n",
    "* * * * \n",
    "* * * \n",
    "* * \n",
    "* \n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "static-criticism",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n",
      "* * * * \n",
      "* * * \n",
      "* * \n",
      "* \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# S 6:\n",
    "def isosceles_triangle_with_for(n):\n",
    "    \n",
    "    \n",
    "    for i in range(n):\n",
    "        for j in range(i+1):\n",
    "            print(\"*\", end=' ')\n",
    "        print(\"\\r\")\n",
    "    for i in range(n, 0, -1):\n",
    "        for j in range( i-1):\n",
    "            print(\"*\", end=' ')\n",
    "        print(\"\\r\")\n",
    "\n",
    "        \n",
    "\n",
    "isosceles_triangle_with_for(5)\n",
    "\n",
    "\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "b90fc171-610a-4322-ae98-4c0addff350c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n",
      "* * * * * * \n",
      "* * * * * * * \n",
      "* * * * * * * * \n",
      "* * * * * * * * * \n",
      "* * * * * * * * * * \n",
      "* * * * * * * * * \n",
      "* * * * * * * * \n",
      "* * * * * * * \n",
      "* * * * * * \n",
      "* * * * * \n",
      "* * * * \n",
      "* * * \n",
      "* * \n",
      "* \n",
      "\n"
     ]
    }
   ],
   "source": [
    "isosceles_triangle_with_for(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "marked-juice",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n",
      "* * * * \n",
      "* * * \n",
      "* * \n",
      "* \n"
     ]
    }
   ],
   "source": [
    "isosceles_triangle_with_for(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "younger-jonathan",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n",
      "* * * * * * \n",
      "* * * * * * * \n",
      "* * * * * * * * \n",
      "* * * * * * * * * \n",
      "* * * * * * * * * * \n",
      "* * * * * * * * * \n",
      "* * * * * * * * \n",
      "* * * * * * * \n",
      "* * * * * * \n",
      "* * * * * \n",
      "* * * * \n",
      "* * * \n",
      "* * \n",
      "* \n"
     ]
    }
   ],
   "source": [
    "isosceles_triangle_with_for(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sophisticated-border",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "compatible-richards",
   "metadata": {},
   "source": [
    "**Q 7:**\n",
    "\n",
    "Define a `bool` function which checks if the given number (parameter) is a prime number.\n",
    "\n",
    "The function name will be **is_prime** and it will return True if the number is prime, False otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "psychological-binary",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# S 7:\n",
    "def is_prime(num):\n",
    "    for i in range(2,num):\n",
    "        if (num % i) == 0:\n",
    "            return False\n",
    "    return True \n",
    "    \n",
    "is_prime(31)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "close-tuning",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now test the function\n",
    "\n",
    "is_prime(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "apart-process",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_prime(18)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "lonely-fireplace",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_prime(21)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "peripheral-locator",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "potential-potential",
   "metadata": {},
   "source": [
    "**Q 8:**\n",
    "\n",
    "Define a function named **prime_factors**.\n",
    "\n",
    "The function will take an integer parameter and will find all the `prime factors` of that number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "abstract-giving",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 2 "
     ]
    }
   ],
   "source": [
    "# S 8:\n",
    "\n",
    "def prime_factors(n):\n",
    " \n",
    "    for c in range(2,n):\n",
    "        while(n > 1):\n",
    " \n",
    "            if(n % c == 0):\n",
    "                print(c, end=\" \")\n",
    "            n = n / c\n",
    "        else:\n",
    "            c = c + 1\n",
    "            \n",
    "prime_factors(28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "above-campbell",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 2 2 "
     ]
    }
   ],
   "source": [
    "prime_factors(24)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "successful-worry",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "prime_factors(98)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "thrown-joshua",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "prime_factors(18)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "prescribed-handbook",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "coral-conservative",
   "metadata": {},
   "source": [
    "**Q 9:**\n",
    "\n",
    "Define a function named **trees_and_fives**.\n",
    "\n",
    "It will loop over the integers from 1 to 50, both included.\n",
    "\n",
    "It will print the numbers but:\n",
    "* If the number is a multiple of 3 it will print \"Trees\" instead of the number\n",
    "* If the number is a multiple of 5 it will print \"Fives\" instead of the number\n",
    "* If the number is a multiple of both 3 and 5 it will print \"Trees&Fives\" instead of the number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "statutory-circus",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "Trees\n",
      "4\n",
      "Fives\n",
      "Trees\n",
      "7\n",
      "8\n",
      "Trees\n",
      "Fives\n",
      "11\n",
      "Trees\n",
      "13\n",
      "14\n",
      "Fives&Trees\n",
      "16\n",
      "17\n",
      "Trees\n",
      "19\n",
      "Fives\n",
      "Trees\n",
      "22\n",
      "23\n",
      "Trees\n",
      "Fives\n",
      "26\n",
      "Trees\n",
      "28\n",
      "29\n",
      "Fives&Trees\n",
      "31\n",
      "32\n",
      "Trees\n",
      "34\n",
      "Fives\n",
      "Trees\n",
      "37\n",
      "38\n",
      "Trees\n",
      "Fives\n",
      "41\n",
      "Trees\n",
      "43\n",
      "44\n",
      "Fives&Trees\n",
      "46\n",
      "47\n",
      "Trees\n",
      "49\n",
      "Fives\n"
     ]
    }
   ],
   "source": [
    "# S 9:\n",
    "def trees_and_fives():\n",
    "    \n",
    "    for n in range(1, 51):\n",
    "        if (n%3 == 0 and n%5 == 0):\n",
    "            print('Fives&Trees')\n",
    "        elif n%3 == 0:\n",
    "            print('Trees')\n",
    "        elif (n%5 == 0):\n",
    "            print('Fives')\n",
    "        else:\n",
    "            print(n)\n",
    "trees_and_fives()     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "corporate-collect",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "Trees\n",
      "4\n",
      "Fives\n",
      "Trees\n",
      "7\n",
      "8\n",
      "Trees\n",
      "Fives\n",
      "11\n",
      "Trees\n",
      "13\n",
      "14\n",
      "Trees&Fives\n",
      "16\n",
      "17\n",
      "Trees\n",
      "19\n",
      "Fives\n",
      "Trees\n",
      "22\n",
      "23\n",
      "Trees\n",
      "Fives\n",
      "26\n",
      "Trees\n",
      "28\n",
      "29\n",
      "Trees&Fives\n",
      "31\n",
      "32\n",
      "Trees\n",
      "34\n",
      "Fives\n",
      "Trees\n",
      "37\n",
      "38\n",
      "Trees\n",
      "Fives\n",
      "41\n",
      "Trees\n",
      "43\n",
      "44\n",
      "Trees&Fives\n",
      "46\n",
      "47\n",
      "Trees\n",
      "49\n",
      "Fives\n"
     ]
    }
   ],
   "source": [
    "trees_and_fives()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "accepting-hands",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sufficient-nicaragua",
   "metadata": {},
   "source": [
    "**Q 10:**\n",
    "\n",
    "Define a function named **concat_sentence**.\n",
    "\n",
    "The function will take a string as parameter (sentence).\n",
    "\n",
    "It will first split this sentence into its words.\n",
    "\n",
    "Then it will split each word into its characters.\n",
    "\n",
    "And it will add \"-\" between each character.\n",
    "\n",
    "Moreover it will add \"__\" (double underscore) between the words.\n",
    "\n",
    "And it will return the final sentence.\n",
    "\n",
    "Hints:\n",
    "* to split into words -> split()\n",
    "\n",
    "<pre>\n",
    "sentence = \"This is a long story Rango\"\n",
    "final_sentence = concat_sentence(sentence)\n",
    "print(final_sentence)\n",
    "\n",
    "Expected Output:\n",
    "T-h-i-s__i-s__a__l-o-n-g__s-t-o-r-y__R-a-n-g-o\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "directed-advocacy",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'T-h-i-s-__-i-s-__-a-__-l-o-n-g-__-s-t-o-r-y-__-R-a-n-g-o'"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# S 10:\n",
    "user_input = \"This is a long story Rango\"\n",
    "# variable for new input\n",
    "new_input = \"\"\n",
    "\n",
    "# loop with enumerate\n",
    "for index, letter in enumerate(user_input):\n",
    "    \n",
    "    # concatenate the letter\n",
    "    new_input += letter\n",
    "    \n",
    "    # if this is the last index\n",
    "    if index < len(user_input) -1:\n",
    "        new_input += \"-\"\n",
    "\n",
    "\n",
    "(new_input).split()\n",
    "sentence = (new_input).split()\n",
    "\"__\".join(sentence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "hispanic-poultry",
   "metadata": {},
   "outputs": [],
   "source": [
    "sentence = \"This is a long story Rango\"\n",
    "final_sentence = concat_sentence(sentence)\n",
    "print(final_sentence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be2447c3-9f58-4a64-ad52-7e0071590881",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92f4fb80-b16f-4bee-b57a-bce07f01c21d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9f45241-8b66-4efc-95a0-cbbb4eafce64",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c774059-ee51-404a-87e8-5148796d0d73",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}