CSE110_Lab_Assignment_03_(String).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xDNsncrtU1yM"
   },
   "source": [
    "# CSE110 Lab Assignment 3 (String)\n",
    "\n",
    "This Assignment is to help you develop your concept of Strings in Python.\n",
    "\n",
    "**<font color='red'>[Please follow variable naming conventions including using meaningful variable names for all the tasks]</font>**\\\n",
    "<font color='red'>When you run your code, please make sure your outputs exactly match the sample outputs for each of the sample inputs given. Check if your code works for other valid inputs not given in the samples.</font>\n",
    "\n",
    "## Write the code in Python to do the following tasks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "OAYfzLIqgqyE"
   },
   "outputs": [],
   "source": [
    "#Write your name, student ID and theory section number below:\n",
    "#Student Name: MD. Shafiur Rahman\n",
    "#Student ID: 21201613\n",
    "#CSE110 Theory Section No: 38"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5bNoypiTBWqt"
   },
   "source": [
    "### Task 1 \n",
    "\n",
    "Write a Python program that takes a String as an input from the user and prints that String in **reverse** order.\n",
    "\n",
    "**<font color='red'>You cannot use the built-in reverse() function for this task.**\n",
    "\n",
    "=====================================================================\n",
    " \n",
    "**Sample Input 1:**\\\n",
    " CSE110\n",
    "\n",
    "**Sample Output 1:**\\\n",
    " 011ESC\n",
    " \n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 2:**\\\n",
    "Python \n",
    "\n",
    "**Sample Output 2:**\\\n",
    "nohtyP\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 3:**\\\n",
    "1576527  \n",
    "\n",
    "**Sample Output 3:**\\\n",
    "7256751\n",
    "\n",
    "====================================================================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "k8uIngEeCI3T",
    "outputId": "a91f2089-45cc-427e-bc6f-88e7f435c748"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: CSE110\n",
      "011ESC"
     ]
    }
   ],
   "source": [
    "#todo\n",
    "string = input(\"Enter a string: \")\n",
    "for i in range((len(string)-1), -1, -1):\n",
    "  print(string[i], end = \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4zI6tmFN0i4y"
   },
   "source": [
    "\n",
    "### Task 2\n",
    "\n",
    "Write a python program that takes 2 inputs from the user, where the first input is a string with length greater than 1. The second input is the index of the first given string from where you have to start reversing. After reversing the first input string from that index, print the new string back to the user. See samples below for clarification.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 1:**\n",
    "\n",
    "72418\n",
    "\n",
    "4\n",
    "\n",
    "**Sample Output 1:**\n",
    "\n",
    "81427\n",
    "\n",
    "\n",
    "**Explanation**: Our second input, index '4' is the last index of our first input String '72418', hence the entire string is reversed giving us '81427'.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 2:**\n",
    "\n",
    "12345 \n",
    "\n",
    "2\n",
    "\n",
    "**Sample Output 2:**\n",
    "\n",
    "32145\n",
    "\n",
    "**Explanation**: The second input is '2' so we have to reverse from index 2 of our first input. The 2nd index of our first input String is '3', index 1 is '2' and index 0 is '1'. Hence, if we reverse indexes 0 to 2, we get '321'. Index 3 and 4 which is '4' and '5' respectively remains unchanged hence our final output is '32145'.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 3:**\n",
    "\n",
    "aBcd1234defg\n",
    "\n",
    "5\n",
    "\n",
    "**Sample Output 3:**\n",
    "\n",
    "21dcBa34defg\n",
    "\n",
    "**Explanation**: From our first input String 'aBcd1234defg', \n",
    "\n",
    "index 0 = 'a'\n",
    "\n",
    "index 1 = 'B'\n",
    "\n",
    "index 2 = 'c'\n",
    "\n",
    "index 3 = 'd'\n",
    "\n",
    "index 4 = '1'\n",
    "\n",
    "index 5 = '2'\n",
    "\n",
    "index 6 = '3'\n",
    "\n",
    "Since our second input is 5, index 0 to index 5 is reversed and we have '21dcBa' and the rest is unchanged from indexes 6 to 11 ('34defg'). Therefore, we have '21dcBa34defg' finally.\n",
    "\n",
    "=====================================================================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "b5-ePuUsCn9p",
    "outputId": "f5469a50-ce9c-4e80-8064-7a019f5fac0d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: nidwwolo\n",
      "Enter where to start reversing: 3\n",
      "wdinwolo\n"
     ]
    }
   ],
   "source": [
    "#todo\n",
    "string = input(\"Enter a string: \")\n",
    "length = int(input(\"Enter where to start reversing: \"))\n",
    "\n",
    "if len(string) > 1:\n",
    "    sum = string[length::-1] + string[length+1:]\n",
    "    print(sum)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pkTyiploC6gC"
   },
   "source": [
    "### Task 3\n",
    "Write a program that takes a **string** as input and prints “Binary Number” if the string contains only 0s or 1s. Otherwise, print “Not a Binary Number”.\n",
    "\n",
    "=====================================================================\n",
    " \n",
    "**Sample Input 1:**\\\n",
    "01101101101\n",
    "\n",
    "**Sample Output 1:**\\\n",
    "Binary Number\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 2:**\\\n",
    "12344ab0\n",
    "\n",
    "**Sample Output 2:**\\\n",
    "Not a Binary Number\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 3:**\\\n",
    "10127490111\n",
    "\n",
    "**Sample Output 3:**\\\n",
    "Not a Binary Number\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 4:**\\\n",
    "Binary Number\n",
    "\n",
    "**Sample Output 4:**\\\n",
    "Not a Binary Number\n",
    "\n",
    "====================================================================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "DjTV5kx5DslT",
    "outputId": "71944854-09be-4be3-989f-aa0223ce14e6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: 10101010000000000000\n",
      "Binary Number\n"
     ]
    }
   ],
   "source": [
    "#todo\n",
    "var = input(\"Enter a string: \")\n",
    "count = 0\n",
    "\n",
    "for i in var:\n",
    "    \n",
    "    if i==\"0\" or i==\"1\":\n",
    "      count += 1\n",
    "    else:\n",
    "      count = count\n",
    "    \n",
    "if count == len(var):\n",
    "    print(\"Binary Number\")\n",
    "else:\n",
    "    print(\"Not a Binary Number\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pbdeIVcyU1yi"
   },
   "source": [
    "### Task 4\n",
    "\n",
    "Write a Python program that will ask the user to enter a  word as an input. \n",
    "\n",
    "* If the length of the input string is less than 4, then your program should print the same string as an output. \n",
    "* If the input string’s length is greater than 3, then your program should add \"er\" at the end of the input string. \n",
    "* If the input string already ends with \"er\", then add \"est\" instead, regardless of the length of the input string\n",
    "* If the input string already ends with \"est\", then your program should print the same input string as an output.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 1**:\\\n",
    "strong\n",
    "\n",
    "**Sample Output 1**:\\\n",
    "stronger\n",
    "\n",
    "**Explanation**: Length of input = 6, not less than 4, greater than 3, does not end with \"er\" or \"est\", therefore \"er\" is added making \"strong\", \"stronger\".\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 2**:\\\n",
    "stronger\n",
    "\n",
    "**Sample Output 2**:\\\n",
    "strongest\n",
    "\n",
    "**Explanation**: Input string ends with \"er\", therefore \"er\" is replaced with \"est\" instead so we have \"strongest\" from \"stronger\".\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 3**:\\\n",
    "strongest\n",
    "\n",
    "**Sample Output 3**:\\\n",
    "strongest\n",
    "\n",
    "**Explanation**: Our input here already ends with \"est\" so the same input i.e. \"strongest\" is printed.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 4**:\\\n",
    "abc\n",
    "\n",
    "**Sample Output 4**:\\\n",
    "abc\n",
    "\n",
    "**Explanation**: Since length of input string is less than 4, the given input is printed as output.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 5**:\\\n",
    "ber\n",
    "\n",
    "**Sample Output 5**:\\\n",
    "best\n",
    "\n",
    "**Explanation**: Although the length of the input string is 3 which is less than 4, but it ends with er so we ignore the length and replace \"er\" with \"est\" regardless.\n",
    "\n",
    "====================================================================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gEB9Vk09Fjjp",
    "outputId": "0e90776f-9eb4-4b64-d227-63d10cef80f2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word: stronger\n",
      "strongest\n"
     ]
    }
   ],
   "source": [
    "#todo\n",
    "inp = input('Enter a word: ')\n",
    "\n",
    "if (inp[-2:]) == 'er':\n",
    "    print(inp[0:-2] + 'est')\n",
    "elif (inp[-3:]) == 'est':\n",
    "    print(inp) \n",
    "elif len(inp) > 3:\n",
    "    print(inp + 'er')\n",
    "else:\n",
    "    print(inp)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KD4EKJf6U1yQ"
   },
   "source": [
    "\n",
    "### Task 5 \n",
    "\n",
    "Write a Python program that will ask the user to input a string (containing exactly one word). Then your program should print subsequent substrings of the given string as shown in the examples below.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Hints(1):** You may use \"for loop\" for this task.\n",
    "\n",
    "**Hints(2):** You may use print() function for printing newlines.\n",
    "\n",
    "For example:\\\n",
    "print(1)\\\n",
    "print(2)\n",
    "\n",
    "Output:\\\n",
    "1\\\n",
    "2\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "We can use print(end = \"\") to skip printing the additional newline.\n",
    "\n",
    "For example:\\\n",
    "print(1, end =\"\")\\\n",
    "print(2)\n",
    "\n",
    "Output:(prints the following output right next to the previous one)\\\n",
    "12\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 1**:\\\n",
    "BANGLA\n",
    "\n",
    "**Sample Output 1**:\\\n",
    "B\\\n",
    "BA\\\n",
    "BAN\\\n",
    "BANG\\\n",
    "BANGL\\\n",
    "BANGLA\n",
    "\n",
    "**Explanation**: The length of the string is 6 so there are 6 lines where in each line a substring of the input string, of length equal to the line number is printed i.e. substring with only the letter \"B\" printed in the first line, substring \"BA\" of length 2 printed in the 2nd line, \"BAN\" length of which is 3 being printed in the 3rd line and so on.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 2**:\\\n",
    "DREAM\n",
    "\n",
    "**Sample Output 2**:\\\n",
    "D\\\n",
    "DR\\\n",
    "DRE\\\n",
    "DREA\\\n",
    "DREAM\n",
    "\n",
    "**Explanation**: Simply, no of lines = length of the input string and no of letters in each line = line number.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 234
    },
    "id": "vJhpmj2XU1yR",
    "outputId": "ca866938-f987-4bf5-f7d7-a19cd772c36f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word: DREAM\n",
      "D\n",
      "DR\n",
      "DRE\n",
      "DREA\n",
      "DREAM\n"
     ]
    }
   ],
   "source": [
    "#todo\n",
    "A=input('Enter a word: ')\n",
    "for char in range(len(A)): \n",
    "  print (A[:char+1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PsBbgc4YU1yp"
   },
   "source": [
    "### Task 6\n",
    "\n",
    "Write a Python program that will ask the user to input a string (containing exactly one word). Then print the ASCII code for each character in the String using the ord() function. \n",
    "\n",
    "To check if your program is working correctly or not, you can find a list of all correct values from the following website. You may look at “Dec” and “Char” columns only and ignore the other columns for this problem.\\\n",
    "link: http://www.asciitable.com/\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 1**:\\\n",
    "Programming\n",
    "\n",
    "**Sample Output 1**:\\\n",
    "P : 80\\\n",
    "r : 114\\\n",
    "o : 111\\\n",
    "g : 103\\\n",
    "r : 114\\\n",
    "a : 97\\\n",
    "m : 109\\\n",
    "m : 109\\\n",
    "i : 105\\\n",
    "n : 110\\\n",
    "g : 103\n",
    "\n",
    "**Explanation**: Each line prints a letter sequentially from the given string and its corresponding ASCII value separated by \" : \".\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 2**:\\\n",
    "hunger\n",
    "\n",
    "**Sample Output 2**:\\\n",
    "h : 104\\\n",
    "u : 117\\\n",
    "n : 110\\\n",
    "g : 103\\\n",
    "e : 101\\\n",
    "r : 114 \n",
    "\n",
    "**Explanation**: Same as previous.\n",
    "\n",
    "====================================================================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "r8by7ONZU1ys",
    "outputId": "ffdba64d-065b-4bfb-e5f5-ef8a36313bf9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: programming\n",
      "p : 112\n",
      "r : 114\n",
      "o : 111\n",
      "g : 103\n",
      "r : 114\n",
      "a : 97\n",
      "m : 109\n",
      "m : 109\n",
      "i : 105\n",
      "n : 110\n",
      "g : 103\n"
     ]
    }
   ],
   "source": [
    "#todo\n",
    "string = input(\"Enter a string: \")\n",
    "for char in string:\n",
    "    code = ord(char)\n",
    "    print(char,\":\",code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "O8lIVppgU1yw"
   },
   "source": [
    "### Task 7\n",
    "\n",
    "Write a Python program that takes a string as an input from the user containing all small letters and then prints the next alphabet in sequence for each alphabet in the input.\n",
    "\n",
    "*Hint: You may need to use the functions ord() and chr(). The ASCII value of ‘a’ is 97 and ‘z’ is 122.*\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 1:**\\\n",
    "abcd\n",
    "\n",
    "**Sample Output 1:**\\\n",
    "bcde\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 2:**\\\n",
    "the cow\n",
    "\n",
    "**Sample Output 2:**\\\n",
    "uif!dpx\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "<font color='red'>[Must fulfil this criteria]</font>\n",
    "\n",
    "**Sample Input 3:**\\\n",
    "xyzabc\n",
    "\n",
    "**Sample Output 3:**\\\n",
    "yzabcd\n",
    "\n",
    "=====================================================================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Hyvy8WNNU1yx",
    "outputId": "74ba22d8-dc0c-4822-c0e7-d8d9e33b3572"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: the cow\n",
      "uif!dpx"
     ]
    }
   ],
   "source": [
    "#todo\n",
    "string = input(\"Enter a string: \")\n",
    "for char in string:\n",
    "    code = ord(char)\n",
    "    if code == 122:\n",
    "        code = code -26\n",
    "    \n",
    "    new_code = chr(code+1)\n",
    "    print(new_code,end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZrjtT-I_U1zD"
   },
   "source": [
    "### Task 8\n",
    "\n",
    "Write a Python program that takes a String as input from the user, removes the characters at even index and prints the resulting String in uppercase without using the built-in function upper().\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 1**:\n",
    "\n",
    "String\n",
    "\n",
    "**Sample Output 1**: \n",
    "\n",
    "TIG\n",
    "\n",
    "**Explanation**: The characters 'S', 'r' and 'n' are at index positions 0, 2, and 4 respectively. Hence they are removed and the remaining characters 'tig' are capitalized giving us output 'TIG'.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 2**:\n",
    "\n",
    "abcd\n",
    "\n",
    "**Sample Output 2**: \n",
    "\n",
    "BD\n",
    "\n",
    "**Explanation**: Only the characters at the odd indices, 1 and 3, 'b' and 'd' are captitalized, concatenated and printed.\n",
    "\n",
    "=====================================================================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "exphFv9wNPOj",
    "outputId": "c4014bcd-36cb-456a-bcd9-3f1551f84064"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: abcd\n",
      "BD\n"
     ]
    }
   ],
   "source": [
    "#todo\n",
    "string = input(\"Enter a string: \")\n",
    "count = 1\n",
    "sum = \"\"\n",
    "for char in string:\n",
    "    code = ord(char)\n",
    "    if count % 2 == 0:\n",
    "        code = code - 32\n",
    "        upper = chr(code)\n",
    "        sum += str(upper)\n",
    "    count += 1\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "G1KGod9C87t_"
   },
   "source": [
    "### Task 9\n",
    "\n",
    "Write a python program that splits a given string on a given split character. The first input is a String and the second input is the character that will be used to split the first String. \n",
    "\n",
    "<font color='red'>[You cannot use the built-in split function for this task]</font>\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 1:**<br/>\n",
    "This-is-CSE110<br/>\n",
    "-<br/>\n",
    "\n",
    "**Sample Output 1:**<br/>\n",
    "This<br/>\n",
    "is<br/>\n",
    "CSE110\n",
    "\n",
    "**Explanation**: The second input which is the character '-', is used to split or divide the first input String 'This-is-CSE110' into 'This', 'is' and 'CSE110' which are printed individually in separate lines.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 2**:\\\n",
    "tom@gmail,harry@yahoo,bob@gmail,mary@gmail\n",
    "\n",
    ",\n",
    "\n",
    "**Sample Output 2**:\n",
    "\n",
    "tom@gmail\n",
    "\n",
    "harry@yahoo\n",
    "\n",
    "bob@gmail\n",
    "\n",
    "mary@gmail\n",
    "\n",
    "====================================================================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "CUBCWh7LHDbx",
    "outputId": "4f367d0e-97e6-4bb1-f061-d3097a3d19af"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: tom@gmail,harry@yahoo,bob@gmail,mary@gmail\n",
      "Enter a charecter: ,\n",
      "tom@gmail\n",
      "harry@yahoo\n",
      "bob@gmail\n",
      "mary@gmail\n"
     ]
    }
   ],
   "source": [
    "#todo\n",
    "string = input(\"Enter a string: \")\n",
    "char = input(\"Enter a charecter: \")\n",
    "sum = \"\"\n",
    "for i in string:\n",
    "    if i == char:\n",
    "        sum = sum + \"\\n\"\n",
    "    else:\n",
    "        sum = sum + i\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AWQJrJW3U1y3"
   },
   "source": [
    "### Task 10\n",
    "Given a string, create a new string with all the **consecutive duplicates removed**. \n",
    "\n",
    "**Hint:** You may make a new string to store the result. You can check whether the current character and the next character are the same, then add that character to the new string.\n",
    "\n",
    "**Note**: Only consecutive letters are removed not all duplicate occurences of a letter. You may try doing this alternative i.e. removing all duplicate letters from a given string, for your own practice.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 1**:\\\n",
    "AAABBBBCDDBBECE\n",
    "\n",
    "**Sample Output 1:**\\\n",
    "ABCDBECE\n",
    "\n",
    "**Explanation**: From the 3 consecutive \"A\"s, 2 are removed and we have 'A' only. Then from the 4 consecutive 'B's, 3 are removed and only one is added to the new string giving us \"AB\". Since we have only one 'C' next, it is added making the resulting string \"ABC\" now and so on.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 2**:\\\n",
    "Jupyter Notebook is better. Case sensitivity check AAaaaAaaAAAa.\n",
    "\n",
    "**Sample Output 2:**\\\n",
    "Jupyter Notebok is beter. Case sensitivity check AaAaAa.\n",
    "\n",
    "**Explanation**: Just the 2 consectutive 'o's and 't's are changed to one at first and the uppercase 'A' and lowercase 'a' are treated separately i.e. case sensitive when checking for consecutive duplicates.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Jgg1D8SNJ1L7",
    "outputId": "2e08a0ca-d6f4-4e14-96d1-c60e05152dd6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: aaaabbccccccddd\n",
      "abcd\n"
     ]
    }
   ],
   "source": [
    "#todo\n",
    "string= input('Enter a string: ')\n",
    "new_string = string[0]\n",
    "for i in string:\n",
    "  if i!= new_string[-1] :\n",
    "    new_string += i\n",
    "print(new_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7a_1pYjfU1zI"
   },
   "source": [
    "### Task 11\n",
    "\n",
    "Write a python program that takes 2 inputs from the user. The first input is a string and the second input is a letter. The program should remove all occurences of the letter from the given string and print the output. If the letter is not found in the string and the length of string is greater than 3, then remove the first letter and last letter of the given string and print it. Otherwise print the string as it is. You can assume that all the input will be in lowercase letter.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "\n",
    "**Sample Input 1**:\\\n",
    "tanjiro kamado\\\n",
    "a\n",
    "\n",
    "**Sample output 1**:\\\n",
    "tnjiro kmdo\n",
    "\n",
    "**Explanation**: All 3 instances of the character 'a' is removed from the input String 'tanjiro kamado' to give us output 'tnjiro kmdo'.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 2**:\\\n",
    "eren yeager\\\n",
    "k\n",
    "\n",
    "\n",
    "**Sample Output 2**:\\\n",
    "ren yeage\n",
    "\n",
    "**Explanation**: The character 'k' is absent in the first input String 'eren yeager' and it's length is 11 which is greater than 3 therefore the first character 'e' and the last character 'r' is removed. Hence, the final String is 'ren yeage'.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 3:**\\\n",
    "hi\\\n",
    "a\n",
    "\n",
    "**Sample Output 3:**\\\n",
    "hi\n",
    "\n",
    "**Explanation**: The letter 'a' is not found in our first input 'hi', the length of which is 2. Since the character is not present and the length is less than 3, we print the String 'hi' as it is.\n",
    "\n",
    "=====================================================================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word: eren yeager\n",
      "Enter a letter: k\n",
      "ren yeage\n"
     ]
    }
   ],
   "source": [
    "#todo\n",
    "word = input(\"Enter a word: \")\n",
    "letter = input(\"Enter a letter: \")\n",
    "output = \"\"\n",
    "\n",
    "if len(word)>3 and letter not in word:\n",
    "    word = word[1:-1]\n",
    "    print(word)\n",
    "    \n",
    "else:\n",
    "    for i in word:\n",
    "        if i != letter:\n",
    "            output += i\n",
    "        else:\n",
    "            output = output\n",
    "        \n",
    "    print(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "leVtdAsdymXM"
   },
   "source": [
    "### Task 12\n",
    "\n",
    "Write a Python program that will take one input from the user made up of two strings separated by a comma and a space (see samples below). Then create a mixed string with alternative characters from each string. Any leftover chars will be appended at the end of the resulting string.\n",
    "\n",
    "*Hint: For adding the leftover characters you may use string slicing.*\n",
    "\n",
    "**Note:** Please do not use lists for this task.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 1:**\\\n",
    "ABCD, efgh\n",
    "\n",
    "**Sample Output 1:**\\\n",
    "AeBfCgDh\n",
    "\n",
    "**Explanation**: At first, the two strings divided by \", \" should be separated. Then the first character of the first string 'A' is concatenated with the first character of the second string 'e' which in turn is concatenated to the second character of the first string 'B', the second character of the second string f and so on since the strings are of equal length.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 2:**\\\n",
    "ABCDENDFGH, ijkl\n",
    "\n",
    "**Sample Output 2:**\\\n",
    "AiBjCkDlENDFGH\n",
    "\n",
    "**Explanation**: Here, since the length of the first string is greater than the length of the second string, after separation, the characters are concatenated alternatively as in sample input/output 1, till the length of the second string i.e. ijkl. Since, there are no more characters in the second string after that, the remaining characters if the first string i.e. ENDFGH in this case are concatenated at the end of the final string.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 3:**\\\n",
    "ijkl, ABCDENDFGH\n",
    "\n",
    "**Sample Output 3:**\\\n",
    "iAjBkClDENDFGH\n",
    "\n",
    "**Explanation**: This time, the length of the second string is greater than the length of the first string therefore the first letters of the 2 strings 'i' and 'A', then the second letters 'j' and 'B' and so on are being concatenated until there are no more letters in the first shorter string following which the remaining letters i.e. ENDFGH again in this case too (this may be different for other different string inputs) are added at the end giving us the resulting output string.\n",
    "\n",
    "=====================================================================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 270
    },
    "id": "kC1cq47myny6",
    "outputId": "47d284a4-3f2b-413e-a6a0-7fc29b639bf0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: ABCDEFGH\n",
      "Enter a string: abcd\n",
      "AaBbCcDdEFGH\n"
     ]
    }
   ],
   "source": [
    "#todo\n",
    "var1 = input('Enter a string: ')\n",
    "var2 = input('Enter a string: ')\n",
    "\n",
    "if len(var1) == len(var2):\n",
    "  for i in range(len(var1)):\n",
    "    print(var1[i]+var2[i], end=\"\")\n",
    "    \n",
    "elif len(var1) > len(var2):\n",
    "  for i in range(len(var2)):\n",
    "    print(var1[i] + var2[i] ,end=\"\")\n",
    "  print(var1[len(var2):])\n",
    "\n",
    "else:\n",
    "  for i in range(len(var1)):\n",
    "    print(var1[i] + var2[i], end=\"\")\n",
    "  print(var2[len(var1):])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WZXnxHTdGrMC"
   },
   "source": [
    "## Optional Tasks (13 - 15) [Ungraded]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lPoDvm8YU1y9"
   },
   "source": [
    "### Task 13\n",
    "\n",
    "Suppose you are given two strings, s1, and s2. Now, print a new string made up of the last characters and then the first characters of the input strings.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 1**:\n",
    "\n",
    "s1 = new\n",
    "\n",
    "s2= string\n",
    "\n",
    "**Sample Output 1**:\n",
    "\n",
    "gwsn\n",
    "\n",
    "**Explanation:** The last character of the String s2 is 'g'. The last character of the String s1 is 'w'. The first character of the String s2 is 's'. The first character of the String s1 is 'n'. Together they give us the ouput we want 'gwsn'.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 2**:\n",
    "\n",
    "s1 = abcd\n",
    "\n",
    "s2= efgh\n",
    "\n",
    "**Sample Output 2**: \n",
    "\n",
    "hdea\n",
    "\n",
    "**Explanation:** The last characters of the Strings s2 and s1 is 'h' and 'd' respectively while the first characters of the Strings is 'e' and 'a' respectively. Together they give us the ouput we want 'gwsn'.\n",
    "\n",
    "=====================================================================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "id": "oMHccx2MGkbh"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: new\n",
      "Enter a string: string\n",
      "gwsn\n"
     ]
    }
   ],
   "source": [
    "#todo\n",
    "s1 = input('Enter a string: ')\n",
    "s2 = input('Enter a string: ')\n",
    "\n",
    "out = s2[-1:] + s1[-1:] + s2[0] + s1[0]\n",
    "\n",
    "print(out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AWgZaBZCzmaM"
   },
   "source": [
    "### Task 14\n",
    "\n",
    "Write a python program that takes two inputs. The first input is a string and the second input is a number. If the number is even then concatenate the given string two times the given number and if the number is odd then concatenate the given string three times the given number.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 1**:\n",
    "\n",
    "CSE110\n",
    "\n",
    "4\n",
    "\n",
    "**Sample output 1**:\n",
    "\n",
    "CSE110CSE110CSE110CSE110CSE110CSE110CSE110CSE110\n",
    "\n",
    "**Explanation**: The second input which is the number 4 is even, therefore the first string input 'CSE110' is concatenated(joined together) 4*2 = 8 times.\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 2**:\n",
    "\n",
    "CSE110\n",
    "\n",
    "3\n",
    "\n",
    "**Sample Output 2**:\n",
    "\n",
    "CSE110CSE110CSE110CSE110CSE110CSE110CSE110CSE110CSE110\n",
    "\n",
    "=====================================================================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "id": "yvIHAACBGy1p"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: CSE110\n",
      "Enter a number: 3\n",
      "CSE110CSE110CSE110CSE110CSE110CSE110CSE110CSE110CSE110"
     ]
    }
   ],
   "source": [
    "#todo\n",
    "string = input('Enter a string: ')\n",
    "num = int(input('Enter a number: '))\n",
    "\n",
    "if num % 2 == 0:\n",
    "    for i in range(num*2):\n",
    "        print(string,end=\"\")\n",
    "        \n",
    "else:\n",
    "    for i in range(num*3):\n",
    "        print(string,end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nwRZ3_0tC3fq"
   },
   "source": [
    "### Task 15\n",
    "\n",
    "Write a python program that takes a string as an input from the user and then modifies the string in such a way that the string always starts with an uppercase letter and the case of each subsequent letter is the opposite of the previous letter (uppercase character followed by a lowercase character followed by an uppercase character and so on).  Finally the modified string is printed to show the user.\n",
    "\n",
    "*Hint:  Flags/counters can be used to manage uppercase-lowercase.*\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 1:**\\\n",
    "Python programming is very easy\n",
    "\n",
    "**Sample Output 1:**\\\n",
    "PyThOn PrOgRaMmInG iS vErY eAsY\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 2:**\\\n",
    "I&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;     love       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Python &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Programming\n",
    "\n",
    "**Sample Output 2:**\\\n",
    "I&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;     lOvE       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;pYtHoN&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;pRoGrAmMiNg\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 3:**\\\n",
    "CSE110 Course\n",
    "\n",
    "**Sample Output 3**\\\n",
    "CsE110 cOuRsE\n",
    "\n",
    "\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Sample Input 4:**\\\n",
    "c\n",
    "\n",
    "**Sample Output 4:**\\\n",
    "C\n",
    "\n",
    "=====================================================================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I       love         Python         Programming\n",
      "I       lOvE         pYtHoN         pRoGrAmMiNg\n"
     ]
    }
   ],
   "source": [
    "#todo\n",
    "var = input('')\n",
    "out = \"\"\n",
    "count = 0\n",
    "\n",
    "for i in var:\n",
    "    if ord(i) >= ord('a') and ord(i)  <= ord('z'):\n",
    "        if count % 2 == 0:\n",
    "            code=ord(i)\n",
    "            code = code -32\n",
    "            char = chr(code)\n",
    "            out += char\n",
    "\n",
    "        else:\n",
    "            out += i\n",
    "        \n",
    "        count += 1\n",
    "\n",
    "            \n",
    "    elif ord(i)  >= ord('A') and ord(i)  <= ord('Z'):\n",
    "        if count % 2 == 0:\n",
    "            out += i\n",
    "\n",
    "        else:\n",
    "            code=ord(i)\n",
    "            code = code +32\n",
    "            char = chr(code)\n",
    "            out += char\n",
    "            \n",
    "        count += 1\n",
    "            \n",
    "    else:\n",
    "        out += i\n",
    "\n",
    "print(out)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "MD.Shafiur Rahman_21201613_38_CSE110_Lab_Assignment_3.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}