Assignment_4_(Strings).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyO6EIPOiJz3FG5qYKt/gv8f",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/azaynul10/Assignments-Of-Programming-Language-1/blob/main/Assignment_4_(Strings).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 1\n",
        "\n",
        "\n",
        "Write a Python program that takes a String as an input from the user and prints that String in reverse order. You cannot use the built-in reverse() function for this task.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "CSE110\n",
        "\n",
        "Sample Output 1:\n",
        "\n",
        "011ESC\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "Python\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "nohtyP\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 3:\n",
        "\n",
        "1576527\n",
        "\n",
        "Sample Output 3:\n",
        "\n",
        "7256751\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "oTFitNgPRD8-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "7__krcev8f5L"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vFB6xoKj5lu5",
        "outputId": "5ff1d9c9-e24c-4e9f-9ff7-6e4c2031dd3b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a string: 1576527\n",
            "7256751\n"
          ]
        }
      ],
      "source": [
        "#Task1\n",
        "str1=input(\"Enter a string: \")\n",
        "print(str1[::-1])"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 2\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",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "72418\n",
        "\n",
        "4\n",
        "Sample Output 1:\n",
        "\n",
        "81427\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",
        "---\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",
        "\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"
      ],
      "metadata": {
        "id": "-oDBZdroR5zW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task2\n",
        "string=input(\"Enter a string: \")\n",
        "n=int(input(\"Enter a string: \"))\n",
        "print(string[n : : -1] + string [n+1 : : ])"
      ],
      "metadata": {
        "id": "lv3ShYfE7wnH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "88785c03-6027-4acc-abfa-f168daf5237c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a string: aBcd1234defg\n",
            "Enter a string: 5\n",
            "21dcBa34defg\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "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",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "01101101101\n",
        "\n",
        "Sample Output 1:\n",
        "\n",
        "Binary Number\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "12344ab0\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "Not a Binary Number\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 3:\n",
        "\n",
        "10127490111\n",
        "\n",
        "Sample Output 3:\n",
        "\n",
        "Not a Binary Number\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 4:\n",
        "\n",
        "Binary Number\n",
        "\n",
        "Sample Output 4:\n",
        "\n",
        "Not a Binary Number\n",
        "\n"
      ],
      "metadata": {
        "id": "Z647OGu_SnZq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task3\n",
        "str1=input(\"Enter a string: \")\n",
        "count=0\n",
        "for i in range(0,len(str1)):\n",
        "  if str1[i]=='0' or str1[i]=='1':\n",
        "    count+=1\n",
        "if count==len(str1):\n",
        "  print(\"Binary Number\")\n",
        "else:\n",
        "  print(\"Not a Binary Number\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w5HOER5zKyQs",
        "outputId": "2c04591b-fa74-40f1-b46e-ac3337aa4d8f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a string: BInary Number\n",
            "Not a Binary Number\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 4\n",
        "\n",
        "\n",
        "Write a Python program that will ask the user to enter a word as an input.\n",
        "If the length of the input string is less than 4, then your program should\n",
        "\n",
        "* If the length of the input string is less than 4, then your program should\n",
        "  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",
        "\n",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "strong\n",
        "Sample Output 1:\n",
        "\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",
        "\n",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "stronger\n",
        "\n",
        "Sample Output 2:\n",
        "\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",
        "\n",
        "\n",
        "\n",
        "Sample Input 3:\n",
        "\n",
        "strongest\n",
        "\n",
        "Sample Output 3:\n",
        "\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",
        "\n",
        "\n",
        "Sample Input 4:\n",
        "\n",
        "abc\n",
        "\n",
        "Sample Output 4:\n",
        "\n",
        "abc\n",
        "\n",
        "Explanation: Since length of input string is less than 4, the given input is printed as output.\n",
        "\n",
        "Sample Input 5:\n",
        "ber\n",
        "Sample Output 5:\n",
        "best\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"
      ],
      "metadata": {
        "id": "PpQ1EGd2TbWK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task4\n",
        "str1=input(\"Enter a string: \")\n",
        "if str1[-2:]==\"er\":\n",
        "  print(str1[:-2:]+\"est\")\n",
        "elif str1[-3::]==\"est\":\n",
        "  print(str1)\n",
        "elif len(str1)<4:\n",
        "  print(str1)\n",
        "elif len(str1)>3:\n",
        "  print(str1+\"er\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BAYIGxvTIbh5",
        "outputId": "9392c3e6-c1a0-4561-9f0b-0a27c61cf643"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a string: ber\n",
            "best\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Task 5\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",
        "\n",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "BANGLA\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Output 1:\n",
        "\n",
        "B\n",
        "\n",
        "BA\n",
        "\n",
        "BAN\n",
        "\n",
        "BANG\n",
        "\n",
        "BANGL\n",
        "\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",
        "\n",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "DREAM\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "D\n",
        "\n",
        "DR\n",
        "\n",
        "DRE\n",
        "\n",
        "DREA\n",
        "\n",
        "DREAM\n",
        "\n",
        "Explanation: Simply, no of lines = length of the input string and no of letters in each line = line number.\n"
      ],
      "metadata": {
        "id": "uGKc_eIc8f7W"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task5\n",
        "str1=input(\"Enter a string: \")\n",
        "for i in range(len(str1)):\n",
        "  for j in range(i+1):\n",
        "    print(str1[j],end=\"\")\n",
        "  print()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m4eKD9PIVtfu",
        "outputId": "113a868e-6ea1-4455-beee-ffca91d5f221"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a string: DREAM\n",
            "D\n",
            "DR\n",
            "DRE\n",
            "DREA\n",
            "DREAM\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Task 6\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",
        "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",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "Programming\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Output 1:\n",
        "\n",
        "P : 80\n",
        "\n",
        "r : 114\n",
        "\n",
        "o : 111\n",
        "\n",
        "g : 103\n",
        "\n",
        "r : 114\n",
        "\n",
        "a : 97\n",
        "\n",
        "m : 109\n",
        "\n",
        "m : 109\n",
        "\n",
        "i : 105\n",
        "\n",
        "n : 110\n",
        "\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",
        "\n",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "hunger\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "h : 104\n",
        "\n",
        "u : 117\n",
        "\n",
        "n : 110\n",
        "\n",
        "g : 103\n",
        "\n",
        "e : 101\n",
        "\n",
        "r : 114\n",
        "\n",
        "Explanation: Same as previous.\n",
        "\n"
      ],
      "metadata": {
        "id": "CIAkdlVoA-S5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task6\n",
        "str1=input(\"Enter a string: \")\n",
        "for i in range(len(str1)):\n",
        "  print(str1[i],ord(str1[i]),sep=\" : \")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nVicT4Gkkefs",
        "outputId": "3b158a05-c508-45e8-c5d7-1c86a926e6d1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a string: hunger\n",
            "h : 104\n",
            "u : 117\n",
            "n : 110\n",
            "g : 103\n",
            "e : 101\n",
            "r : 114\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 7\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",
        "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",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "abcd\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Output 1:\n",
        "\n",
        "bcde\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "the cow\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "uif!dpx\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 3: [Must fulfil this criteria]\n",
        "\n",
        "xyzabc\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Output 3:\n",
        "\n",
        "yzabcd\n"
      ],
      "metadata": {
        "id": "y_cmXquMBpAv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task7\n",
        "str1=input(\"Enter a string: \")\n",
        "for i in range(len(str1)):\n",
        "  if str1[i]!='z':\n",
        "    print(chr(ord(str1[i])+1),end=\"\")\n",
        "  else:\n",
        "    print('a',end=\"\")"
      ],
      "metadata": {
        "id": "LnLp0H8Xoek8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ed3d2fb2-3ab3-4f71-ec2d-d6bedbe05718"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a string: xyzabc\n",
            "yzabcd"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 8\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",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "String\n",
        "\n",
        "\n",
        "Sample Output 1:\n",
        "TIG\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",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "abcd\n",
        "Sample Output 2:\n",
        "\n",
        "BD\n",
        "\n",
        "Explanation: Only the characters at the odd indices, 1 and 3, 'b' and 'd' are capitalized, concatenated and printed.\n",
        "\n"
      ],
      "metadata": {
        "id": "yCN2NVrU31_z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task8\n",
        "str1=input(\"Enter a string: \")\n",
        "for i in range(len(str1)):\n",
        "  if i%2!=0:\n",
        "    print(chr(ord(str1[i])-32),end=\"\")\n",
        "  else:\n",
        "    pass"
      ],
      "metadata": {
        "id": "QiOrXSs6VNNn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "08a9b39e-42df-4433-a1a2-5061191c5521"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a string: string\n",
            "TIG"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 9\n",
        "\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 occurrences 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",
        "---\n",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "AAABBBBCDDBBECE\n",
        "\n",
        "Sample Output 1:\n",
        "\n",
        "ABCDBECE\n",
        "\n",
        "Explanation: From the 3 consecutive \"A\"s, 2 are removed and we have 'A' only. Then from the 4 consecutives '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",
        "---\n",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "Jupyter Notebook is better. Case sensitivity check AAaaaAaaAAAa.\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "Jupyter Notebok is beter. Case sensitivity check AaAaAa.\n",
        "\n",
        "Explanation: Just the 2 consecutive '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"
      ],
      "metadata": {
        "id": "4fVaqdUv4fU_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task9\n",
        "string = \"Jupyter Notebook is better. Case sensitivity check AAaaaAaaAAAa\"\n",
        "output=string[0]\n",
        "for i in range(len(string)):\n",
        "  if output[-1]!=string[i]:\n",
        "    output+=string[i]\n",
        "  else:\n",
        "    pass\n",
        "print(output)"
      ],
      "metadata": {
        "id": "uV7T9bOnKjtA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2ad74a3f-2c7d-4446-ac59-f0566c01d0be"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Jupyter Notebok is beter. Case sensitivity check AaAaAa\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 10\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. [ Do not use lists for this task]\n",
        "\n",
        "\n",
        "Hint: For adding the leftover characters you may use string slicing.\n",
        "\n",
        "\n",
        "---\n",
        "Sample Input 1:\n",
        "ABCD, efgh\n",
        "Sample Output 1:\n",
        "AeBfCgDh\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",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "ABCDENDFGH, ijkl\n",
        "\n",
        "Sample Output 2:\n",
        "\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 of the first string i.e., ENDFGH in this case are concatenated at the end of the final string.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 3:\n",
        "\n",
        "ijkl, ABCDENDFGH\n",
        "\n",
        "Sample Output 3:\n",
        "\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"
      ],
      "metadata": {
        "id": "J6WMdqxq43DL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task10\n",
        "string = input(\"Enter a string: \")\n",
        "output=\"\"\n",
        "out=\"\"\n",
        "for i in range(len(string)):\n",
        "  if string[i]==\",\":\n",
        "    n=string[0:i]\n",
        "    m=string[i+2:len(string)]\n",
        "  else:\n",
        "    pass\n",
        "if len(n)<len(m):\n",
        "  for i in range(len(n)):\n",
        "    out=out+n[i]+m[i]\n",
        "  output=out+m[i::]\n",
        "else:\n",
        "  for i in range(len(m)):\n",
        "    out=out+n[i]+m[i]\n",
        "  output=out+n[i::]\n",
        "print(output)\n",
        "\n"
      ],
      "metadata": {
        "id": "VD8kqn5R_RIY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "09599b9a-ee88-4f2b-f688-5838f2b600a7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a string: ijkl, ABCDENDFGH\n",
            "iAjBkClDDENDFGH\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Optional Tasks (16-19) [Ungraded]\n",
        "\n",
        "These tasks are just for practice. No marks will be deducted for not completing them and no extra marks will be given for solving them. Just try and practice these advanced problems.\n",
        "\n",
        "\n",
        "# Task 16\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",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "tanjiro kamado\n",
        "\n",
        "a\n",
        "\n",
        "Sample output 1:\n",
        "\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",
        "---\n",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "eren yeager\n",
        "\n",
        "k\n",
        "\n",
        "Sample Output 2:\n",
        "\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",
        "---\n",
        "\n",
        "\n",
        "Sample Input 3:\n",
        "\n",
        "hi\n",
        "\n",
        "a\n",
        "\n",
        "Sample Output 3:\n",
        "\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"
      ],
      "metadata": {
        "id": "ZcB_Pffp6Znj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task16\n",
        "string=input(\"Enter a string: \")\n",
        "letter=input(\"Enter a letter: \")\n",
        "signal=None\n",
        "if letter in string:\n",
        "  signal=1\n",
        "elif letter not in string and len(string)>3:\n",
        "  signal=2\n",
        "else:\n",
        "  signal=3\n",
        "if signal==1:\n",
        "  for i in string:\n",
        "    if letter!=i:\n",
        "      print(i,end=\"\")\n",
        "elif signal==2:\n",
        "  print(string[1:len(string)-1:])\n",
        "else:\n",
        "  print(string)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vHo6DQrn1syO",
        "outputId": "3bfcaf05-8004-4bf0-ce5d-d5d9538e6cd8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a string: hi\n",
            "Enter a letter: a\n",
            "hi\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 17\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",
        "[You cannot use the built-in split() function for this task]\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "This-is-CSE110\n",
        "-\n",
        "\n",
        "Sample Output 1:\n",
        "\n",
        "This\n",
        "\n",
        "is\n",
        "\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",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\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"
      ],
      "metadata": {
        "id": "HhcHC2su7Ayx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task17\n",
        "str1=input(\"Enter a string: \")\n",
        "str2=input(\"Enter a string: \")\n",
        "c=\"\"\n",
        "str1=str1+str2\n",
        "for i in str1:\n",
        "  if i==str2:\n",
        "    print(c)\n",
        "    c=\"\"\n",
        "  else:\n",
        "    c+=i"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "30s_2e7To-1X",
        "outputId": "96c7eb16-3210-4f6a-cc62-497610854869"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a string: tom@gmail,harry@yahoo,bob@gmail,mary@gmail\n",
            "Enter a string: ,\n",
            "tom@gmail\n",
            "harry@yahoo\n",
            "bob@gmail\n",
            "mary@gmail\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 18\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",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "CSE110\n",
        "\n",
        "4\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",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "CSE110\n",
        "\n",
        "3\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "CSE110CSE110CSE110CSE110CSE110CSE110CSE110CSE110CSE110\n",
        "\n"
      ],
      "metadata": {
        "id": "DqMfjIcO7Z0K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task18\n",
        "string=input(\"Enter a string: \")\n",
        "number=int(input(\"Enter a string: \"))\n",
        "if number%2==0:\n",
        "   for i in range(number*2):\n",
        "     print(string,end=\"\")\n",
        "else:\n",
        "  for i in range(number*3):\n",
        "     print(string,end=\"\")"
      ],
      "metadata": {
        "id": "OWT8kSmd-IUv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "07c956a1-6de2-4cc6-9535-fff255ffe3fa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a string: CSE110\n",
            "Enter a string: 3\n",
            "CSE110CSE110CSE110CSE110CSE110CSE110CSE110CSE110CSE110"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Task 19\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",
        "Hint: Flags/counters can be used to manage uppercase-lowercase.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "Python programming is very easy\n",
        "\n",
        "Sample Output 1:\n",
        "\n",
        "PyThOn PrOgRaMmInG iS vErY eAsY\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "I       love         Python         Programming\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "I       lOvE        pYtHoN        pRoGrAmMiNg\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 3:\n",
        "\n",
        "CSE110 Course\n",
        "\n",
        "Sample Output 3\n",
        "\n",
        "CsE110 cOuRsE\n",
        "\n",
        "Sample Input 4:\n",
        "\n",
        "c\n",
        "\n",
        "Sample Output 4:\n",
        "\n",
        "C\n"
      ],
      "metadata": {
        "id": "uMAjgCCy7s3N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task19\n",
        "str1=input(\"Enter a string: \")\n",
        "str2=\"\"\n",
        "count=0\n",
        "for i in str1:\n",
        "  ascii_num=ord(i)\n",
        "  if 97<=ascii_num<=122 or 65<=ascii_num<=90:\n",
        "    if count==0:\n",
        "      if 65<=ascii_num<=90:\n",
        "        str2+=i\n",
        "      else:\n",
        "        str2+=chr(ascii_num-32)\n",
        "      count=1\n",
        "    else:\n",
        "        if 97<=ascii_num<=122:\n",
        "          str2+=i\n",
        "        else:\n",
        "          str2+=chr(ascii_num+32)\n",
        "        count=0\n",
        "  else:\n",
        "    str2+=i\n",
        "print(str2)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XfqC1oR4cAsY",
        "outputId": "a11ea5e7-f6db-48e7-c1a3-e47c39007991"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a string: Python programming is very easy\n",
            "PyThOn PrOgRaMmInG iS vErY eAsY\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Book:\n",
        "\n",
        "    def __init__(self, title, author, num_pages, ISBN, publisher):\n",
        "        self.title = title\n",
        "        self.author = author\n",
        "        self._num_pages = num_pages\n",
        "        self._ISBN = ISBN\n",
        "        self._publisher = publisher"
      ],
      "metadata": {
        "id": "aH16ADNDdJP1"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}