solution1_n_2_bbi_coding_challenge.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "solution1_n_2_bbi_coding_challenge.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyNjmLHmc/ChELxBeoL0y3i6",
      "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/HARSHIT097/Learnings/blob/main/solution1_n_2_bbi_coding_challenge.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7ZXNQM0B5R2O"
      },
      "source": [
        "Solution Submitted by\n",
        "\n",
        "HARSHIT KUMAR SINGH\n",
        "harshitsingh097@gmail.com\n",
        "7800333757\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QfUHQCJK5Sxg"
      },
      "source": [
        "# Question 1 – Replace Vowels with a digit"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2sUZDai55XOF"
      },
      "source": [
        "Question:\n",
        "\n",
        "Replace all the vowels of the given input string with a single digit number.\n",
        "\n",
        "Input:\n",
        "\n",
        "String of length L and all lower-case letters.\n",
        "\n",
        "Output:\n",
        "\n",
        "Input String replaced with the digit.\n",
        "\n",
        "Program explanation:\n",
        "Replace all the vowels in the given input string with a single digit number you get after all the below\n",
        "steps.\n",
        "\n",
        "Step 1: Get the index of the vowel in the given input.\n",
        "\n",
        "Step 2: Multiply the index with 100.\n",
        "\n",
        "Step 3: Sum all the prime numbers between 1 and the resulting number from last step.\n",
        "\n",
        "Step 4: Add the digits of the number you get from the last step until you get a single digit.\n",
        "\n",
        "Step 5: Now, Replace the vowel with the digit from the last step.\n",
        "\n",
        "Question 1 – Replace Vowels with a digit\n",
        "Blackbuck Insights Private Limited Confidential and Proprietary\n",
        "P a g e | 2\n",
        "\n",
        "Example 1:\n",
        "Input:\n",
        "hello\n",
        "\n",
        "Output:\n",
        "h7ll9\n",
        "\n",
        "Explanation:\n",
        "\n",
        "Step 1: First vowel found at index 1.\n",
        "\n",
        "Step 2: 1 * 100 = 100\n",
        "\n",
        "Step 3: Sum of prime numbers between 1 and 100 is 1060\n",
        "\n",
        "Step 4: Sum of each digit until we get single digit:\n",
        "= 1 + 0 + 6 + 0\n",
        "= 7\n",
        "\n",
        "Step 5: Replace e with 7\n",
        "\n",
        "Output now: h7llo\n",
        "\n",
        "Step 1: Next vowel found at index 4.\n",
        "\n",
        "Step 2: 4 * 100 = 400\n",
        "\n",
        "Step 3: Sum of prime numbers between 1 and 400 is 13887\n",
        "\n",
        "Step 4: Sum of each digit until we get single digit:\n",
        "= 1 + 3 + 8 + 8 + 7\n",
        "= 27\n",
        "= 2 + 7\n",
        "= 9\n",
        "\n",
        "Step 5: Replace o with 9\n",
        "Final output: h7ll9"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "TLPO_oqUxyOW",
        "outputId": "14ea195c-11e7-4206-e66a-09470a602113"
      },
      "source": [
        "def get_prime(num):\n",
        "  #initializing  with min sum of rime number\n",
        "  sum=2\n",
        "  for num in range(2,num+1):\n",
        "    i=2\n",
        "    for i in range(2,num):\n",
        "      if(int(num%i==0)):\n",
        "            i=num\n",
        "            break;\n",
        "        #when the number is prime calculate sum\n",
        "    if i is not num:\n",
        "        sum+=num\n",
        "  #print(\"Sum of all prime numbers 1 to \",num,\":\",sum)\n",
        "  return sum\n",
        "  \n",
        "\n",
        "def digSum( n):\n",
        "    sum = 0\n",
        "     \n",
        "    while(n > 0 or sum > 9):\n",
        "     \n",
        "        if(n == 0):\n",
        "            n = sum\n",
        "            sum = 0\n",
        "         \n",
        "        sum += n % 10\n",
        "        n //= 10\n",
        "     \n",
        "    return sum\n",
        "def find_digi(input_str):\n",
        "  \n",
        "  vowels = \"aeiou\"\n",
        "\n",
        "  new_str = []\n",
        "  print(\"Entered Input String :\", input_str)\n",
        "  str_list = list(input_str)\n",
        "  #print(str_list)\n",
        "  print(\"Applied results on string one by one\")\n",
        "  print(\"###############################\")\n",
        "  #index = 0\n",
        "  for index, letter in enumerate(input_str):\n",
        "  \n",
        "    for letter2 in vowels:\n",
        "    \n",
        "      if (letter == letter2):\n",
        "        #find index - Step_1\n",
        "        \n",
        "        print(\"Vowel identified at index {} and recognized vowel {}\".format(index, letter))\n",
        "        if index == 0:\n",
        "            sum_prime  = 0\n",
        "            \n",
        "        else:\n",
        "            #find num - Step_2\n",
        "            new_num = index * 100\n",
        "            #print(\"number:\",new_num)\n",
        "            \n",
        "            #get sum of all prime number and the sum of digit\n",
        "            sum_prime = get_prime(new_num)\n",
        "            print(\"sum of prime number between {} and {}\".format(str(1),str(new_num)))\n",
        "            print(\"Sum_Prime_number:\",sum_prime)\n",
        "            \n",
        "        \n",
        "        digit = digSum(sum_prime)\n",
        "        print(\"Sum of digit of Prime Number Obtained:\",digit)\n",
        "        \n",
        "        \n",
        "        print(\"{} going to replaced by {}\".format(letter,digit))\n",
        "        print(\"#########################\")\n",
        "        \n",
        "        new_str = input_str.replace(letter,str(digit))\n",
        "        input_str = new_str\n",
        "        \n",
        "  print(\"Modified String\",new_str)\n",
        "\n",
        "  return (digit,letter)\n",
        "\n",
        "\n",
        "if __name__ == '__main__':\n",
        "  #input_str = input(\"Enter the sentence:\")\n",
        "  input_str = \"hello\"\n",
        "  find_digi(input_str)\n",
        "  #input_str=\"umberella\"\n",
        "  #find_digi(input_str)\n"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Entered Input String : hello\n",
            "Applied results on string one by one\n",
            "###############################\n",
            "Vowel identified at index 1 and recognized vowel e\n",
            "sum of prime number between 1 and 100\n",
            "Sum_Prime_number: 1060\n",
            "Sum of digit of Prime Number Obtained: 7\n",
            "e going to replaced by 7\n",
            "#########################\n",
            "Vowel identified at index 4 and recognized vowel o\n",
            "sum of prime number between 1 and 400\n",
            "Sum_Prime_number: 13887\n",
            "Sum of digit of Prime Number Obtained: 9\n",
            "o going to replaced by 9\n",
            "#########################\n",
            "Modified String h7ll9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rJdFS5xb6OR_"
      },
      "source": [
        "# Question 2 – Minimum Swaps to Symmetric String"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bZeo0iMv6VX2"
      },
      "source": [
        "Question:\n",
        "\n",
        "Given a lowercase alphabet string s, find the minimum number of swaps required to make it a\n",
        "symmetry string. If it's not possible, then return -1.\n",
        "\n",
        "Constraints:\n",
        "n ≤ 1,000 where n is length of s.\n",
        "\n",
        "Example 1\n",
        "Input\n",
        "s = \"aabb\"\n",
        "\n",
        "Output\n",
        "2\n",
        "\n",
        "Explanation\n",
        " We can swap the middle \"a\" and \"b\" and then swap the first two \"a\" and \"b\" to get\n",
        "\n",
        "\"baab\".\n",
        "\n",
        "Example 2\n",
        "\n",
        "Input\n",
        "s = \"aab\"\n",
        "\n",
        "Output\n",
        "1\n",
        "Explanation\n",
        "We can swap the middle \"a\" and \"b\" to get \"aba\".\n",
        "\n",
        "Example 3\n",
        "\n",
        "Input\n",
        "s = \"abca\"\n",
        "\n",
        "Output\n",
        "-1\n",
        "\n",
        "Explanation\n",
        "No Possibilities."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "000Bk2jGwNpD",
        "outputId": "97adeac1-e999-4646-9aa5-2bb7a8676238"
      },
      "source": [
        "def CountSwap(input_str, len_str):\n",
        "    #coversion to list for indexing\n",
        "    s = list(input_str)\n",
        "    n = len_str\n",
        "    print(\"length of string\",len_str)\n",
        "    print(s)\n",
        "    # Intializing Counter to count minimum swap\n",
        "    count = 0\n",
        "    ans = True\n",
        " \n",
        "    # A loop which run in half string\n",
        "    # from starting\n",
        "    for i in range(n // 2):\n",
        " \n",
        "        # Left pointer\n",
        "        left = i\n",
        " \n",
        "        # Right pointer\n",
        "        right = n - left - 1\n",
        " \n",
        "        # A loop which run from right pointer\n",
        "        # to left pointer\n",
        "        while left < right:\n",
        " \n",
        "            # if both char same then\n",
        "            # break the loop if not\n",
        "            # same then we have to move\n",
        "            # right pointer to one step left\n",
        "            if s[left] == s[right]:\n",
        "                print(\"String found equal\",count)\n",
        "                break\n",
        "            else:\n",
        "                right -= 1\n",
        " \n",
        "        # it denotes both pointer at\n",
        "        # same position and we don't\n",
        "        # have sufficient char to make\n",
        "        # palindrome string\n",
        "        if left == right:\n",
        "            ans = False\n",
        "            print(\"symmetry found total count\", count)\n",
        "            break\n",
        "        else:\n",
        "            for j in range(right, n - left - 1):\n",
        "                (s[j], s[j + 1]) = (s[j + 1], s[j])\n",
        "                print(count)\n",
        "                print(\"\")\n",
        "                count += 1\n",
        "    if ans:\n",
        "        return (count)\n",
        "    else:\n",
        "        print(\"No possible swaps\")\n",
        "        return -1\n",
        "\n",
        "if __name__ == '__main__':\n",
        "  input_str = input(\"Enter the sentence:\")\n",
        "  input_str = input_str.lower()\n",
        "  print(\"Entered string for evaluation:\", input_str)\n",
        "  #input_str = \"aabbaa\"\n",
        "  len_str = len(input_str)\n",
        "  print(\"####################\")\n",
        "  \n",
        "  CountSwap(input_str, len_str)\n",
        "    # Function calling\n",
        "  ans1 = CountSwap(input_str, len_str)\n",
        "  print(\"forward\",ans1)\n",
        "  print(\"####################\")\n",
        "  ans2 = CountSwap(input_str[::-1], len_str)\n",
        "  print(\"backward\",ans2)\n",
        "  print(\"####################\")\n",
        "  print(\"Possible number of swaps:\",max(ans1, ans2))\n",
        "  print(\"####################\")\n",
        "  print(\" -1 indicates no possible swaps\")\n",
        "  print(\"####################\")"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the sentence:aba\n",
            "Entered string for evaluation: aba\n",
            "####################\n",
            "length of string 3\n",
            "['a', 'b', 'a']\n",
            "String found equal 0\n",
            "length of string 3\n",
            "['a', 'b', 'a']\n",
            "String found equal 0\n",
            "forward 0\n",
            "####################\n",
            "length of string 3\n",
            "['a', 'b', 'a']\n",
            "String found equal 0\n",
            "backward 0\n",
            "####################\n",
            "Possible number of swaps: 0\n",
            "####################\n",
            " -1 indicates no possible swaps\n",
            "####################\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "7oMeM8hTwm2_",
        "outputId": "cfca9265-091e-430c-9473-cc3003923edc"
      },
      "source": [
        "if __name__ == '__main__':\n",
        "  input_str = input(\"Enter the sentence:\")\n",
        "  input_str = input_str.lower()\n",
        "  print(\"Entered string for evaluation:\", input_str)\n",
        "  #input_str = \"aabbaa\"\n",
        "  len_str = len(input_str)\n",
        "  print(\"####################\")\n",
        "  \n",
        "  CountSwap(input_str, len_str)\n",
        "    # Function calling\n",
        "  ans1 = CountSwap(input_str, len_str)\n",
        "  print(\"forward\",ans1)\n",
        "  print(\"####################\")\n",
        "  ans2 = CountSwap(input_str[::-1], len_str)\n",
        "  print(\"backward\",ans2)\n",
        "  print(\"####################\")\n",
        "  print(\"Possible number of swaps:\",max(ans1, ans2))\n",
        "  print(\"####################\")\n",
        "  print(\" -1 indicates no possible swaps\")\n",
        "  print(\"####################\")"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the sentence:aab\n",
            "Entered string for evaluation: aab\n",
            "####################\n",
            "length of string 3\n",
            "['a', 'a', 'b']\n",
            "String found equal 0\n",
            "0\n",
            "\n",
            "length of string 3\n",
            "['a', 'a', 'b']\n",
            "String found equal 0\n",
            "0\n",
            "\n",
            "forward 1\n",
            "####################\n",
            "length of string 3\n",
            "['b', 'a', 'a']\n",
            "symmetry found total count 0\n",
            "No possible swaps\n",
            "backward -1\n",
            "####################\n",
            "Possible number of swaps: 1\n",
            "####################\n",
            " -1 indicates no possible swaps\n",
            "####################\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "Ye8IDD5Sxepe",
        "outputId": "b625772b-58a3-458e-91fb-2648639103ca"
      },
      "source": [
        "if __name__ == '__main__':\n",
        "  input_str = input(\"Enter the sentence:\")\n",
        "  input_str = input_str.lower()\n",
        "  print(\"Entered string for evaluation:\", input_str)\n",
        "  #input_str = \"aabbaa\"\n",
        "  len_str = len(input_str)\n",
        "  print(\"####################\")\n",
        "  \n",
        "  CountSwap(input_str, len_str)\n",
        "    # Function calling\n",
        "  ans1 = CountSwap(input_str, len_str)\n",
        "  print(\"forward\",ans1)\n",
        "  print(\"####################\")\n",
        "  ans2 = CountSwap(input_str[::-1], len_str)\n",
        "  print(\"backward\",ans2)\n",
        "  print(\"####################\")\n",
        "  print(\"Possible number of swaps:\",max(ans1, ans2))\n",
        "  print(\"####################\")\n",
        "  print(\" -1 indicates no possible swaps\")\n",
        "  print(\"####################\")"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the sentence:abcd\n",
            "Entered string for evaluation: abcd\n",
            "####################\n",
            "length of string 4\n",
            "['a', 'b', 'c', 'd']\n",
            "symmetry found total count 0\n",
            "No possible swaps\n",
            "length of string 4\n",
            "['a', 'b', 'c', 'd']\n",
            "symmetry found total count 0\n",
            "No possible swaps\n",
            "forward -1\n",
            "####################\n",
            "length of string 4\n",
            "['d', 'c', 'b', 'a']\n",
            "symmetry found total count 0\n",
            "No possible swaps\n",
            "backward -1\n",
            "####################\n",
            "Possible number of swaps: -1\n",
            "####################\n",
            " -1 indicates no possible swaps\n",
            "####################\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bdONzIgdxgzk"
      },
      "source": [
        ""
      ],
      "execution_count": 4,
      "outputs": []
    }
  ]
}