Chapter_1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Assignment 1 Chapter 1.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "H71heObrRXlO",
        "WEj-LvMPR7il",
        "Bkp10jJWR73S",
        "_n-RAldzR8Ti",
        "AxOMHvvDR8jD",
        "P5cl66_bR8wz",
        "nYJizVXqR8-k",
        "-iXZ-6vaR9Lz",
        "ntLEEdWMR9YU",
        "EAzp0LHfRs6w"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H71heObrRXlO"
      },
      "source": [
        "#### BA1A: Compute the Number of Times a Pattern Appears in a Text"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lmmzKgfyQLaW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5b5fc868-883d-4249-b9c3-4f9e48301d30"
      },
      "source": [
        "# inputs:\n",
        "# Input protein sequence: ataataaaaaaa\n",
        "# Enter the pattern you are looking for: aaaa\n",
        "    \n",
        "    \n",
        "def count_occurences(string, sub):\n",
        "    count = start = 0 \n",
        "    while start < len(string): # from 0 to lenght of that string\n",
        "        position = string.find(sub, start) # find returns start position of the first occurrence\n",
        "        if position != -1:\n",
        "            start = position + 1 # increment by 1\n",
        "            count += 1 # add to our count\n",
        "        else:\n",
        "            break # no occurrence found as find finds out first occurrence\n",
        "    return count\n",
        "\n",
        "# taking input a string of sequence\n",
        "sequence = \"GCGCG\"\n",
        "pattern = \"GCG\"\n",
        "# making all the text upper\n",
        "sequence = sequence.upper()\n",
        "pattern = pattern.upper()\n",
        "\n",
        "# count total overlapping occurence\n",
        "occurrences = count_occurences(sequence, pattern)\n",
        "\n",
        "# printing the value\n",
        "print(\"Total Occurrences: \", occurrences)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Total Occurrences:  2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WEj-LvMPR7il"
      },
      "source": [
        "#### BA1B: Find the Most Frequent Words in a String"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MLBIRhtmR7rr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3d8762e9-438a-48a8-f090-48fe9e6fac0d"
      },
      "source": [
        "\n",
        "\n",
        "def find_most_occurrence_by_length(text, k):\n",
        "    #creating a dictionary\n",
        "    my_dict = {}\n",
        "    for i in range(len(text)-k+1):\n",
        "        pattern = text[i:i+k]\n",
        "        if pattern in my_dict:\n",
        "            my_dict[pattern] += 1  #if pattern already present in dictionary then add 1 with it\n",
        "        else:\n",
        "            my_dict[pattern] = 1  #if not then put 1 in the value\n",
        "    max_value = max(my_dict.values())  # maximum value\n",
        "    max_keys = [key for key, val in my_dict.items() if val == max_value]   #getting all keys with mas value\n",
        "    print(max_keys)\n",
        "    \n",
        "# taking input a string of sequence\n",
        "sequence = \"ACGTTGCATGTCGCATGATGCATGAGAGCT\"\n",
        "length = 4\n",
        "\n",
        "# recalling the function which will calculate value for us\n",
        "find_most_occurrence_by_length(sequence, length)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['GCAT', 'CATG']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bkp10jJWR73S"
      },
      "source": [
        "#### BA1C: Find the Reverse Complement of a String"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AhgMF5cdR7_b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "67f19ce2-53d6-42bd-f0c8-dd1f48a4ceac"
      },
      "source": [
        "pattern = \"AAAACCCGGT\" #Taking pattern input as string\n",
        "            # make all the letter uppercase\n",
        "\n",
        "compliment = list(pattern)               # making a compliment list\n",
        "index = 0\n",
        "while index < len(pattern):\n",
        "    if pattern[index] == 'A':\n",
        "        compliment[index] = 'T'\n",
        "    if pattern[index] == 'T':\n",
        "        compliment[index] = 'A'\n",
        "    if pattern[index] == 'G':\n",
        "        compliment[index] = 'C'\n",
        "    if pattern[index] == 'C':\n",
        "        compliment[index] = 'G'\n",
        "    index += 1\n",
        "\n",
        "#print(compliment)                      output is compliment list:  i.e. ['T', 'T', 'T', 'T']\n",
        "reverse_compliment = compliment[::-1]         # make reverse compliment\n",
        "reverse_compliment = \"\".join(reverse_compliment)    # making string\n",
        "print(reverse_compliment)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ACCGGGTTTT\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cpoi50_wR8F9"
      },
      "source": [
        "#### BA1D: \tFind All Occurrences of a Pattern in a String"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bk5u0oSuR8MG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a4b40f36-7344-45ca-efc2-0831646a9ea4"
      },
      "source": [
        "def Occurences(string, sub):\n",
        "  count = 0;\n",
        "  string_len = len(string)\n",
        "  sub_len = len(sub)\n",
        "  for i in range(string_len-sub_len+1):\n",
        "    if string[i:i+sub_len] == sub:\n",
        "      print(i, end =\" \")\n",
        "      \n",
        "\n",
        "substring = \"ATAT\"\n",
        "string = \"GATATATGCATATACTT\"\n",
        "Occurences(string, substring)"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 3 9 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_n-RAldzR8Ti"
      },
      "source": [
        "#### BA1E: Find Patterns Forming Clumps in a String"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TplSRZtkR8b7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ced3c691-6c84-49c3-b004-43a29cf60b20"
      },
      "source": [
        "def GenerateKmer(text, k):\n",
        "  kmers = set()\n",
        "  for i in range(len(text)-k+1):\n",
        "    kmers.add(text[i:i+k])\n",
        "  return kmers\n",
        "\n",
        "\n",
        "\n",
        "def FreqCountUptoT(string, substr, t):\n",
        "    count = 0;\n",
        "    for i in range(len(string)-len(substr)+1):\n",
        "        if string[i:i+len(substr)] == substr:\n",
        "            count=count+1\n",
        "            if count >= t:\n",
        "              return True\n",
        "    return False\n",
        "\n",
        "\n",
        "def LtClump(genome, k, l, t):\n",
        "  ltclump = set() \n",
        "  for i in range(len(genome)-l+1):\n",
        "    lkmers = GenerateKmer(genome[i:i+l], k)\n",
        "    for kmer in lkmers:\n",
        "      if FreqCountUptoT(genome[i:i+l], kmer, t):\n",
        "        ltclump.add(kmer)\n",
        "  print(*ltclump, sep=\" \")\n",
        "\n",
        " \n",
        "genome = \"CGGACTCGACAGATGTGAAGAAATGTGAAGACTGAGTGAAGAGAAGAGGAAACACGACACGACATTGCGACATAATGTACGAATGTAATGTGCCTATGGC\"\n",
        "k = 5\n",
        "l = 75\n",
        "t = 4\n",
        "LtClump(genome, k, l, t)"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "AATGT GAAGA CGACA\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AxOMHvvDR8jD"
      },
      "source": [
        "#### BA1F: Find a Position in a Genome Minimizing the Skew"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MRT9m13wR8pt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7a039f66-b133-4401-9989-bbe51188a574"
      },
      "source": [
        "\n",
        "def minimizingSkew(genomeList):\n",
        "    result = [] # skew list\n",
        "    count = 0\n",
        "    for i in range(len(genomeList)):\n",
        "        if genomeList[i] == 'C':\n",
        "            count -= 1\n",
        "            result.append(count)\n",
        "        elif genomeList[i] == 'G':\n",
        "            count += 1\n",
        "            result.append(count)\n",
        "        else:\n",
        "            result.append(count)\n",
        "    #print(result)\n",
        "    minValue = min(result) # getting minimum value from result list\n",
        "    #print(minValue)\n",
        "    for i in range(len(result)):\n",
        "        if result[i] == minValue:\n",
        "            print(i+1, end = \" \") # printing all the index of the minimum value\n",
        "    \n",
        "\n",
        "\n",
        "Genome = \"CCTATCGGTGGATTAGCATGTCCCTGTACGTTTCGCCGCGAACTAGTTCACACGGCTTGATGGCAAATGGTTTTTCCGGCGACCGTAATCGTCCACCGAG\"\n",
        "Genome = Genome.upper()  \n",
        "\n",
        "genomeList = list(Genome) # converting genome string into list\n",
        "minimizingSkew(genomeList)\n",
        "\n",
        "#print(genomeList)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "53 97 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P5cl66_bR8wz"
      },
      "source": [
        "#### BA1G: Compute the Hamming Distance Between Two Strings"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A7fQZP_KR83E",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5386ac56-b5a2-4cc4-bce5-b4836863d7e4"
      },
      "source": [
        "str1 = \"GGGCCGTTGGT\" #Taking pattern input as string\n",
        "str2 = \"GGACCGTTGAC\"\n",
        "\n",
        "str1 = str1.upper()                # make all the letter uppercase\n",
        "str2 = str2.upper()\n",
        "\n",
        "#str1 = list(str1)\n",
        "#str2 = list(str2)\n",
        "\n",
        "#print(str1, str2)\n",
        "index = hammingDisctance = int(0)\n",
        "while index < len(str1):\n",
        "    if str1[index] != str2[index]:\n",
        "        hammingDisctance += 1\n",
        "    index += 1\n",
        "print(hammingDisctance)"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nYJizVXqR8-k"
      },
      "source": [
        "#### BA1H: Find All Approximate Occurrences of a Pattern in a String"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ca6eKtD8R9FL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3d564eae-2359-4a41-ae57-7deb4f217c74"
      },
      "source": [
        "########### input ###########\n",
        "#### ATTCTGGA\n",
        "#### CGCCCGAATCCAGAACGCATTCCCATATTTCGGGACCACTGGCCTCCACGGTACGGACGTCAATCAAATGCCTAGCGGCTTGTGGTTTCTCCTACGCTCC\n",
        "#### 3\n",
        "###############################\n",
        "pattern = \"ATTCTGGA\" #Taking pattern input as string\n",
        "text = \"CGCCCGAATCCAGAACGCATTCCCATATTTCGGGACCACTGGCCTCCACGGTACGGACGTCAATCAAATGCCTAGCGGCTTGTGGTTTCTCCTACGCTCC\"\n",
        "hd = 3\n",
        "\n",
        "pattern = pattern.upper()                # make all the letter uppercase\n",
        "text = text.upper()\n",
        "output = []  # declaring output list for collecting output index\n",
        "\n",
        "index = 0\n",
        "k = len(pattern) \n",
        "while index < len(text)-k+1:\n",
        "    currentstr = text[index:index+k] # make a substring\n",
        "    #print(currentstr)\n",
        "    i = 0\n",
        "    counter = int(0) \n",
        "    if currentstr == pattern:  # if substring is equal to pattern then add the index and ignore rest of the code\n",
        "        output.append(index)\n",
        "        continue\n",
        "    while i < len(currentstr): # otherwise check index by index\n",
        "        if currentstr[i] != pattern[i]:\n",
        "            counter += 1\n",
        "        i += 1\n",
        "    if counter <= hd:    \n",
        "        output.append(index)   # take the starting index position of current string\n",
        "    index += 1\n",
        "    \n",
        "\n",
        "for x in output:\n",
        "    print(x, end = \" \")# print the list"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "6 7 26 27 78 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-iXZ-6vaR9Lz"
      },
      "source": [
        "#### BA1I: Find the Most Frequent Words with Mismatches in a String"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PBfPmjcyR9SC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1b1e53e5-cb60-4570-9bb3-e3066cd84893"
      },
      "source": [
        "import itertools\n",
        "\n",
        "def genAllPossibleKmers(characters, k):\n",
        "     yield from itertools.product(*([characters] * k))\n",
        "\n",
        "def count_occurrences(substrs, pattern, d):\n",
        "    i = found = int(0)\n",
        "    while i < len(substrs):     # travers all the substrings\n",
        "        current = substrs[i]  \n",
        "        j = count = int(0)\n",
        "        #print(\"current: \", current, \"pattern: \", pattern)\n",
        "        while j < len(pattern):   # checking if the current substring is exists into substrings list having maximum d hamming distance\n",
        "            if pattern[j] != current[j]:\n",
        "                \n",
        "                count += 1\n",
        "            j += 1\n",
        "        if count <= d:\n",
        "            found += 1\n",
        "        i += 1\n",
        "    return found\n",
        "\n",
        "\n",
        "\n",
        "text = \"ACGTTGCATGTCGCATGATGCATGAGAGCT\"\n",
        "k = 4\n",
        "d = 1\n",
        "\n",
        "dect = {}\n",
        "DNABases = ['A', 'C', 'T', 'G']\n",
        "\n",
        "allpossiblePatterns = substrs = []\n",
        "i = 0\n",
        "\n",
        "for i in genAllPossibleKmers(DNABases, k):\n",
        "    allpossiblePatterns.append(''.join(i))\n",
        "\n",
        "\n",
        "\n",
        "i = int(0)\n",
        "while i < len(text)-k+1:\n",
        "    currentstr = text[i:i+k]  # make a substring\n",
        "    substrs.append(currentstr) # added into substring list\n",
        "    i += 1\n",
        "\n",
        "LenPatterns = len(allpossiblePatterns)\n",
        "LenSubstrs = len(substrs)\n",
        "iterator = int(0)\n",
        "while iterator < LenPatterns:\n",
        "    value = count_occurrences(substrs, allpossiblePatterns[iterator], d) # calculate occurrence\n",
        "    #print(\"value: \", value)\n",
        "    dect[allpossiblePatterns[iterator]] = value # added both the substring and occurrence value into dictionary   \n",
        "        #substr += 1\n",
        "    iterator += 1\n",
        "\n",
        "\n",
        "#print(dect, \"\\n\\n\\n\")\n",
        "max_values =  max(dect.values()) # getting the max values from dictionary\n",
        "keys = []\n",
        "for key, value in dect.items():\n",
        "    if value == max_values:\n",
        "        keys.append(key)  # added max values's corresponding keys\n",
        "\n",
        "for x in keys:\n",
        "    print(x, end = \" \")\n",
        "    "
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ATGC ATGT GATG "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ntLEEdWMR9YU"
      },
      "source": [
        "#### BA1J: Find Frequent Words with Mismatches and Reverse Complements"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LtUP8mEnR9fI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "78a28050-cf1e-4039-bb8e-e07114af86e6"
      },
      "source": [
        "import itertools\n",
        "\n",
        "def genAllPossibleKmers(characters, k):\n",
        "     yield from itertools.product(*([characters] * k))\n",
        "\n",
        "def comp(pattern):\n",
        "    compliment = list(pattern)               # making a compliment list\n",
        "    index = 0\n",
        "    while index < len(pattern):\n",
        "        if pattern[index] == 'A':\n",
        "            compliment[index] = 'T'\n",
        "        if pattern[index] == 'T':\n",
        "            compliment[index] = 'A'\n",
        "        if pattern[index] == 'G':\n",
        "            compliment[index] = 'C'\n",
        "        if pattern[index] == 'C':\n",
        "            compliment[index] = 'G'\n",
        "        index += 1\n",
        "    return \"\".join(compliment)\n",
        "\n",
        "def reverseComp(string):\n",
        "    compliment = comp(string)\n",
        "    reverse_compliment = compliment[::-1]\n",
        "    return reverse_compliment\n",
        "\n",
        "\n",
        "def count_occurrences(substrs, pattern, d):\n",
        "    i = found = int(0)\n",
        "    while i < len(substrs):     # travers all the substrings\n",
        "        current = substrs[i]  \n",
        "        j = count = int(0)\n",
        "        #print(\"current: \", current, \"pattern: \", pattern)\n",
        "        while j < len(pattern):   # checking if the current substring is exists into substrings list having maximum d hamming distance\n",
        "            if pattern[j] != current[j]:\n",
        "                \n",
        "                count += 1\n",
        "            j += 1\n",
        "        if count <= d:\n",
        "            found += 1\n",
        "        i += 1\n",
        "    return found\n",
        "\n",
        "\n",
        "text = \"ACGTTGCATGTCGCATGATGCATGAGAGCT\"\n",
        "k = 4\n",
        "d = 1\n",
        "\n",
        "\n",
        "dect = {}\n",
        "DNABases = ['A', 'C', 'T', 'G']\n",
        "\n",
        "allpossiblePatterns = revPatterns = substrs = []\n",
        "i = 0\n",
        "\n",
        "for i in genAllPossibleKmers(DNABases, k):\n",
        "    allpossiblePatterns.append(''.join(i))\n",
        "    current = reverseComp(i)\n",
        "    allpossiblePatterns.append(''.join(current))\n",
        "\n",
        "i = int(0)\n",
        "while i < len(text)-k+1:\n",
        "    currentstr = text[i:i+k]  # make a substring\n",
        "    substrs.append(currentstr) # added into substring list\n",
        "    i += 1\n",
        "\n",
        "LenPatterns = len(allpossiblePatterns)\n",
        "LenRev = len(revPatterns)\n",
        "LenSubstrs = len(substrs)\n",
        "iterator = int(0)\n",
        "while iterator < LenPatterns/2:\n",
        "    value = count_occurrences(substrs, allpossiblePatterns[iterator], d) + count_occurrences(substrs, allpossiblePatterns[iterator+1], d)# calculate occurrence\n",
        "    dect[allpossiblePatterns[iterator]] = value # added both the substring and occurrence value into dictionary   \n",
        "        #substr += 1\n",
        "    iterator += 2\n",
        "\n",
        "\n",
        "max_values =  max(dect.values()) # getting the max values from dictionary\n",
        "keys = []\n",
        "for key, value in dect.items():\n",
        "    if value == max_values:\n",
        "        keys.append(key)  # added max values's corresponding keys\n",
        "\n",
        "for x in keys:\n",
        "    print(x, end = \" \")\n",
        " "
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ACAT ATGT "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "30EU43r0ezn_"
      },
      "source": [
        "#### BA1K: Generate the Frequency Array of a String"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hY69aVtPRrJp",
        "outputId": "22147616-f5d7-441a-d0e4-c520b66a20ed"
      },
      "source": [
        "def generateAllKmers(k):\n",
        "    base_neucleotides = [\"A\", \"T\", \"G\", \"C\"]\n",
        "    last_base = base_neucleotides #copying base neucleotides in last_base\n",
        "    current_array = [] #declare an emty list\n",
        "    for i in range(k-1): #for 2 length kmer the loop will run for i=0 and i=1\n",
        "        for j in base_neucleotides: #A, T, G, C\n",
        "            for k in last_base: #copy of A, T, G, C\n",
        "                current_array.append(j+k) \n",
        "        last_base = current_array #update last_base\n",
        "        current_array = [] #empty current array\n",
        "    return sorted(last_base)\n",
        "\n",
        "def patternCount(text, pattern):\n",
        "    count = 0;\n",
        "    #if text length is 4 and pattern length is 2 then the loop will run till 3rd charachter\n",
        "    for i in range(len(text)-len(pattern)+1):\n",
        "        #print(i)\n",
        "        # slice in text from i to i+pattern length\n",
        "        #abcde if i=0 and pattern length = 3 the slice will be from a to c\n",
        "        if text[i:i+len(pattern)] == pattern:\n",
        "            count=count+1\n",
        "    return count\n",
        "\n",
        "def FrequencyArray(text, k):\n",
        "  kmers = generateAllKmers(k)\n",
        "  for kmer in kmers:\n",
        "   print(patternCount(text, kmer), end = \" \")\n",
        "\n",
        "text = \"ACGCGGCTCTGAAA\"\n",
        "k = 2\n",
        "FrequencyArray(text, k)"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2 1 0 0 0 0 2 2 1 2 1 0 0 1 1 0 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1nm12HFcR9yR"
      },
      "source": [
        "#### BA1L: Implement PatternToNumber"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EAiDM_1FR94p"
      },
      "source": [
        "def convertToNum(ch, i):\n",
        "    assign = value = int(0)\n",
        "    if(ch == 'A'): assign = 0\n",
        "    elif(ch == 'C'): assign = 1\n",
        "    elif(ch == 'G'): assign = 2\n",
        "    elif(ch == 'T'): assign = 3\n",
        "    \n",
        "    valueb4 = assign*pow(4, i) # converting to base 4\n",
        "    return valueb4\n",
        "\n",
        "DNAstr = str(input(\"Enter your sequence: \"))\n",
        "DNAstr = DNAstr.upper() # making strand sequence upper\n",
        "Rev = DNAstr[::-1] # reversing the sequence\n",
        "DNAlen = len(Rev)\n",
        "\n",
        "i = value = int(0)\n",
        "while i < DNAlen: # take each char and convert it to numeric\n",
        "    ch = Rev[i]\n",
        "    \n",
        "    value += convertToNum(ch, i)\n",
        "    i += 1\n",
        "    \n",
        "print(value)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GivARGPMegoI"
      },
      "source": [
        "#### BA1M: Implement NumberToPattern"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-uIx7Rvbegy2"
      },
      "source": [
        "neucleotide_base = {0:'A', 1:'C', 2:'G', 3:'T'}\n",
        "def numberToPattern(index, k):\n",
        "    if(k == 1): #base case\n",
        "        return neucleotide_base[index]\n",
        "    pref_index = int(index/4)\n",
        "    rem = int(index%4)\n",
        "    symbol = neucleotide_base[rem] #remainder is the single symbol\n",
        "    pref_pattern = numberToPattern(pref_index, k-1) #recursive call\n",
        "    \n",
        "    return pref_pattern+symbol\n",
        "\n",
        "index = int(input(\"Enter the index: \"))\n",
        "k = int(input(\"Enter k: \"))\n",
        "print(numberToPattern(index, k))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EAzp0LHfRs6w"
      },
      "source": [
        "#### BA1N: Generate the d-Neighborhood of a String"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qsdfk6z-ez1x",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b86d5efc-89d3-46c9-8b92-6948ef91eb41"
      },
      "source": [
        "def generateAllKmers(k):\n",
        "    base_neucleotides = [\"A\", \"T\", \"G\", \"C\"]\n",
        "    last_base = base_neucleotides #copying base neucleotides in last_base\n",
        "    current_array = [] #declare an emty list\n",
        "    for i in range(k-1): #for 2 length kmer the loop will run for i=0 and i=1\n",
        "        for j in base_neucleotides: #A, T, G, C\n",
        "            for k in last_base: #copy of A, T, G, C\n",
        "                current_array.append(j+k) \n",
        "        last_base = current_array #update last_base\n",
        "        current_array = [] #empty current array\n",
        "    return sorted(last_base)\n",
        "\n",
        "def hammingDistance(text1, text2):\n",
        "    count=0;\n",
        "    for i in range(len(text1)):\n",
        "        if(text1[i] != text2[i]):\n",
        "            count+=1\n",
        "    return count\n",
        "\n",
        "def DNeighbours(text, d):\n",
        "  length = len(text)\n",
        "  ans = []\n",
        "  kmers = generateAllKmers(length)\n",
        "  for kmer in kmers:\n",
        "    if hammingDistance(text, kmer) <= d:\n",
        "      ans.append(kmer)\n",
        "  return ans\n",
        "\n",
        "text = \"ACG\"\n",
        "distance = 1\n",
        "res = DNeighbours(text, distance)\n",
        "for i in res:\n",
        "  print(i)"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "AAG\n",
            "ACA\n",
            "ACC\n",
            "ACG\n",
            "ACT\n",
            "AGG\n",
            "ATG\n",
            "CCG\n",
            "GCG\n",
            "TCG\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}