Python Practice Problems Basics (101-110).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "93880df9",
   "metadata": {},
   "source": [
    "# Python Practice Problems (101-120)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20ceb300",
   "metadata": {},
   "source": [
    "#### 101. Write a Python program to check the sum of three elements (each from an array) from three arrays is equal to a target value. Print all those three-element combinations."
   ]
  },
  {
   "cell_type": "raw",
   "id": "f06789f2",
   "metadata": {},
   "source": [
    "Sample data:\n",
    "X = [10, 20, 20, 20]\n",
    "Y = [10, 20, 30, 40]\n",
    "Z = [10, 30, 40, 20]\n",
    "\n",
    "target = 70 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "555803f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X = [10, 20, 20, 20]\n",
      "Y = [10, 20, 30, 40]\n",
      "Z = [10, 30, 40, 20]\n",
      " \n",
      "Sum of three elements (one from each array) should be equal to 70\n",
      "\n",
      "All three elements combinations whose sum is equal to 70 are as follows : \n",
      "\n",
      "Sum of (10, 20, 40) = 70\n",
      "Sum of (10, 30, 30) = 70\n",
      "Sum of (10, 40, 20) = 70\n",
      "Sum of (20, 10, 40) = 70\n",
      "Sum of (20, 20, 30) = 70\n",
      "Sum of (20, 30, 20) = 70\n",
      "Sum of (20, 40, 10) = 70\n",
      "Sum of (20, 10, 40) = 70\n",
      "Sum of (20, 20, 30) = 70\n",
      "Sum of (20, 30, 20) = 70\n",
      "Sum of (20, 40, 10) = 70\n",
      "Sum of (20, 10, 40) = 70\n",
      "Sum of (20, 20, 30) = 70\n",
      "Sum of (20, 30, 20) = 70\n",
      "Sum of (20, 40, 10) = 70\n",
      "\n",
      "List of all possible combinations :\n",
      "[(10, 20, 40), (10, 30, 30), (10, 40, 20), (20, 10, 40), (20, 20, 30), (20, 30, 20), (20, 40, 10), (20, 10, 40), (20, 20, 30), (20, 30, 20), (20, 40, 10), (20, 10, 40), (20, 20, 30), (20, 30, 20), (20, 40, 10)]\n",
      "\n",
      "List of all unique possible combinations :\n",
      "{(10, 20, 40), (20, 40, 10), (20, 20, 30), (20, 10, 40), (10, 40, 20), (20, 30, 20), (10, 30, 30)}\n"
     ]
    }
   ],
   "source": [
    "X = [10, 20, 20, 20]\n",
    "Y = [10, 20, 30, 40]\n",
    "Z = [10, 30, 40, 20]\n",
    "\n",
    "print(f\"X = {X}\\nY = {Y}\\nZ = {Z}\\n \")\n",
    "\n",
    "target = 70\n",
    "\n",
    "list_num =[]\n",
    "print(f\"Sum of three elements (one from each array) should be equal to {target}\\n\")\n",
    "\n",
    "print(f\"All three elements combinations whose sum is equal to {target} are as follows : \\n\")\n",
    "\n",
    "for x in X:\n",
    "    for y in Y:\n",
    "        for z in Z:\n",
    "            if (x+y+z) == target:\n",
    "                list_num.append((x,y,z))\n",
    "                print(f\"Sum of {x,y,z} = {target}\")\n",
    "\n",
    "print(f\"\\nList of all possible combinations :\\n{list_num}\")\n",
    "\n",
    "\n",
    "print(f\"\\nList of all unique possible combinations :\\n{set(list_num)}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "94c7f641",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X = [10, 20, 20, 20]\n",
      "Y = [10, 20, 30, 40]\n",
      "Z = [10, 30, 40, 20]\n",
      " \n",
      "Sum of three elements (one from each array) should be equal to 70\n",
      "\n",
      "[(10, 20, 40), (10, 30, 30), (10, 40, 20), (20, 10, 40), (20, 20, 30), (20, 30, 20), (20, 40, 10), (20, 10, 40), (20, 20, 30), (20, 30, 20), (20, 40, 10), (20, 10, 40), (20, 20, 30), (20, 30, 20), (20, 40, 10)] \n",
      "\n",
      "All three elements combinations whose sum is equal to 70 are as follows : \n",
      "\n",
      "{(10, 20, 40), (20, 40, 10), (20, 20, 30), (20, 10, 40), (10, 40, 20), (20, 30, 20), (10, 30, 30)}\n"
     ]
    }
   ],
   "source": [
    "X = [10, 20, 20, 20]\n",
    "Y = [10, 20, 30, 40]\n",
    "Z = [10, 30, 40, 20]\n",
    "\n",
    "print(f\"X = {X}\\nY = {Y}\\nZ = {Z}\\n \")\n",
    "\n",
    "target = 70\n",
    "\n",
    "list_num =[]\n",
    "print(f\"Sum of three elements (one from each array) should be equal to {target}\\n\")\n",
    "\n",
    "print([(x, y, z) for x in X for y in Y for z in Z if x + y + z == 70],\"\\n\")\n",
    "\n",
    "print(f\"All three elements combinations whose sum is equal to {target} are as follows : \\n\")\n",
    "\n",
    "print(set([(x, y, z) for x in X for y in Y for z in Z if x + y + z == 70]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe0cfcc2",
   "metadata": {},
   "source": [
    "#### 102. Write a Python program that generates a list of all possible permutations from a given collection of distinct numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "83fc5684",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X = [1, 2, 3]\n",
      "\n",
      "All possible permutation of [1, 2, 3] are as follows :\n",
      "[(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)] \n",
      "\n",
      "All unique possible permutation [1, 2, 3] are as follows :\n",
      "{(1, 3, 2), (1, 2, 3), (2, 1, 3), (3, 2, 1), (3, 1, 2), (2, 3, 1)}\n"
     ]
    }
   ],
   "source": [
    "X = [1,2,3]\n",
    "\n",
    "print(f\"X = {X}\\n\")\n",
    "\n",
    "possible_permutation = []\n",
    "\n",
    "for a1 in X:\n",
    "    for a2 in X:\n",
    "        for a3 in X:\n",
    "            if (a1+a2+a3)==sum(X) and a1!=a2!=a3:\n",
    "                possible_permutation.append((a1,a2,a3))\n",
    "                \n",
    "print(f\"All possible permutation of {X} are as follows :\")\n",
    "\n",
    "print(possible_permutation,\"\\n\")\n",
    "\n",
    "print(f\"All unique possible permutation {X} are as follows :\")                \n",
    "\n",
    "print(set(possible_permutation))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbe568bd",
   "metadata": {},
   "source": [
    "#### 103. Write a Python program to add two positive integers without using the '+' operator.\n",
    "Note: Use bitwise operations to add two numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2b2543e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of 23 and 10 is 33\n"
     ]
    }
   ],
   "source": [
    "num_1, num_2 = 23, 10\n",
    "sum_num= num_1-(-num_2)\n",
    "print(f\"Sum of {num_1} and {num_2} is {sum_num}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "29cf53d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequence of numbers from 23:\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]\n",
      "\n",
      "Sequence of numbers from 10:\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "\n",
      "The sum of 23 and 10 is 33\n"
     ]
    }
   ],
   "source": [
    "num_1, num_2 = 23, 10\n",
    "\n",
    "list_num_1 = list(range(num_1))\n",
    "\n",
    "print(f\"Sequence of numbers from {num_1}:\\n{list_num_1}\\n\")\n",
    "\n",
    "list_num_2 = list(range(num_2))\n",
    "\n",
    "print(f\"Sequence of numbers from {num_2}:\\n{list_num_2}\\n\")\n",
    "\n",
    "sum_num = len(list_num_1) + len(list_num_2)\n",
    "\n",
    "print(f\"The sum of {num_1} and {num_2} is {sum_num}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8aa82cbf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequence of numbers from 23:\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]\n",
      "\n",
      "Sequence of numbers from 45:\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44]\n",
      "\n",
      "The sum of 23 and 45 is 68\n"
     ]
    }
   ],
   "source": [
    "num_1, num_2 = 23, 45\n",
    "\n",
    "list_num_1 = list(range(num_1))\n",
    "\n",
    "print(f\"Sequence of numbers from {num_1}:\\n{list_num_1}\\n\")\n",
    "\n",
    "list_num_2 = list(range(num_2))\n",
    "\n",
    "print(f\"Sequence of numbers from {num_2}:\\n{list_num_2}\\n\")\n",
    "\n",
    "for num in list_num_1:\n",
    "    list_num_2.append(num)\n",
    "    \n",
    "sum_num = len(list_num_2)\n",
    "\n",
    "print(f\"The sum of {num_1} and {num_2} is {sum_num}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "cff7d134",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum is 68\n"
     ]
    }
   ],
   "source": [
    "# careful about bitwise operators\n",
    "num_1, num_2 = 23, 45\n",
    "\n",
    "while num_2 !=0:\n",
    "    temp = num_1 & num_2\n",
    "    num_1 = num_1^num_2\n",
    "    num_2 = temp<<1\n",
    "    \n",
    "print(f\"The sum is {num_1}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f21fbfff",
   "metadata": {},
   "source": [
    "#### 104. Write a Python program to find the median among given three numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "f1805447",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter list of numbers, each element separated with comma (,) : 85,1,36\n",
      "You have given list: \n",
      "[85, 1, 36]\n",
      "Numbers in ascending order: \n",
      "[1, 36, 85]\n",
      "36 is the median number of [1, 36, 85]\n"
     ]
    }
   ],
   "source": [
    "num_list = input(\"Enter list of numbers, each element separated with comma (,) : \").split(\",\")\n",
    "\n",
    "num_list = [int(x) for x in num_list]\n",
    "\n",
    "print(f\"You have given list: \\n{num_list}\")\n",
    "\n",
    "num_list.sort()\n",
    "\n",
    "print(f\"Numbers in ascending order: \\n{num_list}\")\n",
    "\n",
    "print(f\"{num_list[1]} is the median number of {num_list}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "dab727a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter list of numbers, each element separated with comma (,) : 85,58,25,1,2,3,5,6,74,5,5,6,4\n",
      "You have given list: \n",
      "[85, 58, 25, 1, 2, 3, 5, 6, 74, 5, 5, 6, 4]\n",
      "Numbers in ascending order: \n",
      "[1, 2, 3, 4, 5, 5, 5, 6, 6, 25, 58, 74, 85]\n",
      "Number of terms in the list: 13\n",
      "Median of [1, 2, 3, 4, 5, 5, 5, 6, 6, 25, 58, 74, 85] is  5\n"
     ]
    }
   ],
   "source": [
    "num_list = input(\"Enter list of numbers, each element separated with comma (,) : \").split(\",\")\n",
    "\n",
    "num_list = [int(x) for x in num_list]\n",
    "\n",
    "print(f\"You have given list: \\n{num_list}\")\n",
    "\n",
    "num_list.sort()\n",
    "\n",
    "print(f\"Numbers in ascending order: \\n{num_list}\")\n",
    "\n",
    "list_len = len(num_list)\n",
    "\n",
    "print(f\"Number of terms in the list: {list_len}\")\n",
    "\n",
    "if list_len % 2 == 1:\n",
    "    print(f\"Median of {num_list} is \",num_list[list_len//2])\n",
    "else:\n",
    "    print(f\"Median of {num_list} is \",(num_list[list_len//2] + num_list[(list_len//2)+1])/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75a5f5a4",
   "metadata": {},
   "source": [
    "#### 105. Write a Python program to calculate the length of a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "fa53f6e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string : India is great\n",
      "The number of characters (length of string) India is great is 14\n"
     ]
    }
   ],
   "source": [
    "input_string = input(\"Enter the string : \")\n",
    "\n",
    "char_count = 0\n",
    "\n",
    "for char in input_string:\n",
    "    char_count += 1\n",
    "    char_count\n",
    "    \n",
    "print(f\"The number of characters (length of string) {input_string} is {char_count}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4aa8560",
   "metadata": {},
   "source": [
    "#### 106. Write a Python program to count the number of characters (character frequency) in a string."
   ]
  },
  {
   "cell_type": "raw",
   "id": "93363b3c",
   "metadata": {},
   "source": [
    "Sample String : \n",
    "google.com\n",
    "\n",
    "Expected Result : \n",
    "{'g': 2, 'o': 3, 'l': 1, 'e': 1, '.': 1, 'c': 1, 'm': 1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "66f034f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given String :  google.com\n",
      "\n",
      "Character frequency of google.com is :\n",
      "{'g': 2, 'o': 3, 'l': 1, 'e': 1, '.': 1, 'c': 1, 'm': 1}\n"
     ]
    }
   ],
   "source": [
    "string_given = 'google.com'\n",
    "\n",
    "print(\"Given String : \", string_given)\n",
    "\n",
    "char_count = {}\n",
    "\n",
    "for char in string_given:\n",
    "    char_count[char] = string_given.count(char)\n",
    "    \n",
    "print(f\"\\nCharacter frequency of {string_given} is :\\n{char_count}\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "48bfcf7e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given String :  google.com\n",
      "\n",
      "Character frequency of google.com is :\n",
      "{'g': 2, 'o': 3, 'l': 1, 'e': 1, '.': 1, 'c': 1, 'm': 1}\n"
     ]
    }
   ],
   "source": [
    "string_given = 'google.com'\n",
    "\n",
    "print(\"Given String : \", string_given)\n",
    "\n",
    "char_count = {char:string_given.count(char) for char in string_given}\n",
    "\n",
    "print(f\"\\nCharacter frequency of {string_given} is :\\n{char_count}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ad02b4fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given String :  google.com\n",
      "\n",
      "Character frequency of google.com is :\n",
      "{'g': 2, 'o': 3, 'l': 1, 'e': 1, '.': 1, 'c': 1, 'm': 1}\n"
     ]
    }
   ],
   "source": [
    "string_given = 'google.com'\n",
    "\n",
    "print(\"Given String : \", string_given)\n",
    "\n",
    "char_count = {}\n",
    "\n",
    "for char in string_given:\n",
    "    char_as_key = char_count.keys()\n",
    "    if char in char_as_key:\n",
    "        char_count[char] += 1\n",
    "    else:\n",
    "        char_count[char] = 1\n",
    "\n",
    "print(f\"\\nCharacter frequency of {string_given} is :\\n{char_count}\")        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65f80f92",
   "metadata": {},
   "source": [
    "#### 107. Write a Python program to get a string made of the first 2 and last 2 characters of a given string. If the string length is less than 2, return the empty string instead"
   ]
  },
  {
   "cell_type": "raw",
   "id": "4934d050",
   "metadata": {},
   "source": [
    "Sample String : 'a1resource'\n",
    "Expected Result : 'a1ce'\n",
    "\n",
    "Sample String : 'a1'\n",
    "Expected Result : 'w3w3'\n",
    "\n",
    "Sample String : 'a'\n",
    "Expected Result : Empty String "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "ece924d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For given string 'a1resource', the new string formed is 'a1ce'\n",
      "For given string 'a1', the new string formed is 'a1a1'\n",
      "For given string 'a', the new string formed is ''\n"
     ]
    }
   ],
   "source": [
    "def new_string_formation(given_string):\n",
    "    if len(given_string) < 2:\n",
    "        return ''\n",
    "    else:\n",
    "        return given_string[0:2]+given_string[-2:]\n",
    "    \n",
    "given_string1 = 'a1resource'\n",
    "given_string2 = 'a1'\n",
    "given_string3 = 'a'\n",
    "    \n",
    "print(f\"For given string '{given_string1}', the new string formed is '{new_string_formation(given_string1)}'\")\n",
    "print(f\"For given string '{given_string2}', the new string formed is '{new_string_formation(given_string2)}'\")\n",
    "print(f\"For given string '{given_string3}', the new string formed is '{new_string_formation(given_string3)}'\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "01e4d9af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For given string 'a1resource', the new string formed is 'a1ce' \n",
      "For given string 'a1', the new string formed is 'a1a1' \n",
      "For given string 'a', the new string formed is '' \n"
     ]
    }
   ],
   "source": [
    "given_string1 = 'a1resource'\n",
    "\n",
    "new_string_formed1  = given_string1[0:2]+given_string1[-2:] if len(given_string1)>=2 else ''\n",
    "print(f\"For given string '{given_string1}', the new string formed is '{new_string_formed1}' \")\n",
    "\n",
    "\n",
    "given_string2 = 'a1'\n",
    "\n",
    "new_string_formed2  = given_string2[0:2]+given_string2[-2:] if len(given_string2)>=2 else ''\n",
    "print(f\"For given string '{given_string2}', the new string formed is '{new_string_formed2}' \")\n",
    "\n",
    "given_string3 = 'a'\n",
    "\n",
    "new_string_formed3  = given_string3[0:2]+given_string3[-2:] if len(given_string3)>=2 else ''\n",
    "print(f\"For given string '{given_string3}', the new string formed is '{new_string_formed3}' \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6bc02701",
   "metadata": {},
   "outputs": [],
   "source": [
    "input_string = input(\"Enter the string : \")\n",
    "\n",
    "print(f\"You have entered {input_string}\")\n",
    "\n",
    "new_string_formed = lambda x: '' if len(x)<2 else x[0:2]+x[-2:]\n",
    "\n",
    "print(f\"For given string '{input_string}', the new string formed is '{new_string_formed(input_string)}' \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42528c91",
   "metadata": {},
   "source": [
    "### 108. Write a Python program to get a string from a given string where all occurrences of its first char have been changed to '$', except the first char itself."
   ]
  },
  {
   "cell_type": "raw",
   "id": "acb8d477",
   "metadata": {},
   "source": [
    "Sample String : 'restart'\n",
    "Expected Result : 'resta$t'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "e5b76348",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For the given string 'restart', new string formed is 'resta$t'\n"
     ]
    }
   ],
   "source": [
    "given_string = 'restart'\n",
    "\n",
    "new_string_formed = given_string[0]+given_string[1:].replace(given_string[0],'$')\n",
    "\n",
    "print(f\"For the given string '{given_string}', new string formed is '{new_string_formed}'\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae651f1b",
   "metadata": {},
   "source": [
    "#### 109. Write a Python program to get a single string from two given strings, separated by a space and swap the first two characters of each string."
   ]
  },
  {
   "cell_type": "raw",
   "id": "3c9a5701",
   "metadata": {},
   "source": [
    "Sample String : 'abc', 'xyz'\n",
    "Expected Result : 'xyc abz'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "e59511cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Required String formed : xyc abz\n"
     ]
    }
   ],
   "source": [
    "given_string1 = 'abc'\n",
    "\n",
    "given_string2 = 'xyz'\n",
    "\n",
    "swapped_string1 = given_string2[0:2]+given_string1[2:]\n",
    "\n",
    "swapped_string2 = given_string1[0:2]+given_string2[2:]\n",
    "\n",
    "new_string_formed = swapped_string1 + ' ' + swapped_string2\n",
    "\n",
    "print(f\"Required String formed : {new_string_formed}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "5768eecc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Required String formed : xyc abz\n"
     ]
    }
   ],
   "source": [
    "given_string1 = 'abc'\n",
    "\n",
    "given_string2 = 'xyz'\n",
    "\n",
    "swapped_string1 = given_string1.replace(given_string1[0:2],given_string2[0:2])\n",
    "\n",
    "swapped_string2 = given_string2.replace(given_string2[0:2],given_string1[0:2])\n",
    "\n",
    "new_string_formed = swapped_string1 + ' ' + swapped_string2\n",
    "\n",
    "print(f\"Required String formed : {new_string_formed}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9ef12c0",
   "metadata": {},
   "source": [
    "#### 110. Write a Python program to add 'ing' at the end of a given string (length should be at least 3). If the given string already ends with 'ing', add 'ly' instead. If the string length of the given string is less than 3, leave it unchanged."
   ]
  },
  {
   "cell_type": "raw",
   "id": "0b35d66d",
   "metadata": {},
   "source": [
    "Sample String : 'abc'\n",
    "Expected Result : 'abcing'\n",
    "Sample String : 'string'\n",
    "Expected Result : 'stringly'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "1d69197a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string : abc\n",
      "You have entered : abc\n",
      "\n",
      "Required new string formed : abcing\n"
     ]
    }
   ],
   "source": [
    "input_string = input(\"Enter the string : \")\n",
    "\n",
    "print(f\"You have entered : {input_string}\")\n",
    "\n",
    "if len(input_string)<3:\n",
    "    pass\n",
    "else:\n",
    "    if input_string[-3:]=='ing':\n",
    "        new_string_formed = input_string + 'ly'\n",
    "    else:\n",
    "        new_string_formed = input_string + 'ing'\n",
    "print(f\"\\nRequired new string formed : {new_string_formed}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "56ded570",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string : string\n",
      "You have entered : string\n",
      "\n",
      "Required new string formed : stringly\n"
     ]
    }
   ],
   "source": [
    "input_string = input(\"Enter the string : \")\n",
    "\n",
    "print(f\"You have entered : {input_string}\")\n",
    "\n",
    "if len(input_string)<3:\n",
    "    pass\n",
    "else:\n",
    "    if input_string[-3:]=='ing':\n",
    "        new_string_formed = input_string + 'ly'\n",
    "    else:\n",
    "        new_string_formed = input_string + 'ing'\n",
    "print(f\"\\nRequired new string formed : {new_string_formed}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}