Rosalind_notebook.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "It is best to run this notebook on Google collaboratory platform as it utilises some of its featuers. You can do that using [this link](https://colab.research.google.com/github/paq88/Rosalind/blob/main/Rosalind_notebook.ipynb)"
      ],
      "metadata": {
        "id": "_zCKNubxwDjw"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NJkHrPcmGBs9"
      },
      "outputs": [],
      "source": [
        "def rosalind(name):\n",
        "  \"\"\"Uses name id from rosalind to read input file and write output file\n",
        "\n",
        "  \"\"\"\n",
        "  from google.colab import files\n",
        "  function = eval(name)\n",
        "\n",
        "  link = f\"https://rosalind.info/problems/{name}\"\n",
        "  output_filename = f'rosalind_{name}_output.txt'\n",
        "\n",
        "  print(f\"First download set from {link}\")\n",
        "  print(\"Then upload file here by pressing choose file button below\")\n",
        "  rfile = files.upload()\n",
        "\n",
        "\n",
        "\n",
        "  for bytesObject in rfile.values(): # https://www.w3schools.com/python/ref_dictionary_values.asp\n",
        "    data = bytesObject.decode('utf-8')\n",
        "  print(\"data got = \",data)\n",
        "\n",
        "  output_string = function(data)\n",
        "  print(\"output = \",output_string)\n",
        "  with open(output_filename, mode = \"w\", encoding = \"utf8\") as out_file:\n",
        "\n",
        "    out_file.write(output_string)\n",
        "\n",
        "\n",
        "  print(f\"Writen solution to file: {output_filename}\")\n",
        "  files.download(output_filename)\n",
        "  return 0\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def read_fasta(input_string):\n",
        "  \"\"\"Reads fasta file from string and returns list of tuples (header, sequence)\n",
        "  \"\"\"\n",
        "  lines = input_string.split(\">\")\n",
        "  result = []\n",
        "  for line in lines[1:]:\n",
        "    line_s = line.splitlines()\n",
        "    header = line_s[0]\n",
        "    seq = \"\".join(line_s[1:])\n",
        "\n",
        "    result.append((header,seq))\n",
        "\n",
        "\n",
        "  return result"
      ],
      "metadata": {
        "id": "jF4CQuZ6TjMj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def int_to_str(l):\n",
        "  \"\"\"Converts list of integers to list of stringns\n",
        "  \"\"\"\n",
        "  string_l = [0]*len(l)\n",
        "  for i in range(len(l)):\n",
        "    string_l[i] = str(l[i])\n",
        "  return string_l"
      ],
      "metadata": {
        "id": "erB2bCk2aTLt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def find_shortest(sequence_list):\n",
        "  \"\"\"Searches for first shortest sequence in sequence list\n",
        "  returns tuple (length of sequence, index in input list)\n",
        "  \"\"\"\n",
        "  l = len(sequence_list[0])\n",
        "  id = 0\n",
        "  for i,seq in enumerate(sequence_list):\n",
        "    curent_len = len(seq)\n",
        "    if curent_len < l:\n",
        "      l = curent_len\n",
        "      id = i\n",
        "  return (l,id)\n",
        "\n",
        "\n",
        "def find_longest(sequence_list):\n",
        "  \"\"\"Searches for first longest sequence in sequence list\n",
        "  returns tuple (length of sequence, index in input list)\n",
        "  \"\"\"\n",
        "  l = len(sequence_list[0])\n",
        "  id = 0\n",
        "  for i,seq in enumerate(sequence_list):\n",
        "    curent_len = len(seq)\n",
        "    if curent_len > l:\n",
        "      l = curent_len\n",
        "      id = i\n",
        "  return (l,id)"
      ],
      "metadata": {
        "id": "cBO82ttjBFkb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mv37vcRBAnh8"
      },
      "source": [
        "#### [DNA:Counting DNA Nucleotides](https://rosalind.info/problems/dna/)\n",
        "\n",
        "Given: A DNA string s of length at most 1000 nt.\n",
        "\n",
        "Return: Four integers (separated by spaces)\n",
        "counting the respective number of times that\n",
        " the symbols 'A', 'C', 'G', and 'T' occur in s."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eR-oPrrUAlfU"
      },
      "outputs": [],
      "source": [
        "def dna_alg(s):\n",
        "  A = str(s.count(\"A\"))\n",
        "  T = str(s.count(\"T\"))\n",
        "  G = str(s.count(\"G\"))\n",
        "  C = str(s.count(\"C\"))\n",
        "  return(A+\" \"+C+\" \"+G+\" \"+T)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Uprz1yAzAl24"
      },
      "outputs": [],
      "source": [
        "def dna(input_string):\n",
        "  \"\"\"https://rosalind.info/problems/dna/\n",
        "\n",
        "  Given: A DNA string s of length at most 1000 nt.\n",
        "\n",
        "  Return: Four integers (separated by spaces)\n",
        "  counting the respective number of times that\n",
        "  the symbols 'A', 'C', 'G', and 'T' occur in s.\n",
        "  \"\"\"\n",
        "  return dna_alg(input_string)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "anzkwgbdAmIv"
      },
      "outputs": [],
      "source": [
        "rosalind(\"dna\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "unHGuanPCKcH"
      },
      "source": [
        "#### [RNA:Transcribing DNA into RNA](https://rosalind.info/problems/rna/)\n",
        "Given: A DNA string t having length at most 1000 nt.\n",
        "\n",
        "Return: The transcribed RNA string of t.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TpnTs36HCKqK",
        "outputId": "6b2a8a29-3de4-4060-e789-e965a8144884"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'GAUGGAACUUGACUACGUAAAUU'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 4
        }
      ],
      "source": [
        "def rna_alg(t):\n",
        "  return t.replace(\"T\",\"U\")\n",
        "\n",
        "rna_alg(\"GATGGAACTTGACTACGTAAATT\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ONQCIHNLCKys"
      },
      "outputs": [],
      "source": [
        "def rna(input_string):\n",
        "  \"\"\"Solves https://rosalind.info/problems/rna/\n",
        "\n",
        "  Given: A DNA string t having length at most 1000 nt.\n",
        "\n",
        "  Return: The transcribed RNA string of t.\n",
        "  \"\"\"\n",
        "  return rna_alg(input_string)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4GRbKPSxCK6n",
        "outputId": "778f4113-242a-405b-d7f2-fda78deff82f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "First download set from https://rosalind.info/problems/rna\n",
            "Then upload file here by pressing choose file button below\n"
          ]
        },
        {
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-2ce71c1a-dc26-4291-8705-f7140b176352\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-2ce71c1a-dc26-4291-8705-f7140b176352\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Saving rosalind_rna.txt to rosalind_rna.txt\n",
            "data got =  GGTTGCAGTTGCCTAGCGCCCTCCCGTCAGCGTATGCGCGAAGGATATCTACAGGGGAATAGGGTTGTACCACCCTCCCAGCTGTACCCAATCACCTGATATGATGGTGTTAGCTACAAACGTCACTTGGATAGCGATAGATGCAATGCCTTCGCCGCCGATTTAAGTCGAATGGTGGTGCGCCACAGCTCCACGGCACATTCGTCGCTCCGCCGAATGAGGCACCAGTGCAGTTGTTGGACCAAGCGGTCAAAAAATGTAGCTCATCCACGTAGGTCATAGTTCCTGCTGCCGGTGGCAGGCACTGGGTGGGCCGTTGCCTTTAGAGGGCTGTCCTACATGTCAGTAACCACGACTGTCTCGTAGTTGACTTCCTCATCAAGACCCTCGTTCGGGTTGCCCGTCCGACGTGTTGTACGCTAGGTGAAGGAAGGGTTAGACCACACAACCGAGTCTCTTGGATGACAACACCTTCTTGGTCCTTAAGGTCGAACAGGTGAATCGACTCCTCATAGTGTGGGGCTCCTACCTGAGCGAGCAGGGGATAACGTGAGGTCCTTGCGATCCATTGCCGTCTATCCGACTTTCGGCGATCGTGGGAACAACCTGGGGTACCATGCGACACCGTCTAGGGAACAGGATGTGCTAGTTCGTTATTGCTAATGGAGGTGCCACTCGCCCAACCGTCCGACAAAGCGCATGCTTCAACGCATAAATACGGTGGCTCTACAAATCGTGGATATACGTGGACGGGCGACGACAGAACAAGTTAGTATCGCGATTATTTTCGTTATACGTTGCTCTGATTCGTGCCTGTTCCACGGTGATCCCGAGGCAGTAAGACTTTGACACCCTAGACTTCAACGAGGGGGAAAATATTCTATCAGGCATATCAAACGTAGTAAGATGCGTATTCGGGAAACGGTTCAAGTTGGGTACCGCGACTGGTCCGTAGCGGTTCAGGCCCCGC\r\n",
            "\n",
            "output =  GGUUGCAGUUGCCUAGCGCCCUCCCGUCAGCGUAUGCGCGAAGGAUAUCUACAGGGGAAUAGGGUUGUACCACCCUCCCAGCUGUACCCAAUCACCUGAUAUGAUGGUGUUAGCUACAAACGUCACUUGGAUAGCGAUAGAUGCAAUGCCUUCGCCGCCGAUUUAAGUCGAAUGGUGGUGCGCCACAGCUCCACGGCACAUUCGUCGCUCCGCCGAAUGAGGCACCAGUGCAGUUGUUGGACCAAGCGGUCAAAAAAUGUAGCUCAUCCACGUAGGUCAUAGUUCCUGCUGCCGGUGGCAGGCACUGGGUGGGCCGUUGCCUUUAGAGGGCUGUCCUACAUGUCAGUAACCACGACUGUCUCGUAGUUGACUUCCUCAUCAAGACCCUCGUUCGGGUUGCCCGUCCGACGUGUUGUACGCUAGGUGAAGGAAGGGUUAGACCACACAACCGAGUCUCUUGGAUGACAACACCUUCUUGGUCCUUAAGGUCGAACAGGUGAAUCGACUCCUCAUAGUGUGGGGCUCCUACCUGAGCGAGCAGGGGAUAACGUGAGGUCCUUGCGAUCCAUUGCCGUCUAUCCGACUUUCGGCGAUCGUGGGAACAACCUGGGGUACCAUGCGACACCGUCUAGGGAACAGGAUGUGCUAGUUCGUUAUUGCUAAUGGAGGUGCCACUCGCCCAACCGUCCGACAAAGCGCAUGCUUCAACGCAUAAAUACGGUGGCUCUACAAAUCGUGGAUAUACGUGGACGGGCGACGACAGAACAAGUUAGUAUCGCGAUUAUUUUCGUUAUACGUUGCUCUGAUUCGUGCCUGUUCCACGGUGAUCCCGAGGCAGUAAGACUUUGACACCCUAGACUUCAACGAGGGGGAAAAUAUUCUAUCAGGCAUAUCAAACGUAGUAAGAUGCGUAUUCGGGAAACGGUUCAAGUUGGGUACCGCGACUGGUCCGUAGCGGUUCAGGCCCCGC\r\n",
            "\n",
            "Writen solution to file: rosalind_rna_output.txt\n"
          ]
        },
        {
          "data": {
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "application/javascript": [
              "download(\"download_f2a122f7-c463-4703-b309-b604873c75f2\", \"rosalind_rna_output.txt\", 972)"
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "execution_count": 70,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "rosalind(\"rna\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bL7smlsADI42"
      },
      "source": [
        "#### [REVC:Complementing a Strand of DNA](https://rosalind.info/problems/revc/)\n",
        "Given: A DNA string s of length at most 1000 bp.\n",
        "\n",
        "Return: The reverse complement sc of s."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "IP9pS938DJDM",
        "outputId": "73f77b3d-d4c2-4d13-8125-3e60ffc6e6c2"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'ACCGGGTTTT'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "def revc_alg(s):\n",
        "  complement = {\"A\": \"T\", \"T\": \"A\", \"G\": \"C\", \"C\": \"G\"}\n",
        "  sc = \"\"\n",
        "  for nuc in s:\n",
        "    if nuc in complement:\n",
        "      sc+=complement[nuc]\n",
        "    else:\n",
        "      continue\n",
        "\n",
        "  sc = sc[::-1]\n",
        "  return sc\n",
        "\n",
        "revc_alg(\"AAAACCCGGT\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dPnp5MvDDJHh"
      },
      "outputs": [],
      "source": [
        "def revc(input_string):\n",
        "  \"\"\" Solves https://rosalind.info/problems/revc/\n",
        "  Given: A DNA string s of length at most 1000 bp.\n",
        "\n",
        "  Return: The reverse complement sc of s.\n",
        "  \"\"\"\n",
        "  return revc_alg(input_string)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 221
        },
        "id": "xEQRpGNKDJMO",
        "outputId": "b706c303-3c1c-4784-9576-8b7793d3e0e5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "First download set from https://rosalind.info/problems/revc\n",
            "Then upload file here by pressing choose file button below\n"
          ]
        },
        {
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-6dafb09b-02ca-4278-92c8-5b7a7bf5c5c5\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-6dafb09b-02ca-4278-92c8-5b7a7bf5c5c5\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Saving rosalind_revc.txt to rosalind_revc (1).txt\n",
            "data got =  GGATTTGGGTTGAAGGTATTTTTTCTCACAATACAGTAATCCACGATCATGAGCGGGATCTGCACATTCGTACTGTCAATGCTCGCACGTTGGCGTCTTAGGACAATGCGCTCGGGATCTGAGGTCGTCGGACAGTTGGAGAGCATTAGGCGTACTAGCGAACCCCGGGGGCCATAGCCTATACAAAGGTTGTATCGGATTAAGGTCCCCTAGATTGTACTGCAGATACCTCGTCTGTCACGATTCTGAGAGACCCGGTTGACCCCCAACTTACGATTGCACTATCAAGAATCTGGGTGTACAGCACCGAGACGTTGTGAGCAGGCCATGGAAATACCGGGGCCACTATCAAGGAAGAGAACAGTTGTAAACACTATCGTAGAGAACGTAGCTATCTACCGCGTTTACTTGGCCTATTCTGGTCCGCAGGCAAAAGATAGCCAGTAATGGGAATTTGTACATGTCGCTGGCAATCCCGCACCGATCTGCTCTTTGCACTTCATTCGGCTATAGTCCGCCGTAGCTAAGCCAATAAATAAGATCTGTTAGGTAAAGGCAAGGCCATACGAATCATAGGGGATATATACTAGGCGCCAATTACCATTGAGCGAAGATAAATCGCGCACCTAGGCGGCGCTACGAATATAGCGACGGTACCGCGACGTGCCTCTTCAAACACCCCCCCCCCCGAAGAGGAAGGCGGCTATAGCGGCTATTACTGCTACGATGGACAGGTCATTCAACGATTCTTAGTTCCGTCACGGAGAATAGTAATTATCCGAAACCTTTTAGAACAATGG\r\n",
            "\n",
            "output =  CCATTGTTCTAAAAGGTTTCGGATAATTACTATTCTCCGTGACGGAACTAAGAATCGTTGAATGACCTGTCCATCGTAGCAGTAATAGCCGCTATAGCCGCCTTCCTCTTCGGGGGGGGGGGTGTTTGAAGAGGCACGTCGCGGTACCGTCGCTATATTCGTAGCGCCGCCTAGGTGCGCGATTTATCTTCGCTCAATGGTAATTGGCGCCTAGTATATATCCCCTATGATTCGTATGGCCTTGCCTTTACCTAACAGATCTTATTTATTGGCTTAGCTACGGCGGACTATAGCCGAATGAAGTGCAAAGAGCAGATCGGTGCGGGATTGCCAGCGACATGTACAAATTCCCATTACTGGCTATCTTTTGCCTGCGGACCAGAATAGGCCAAGTAAACGCGGTAGATAGCTACGTTCTCTACGATAGTGTTTACAACTGTTCTCTTCCTTGATAGTGGCCCCGGTATTTCCATGGCCTGCTCACAACGTCTCGGTGCTGTACACCCAGATTCTTGATAGTGCAATCGTAAGTTGGGGGTCAACCGGGTCTCTCAGAATCGTGACAGACGAGGTATCTGCAGTACAATCTAGGGGACCTTAATCCGATACAACCTTTGTATAGGCTATGGCCCCCGGGGTTCGCTAGTACGCCTAATGCTCTCCAACTGTCCGACGACCTCAGATCCCGAGCGCATTGTCCTAAGACGCCAACGTGCGAGCATTGACAGTACGAATGTGCAGATCCCGCTCATGATCGTGGATTACTGTATTGTGAGAAAAAATACCTTCAACCCAAATCC\n",
            "Writen solution to file: rosalind_revc_output.txt\n"
          ]
        },
        {
          "data": {
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "application/javascript": [
              "download(\"download_16c63527-eee8-4761-8a5f-3b7250e4d68d\", \"rosalind_revc_output.txt\", 800)"
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "execution_count": 80,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "rosalind(\"revc\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c2cwqS16b1i-"
      },
      "source": [
        "#### [HAMM:Counting Point Mutations](https://rosalind.info/problems/hamm/)\n",
        "Given two strings s and t of equal length,\n",
        "  the Hamming distance between s and t,\n",
        "  denoted dH(s,t), is the number of corresponding\n",
        "  symbols that differ in s and t."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6zk-63wL-JFY"
      },
      "outputs": [],
      "source": [
        "def hamm_alg(s,t):\n",
        "  count = sum(1 for a, b in zip(s, t) if a != b)\n",
        "  return count\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3YUAwaENb1uN"
      },
      "outputs": [],
      "source": [
        "def hamm(input_string):\n",
        "  \"\"\" Solves https://rosalind.info/problems/hamm/\n",
        "\n",
        "  Given two strings s and t of equal length,\n",
        "  the Hamming distance between s and t,\n",
        "  denoted dH(s,t), is the number of corresponding\n",
        "  symbols that differ in s and t.\n",
        "\n",
        "  \"\"\"\n",
        "\n",
        "  input_list = input_string.splitlines()\n",
        "\n",
        "  output = hamm_alg(input_list[0],input_list[1])\n",
        "\n",
        "  return str(output)\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 232
        },
        "id": "8oBfgKwK-I76",
        "outputId": "0e840fad-e9dd-4505-8548-1093d0440f71"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "First download set from https://rosalind.info/problems/hamm\n",
            "Then upload file here by pressing choose file button below\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-6c355838-bd3e-4743-8f64-ab088718af6d\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-6c355838-bd3e-4743-8f64-ab088718af6d\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving rosalind_hamm.txt to rosalind_hamm.txt\n",
            "data got =  GCTACCATCACGGATTTAATTAGGTTAAGTCTGCAGTCCTGTGAAGAGACCTTCGCACCTGCGGTCCACTGTAAGGCGAGATATAATTCCGGAACTATGACTGTATGATGTATATGCGTCGCGTACCCCGTCCGGGCTGTCGGACCAATTGAAGCCCCGGGCGCAAGGAAGCATGATAATCCAAATCGCAGCTCATCATAAGCTAACGCTGTATAGACCCTTCAAAAACATTGCAAGCAATTGTAGTAGTTATCTACTCCCGAATGTAGCTCAAATTGGTAAACTCTATCCATGCCATGATTCTGGGTTGGGGAAGCGATGCTGCCATTTGCACTTCCCGTTTCAATCCGTCAAGCAACCCTAAAGGGACATGTCTAGAACACGAGAGACTGCAACAATCCCAAACTCCTCAGGTAGTGTTAATGGGTACGTTAAGGCATATGTCGCGTGTTGGGAGGGTTTCCTGCCCGCCATGTCTACCATGGGTCTGCGAGCCTGGGCCTGGGCGCGTCAATCTGATGGTACGGGGTGGCTCCAATCGTGAGCAGGTGGCGCGCGCCCCTGGTGTACTCTGCAGTCTAGGTCTGGGTTCCCTTGCTTCGCCTGCTGTTTCAACTAGAGTTGCCTCAGATCCTGGAGGGCCCTCGCTCACAGGTTCCTAACATGCTGGGCAGTGGAGCTTCGCTCAACCCAGTCAGTAAAGTGAGCCGCACGGCCCGGGGGCCATAGACTCAAGCCGCTGGGACCACACTCGCTGCCTGGGCGGTGCTAACTAGCAGTCGTTTAACAGCGCGGTGTGTGCATTTCTCTGCTGTCGCCCGGATTATATGATAGAAGAACGAACGGCCCGTTCTGGGCCGCCAAAGATAGGCCAGAGTTGATGGCTACGCAGAGGGCCGTCAGGCGTTCCATCAACGATAGGCA\r\n",
            "TTCAGCATTAATGAATTAGCGCGGCCCCGACTGCGCAGTACTTTACATACCGTCTCAACTGTTGTCCACTATCACTACTCGGATAGGAGAGCACCTATTCGCGCGTCATTTAGCTAGTGGACGGACGCACTCCAATGAGTCGGGCGCATTCCAGATCTGGGGGCCTTGAAAAAAAACGAACAGCGTCGCGACTGGTCTATACGTACGGCTTTGTGGGCGCGTATCAACGATTGCGACGACTTGGAGATATTCGATACTCCCGATTTGAACGCCAAGTAGTGCAATATACCCGTGCTCCCATGCTCGGGTGTGGTTTCTTTGCGCGAGTTTCCCCTATCGGTGTGTATACGTTAATCACAATTTAAGCGGTTCCGTCAGGACACATCTACCTGGACGACCCAAAAAGGTTTGAATTAATGCTAAGCCTTATCTTAAGATGCACCTGCTCTAGGGGCTGGGTTCCCACCACGCTTAGTTGCGCTCGGGGTTCCGACAGTGCGCGTTGTTTCATGGCCGCGCTGCTACTGTTAGTACAACACTAGGAGGTGCCATCAGGTGGACCTCGTGCAAGGTTCAGGCCACTCACGGTGTTCAATGGTTAGAATGGTATTGCTCGCGACGGCGCCTCCCGTCGTGGTAAGCGCCCACGCAGAACTTAAAACCCTATGGAGATGCTGGGCAACGGGATACTAAGGTAGTTTTGCGAGCGGAACGGCAAGCGAACGGCATACGAAAGCCGGTACGACAACGAGCTCTTCATGCGAGTAGCCAACTAGTAGTAGACAAACAGCGCGGTATGGGGCCAATACTGGTGCGGCTCGGAAGCTACGCCATAATAGCGTTGACCACATCCCTTGACGTAACGGACTCCAAGGGGAGAAGTGCTAAGGAAAAGCCAGTAAGTCATTCAGTTAACCAACGTCT\r\n",
            "\n",
            "output =  468\n",
            "Writen solution to file: rosalind_hamm_output.txt\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_2b8b045a-4d04-42fc-bee9-4ea3c9d88bfe\", \"rosalind_hamm_output.txt\", 3)"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ],
      "source": [
        "rosalind(\"hamm\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "THD4USs4Hn9k"
      },
      "source": [
        "#### [FIB:Rabbits and Recurrence Relations](https://rosalind.info/problems/fib/)\n",
        "Given: Positive integers n≤40\n",
        "and k≤5.\n",
        "\n",
        "Return: The total number of rabbit pairs that will be present after n\n",
        " months, if we begin with 1 pair and in each generation, every pair of reproduction-age rabbits produces a litter of k\n",
        " rabbit pairs (instead of only 1 pair)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6vwGHcXdICxg",
        "outputId": "09dbe857-9376-48a8-e8a4-44ec4f15a817"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "19"
            ]
          },
          "execution_count": 52,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "def fib_alg(pok,miot):\n",
        "\n",
        "  rabits = [0]*pok\n",
        "\n",
        "  rabits[0]=1\n",
        "  rabits[1]=1\n",
        "\n",
        "  for i in range(2,pok):\n",
        "    rabits[i] = rabits[i-1] + rabits[i-2]*miot\n",
        "\n",
        "  return rabits[-1]\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UEECQ0nMHoMW"
      },
      "outputs": [],
      "source": [
        "def fib(input_string):\n",
        "  \"\"\"Solves https://rosalind.info/problems/fib/\n",
        "\n",
        "  Given: Positive integers n≤40\n",
        "  and k≤5.\n",
        "\n",
        "  Return: The total number of rabbit pairs that will be present after n\n",
        "  months, if we begin with 1 pair and in each generation, every pair of\n",
        "  reproduction-age rabbits produces a litter of k  rabbit pairs\n",
        "  (instead of only 1 pair).\n",
        "  \"\"\"\n",
        "  input_list = input_string.split(\" \")\n",
        "  n = int(input_list[0])\n",
        "  k = int(input_list[1])\n",
        "\n",
        "  output = fib_alg(n,k)\n",
        "\n",
        "  return str(output)\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 201
        },
        "id": "iN1UmnhmKPhR",
        "outputId": "faceffa4-a4b9-4a68-d36a-2641cc26a8dd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "First download set from https://rosalind.info/problems/fib\n",
            "Then upload file here by pressing choose file button below\n"
          ]
        },
        {
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-c51dfb77-fdb1-4f1b-b5f1-bd65de962653\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-c51dfb77-fdb1-4f1b-b5f1-bd65de962653\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Saving rosalind_fib (1).txt to rosalind_fib (1) (1).txt\n",
            "data got =  35 4\r\n",
            "\n",
            "output =  48127306357829\n",
            "Writen solution to file: rosalind_fib_output.txt\n"
          ]
        },
        {
          "data": {
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "application/javascript": [
              "download(\"download_bfa5945a-ee5c-43fc-b224-7c153ceae144\", \"rosalind_fib_output.txt\", 14)"
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "execution_count": 55,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "rosalind('fib')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FsNvFz7C8nbI"
      },
      "source": [
        "#### [GC: Computing GC content](https://rosalind.info/problems/gc/)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bcBJUF5Q-6Ax"
      },
      "outputs": [],
      "source": [
        "def gc_alg(seq):\n",
        "  return (seq.count(\"G\") + seq.count(\"C\"))/len(seq)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QbaLIydA8njx"
      },
      "outputs": [],
      "source": [
        "def gc(input_string):\n",
        "  \"\"\" Solves https://rosalind.info/problems/gc/\n",
        "\n",
        "  The GC-content of a DNA string is given by the percentage of symbols\n",
        "  in the string that are 'C' or 'G'. For example, the GC-content of\n",
        "  \"AGCTATAG\" is 37.5%. Note that the reverse complement of any DNA string\n",
        "   has the same GC-content.\n",
        "\n",
        "   \"\"\"\n",
        "  gc_dict = {}\n",
        "  fasta_tup = read_fasta(input_string)\n",
        "\n",
        "\n",
        "  for sequence in fasta_tup:\n",
        "    header = sequence[0]\n",
        "    seq = sequence[1]\n",
        "\n",
        "    gc_con = gc_alg(seq)\n",
        "    gc_dict[header]=gc_con\n",
        "\n",
        "\n",
        "  gc_dict = dict(sorted(gc_dict.items(), key = lambda x:x[1],reverse = True))\n",
        "\n",
        "\n",
        "  for key, value in gc_dict.items():\n",
        "    gc_dict[key] = gc_dict[key]*100\n",
        "    gc_dict[key] = round(gc_dict[key],6)\n",
        "\n",
        "  name = (list(gc_dict.keys())[0])\n",
        "  result = gc_dict[(list(gc_dict.keys())[0])]\n",
        "\n",
        "  output = str(name)+\"\\n\"+str(result)\n",
        "  return output\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IV4yxZxO-57F",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "33713043-d36a-4db8-8bb0-492dd88937c6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "First download set from https://rosalind.info/problems/gc\n",
            "Then upload file here by pressing choose file button below\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-8950e9e4-33a9-4474-85bf-a66a387fdd71\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-8950e9e4-33a9-4474-85bf-a66a387fdd71\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving rosalind_gc.txt to rosalind_gc.txt\n",
            "data got =  >Rosalind_6778\n",
            "ACAGTATCCGCGGACCGGAAAACCCAGGTCACCCTCAAAGCCCATCTGTACAAAAGCACG\n",
            "CGTGACCGCCGGGCTACCCACCGGTAGGGTCTTAGCTAGAGGCGATCTCCGAGCAGGCAA\n",
            "TGATTTCATAACTGGGGTTGCTAGGAGGCGGGGACGCGTTAGCTCCTAAACCTCGGAAAG\n",
            "GCGTTGGAGGGAATCGGTACTTTGTAAGAAGTACTTCGGCGCAGTGTACGACATGGCGGG\n",
            "TAAAAGAGTGCGGGGATCAATCGGATAGGGGATGGCCTTATGCCCATAATGCGCCGCCCC\n",
            "AAAGTAAGAGCACGCTACACCTGGCCGGTGGTCTGAGTCAAGGCACTCTATAGTAGATCT\n",
            "GTTTACGGGCGCTGCACGTCTTACTACAATCTACATTAGAGTAAGCGCACCAAGGTCCTT\n",
            "AAGGTATCACAGCAAGGGTCGGGCTTACGGCGCGCCCAGCCGAGAGCGGACATTAACCTG\n",
            "GGAAATGGATAGAGCCATACGACAGCACCATGACTGGCTACTACTAATGAAAGCAGTGTG\n",
            "ACACAGTGATCGTCGATTTGATGTTTAACTCCTCTCCTATGATCTCCTGACATACGTGTG\n",
            "ACAGTCCGCGATATAGAAGCAGAATGGTGTCAAATTCTACCCTTGTAGGAATCTACGTAT\n",
            "CAGGGATAGACTAAAGTTGCACTCTTCTGGTCTGTTGCGAGCATTGCACCCATATGCTAT\n",
            "ACCAATACTGATCATGTCGCCGAGATCCTTAGAAACTCCGTCCCTCCCCGGCTTCGATCC\n",
            "GCACCGACTGATCGCATTCTACCCAATGCCCTCCCCTGTTTCCATGAAAAACGTGAGTAC\n",
            "GGAAGCTTGAACTGGTCTTGAGTGCGTACCTGGGCGGTTGTTAATAGAGCCTCTTCCGGT\n",
            "CCCAGGGCTCCATCGCCACATCCTTCTGGTATAGGTATCGCAATTCAGTGAAGCCGGCCA\n",
            "GTCGTCGGATCGCAGATTACCCCGAT\n",
            ">Rosalind_9296\n",
            "GCCGCGTAGGCACCTTCATTTTCTATTATTCAGCAGAATTCTGAGCTGTCCCCCCCGTTA\n",
            "GGCGGCGGCCCTAATACGGACCGTCGAAATTGCCGCCCAAATCGAGTCTAGACCCGGGTA\n",
            "GGTTACAGATACGCCTATCCGCTAAGGTATCTACTAATCTGAGGGGATTCCTCATCGTAA\n",
            "GAACACAGGACACTGTAGGAATGAAACCGTCAACTATCTGTAGCCGAAGCATTACATCAA\n",
            "AATTACCGCATGCAAGGCCGCCGCCGACGTGGTATCTAAACTATGAATATAAGAATTGTC\n",
            "CGGCTTACTAATTTCGCAGCATGCTAAACAGACAGGGCTTCGTCCGTGGGGTGATCCTAC\n",
            "CCCTCTGTGACTTCTATCTGCCGGCAGCCTTAGGCGGGGGGCCGCATGACCATTGAGTTC\n",
            "ACTGCCATCTGTCAATAAAAGTTCCTGGTTGACCTCCTTGGCAGTGCCAGGCGCTAAGAT\n",
            "AGGCTACTGGCAGTTTCTGTCTACGGTGCGTATTACCAGGGTCACAGGAGGATAGCATGG\n",
            "GTTTGGGCCGGTATATGCAACATATGAACCCTGCAATCGACATTAGCGTCCTTAGAACGC\n",
            "ACAGTGAGACGCTGCGATAGGCAGCTTACCCTTTAAAAAATCTAAGACGCCGTATGCGCG\n",
            "TAGGTGGATGTGTCGCCGCGGTGCCGTAGAGTGAATAGTGATCTCCACAAATCATGCGCG\n",
            "ATGGGGTGAGAGCCCCTGTTTGGATTAAATCTCCTTGGATACAAACATGCCGATATGCGT\n",
            "ACCTTGCCGTTTGAGATGATCGTTCTTTCGCACGTCTGTCTTGTATGCAAACGGGTCGGT\n",
            "T\n",
            ">Rosalind_1769\n",
            "TACCCGATTGCCACTGTAAATGCGGAAGGTAATGAATACACTTATGATGGGTGTGATCAC\n",
            "CCTTCTCTGTCTGGGCCGAGCCTTGGATGTCTCCGCACTCCGGTATTTTACGCCAATTAG\n",
            "AGCACAAATAAGGGCTGGGGTAGGGTTCCGTCCTAGACAAGCCTGAACAGCATTATGAAT\n",
            "AAGCGTAGCATGCTTACCTACCCAGCGTGCCTCAGCGGCCGGAGCTAGCGTGTAGGTCGC\n",
            "CGTCATTCGCACCACCGATTCAGAGGTGTATATACCGCCATAAGAGTTAGTTACTATGAC\n",
            "AGCAGGAAGAACGTGAAAATGTAAGGGCGATTGTACCACACATCGGGTTCTTGGTGAGTT\n",
            "GTCACTCAACACTGGCGAAACGAGTTGCTAGACCACACGATTAGGTCCCGGCTTCTATAA\n",
            "TGGAAAGGGCTCACGACAACCTGGTTTACCACTCAAGCCTTAGTTGTGCACGAGTTCAAT\n",
            "CGCTCGTATAAGTTAGTAACAGTCGAACTTACTGCACGGCTAGTTCGCGTTATGGAAGCG\n",
            "TACTCATCAATGCACCGTACCGCTGCTACGTGGAGGAGGACTACGTGGTCATAGTACACC\n",
            "ATTGGTGACGTGTTGCACCGTAAGGCTATGACCTTGTATCAGCTCCCTACGCGGGAAGCA\n",
            "ACAACTCTGCATTCTGTAATGTTGAGTTGGTACCCCCTTATCGCGTCGTCCAAAATTATA\n",
            "GACCTCGAGCAAGACCGTCAGTGCCCCTGTAACAGGCTCCCGACGATGTTAGAAAGTCCG\n",
            "CTCTTAACTCCCACAGCCGCAATAGATTCCTCACTTAATCGCTTCTTTGGACTTCTAATC\n",
            "GGTTGTTATCTCCCAGCATTAAGTCAGGTAAACTATACCCCACCTAATCTGATTGTCCGG\n",
            "TTTTCTCCTGTATGTTTTTACCCCACGTG\n",
            ">Rosalind_4236\n",
            "TCTGTCTAGACTTACCTCGCAATCAGCTGTTATTTCTGTAAAGGGCCTTAAGACAAGCCT\n",
            "GCTACTAATCCATCTTCAGAATATCTCGCCATTCGGGCGTGGCACGCTTCAGGACGAGCG\n",
            "TAATGGATACATGGCAGCGGCAGCGGGCCCCTTAGTCACCGCGTACATGTTTTTGGCGAC\n",
            "TGGTCTGAGCTTTAGCAGATACGGACCGAGGCCTGCCCAGAGGAAAGTGCCAGAAACTCT\n",
            "CAAAATCTATGGAGATACAGTACGTGCCTAACAGTATATGCCCCGTTCGGCCCGGCAGTA\n",
            "CATGCGCGCATGGTGCAATTTCTGGACGGTCTGTTACACTCCTCTAGTTTAAGGTTTTTC\n",
            "CACGTCGTGTGCACCCTGCACTAGAAATGCGACAGCGGTATCCCTGCAGGCGGAGAATGT\n",
            "TACGCCAGCGCAACAGGACTATGGAAACAGGACGCATAGGGTGTGCGAGAGACATTGAGA\n",
            "GGCAGCGTGACTGAGCAAGGCTCCTCACAAATGATAGACTGCAGGGGACCTTGACAGGTC\n",
            "TTTGCAGAGGGCAGCATATGATCGTCCTAGGGGGGGATCCCCTCTCCGAACAGCGCGAAA\n",
            "GCGAGAGTGGGTTCCTCGCAGATGATCTGGGCGCTTGAGAGTGCGGATATGTCCGGAGCC\n",
            "TTCCAAGTCCAAACTAGTGCGTTATTATTAGGGCTGGTCCCCATCTTGCCTATTCCTTTA\n",
            "CATGACAATACTCGATGACGGAGTGGTCTCGACTTACTCCGTGCATACTGGATGAGTCCT\n",
            "GTATGTAGGAATCTGTTTAGTGACTACATATCACGACAATCCTGTTGAAGCCAGTTAGGT\n",
            "TGGGAAGTGCCCCTGAATTCGCTGAATTCCTTCGATGGATTTATGAGAGAACGGTGTGAC\n",
            "CTAGAA\n",
            ">Rosalind_9574\n",
            "CGCATTGAGGTCTTTGGGCCGGACGCTAGTTACCTAACCGGCTATCTCCCCTTCCCAGCG\n",
            "CCATTACCTGAAATTCTCATTGATATTCCTTTGCAAACGGAACAGCAGAAACACGAACCA\n",
            "TATACGACCCGCGAGAGCGTGGGCCTGAGAATACAATGTCTGGCGGCCTCCATAGGGTAA\n",
            "AATTCCTGCTAAATGGTGGACAAGCACGTTTGTGCGTTACGGTTCGTATGCTACTGCAGG\n",
            "GTGTTCTCGTGCCACGGCTTTAGATGCATCTGTATCAAAAACTACTTCGACAGCCGACCT\n",
            "ACGACGACAAACCGATATCGATCCGTTCGACTTCTTTTAGCGCGTACGTATACGCGCATT\n",
            "TAGGCCAACTATCGCTAGGGCGACAGAATGTCCCCATTGAATTAATGAAACGTGCGTGAG\n",
            "CATTTTGGTGCAAGTGCTTTGCAATGATACCGGAAAACGCGCGCCGGGCAGGCAATAAGA\n",
            "GGGTAGTATGAATGATCGGGTAACCTGTGTACGTCCAACTACGATTGGCAGCATTAGTCA\n",
            "CGGTTAAGGATCTACGAAATACTCACACGCAATGATTGAAGGGTGCAAAATGATAGACAA\n",
            "ATCGTTCGGATGATAAATGAGTCCGAAAGAGGAACGTATCAAAGCGAGGCGATCCGCTCT\n",
            "AATTGGGGTGCGGGGGCCTACATGAGGAGATTTGATCCTTGACATTGGTCGTGTACTTTA\n",
            "TATGCGCCTCACCGGGGATCAAAAGGACCGGCCCAGTCTCAGATCCTATCCTAGGGGAGA\n",
            "TCTTCTAACTGGGGTCGGCAGTTTACCGCCGGCCTCGTTACGCC\n",
            ">Rosalind_9628\n",
            "CTTTGTTTCGGACCCCCGGCACCATTCATTTTCGGGAAGCCTTTTAAGACCAACGCAGCT\n",
            "TATCTAGTCTTCAATTCGTTCAGGTAGATAATGGATCTTTCTATCTCCGAGTTAATTGCA\n",
            "CCACGGCTCCGGAGCCACTATTTGGATAATTCTCGGGAGCGTAGTATGAGGTATGCAACA\n",
            "TCCAGATGTGCCCTTGAGAACGTACTGGGCTAATCTTATTTGAGGTTCCAGTCCACAATT\n",
            "ATGAACCAAATGACGTGTCCGGTGGCGGGTCGCCTTCAGATAATCCGACCCTACAAATAT\n",
            "TACTCGGCTTTATCATGTGACGTGGCGTCCTTGCCTGCAACCCTGGTGCGCTCTTAAGGC\n",
            "CAGTTGGCTTTACTTCGCCTTGGAGGCAATAAACGGCCTACACCCAGCCTCTCTCCCTAG\n",
            "CACGGAGGCCTCATGCCACTAGCTCATTGACGGCTACCGTCATCACTCAATCCCGCAGCG\n",
            "CCACCGTGTCGCCAGGGTCGTTCTCCTGAAAGTGGCCGCCTTACTATGGCGTCAGGCCCT\n",
            "AGTGGTGGTCAGTGGGCTGATATATTACAGTGTGGGATAGCGTAAATGAAGAAACAGAAC\n",
            "GTATGGACCGGTACCGGTGATAACAAGATGCGCAGGGTACCAGAAACTAGGTTTTTAATT\n",
            "AGGGAATGACTCCTTACACCTATGCGCTATGTGCCACGCACTAAGTCGTTTAGCAAACTA\n",
            "ATGTGGGTGTCCCCGCGCTCAGTGGTCGGTTAGTCGATCGTCTCGCGCAGGCATTGCGTC\n",
            "AATGCGCATACGCGTAGGTAATGGGTTCAGCCTACGTTAAATTGGGATATAAAGTCGC\n",
            "\n",
            "output =  Rosalind_6778\n",
            "52.636917\n",
            "Writen solution to file: rosalind_gc_output.txt\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_cea8a596-65da-4551-9014-32dd3c9f95fd\", \"rosalind_gc_output.txt\", 23)"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ],
      "source": [
        "rosalind('gc')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JnJFoTFxc33c"
      },
      "source": [
        "\n",
        "#### [IPRB:Mendel's First Law](https://rosalind.info/problems/iprb/)\n",
        "Given: Three positive integers k, m, and n,\n",
        " representing a population containing k+m+n\n",
        " organisms: k individuals are homozygous\n",
        " dominant for a factor, m are heterozygous,\n",
        " and n are homozygous recessive.\n",
        "\n",
        "Return: The probability that two randomly selected\n",
        "mating organisms will produce an individual possessing\n",
        " a dominant allele (and thus displaying the dominant\n",
        " phenotype). Assume that any two organisms can mate."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9-KiP5yD09S0"
      },
      "outputs": [],
      "source": [
        "def iprb_alg(d,h,r):\n",
        "\n",
        "  n = d+h+r\n",
        "  n1 = n-1\n",
        "\n",
        "  D_prob_total = d/n\n",
        "  H_prob = h/n\n",
        "  R_prob = r/n\n",
        "\n",
        "  H_prob_total=(\n",
        "  H_prob*(d/n1)           +\n",
        "  H_prob*((h-1)/n1)*0.75  +\n",
        "  H_prob*(r/n1)*0.5\n",
        "  )\n",
        "  R_prob_total=(\n",
        "  R_prob*(d/n1)           +\n",
        "  R_prob*(h/n1)*0.5\n",
        "  )\n",
        "\n",
        "  result = D_prob_total + H_prob_total + R_prob_total\n",
        "  return result\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UZ6j1J-mc4I6"
      },
      "outputs": [],
      "source": [
        "def iprb(input_string):\n",
        "  \"\"\"Solves https://rosalind.info/problems/iprb/\n",
        "\n",
        "  Given: Three positive integers d, h, and r,\n",
        "  representing a population containing k+m+n\n",
        "  organisms: d individuals are homozygous\n",
        "  dominant for a factor, h are heterozygous,\n",
        "  and r are homozygous recessive.\n",
        "\n",
        "  Return: The probability that two randomly selected\n",
        "  mating organisms will produce an individual possessing\n",
        "  a dominant allele (and thus displaying the dominant\n",
        "  phenotype). Assume that any two organisms can mate.\n",
        "  \"\"\"\n",
        "  s = input_string.split(\" \")\n",
        "  output = iprb_alg(int(s[0]),int(s[1]),int(s[2]))\n",
        "  return str(output)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 183
        },
        "id": "v_42SyeN1h7n",
        "outputId": "87abc655-2e3e-498c-bb84-1275d0cebeb6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "First download set from https://rosalind.info/problems/iprb\n",
            "Then upload file here by pressing choose file button below\n"
          ]
        },
        {
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-b1486e8a-e150-44cc-bc28-2ab59dffb2b8\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-b1486e8a-e150-44cc-bc28-2ab59dffb2b8\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Saving rosalind_iprb (1).txt to rosalind_iprb (1) (2).txt\n",
            "30 21 27\r\n",
            "\n",
            "Writen solution to file: rosalind_iprb_output.txt\n"
          ]
        },
        {
          "data": {
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "application/javascript": [
              "download(\"download_d45828d1-3251-422e-be12-09b2e27178be\", \"rosalind_iprb_output.txt\", 18)"
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "execution_count": 11,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "rosalind(\"iprb\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VwcAS2yVQPnp"
      },
      "source": [
        "#### [PROT:Translating RNA into Protein](https://rosalind.info/problems/prot/)\n",
        "Given: An RNA string s\n",
        " corresponding to a strand of mRNA (of length at most 10 kbp).\n",
        "\n",
        "Return: The protein string encoded by s\n",
        "\n",
        "[codon table](https://rosalind.info/glossary/rna-codon-table/)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JqL_0JctRN6b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bf7d3e5e-a311-4e83-e96c-04a7a7990f6b"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'MATNRG'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 1
        }
      ],
      "source": [
        "def prot_alg(seq):\n",
        "  amino_dict = {'F': ['UUU', 'UUC'], 'L': ['UUA', 'UUG', 'CUU', 'CUC', 'CUA', 'CUG'],\n",
        "                'S': ['UCU', 'UCC', 'UCA', 'UCG', 'AGU', 'AGC'], 'Y': ['UAU', 'UAC'],\n",
        "                'STOP': ['UAA', 'UAG', 'UGA'], 'C': ['UGU', 'UGC'], 'W': ['UGG'],\n",
        "                'P': ['CCU', 'CCC', 'CCA', 'CCG'], 'H': ['CAU', 'CAC'], 'Q': ['CAA', 'CAG'],\n",
        "                'R': ['CGU', 'CGC', 'CGA', 'CGG', 'AGA', 'AGG'], 'I': ['AUU', 'AUC', 'AUA'],\n",
        "                'M': ['AUG'], 'T': ['ACU', 'ACC', 'ACA', 'ACG'], 'N': ['AAU', 'AAC'],\n",
        "                'K': ['AAA', 'AAG'], 'V': ['GUU', 'GUC', 'GUA', 'GUG'],\n",
        "                'A': ['GCU', 'GCC', 'GCA', 'GCG'], 'D': ['GAU', 'GAC'],\n",
        "                'E': ['GAA', 'GAG'], 'G': ['GGU', 'GGC', 'GGA', 'GGG']}\n",
        "  i=0\n",
        "  result = \"\"\n",
        "  while i < len(seq):\n",
        "    codon = seq[i:i+3]\n",
        "    if codon in amino_dict[\"STOP\"]:\n",
        "      break\n",
        "    for amino, codons in amino_dict.items():\n",
        "      if codon in codons:\n",
        "        result+=amino\n",
        "    i+=3\n",
        "\n",
        "  return result"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GEKeVIMZQW62"
      },
      "outputs": [],
      "source": [
        "def prot(input_string):\n",
        "  \"\"\"Solves https://rosalind.info/problems/prot/\n",
        "\n",
        "  Given: An RNA string s\n",
        "  corresponding to a strand of mRNA (of length at most 10 kbp).\n",
        "\n",
        "  Return: The protein string encoded by s\n",
        "  \"\"\"\n",
        "  output = prot_alg(input_string)\n",
        "\n",
        "  return output\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "isHB7p4iaGF5"
      },
      "outputs": [],
      "source": [
        "rosalind('prot')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Cn7r4OWISY77"
      },
      "outputs": [],
      "source": [
        "# for manualy inputing codon translations\n",
        "codon_table_text = \"\"\"\n",
        "UUU F      CUU L      AUU I      GUU V\n",
        "UUC F      CUC L      AUC I      GUC V\n",
        "UUA L      CUA L      AUA I      GUA V\n",
        "UUG L      CUG L      AUG M      GUG V\n",
        "UCU S      CCU P      ACU T      GCU A\n",
        "UCC S      CCC P      ACC T      GCC A\n",
        "UCA S      CCA P      ACA T      GCA A\n",
        "UCG S      CCG P      ACG T      GCG A\n",
        "UAU Y      CAU H      AAU N      GAU DC\n",
        "UAC Y      CAC H      AAC N      GAC D\n",
        "UAA Stop   CAA Q      AAA K      GAA E\n",
        "UAG Stop   CAG Q      AAG K      GAG E\n",
        "UGU C      CGU R      AGU S      GGU G\n",
        "UGC C      CGC R      AGC S      GGC G\n",
        "UGA Stop   CGA R      AGA R      GGA G\n",
        "UGG W      CGG R      AGG R      GGG G\n",
        "\"\"\"\n",
        "\n",
        "# codon_table = {}\n",
        "\n",
        "\n",
        "# while True:\n",
        "#   amino_acid = input(\"type amino acid: \")\n",
        "#   if amino_acid == \"done\":\n",
        "#     break\n",
        "#   assert amino_acid.isupper(),\"Not an  uppercase letter\"\n",
        "\n",
        "#   sequence = input(\"type sequence\")\n",
        "#   assert sequence.isupper(),\"Not an  uppercase letter\"\n",
        "\n",
        "#   if amino_acid in codon_table:\n",
        "#     codon_table[amino_acid].append(sequence)\n",
        "#   else:\n",
        "#     codon_table[amino_acid] = [sequence]\n",
        "# print(codon_table)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UE2uj9JG_1c5"
      },
      "source": [
        "#### [SUBS: Finding motif in DNA](https://rosalind.info/problems/subs/)\n",
        "Given two strings s and t, t is a substring of s\n",
        " if t is contained as a contiguous collection of\n",
        " symbols in s (as a result, t must be no longer\n",
        "  than s)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rEzgm6NV2omp"
      },
      "outputs": [],
      "source": [
        "def subs_alg(s,t):\n",
        "  t_len = len(t)\n",
        "  positions = []\n",
        "  i=0\n",
        "  current = s\n",
        "  while i<=len(s)-t_len:\n",
        "    position = s.find(t ,i)\n",
        "\n",
        "    if position != -1:\n",
        "      positions.append(str(position+1))\n",
        "      i = position+1\n",
        "    else:\n",
        "      break\n",
        "  result = \" \".join(positions)\n",
        "\n",
        "  return result\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ip-0KDIP_64k"
      },
      "outputs": [],
      "source": [
        "def subs (input_string):\n",
        "  \"\"\"Solves https://rosalind.info/problems/subs/\n",
        "\n",
        "  Given two strings s and t, t is a substring of s\n",
        " if t is contained as a contiguous collection of\n",
        " symbols in s (as a result, t must be no longer\n",
        "  than s).\n",
        "  \"\"\"\n",
        "\n",
        "  input_list = input_string.splitlines()\n",
        "\n",
        "  output = subs_alg(input_list[0],input_list[1])\n",
        "\n",
        "  return str(output)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 239
        },
        "id": "uRRIsWaG2os4",
        "outputId": "1c26bdc7-508d-4dd6-dfec-f72caa1f7401"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "First download set from https://rosalind.info/problems/subs\n",
            "Then upload file here by pressing choose file button below\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-2473eb3d-2d10-4c53-bfbb-ed3e18daaa97\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-2473eb3d-2d10-4c53-bfbb-ed3e18daaa97\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving rosalind_subs.txt to rosalind_subs.txt\n",
            "data got =  ATATTACCGGACATGGTTTTACCGGATACCGGACGTACCGGAGGTGACTATACCGGATTGGTTACCGGATTACCGGAAGCATACCGGAGTACCGGAGGCTACCGGATTACCGGATAATACCGGACTACCGGACCTGTACCGGATACCGGATGTACCGGATATACCGGAGAGACGTACCGGAACTTACCGGAATACCGGAATACCGGATACCGGATTACCGGAGTACCGGAGATACCGGATACCGGACTTACCGGATTACCGGAATACCGGATACCGGATACCGGATTACCGGAAGTACCGGAAAACACTACCGGATTACCGGAAGCTGCTTACCGGATACCGGATACCGGACATTACCGGACGTACCGGATACCGGATACCGGACCCGGTTACCGGAATACCGGATACCGGAAACCGTACCGGATGAGTAATACCGGATACCGGAGGATTTAGGGTTGGAATACCGGAATACCGGATACCGGAAATACCGGACTACCGGAACTACCGGATTACCGGATTACCGGATACCGGACTACCGGATGCTCATTACCGGACTTCTACCGGATACCGGATACCGGATACCGGACGTTATACCGGAAAAACCAATGCATACCGGATACCGGACTACCGGACGTACCGGAAGACCTACCGGAGTTACCGGATTACCGGATACCGGATACCGGAACCAAGTACCGGACGTACCGGACCGCTGAACGTACCGGACGCCGATACCGGATACCGGATACCGGAATCGACCGGGTACCGGAAGTCTACCGGACTGATACCGGAAATGTACCGGAATTGTACCGGATACCGGAGCTACCGGATACCGGAATCGCTACCGGATATACCGGAATCAAGATACCGGAAATACCGGATACCGGATTTACCGGATACCGGATTATTACCGGA\r\n",
            "TACCGGATA\r\n",
            "\n",
            "output =  20 108 137 153 201 233 265 272 331 338 364 371 399 432 470 519 559 566 573 611 664 671 730 737 805 821 840 872 888\n",
            "Writen solution to file: rosalind_subs_output.txt\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_9adc8571-286b-4db3-ae45-18a97922d8ac\", \"rosalind_subs_output.txt\", 114)"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ],
      "source": [
        "rosalind(\"subs\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cWRP6Ms84C8d"
      },
      "source": [
        "#### [IEV:Calculating Exptected Offspring](https://rosalind.info/problems/iev/)\n",
        "\n",
        "  Given: Six nonnegative integers, each of which does not exceed 20,000.\n",
        "  The integers correspond to the number of couples in a population\n",
        "  possessing each genotype pairing for a given factor. In order,\n",
        "  the six given integers represent the number of couples having the\n",
        "  following genotypes:\n",
        " -  AA-AA\n",
        " - AA-Aa\n",
        " - AA-aa\n",
        " - Aa-Aa\n",
        " - Aa-aa\n",
        " - aa-aa\n",
        "  \n",
        "  Return: The expected number of offspring displaying the dominant phenotype\n",
        "  in the next generation, under the assumption that every couple has exactly\n",
        "  two offspring."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RIg0TKrvAER4",
        "outputId": "9bb708e9-2ace-4892-9af0-9d61cb78234a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "157923.5"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "def iev_alg(DD,DH,DR,HH,HR,RR):\n",
        "  \"\"\" Inputs number of couples with certain genotypes in population\n",
        "\n",
        "  DD - Dominant homozygous - Dominant homozygous\n",
        "  Output - number\n",
        "  \"\"\"\n",
        "  D = DD+DH+DR\n",
        "  dominants = D*2 + HH * 2* 0.75 + HR * 2 * 0.5\n",
        "\n",
        "\n",
        "  return dominants\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yp4JrkDX4DIe"
      },
      "outputs": [],
      "source": [
        "def iev (inlist):\n",
        "  \"\"\"Solves https://rosalind.info/problems/iev/\n",
        "\n",
        "  Given: Six nonnegative integers, each of which does not exceed 20,000.\n",
        "  The integers correspond to the number of couples in a population\n",
        "  possessing each genotype pairing for a given factor. In order,\n",
        "  the six given integers represent the number of couples having the\n",
        "  following genotypes:\n",
        "  AA-AA 100\n",
        "  AA-Aa 100\n",
        "  AA-aa 100\n",
        "  Aa-Aa 75\n",
        "  Aa-aa 50\n",
        "  aa-aa 0\n",
        "  Return: The expected number of offspring displaying the dominant phenotype\n",
        "  in the next generation, under the assumption that every couple has exactly\n",
        "  two offspring.\n",
        "  \"\"\"\n",
        "  instring = inlist.split(\" \")\n",
        "\n",
        "  DD = int(instring[0])\n",
        "  DH = int(instring[1])\n",
        "  DR = int(instring[2])\n",
        "  HH = int(instring[3])\n",
        "  HR = int(instring[4])\n",
        "  RR = int(instring[5])\n",
        "  result = iev_alg(DD,DH,DR,HH,HR,RR)\n",
        "  return str(result)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oMI99wXprRuk"
      },
      "outputs": [],
      "source": [
        "rosalind(\"iev\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F7lMLZ2S50Vn"
      },
      "source": [
        "#### [MPRT:Finding a Protein Motif](https://rosalind.info/problems/mprt/)\n",
        "Given: At most 15 UniProt Protein Database access IDs.\n",
        "\n",
        "Return: For each protein possessing the N-glycosylation motif, output its given access ID followed by a list of locations in the protein string where the motif can be found."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N4jRWtCl6Pck",
        "outputId": "a228aeac-0c1a-4f9e-db3e-f887f741dcad"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[]"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "\n",
        "def mprt_alg(seq):\n",
        "\n",
        "  pattern = \"(?=(N[^P][ST][^P]))\"\n",
        "  matches = []\n",
        "  match  = re.finditer(pattern,seq)\n",
        "  for i in match:\n",
        "    matches.append(i.start()+1)\n",
        "  return matches"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_0ynZosi50i6"
      },
      "outputs": [],
      "source": [
        "import requests\n",
        "import re\n",
        "def mprt(input_string):\n",
        "  \"\"\" Solves https://rosalind.info/problems/mprt/\n",
        "\n",
        "  Given: At most 15 UniProt Protein Database access IDs.\n",
        "\n",
        "  Return: For each protein possessing the N-glycosylation\n",
        "  motif, output its given access ID followed by a list of locations\n",
        "  in the protein string where the motif can be found.\n",
        "  \"\"\"\n",
        "\n",
        "\n",
        "  output = \"\"\n",
        "  input_list = input_string.splitlines()\n",
        "\n",
        "  for seq_id in input_list:\n",
        "\n",
        "    seq_id=seq_id.strip(\"\\n\")\n",
        "    seq_id_f = seq_id\n",
        "    seq_id = seq_id[:6]\n",
        "\n",
        "    url = f\"http://www.uniprot.org/uniprot/\"+seq_id+\".fasta\"\n",
        "\n",
        "    response = requests.get(url)\n",
        "    assert response.status_code == 200, f\"Uncorrect response code {response.status_code} while processing {seq_id} url: {url}\"\n",
        "    sequence = response.text\n",
        "\n",
        "    seq_tup = read_fasta(sequence)\n",
        "\n",
        "    seq = seq_tup[0][1]\n",
        "\n",
        "    matches = mprt_alg(seq)\n",
        "\n",
        "    if len(matches) == 0:\n",
        "      continue\n",
        "    else:\n",
        "      for i in range(len(matches)):\n",
        "        matches[i] = str(matches[i])\n",
        "\n",
        "      matches_str = \" \".join(matches)\n",
        "\n",
        "      output += (seq_id_f+\"\\n\"+matches_str+\"\\n\")\n",
        "\n",
        "\n",
        "  return output\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "NtU8_C9v6PZT",
        "outputId": "b2616bde-77d4-49e7-ccfe-f9630ccb70f3"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "First download set from https://rosalind.info/problems/mprt\n",
            "Then upload file here by pressing choose file button below\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-012a161d-c34e-4e56-b7ae-0aa19c7073fc\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-012a161d-c34e-4e56-b7ae-0aa19c7073fc\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving rosalind_mprt.txt to rosalind_mprt (3).txt\n",
            "data got =  B3PYU7\r\n",
            "Q7S432\r\n",
            "A1X8C2\r\n",
            "A6UDH9\r\n",
            "P02725_GLP_PIG\r\n",
            "P11831_SRF_HUMAN\r\n",
            "B5FNU0\r\n",
            "P42098_ZP3_PIG\r\n",
            "P05231_IL6_HUMAN\r\n",
            "Q8LCP6\r\n",
            "A1TJ10\r\n",
            "P25174\r\n",
            "P28314_PER_COPCI\r\n",
            "A5F5B4\r\n",
            "P00744_PRTZ_BOVIN\r\n",
            "\n",
            ">sp|B3PYU7|HFQ_RHIE6 RNA-binding protein Hfq OS=Rhizobium etli (strain CIAT 652) OX=491916 GN=hfq PE=3 SV=1\n",
            "MAERSQNLQDLFLNTVRKQKISLTIFLINGVKLTGVVTSFDNFCVLLRRDGHSQLVYKHA\n",
            "ISTIMPGQPMQMFESEEAAS\n",
            "\n",
            "[('sp|B3PYU7|HFQ_RHIE6 RNA-binding protein Hfq OS=Rhizobium etli (strain CIAT 652) OX=491916 GN=hfq PE=3 SV=1', 'MAERSQNLQDLFLNTVRKQKISLTIFLINGVKLTGVVTSFDNFCVLLRRDGHSQLVYKHAISTIMPGQPMQMFESEEAAS')]\n",
            ">sp|Q7S432|PSF3_NEUCR DNA replication complex GINS protein psf3 OS=Neurospora crassa (strain ATCC 24698 / 74-OR23-1A / CBS 708.71 / DSM 1257 / FGSC 987) OX=367110 GN=drc-3 PE=3 SV=1\n",
            "MSYYDIDAILTDAEKIPCTFQIDVPDLGYLDNQPGHTLKSGSRVALPIWLAEMLAIANTG\n",
            "AVDMDDPSQSSKSFITFDLPPALGNDVVQALKADPRSVPLRDQSAHFYALATHMMELSEE\n",
            "PELSAVLRKTFVSRAAEIALHARKVGGGGSSYHGRDGGGAGGKGKGKATKDDNASNLGVG\n",
            "GAGEDFLRGLDEWERKLFRSAHDGTKASKEWMENVKKR\n",
            "\n",
            "[('sp|Q7S432|PSF3_NEUCR DNA replication complex GINS protein psf3 OS=Neurospora crassa (strain ATCC 24698 / 74-OR23-1A / CBS 708.71 / DSM 1257 / FGSC 987) OX=367110 GN=drc-3 PE=3 SV=1', 'MSYYDIDAILTDAEKIPCTFQIDVPDLGYLDNQPGHTLKSGSRVALPIWLAEMLAIANTGAVDMDDPSQSSKSFITFDLPPALGNDVVQALKADPRSVPLRDQSAHFYALATHMMELSEEPELSAVLRKTFVSRAAEIALHARKVGGGGSSYHGRDGGGAGGKGKGKATKDDNASNLGVGGAGEDFLRGLDEWERKLFRSAHDGTKASKEWMENVKKR')]\n",
            ">sp|A1X8C2|CA18_CONLE Alpha-conotoxin-like Lp1.8 OS=Conus leopardus OX=101306 PE=3 SV=1\n",
            "MGMRMMFTMFLLVVLTTTVVSFNSDRESNHENRRTSNQITRGVWDECCKDPQCRQNHMQH\n",
            "CPAR\n",
            "\n",
            "[('sp|A1X8C2|CA18_CONLE Alpha-conotoxin-like Lp1.8 OS=Conus leopardus OX=101306 PE=3 SV=1', 'MGMRMMFTMFLLVVLTTTVVSFNSDRESNHENRRTSNQITRGVWDECCKDPQCRQNHMQHCPAR')]\n",
            ">sp|A6UDH9|DXR_SINMW 1-deoxy-D-xylulose 5-phosphate reductoisomerase OS=Sinorhizobium medicae (strain WSM419) OX=366394 GN=dxr PE=3 SV=1\n",
            "MASGDELKRRLTILGSTGSIGTSTLDVIERLGGRDRFEVAALTGNGNIPLLAAQARRMGA\n",
            "ELAVTADGDRYGELKDALSGSGIEVAAGRTGLSEAAERDAGWVMAAIVGNAGLGPTLAAA\n",
            "RRGADIALANKECLVSAGSLFIDAVAEGGGRLLPVDSEHNAIFQVLENDQRHAVERIVLT\n",
            "ASGGPFRTKSLDEMQHVTAEAARAHPNWSMGLKISIDSASMFNKALEMIEARHLFNLRPD\n",
            "QIEVIVHPQSVVHSMVGYADGSVLAQLGCPDMRTAIGYALSYPRRCDLPVERLDFARLAR\n",
            "LDFEAPDEVRFPALRLARRAMEEGGLQGAVLNGAKETALGAFIEGRVGFLDMAEIVEEVM\n",
            "NDLAGLPAATSMDDVFAADEQARQAAAGMIP\n",
            "\n",
            "[('sp|A6UDH9|DXR_SINMW 1-deoxy-D-xylulose 5-phosphate reductoisomerase OS=Sinorhizobium medicae (strain WSM419) OX=366394 GN=dxr PE=3 SV=1', 'MASGDELKRRLTILGSTGSIGTSTLDVIERLGGRDRFEVAALTGNGNIPLLAAQARRMGAELAVTADGDRYGELKDALSGSGIEVAAGRTGLSEAAERDAGWVMAAIVGNAGLGPTLAAARRGADIALANKECLVSAGSLFIDAVAEGGGRLLPVDSEHNAIFQVLENDQRHAVERIVLTASGGPFRTKSLDEMQHVTAEAARAHPNWSMGLKISIDSASMFNKALEMIEARHLFNLRPDQIEVIVHPQSVVHSMVGYADGSVLAQLGCPDMRTAIGYALSYPRRCDLPVERLDFARLARLDFEAPDEVRFPALRLARRAMEEGGLQGAVLNGAKETALGAFIEGRVGFLDMAEIVEEVMNDLAGLPAATSMDDVFAADEQARQAAAGMIP')]\n",
            ">sp|P02725|GLPA_PIG Glycophorin-A OS=Sus scrofa OX=9823 GN=GYPA PE=1 SV=1\n",
            "TETPVTGEQGSATPGNVSNATVTAGKPSATSPGVMTIKNTTAVVQKETGVPESYHQDFSH\n",
            "AEITGIIFAVMAGLLLIIFLIAYLIRRMIKKPLPVPKPQDSPDIGTENTADPSELQDTED\n",
            "PPLTSVEIETPAS\n",
            "\n",
            "[('sp|P02725|GLPA_PIG Glycophorin-A OS=Sus scrofa OX=9823 GN=GYPA PE=1 SV=1', 'TETPVTGEQGSATPGNVSNATVTAGKPSATSPGVMTIKNTTAVVQKETGVPESYHQDFSHAEITGIIFAVMAGLLLIIFLIAYLIRRMIKKPLPVPKPQDSPDIGTENTADPSELQDTEDPPLTSVEIETPAS')]\n",
            ">sp|P11831|SRF_HUMAN Serum response factor OS=Homo sapiens OX=9606 GN=SRF PE=1 SV=1\n",
            "MLPTQAGAAAALGRGSALGGSLNRTPTGRPGGGGGTRGANGGRVPGNGAGLGPGRLEREA\n",
            "AAAAATTPAPTAGALYSGSEGDSESGEEEELGAERRGLKRSLSEMEIGMVVGGPEASAAA\n",
            "TGGYGPVSGAVSGAKPGKKTRGRVKIKMEFIDNKLRRYTTFSKRKTGIMKKAYELSTLTG\n",
            "TQVLLLVASETGHVYTFATRKLQPMITSETGKALIQTCLNSPDSPPRSDPTTDQRMSATG\n",
            "FEETDLTYQVSESDSSGETKDTLKPAFTVTNLPGTTSTIQTAPSTSTTMQVSSGPSFPIT\n",
            "NYLAPVSASVSPSAVSSANGTVLKSTGSGPVSSGGLMQLPTSFTLMPGGAVAQQVPVQAI\n",
            "QVHQAPQQASPSRDSSTDLTQTSSSGTVTLPATIMTSSVPTTVGGHMMYPSPHAVMYAPT\n",
            "SGLGDGSLTVLNAFSQAPSTMQVSHSQVQEPGGVPQVFLTASSGTVQIPVSAVQLHQMAV\n",
            "IGQQAGSSSNLTELQVVNLDTAHSTKSE\n",
            "\n",
            "[('sp|P11831|SRF_HUMAN Serum response factor OS=Homo sapiens OX=9606 GN=SRF PE=1 SV=1', 'MLPTQAGAAAALGRGSALGGSLNRTPTGRPGGGGGTRGANGGRVPGNGAGLGPGRLEREAAAAAATTPAPTAGALYSGSEGDSESGEEEELGAERRGLKRSLSEMEIGMVVGGPEASAAATGGYGPVSGAVSGAKPGKKTRGRVKIKMEFIDNKLRRYTTFSKRKTGIMKKAYELSTLTGTQVLLLVASETGHVYTFATRKLQPMITSETGKALIQTCLNSPDSPPRSDPTTDQRMSATGFEETDLTYQVSESDSSGETKDTLKPAFTVTNLPGTTSTIQTAPSTSTTMQVSSGPSFPITNYLAPVSASVSPSAVSSANGTVLKSTGSGPVSSGGLMQLPTSFTLMPGGAVAQQVPVQAIQVHQAPQQASPSRDSSTDLTQTSSSGTVTLPATIMTSSVPTTVGGHMMYPSPHAVMYAPTSGLGDGSLTVLNAFSQAPSTMQVSHSQVQEPGGVPQVFLTASSGTVQIPVSAVQLHQMAVIGQQAGSSSNLTELQVVNLDTAHSTKSE')]\n",
            ">sp|B5FNU0|ARND_SALDC Probable 4-deoxy-4-formamido-L-arabinose-phosphoundecaprenol deformylase ArnD OS=Salmonella dublin (strain CT_02021853) OX=439851 GN=arnD PE=3 SV=1\n",
            "MTKVGLRIDVDTLRGTREGVPRLLATLHRHGVQASFFFSVGPDNMGRHLWRLIRPRFLWK\n",
            "MLRSNAASLYGWDILLAGTAWPGKNIGNANAGIIRETATYHETGLHAWDHHAWQTHSGHW\n",
            "SIRQLEEDIARGITALEAIIGKPVTCSAAAGWRADGRVVRAKEPFNLRYNSDCRGTTLFR\n",
            "PLLMPGQTGTPQIPVTLPTWDEVIGPAVQAQSFNTWIISRMLQDKGTPVYTIHAEVEGIV\n",
            "HQPLFEDLLVRARDAGITFCPLGELLPTSPESLPLGQIVRGHIPGREGWLGCQQAASAS\n",
            "\n",
            "[('sp|B5FNU0|ARND_SALDC Probable 4-deoxy-4-formamido-L-arabinose-phosphoundecaprenol deformylase ArnD OS=Salmonella dublin (strain CT_02021853) OX=439851 GN=arnD PE=3 SV=1', 'MTKVGLRIDVDTLRGTREGVPRLLATLHRHGVQASFFFSVGPDNMGRHLWRLIRPRFLWKMLRSNAASLYGWDILLAGTAWPGKNIGNANAGIIRETATYHETGLHAWDHHAWQTHSGHWSIRQLEEDIARGITALEAIIGKPVTCSAAAGWRADGRVVRAKEPFNLRYNSDCRGTTLFRPLLMPGQTGTPQIPVTLPTWDEVIGPAVQAQSFNTWIISRMLQDKGTPVYTIHAEVEGIVHQPLFEDLLVRARDAGITFCPLGELLPTSPESLPLGQIVRGHIPGREGWLGCQQAASAS')]\n",
            ">sp|P42098|ZP3_PIG Zona pellucida sperm-binding protein 3 OS=Sus scrofa OX=9823 GN=ZP3 PE=1 SV=1\n",
            "MAPSWRFFVCFLLWGGTELCSPQPVWQDEGQRLRPSKPPTVMVECQEAQLVVIVSKDLFG\n",
            "TGKLIRPADLSLGPAKCEPLVSQDTDAVVRFEVGLHECGSSLQVTDDALVYSTFLRHDPR\n",
            "PAGNLSILRTNRAEVPIECHYPRQGNVSSWAILPTWVPFRTTVFSEEKLVFSLRLMEENW\n",
            "SAEKMTPTFQLGDRAHLQAQVHTGSHVPLRLFVDHCVATLTPDWNTSPSHTIVDFHGCLV\n",
            "DGLTEASSAFKAPRPGPETLQFTVDVFHFANDSRNTIYITCHLKVTPADRVPDQLNKACS\n",
            "FSKSSNRWSPVEGPAVICRCCHKGQCGTPSLSRKLSMPKRQSAPRSRRHVTDEADVTVGP\n",
            "LIFLGKTSDHGVEGSTSSPTSVMVGLGLATVVTLTLATIVLGVPRRRRAAAHLVCPVSAS\n",
            "Q\n",
            "\n",
            "[('sp|P42098|ZP3_PIG Zona pellucida sperm-binding protein 3 OS=Sus scrofa OX=9823 GN=ZP3 PE=1 SV=1', 'MAPSWRFFVCFLLWGGTELCSPQPVWQDEGQRLRPSKPPTVMVECQEAQLVVIVSKDLFGTGKLIRPADLSLGPAKCEPLVSQDTDAVVRFEVGLHECGSSLQVTDDALVYSTFLRHDPRPAGNLSILRTNRAEVPIECHYPRQGNVSSWAILPTWVPFRTTVFSEEKLVFSLRLMEENWSAEKMTPTFQLGDRAHLQAQVHTGSHVPLRLFVDHCVATLTPDWNTSPSHTIVDFHGCLVDGLTEASSAFKAPRPGPETLQFTVDVFHFANDSRNTIYITCHLKVTPADRVPDQLNKACSFSKSSNRWSPVEGPAVICRCCHKGQCGTPSLSRKLSMPKRQSAPRSRRHVTDEADVTVGPLIFLGKTSDHGVEGSTSSPTSVMVGLGLATVVTLTLATIVLGVPRRRRAAAHLVCPVSASQ')]\n",
            ">sp|P05231|IL6_HUMAN Interleukin-6 OS=Homo sapiens OX=9606 GN=IL6 PE=1 SV=1\n",
            "MNSFSTSAFGPVAFSLGLLLVLPAAFPAPVPPGEDSKDVAAPHRQPLTSSERIDKQIRYI\n",
            "LDGISALRKETCNKSNMCESSKEALAENNLNLPKMAEKDGCFQSGFNEETCLVKIITGLL\n",
            "EFEVYLEYLQNRFESSEEQARAVQMSTKVLIQFLQKKAKNLDAITTPDPTTNASLLTKLQ\n",
            "AQNQWLQDMTTHLILRSFKEFLQSSLRALRQM\n",
            "\n",
            "[('sp|P05231|IL6_HUMAN Interleukin-6 OS=Homo sapiens OX=9606 GN=IL6 PE=1 SV=1', 'MNSFSTSAFGPVAFSLGLLLVLPAAFPAPVPPGEDSKDVAAPHRQPLTSSERIDKQIRYILDGISALRKETCNKSNMCESSKEALAENNLNLPKMAEKDGCFQSGFNEETCLVKIITGLLEFEVYLEYLQNRFESSEEQARAVQMSTKVLIQFLQKKAKNLDAITTPDPTTNASLLTKLQAQNQWLQDMTTHLILRSFKEFLQSSLRALRQM')]\n",
            ">sp|Q8LCP6|GUN10_ARATH Endoglucanase 10 OS=Arabidopsis thaliana OX=3702 GN=At1g75680 PE=2 SV=2\n",
            "MEEKSKSRGWCGWFIAIIVLASVILAVVYTVKLRTKKSGDDDGGGPVPGPPGAIDKKYAD\n",
            "ALKLALQFFDIQKSGKLENNKIPWRGDSGLKDGSEDNLDLSKGLYDAGDHIKFGFPMAFT\n",
            "ATVLSWSILEYGDQMNAVNQLDPAKDSLRWITDYLIKAHPSDNVLYIQVGDPKVDHPCWE\n",
            "RPEDMKEKRPLTKIDVDTPGTEVAAETAAAMASASLVFKDSDPTYSATLLKHAKQLFNFA\n",
            "DTKRGSYSVNIPEVQKFYNSTGYGDELLWAASWLYHATEDKTYLDYVSNHGKEFASFGNP\n",
            "TWFSWDNKLAGTQVLLSRLLFFKKDLSGSKGLGNYRNTAKAVMCGLLPKSPTSTASRTNG\n",
            "GLIWVSEWNSMQQSVSSAFLASLFSDYMLTSRIHKISCDGKIFKATELRDFAKSQADYML\n",
            "GKNPLGTSFVVGYGDKYPQFVHHRGASIPADATTGCLDGFKWFNSTKPNPNIAYGALVGG\n",
            "PFFNETFTDSRENPMQNEPTTYNNALLVGLLSSLVTTSSTLQSLK\n",
            "\n",
            "[('sp|Q8LCP6|GUN10_ARATH Endoglucanase 10 OS=Arabidopsis thaliana OX=3702 GN=At1g75680 PE=2 SV=2', 'MEEKSKSRGWCGWFIAIIVLASVILAVVYTVKLRTKKSGDDDGGGPVPGPPGAIDKKYADALKLALQFFDIQKSGKLENNKIPWRGDSGLKDGSEDNLDLSKGLYDAGDHIKFGFPMAFTATVLSWSILEYGDQMNAVNQLDPAKDSLRWITDYLIKAHPSDNVLYIQVGDPKVDHPCWERPEDMKEKRPLTKIDVDTPGTEVAAETAAAMASASLVFKDSDPTYSATLLKHAKQLFNFADTKRGSYSVNIPEVQKFYNSTGYGDELLWAASWLYHATEDKTYLDYVSNHGKEFASFGNPTWFSWDNKLAGTQVLLSRLLFFKKDLSGSKGLGNYRNTAKAVMCGLLPKSPTSTASRTNGGLIWVSEWNSMQQSVSSAFLASLFSDYMLTSRIHKISCDGKIFKATELRDFAKSQADYMLGKNPLGTSFVVGYGDKYPQFVHHRGASIPADATTGCLDGFKWFNSTKPNPNIAYGALVGGPFFNETFTDSRENPMQNEPTTYNNALLVGLLSSLVTTSSTLQSLK')]\n",
            ">sp|A1TJ10|RL2_PARC0 Large ribosomal subunit protein uL2 OS=Paracidovorax citrulli (strain AAC00-1) OX=397945 GN=rplB PE=3 SV=1\n",
            "MAVIKMKPTSPGQRAVVKVTRDHLYKGEAFAALLEPQHQKSGRNNNGHITTRHKGGGHKH\n",
            "HYRVVDFKRNKDAIPAKVERIEYDPNRTAHIALVCYADGERRYIIAPRNLEVGATIVSGS\n",
            "EAPIRVGNTLPIRNIPVGSTIHCIELKPGAGAQIARSAGTSATLLAREGTYAQVRMRSGE\n",
            "VRRIHIECRATIGEVANEEHSLRQLGKAGVKRWMGIRPTVRGVAMNPIDHPHGGGEGRTG\n",
            "EGRHAVDPWGNLTKGYRTRNNKRTQVMIVSRRKK\n",
            "\n",
            "[('sp|A1TJ10|RL2_PARC0 Large ribosomal subunit protein uL2 OS=Paracidovorax citrulli (strain AAC00-1) OX=397945 GN=rplB PE=3 SV=1', 'MAVIKMKPTSPGQRAVVKVTRDHLYKGEAFAALLEPQHQKSGRNNNGHITTRHKGGGHKHHYRVVDFKRNKDAIPAKVERIEYDPNRTAHIALVCYADGERRYIIAPRNLEVGATIVSGSEAPIRVGNTLPIRNIPVGSTIHCIELKPGAGAQIARSAGTSATLLAREGTYAQVRMRSGEVRRIHIECRATIGEVANEEHSLRQLGKAGVKRWMGIRPTVRGVAMNPIDHPHGGGEGRTGEGRHAVDPWGNLTKGYRTRNNKRTQVMIVSRRKK')]\n",
            ">sp|P25174|VP4_ROTPY Outer capsid protein VP4 OS=Rotavirus A (strain RVA/Pig/Mexico/YM/1983/G11P9[7]) OX=10919 PE=3 SV=1\n",
            "MASLNYRQLLTNSYTVNLSDEIQEIGSAKAQNVTINPGPFAQTGYAPVNWGAGETNDSTT\n",
            "VEPLLDGPYQPTTFNPPTSYWVLLAPTVEGVIIQGTNNTDRWLATILIEPNVQTTNRTYN\n",
            "LFGQQVTLSVDNTSQTQWKFIDVSKTTLTGNYTQHGPLFSTPKLYAVMKFSGRIYTYNGT\n",
            "TPNATTGYYSTTNYDTVNMTSFCDFYIIPRNQEEKCTEYINHGLPPIQNTRNVVPVSLSA\n",
            "REIVHTRAQVNEDIVVSKTSLWKEMQYNRDITIRFKFDRTIIKAGGLGYKWSEISFKPIT\n",
            "YQYTYTRDGEQITAHTTCSVNGVNNFSYNGGSLPTDFAISRYEVIKENSFVYIDYWDDSQ\n",
            "AFRNMVYVRSLAANLNTVTCTGGSYSFALPLGNYPVMTGGTVTLHPAGVTLSTQFTDFVS\n",
            "LNSLRFRFRLTVGEPSFSITRTRVSRLYGLPAANPNNQREHYEISGRLSLISLVPSNDDY\n",
            "QTPIMNSVTVRQDLERQLGELRDEFNSLSQQIAMSQLIDLALLPLDMFSMFSGIKSTIDA\n",
            "AKSMATNVMKRFKRSNLASSVSTLTDAMSDAASSISRSSSIRSIGSSASAWTEVSTSITD\n",
            "ISTTVDTVSTQTATIAKRLRLKEIATQTDGMNFDDISAAVLKTKIDKSAQITPSTLPEIV\n",
            "TEASEKFIPNRTYRVINNDEVFEAGMDGKFFAYRVDTFDEIPFDVQKFADLVTDSPVISA\n",
            "IIDLKTLKNLKDNYGISKQQAFDLLRSDPKVLREFINQNNPIIRNRIENLIMQCRL\n",
            "\n",
            "[('sp|P25174|VP4_ROTPY Outer capsid protein VP4 OS=Rotavirus A (strain RVA/Pig/Mexico/YM/1983/G11P9[7]) OX=10919 PE=3 SV=1', 'MASLNYRQLLTNSYTVNLSDEIQEIGSAKAQNVTINPGPFAQTGYAPVNWGAGETNDSTTVEPLLDGPYQPTTFNPPTSYWVLLAPTVEGVIIQGTNNTDRWLATILIEPNVQTTNRTYNLFGQQVTLSVDNTSQTQWKFIDVSKTTLTGNYTQHGPLFSTPKLYAVMKFSGRIYTYNGTTPNATTGYYSTTNYDTVNMTSFCDFYIIPRNQEEKCTEYINHGLPPIQNTRNVVPVSLSAREIVHTRAQVNEDIVVSKTSLWKEMQYNRDITIRFKFDRTIIKAGGLGYKWSEISFKPITYQYTYTRDGEQITAHTTCSVNGVNNFSYNGGSLPTDFAISRYEVIKENSFVYIDYWDDSQAFRNMVYVRSLAANLNTVTCTGGSYSFALPLGNYPVMTGGTVTLHPAGVTLSTQFTDFVSLNSLRFRFRLTVGEPSFSITRTRVSRLYGLPAANPNNQREHYEISGRLSLISLVPSNDDYQTPIMNSVTVRQDLERQLGELRDEFNSLSQQIAMSQLIDLALLPLDMFSMFSGIKSTIDAAKSMATNVMKRFKRSNLASSVSTLTDAMSDAASSISRSSSIRSIGSSASAWTEVSTSITDISTTVDTVSTQTATIAKRLRLKEIATQTDGMNFDDISAAVLKTKIDKSAQITPSTLPEIVTEASEKFIPNRTYRVINNDEVFEAGMDGKFFAYRVDTFDEIPFDVQKFADLVTDSPVISAIIDLKTLKNLKDNYGISKQQAFDLLRSDPKVLREFINQNNPIIRNRIENLIMQCRL')]\n",
            ">sp|P28314|PER_COPCI Peroxidase OS=Coprinopsis cinerea OX=5346 GN=CIP1 PE=1 SV=2\n",
            "MKLSLLSTFAAVIIGALALPQGPGGGGSVTCPGGQSTSNSQCCVWFDVLDDLQTNFYQGS\n",
            "KCESPVRKILRIVFHDAIGFSPALTAAGQFGGGGADGSIIAHSNIELAFPANGGLTDTVE\n",
            "ALRAVGINHGVSFGDLIQFATAVGMSNCPGSPRLEFLTGRSNSSQPSPPSLIPGPGNTVT\n",
            "AILDRMGDAGFSPDEVVDLLAAHSLASQEGLNSAIFRSPLDSTPQVFDTQFYIETLLKGT\n",
            "TQPGPSLGFAEELSPFPGEFRMRSDALLARDSRTACRWQSMTSSNEVMGQRYRAAMAKMS\n",
            "VLGFDRNALTDCSDVIPSAVSNNAAPVIPGGLTVDDIEVSCPSEPFPEIATASGPLPSLA\n",
            "PAP\n",
            "\n",
            "[('sp|P28314|PER_COPCI Peroxidase OS=Coprinopsis cinerea OX=5346 GN=CIP1 PE=1 SV=2', 'MKLSLLSTFAAVIIGALALPQGPGGGGSVTCPGGQSTSNSQCCVWFDVLDDLQTNFYQGSKCESPVRKILRIVFHDAIGFSPALTAAGQFGGGGADGSIIAHSNIELAFPANGGLTDTVEALRAVGINHGVSFGDLIQFATAVGMSNCPGSPRLEFLTGRSNSSQPSPPSLIPGPGNTVTAILDRMGDAGFSPDEVVDLLAAHSLASQEGLNSAIFRSPLDSTPQVFDTQFYIETLLKGTTQPGPSLGFAEELSPFPGEFRMRSDALLARDSRTACRWQSMTSSNEVMGQRYRAAMAKMSVLGFDRNALTDCSDVIPSAVSNNAAPVIPGGLTVDDIEVSCPSEPFPEIATASGPLPSLAPAP')]\n",
            ">sp|A5F5B4|MURA_VIBC3 UDP-N-acetylglucosamine 1-carboxyvinyltransferase OS=Vibrio cholerae serotype O1 (strain ATCC 39541 / Classical Ogawa 395 / O395) OX=345073 GN=murA PE=3 SV=1\n",
            "MEKFRVIGSTQPLQGEVTISGAKNAALPILFASILAEEPVEVANVPHLRDIDTTMELLER\n",
            "LGAKVERNGSVHVDAGPINQYCAPYDLVKTMRASIWALGPLVARFGQGQVSLPGGCAIGA\n",
            "RPVDLHIHGLEQLGATITLEDGYVKAHVDGRLQGAHIVMDKVSVGATITIMCAATLAEGT\n",
            "TVLDNAAREPEIVDTAMFLNKLGAKISGAGTDSITIEGVERLGGGKHAVVPDRIETGTFL\n",
            "VAAAVSRGKIVCRNTHAHLLEAVLAKLEEAGAEIECGEDWISLDMTGRELKAVTVRTAPH\n",
            "PGFPTDMQAQFTLLNMMAKGGGVITETIFENRFMHVPELKRMGAKAEIEGNTVICGDVDR\n",
            "LSGAQVMATDLRASASLVIAGCIAKGETIVDRIYHIDRGYERIEDKLSALGANIERFRD\n",
            "\n",
            "[('sp|A5F5B4|MURA_VIBC3 UDP-N-acetylglucosamine 1-carboxyvinyltransferase OS=Vibrio cholerae serotype O1 (strain ATCC 39541 / Classical Ogawa 395 / O395) OX=345073 GN=murA PE=3 SV=1', 'MEKFRVIGSTQPLQGEVTISGAKNAALPILFASILAEEPVEVANVPHLRDIDTTMELLERLGAKVERNGSVHVDAGPINQYCAPYDLVKTMRASIWALGPLVARFGQGQVSLPGGCAIGARPVDLHIHGLEQLGATITLEDGYVKAHVDGRLQGAHIVMDKVSVGATITIMCAATLAEGTTVLDNAAREPEIVDTAMFLNKLGAKISGAGTDSITIEGVERLGGGKHAVVPDRIETGTFLVAAAVSRGKIVCRNTHAHLLEAVLAKLEEAGAEIECGEDWISLDMTGRELKAVTVRTAPHPGFPTDMQAQFTLLNMMAKGGGVITETIFENRFMHVPELKRMGAKAEIEGNTVICGDVDRLSGAQVMATDLRASASLVIAGCIAKGETIVDRIYHIDRGYERIEDKLSALGANIERFRD')]\n",
            ">sp|P00744|PROZ_BOVIN Vitamin K-dependent protein Z OS=Bos taurus OX=9913 GN=PROZ PE=1 SV=1\n",
            "AGSYLLEELFEGHLEKECWEEICVYEEAREVFEDDETTDEFWRTYMGGSPCASQPCLNNG\n",
            "SCQDSIRGYACTCAPGYEGPNCAFAESECHPLRLDGCQHFCYPGPESYTCSCARGHKLGQ\n",
            "DRRSCLPHDRCACGTLGPECCQRPQGSQQNLLPFPWQVKLTNSEGKDFCGGVLIQDNFVL\n",
            "TTATCSLLYANISVKTRSHFRLHVRGVHVHTRFEADTGHNDVALLDLARPVRCPDAGRPV\n",
            "CTADADFADSVLLPQPGVLGGWTLRGREMVPLRLRVTHVEPAECGRALNATVTTRTSCER\n",
            "GAAAGAARWVAGGAVVREHRGAWFLTGLLGAAPPEGPGPLLLIKVPRYALWLRQVTQQPS\n",
            "RASPRGDRGQGRDGEPVPGDRGGRWAPTALPPGPLV\n",
            "\n",
            "[('sp|P00744|PROZ_BOVIN Vitamin K-dependent protein Z OS=Bos taurus OX=9913 GN=PROZ PE=1 SV=1', 'AGSYLLEELFEGHLEKECWEEICVYEEAREVFEDDETTDEFWRTYMGGSPCASQPCLNNGSCQDSIRGYACTCAPGYEGPNCAFAESECHPLRLDGCQHFCYPGPESYTCSCARGHKLGQDRRSCLPHDRCACGTLGPECCQRPQGSQQNLLPFPWQVKLTNSEGKDFCGGVLIQDNFVLTTATCSLLYANISVKTRSHFRLHVRGVHVHTRFEADTGHNDVALLDLARPVRCPDAGRPVCTADADFADSVLLPQPGVLGGWTLRGREMVPLRLRVTHVEPAECGRALNATVTTRTSCERGAAAGAARWVAGGAVVREHRGAWFLTGLLGAAPPEGPGPLLLIKVPRYALWLRQVTQQPSRASPRGDRGQGRDGEPVPGDRGGRWAPTALPPGPLV')]\n",
            "output =  Q7S432\n",
            "173\n",
            "A6UDH9\n",
            "207\n",
            "P02725_GLP_PIG\n",
            "16 19 39\n",
            "P11831_SRF_HUMAN\n",
            "319 490\n",
            "P42098_ZP3_PIG\n",
            "124 146 179 271\n",
            "P05231_IL6_HUMAN\n",
            "73 172\n",
            "Q8LCP6\n",
            "259 464 484\n",
            "A1TJ10\n",
            "86 251\n",
            "P25174\n",
            "17 32 56 97 116 132 151 178 183 198 325 670\n",
            "P28314_PER_COPCI\n",
            "162\n",
            "A5F5B4\n",
            "68\n",
            "P00744_PRTZ_BOVIN\n",
            "59 191 289\n",
            "\n",
            "Writen solution to file: rosalind_mprt_output.txt\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_fa6adfc0-e4b2-4ab8-a454-0dd1ebc0cc50\", \"rosalind_mprt_output.txt\", 270)"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ],
      "source": [
        "rosalind('mprt')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### [PRTM:Calculating Protein Mass](https://rosalind.info/problems/prtm/)\n",
        "\n",
        "Given: A protein string P of length at most 1000 aa.\n",
        "\n",
        "Return: The total weight of P. Consult the [monoisotopic mass table.](https://rosalind.info/glossary/monoisotopic-mass-table/)"
      ],
      "metadata": {
        "id": "Elp2fFmrCn6-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def prtm_alg(aa_seq,mass_dict):\n",
        "  result = 0\n",
        "  for aa in aa_seq:\n",
        "    if aa in mass_dict:\n",
        "      result+=mass_dict[aa]\n",
        "  return result\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rpyNFZdGCoE_",
        "outputId": "5996f4bc-2581-4def-bc87-90581d580838"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "821.3919199999999"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def prtm (input_string):\n",
        "  \"\"\" Solves https://rosalind.info/problems/prtm/\n",
        "\n",
        "  Given: A protein string P of length at most 1000 aa.\n",
        "\n",
        "  Return: The total weight of P. Consult the monoisotopic mass table.\n",
        "  \"\"\"\n",
        "  mass_dict = {\n",
        "    'A': 71.03711,\n",
        "    'C': 103.00919,\n",
        "    'D': 115.02694,\n",
        "    'E': 129.04259,\n",
        "    'F': 147.06841,\n",
        "    'G': 57.02146,\n",
        "    'H': 137.05891,\n",
        "    'I': 113.08406,\n",
        "    'K': 128.09496,\n",
        "    'L': 113.08406,\n",
        "    'M': 131.04049,\n",
        "    'N': 114.04293,\n",
        "    'P': 97.05276,\n",
        "    'Q': 128.05858,\n",
        "    'R': 156.10111,\n",
        "    'S': 87.03203,\n",
        "    'T': 101.04768,\n",
        "    'V': 99.06841,\n",
        "    'W': 186.07931,\n",
        "    'Y': 163.06333\n",
        "}\n",
        "\n",
        "\n",
        "  output = prtm_alg(input_string,mass_dict)\n",
        "  return str(round(output,3))\n",
        "\n",
        "\n",
        "# test\n",
        "#prtm(\"SKADYEK\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tx_YcVflCoLG",
        "outputId": "f3090f9e-e69e-4c85-bf39-9ff74a0b4881"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'821.392'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rosalind(\"prtm\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wWVB_NdoCoPx",
        "outputId": "fd95e455-35bd-48aa-cc39-80bd06309a2c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "First download set from https://rosalind.info/problems/prtm\n",
            "Then upload file here by pressing choose file button below\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-db2b331f-00a0-4405-96f0-194dd6e166c6\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-db2b331f-00a0-4405-96f0-194dd6e166c6\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving rosalind_prtm.txt to rosalind_prtm (1).txt\n",
            "data got =  GDGYYLTDDRNKYHKGMPSVAIRARGECAGLNLKRCWWNCMYPWYQLKIFRVLKGFNHVGQFGCKMRFKCILNWFCKWYDVMGVVICMLEMWHKIPEFPNAGINSHIFLRSVLEYYMYPEWIWDYHLIDFLMFISCEVHRCLFHWHWVFLYFLYWILSAIWGHHRNSVDDWQKRISMWFGNQLCNWTVQIWWCIAECSTHSNDPMPICLYDWLLMVTTSHVTQFVWRCMAFWKDCHGKDYLYWITGWEMAFPQYMSAKNIFAVTDRSVWQHSPVIPNSLRWTLHTLLRCLPGLITLTFPIKEYYHALQHHVFRTWKDQKLFTQYEMQHNICCNQWNRAAWAYHGDQPILSTWWITKKFGCEFSKDYMPFRMLIPDRIGFSWYAFMRVKKHWWRAERSSAFIWNTGQTPRKRNNEPYMESSMPQARHMDSVWFGVKPVSQVKTFKTKQPEHGHMYEGKPKHKPFLWGELRFNGGCLVYNSPANVTWKRFMCGCHRFETQRFFRVDCTYHNICHYHNAAAWKWHTPFKIYPRETVVVYKAMPMKEIYPCYGWWDKDWFLHTAGMTYDYEYSAQMRYEVDYIEESKSNSVMYNPTIDSNVLVSKPRARKILEPRRVTSHHDCTKWHYITLDENNTIQSDVIMKELSYNHHNAYANKFTGCYSCSLEQQHMNDRNEWKNPHTQWWFVLLWLWMHQRLQKEHWCVIMSHRIKSGNINYNNCTASHRCNPHKMSQNTLGLPNVNHDWMDSDIFKAVILFPWLWLHIPMAYFRADATSVYVGAFVYDVNPPTLDIKLASPSAVDDQCVILCELCMNLANYCWNHQIWPSADQGTVSNAENFKEPLLTDALVMWDGKEDKKHWIEHAVFLCNLRKTHHRAKVQDWPRTFWLGDPKSTCQHLAHGSYKQIFLIYVMWF\r\n",
            "\n",
            "output =  109494.876\n",
            "Writen solution to file: rosalind_prtm_output.txt\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_c4374190-78a8-42ec-87c3-1824a21b0bbd\", \"rosalind_prtm_output.txt\", 10)"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### [SPLC: Splicing RNA](https://rosalind.info/problems/splc/)\n",
        "\n",
        "Given: A DNA string s (of length at most 1 kbp) and\n",
        "a collection of substrings of s acting as introns.\n",
        "All strings are given in FASTA format.\n",
        "\n",
        "Return: A protein string resulting from transcribing\n",
        "and translating the exons of s.\n",
        "(Note: Only one solution will exist for the dataset provided.)"
      ],
      "metadata": {
        "id": "JcCbPGDmFkSt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def remove_introns(seq, intron_list):\n",
        "  for intron in intron_list:\n",
        "    seq = seq.replace(intron,\"\")\n",
        "  return seq"
      ],
      "metadata": {
        "id": "2e0T_BuMFkak"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def splc(input_string):\n",
        "  \"\"\"Solves https://rosalind.info/problems/splc/\n",
        "\n",
        "  Uses prot_alg from PROT and rna_alg from RNA\n",
        "  Given: A DNA string s (of length at most 1 kbp) and\n",
        "  a collection of substrings of s acting as introns.\n",
        "  All strings are given in FASTA format.\n",
        "\n",
        "  Return: A protein string resulting from transcribing\n",
        "  and translating the exons of s.\n",
        "  (Note: Only one solution will exist for the dataset provided.)\n",
        "  \"\"\"\n",
        "  intron_list = []\n",
        "\n",
        "  input = read_fasta(input_string)\n",
        "  seq = input[0][1]\n",
        "  for tup in input[1:]:\n",
        "    intron_list.append(tup[1])\n",
        "\n",
        "\n",
        "\n",
        "  exons = remove_introns(seq,intron_list)\n",
        "  exons = rna_alg(exons)\n",
        "  output = prot_alg(exons)\n",
        "  return output"
      ],
      "metadata": {
        "id": "5QVZHBb6Fkgh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rosalind(\"splc\")"
      ],
      "metadata": {
        "id": "bb5f_CVQFkm_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "####[CONS:Consensus and Profile](https://rosalind.info/problems/cons/)\n",
        "Given: A collection of at most 10 DNA strings of equal length (at most 1 kbp) in FASTA format.\n",
        "\n",
        "Return: A consensus string and profile matrix for the collection.\n",
        "(If several possible consensus strings exist, then you may return\n",
        "any one of them.)"
      ],
      "metadata": {
        "id": "p5PxfeE9Am6m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def cons_alg(sequences):\n",
        "  l = len(sequences[0])\n",
        "  A = [0]*l\n",
        "  C = [0]*l\n",
        "  G = [0]*l\n",
        "  T = [0]*l\n",
        "  for sequence in sequences:\n",
        "    for i in range(l):\n",
        "      nuc = sequence[i]\n",
        "      if nuc == \"A\":\n",
        "        A[i]+=1\n",
        "      elif nuc == \"C\":\n",
        "        C[i]+=1\n",
        "      elif nuc == \"G\":\n",
        "        G[i]+=1\n",
        "      else:\n",
        "        T[i]+=1\n",
        "  return([A,C,G,T])\n",
        "\n",
        "# testing\n",
        "s = [\"ATCCAGCT\",\"GGGCAACT\",\"ATGGATCT\",\"AAGCAACC\",\"TTGGAACT\",\"ATGCCATT\",\"ATGGCACT\"]\n",
        "cons_alg(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_gN4qTrQAnMr",
        "outputId": "16002379-b597-4443-85c7-f7ca5d2c7366"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[5, 1, 0, 0, 5, 5, 0, 0],\n",
              " [0, 0, 1, 4, 2, 0, 6, 1],\n",
              " [1, 1, 6, 3, 0, 1, 0, 0],\n",
              " [1, 5, 0, 0, 0, 1, 1, 6]]"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "def get_cons(prof_matrix):\n",
        "  cons = \"\"\n",
        "  df = pd.DataFrame({\"A\": prof_matrix[0],\"C\":prof_matrix[1],\"G\":prof_matrix[2],\"T\":prof_matrix[3]})\n",
        "  cons_pd = df.idxmax(axis = 1)\n",
        "  cons = cons_pd.to_string(index = False)\n",
        "  cons = cons.replace(\"\\n\",\"\")\n",
        "\n",
        "  return cons\n",
        "\n",
        "# testing\n",
        "get_cons([[5, 1, 0, 0, 5, 5, 0, 0],\n",
        " [0, 0, 1, 4, 2, 0, 6, 1],\n",
        " [1, 1, 6, 3, 0, 1, 0, 0],\n",
        " [1, 5, 0, 0, 0, 1, 1, 6]])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "UCRrrlMDNY69",
        "outputId": "78ac86c2-a65a-4433-8558-a550b7de73e3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'ATGCAACT'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def cons(input_string):\n",
        "  \"\"\"Solves https://rosalind.info/problems/cons/\n",
        "  Given: A collection of at most 10 DNA strings of equal length (at most 1 kbp) in FASTA format.\n",
        "\n",
        "  Return: A consensus string and profile matrix for the collection.\n",
        "  (If several possible consensus strings exist, then you may return\n",
        "  any one of them.)\n",
        "  \"\"\"\n",
        "  # get input data\n",
        "  tup_list = read_fasta(input_string)\n",
        "  sequences = [tup[1] for tup in tup_list]\n",
        "\n",
        "  # get profile matrix list\n",
        "  result = cons_alg(sequences)\n",
        "\n",
        "  cons = get_cons(result)\n",
        "  #convert to string values\n",
        "  for nuc in result:\n",
        "    for i in range(len(nuc)):\n",
        "      nuc[i]=str(nuc[i])\n",
        "  # parse data\n",
        "  A = \" \".join(result[0])\n",
        "  C = \" \".join(result[1])\n",
        "  G = \" \".join(result[2])\n",
        "  T = \" \".join(result[3])\n",
        "  # create profile matrix string\n",
        "  prof_matrix = f\"A: {A}\\nC: {C}\\nG: {G}\\nT: {T}\"\n",
        "\n",
        "  # create final output\n",
        "  output = f\"{cons}\\n{prof_matrix}\"\n",
        "  return output"
      ],
      "metadata": {
        "id": "HkLCm31lAnTQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rosalind(\"cons\")"
      ],
      "metadata": {
        "id": "Tjys0EbTAncw",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "7db1e3c8-d741-442c-962a-ed36d3f63fdb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "First download set from https://rosalind.info/problems/cons\n",
            "Then upload file here by pressing choose file button below\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-8a4493fd-b662-4184-9f8f-6869134ccd99\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-8a4493fd-b662-4184-9f8f-6869134ccd99\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving rosalind_cons.txt to rosalind_cons (1).txt\n",
            "data got =  >Rosalind_6737\n",
            "CATATACTATTTGCTCATGAATCTCCGAAAAAGGCCCGATTGGAAGAAACTAGTGACCCC\n",
            "ACCGTTTTACTCAGCCACTGTTGAAGAGGTAGAATCTTTTAACAGCTTTTCACATACCCG\n",
            "AAGAGACTAGCTCGTGCTTGCGATCTTGTCGGGACTACAATCCCTCAGAAAAAAAAAGAC\n",
            "AGGTAGATGTGGGAAACTTCGATACAGGCAGGCAACCTAATGTGCAGAATGTGCTAGTGG\n",
            "CCAGACAAAAGATTCACGCAACGTTTCCCGCTGCAACGCCCCAGTGCACCTTCAAGCCGA\n",
            "CATGTTTTAACGACAGTGATGAGAGTCATAGTTTCGCTATTGACCGCTCGTGCAACAGCG\n",
            "GCGTGACTAGATGTATTTTGTGTGGGTCCGACCCTCAGCTTCATACAGGGGGCAGATCGT\n",
            "CCATGTACACCGCACACATCTACGAAATTACCATAATAACGTCACCGCTGGTGCGACGTG\n",
            "TGTATCATTGAGGACTACTGTTTTTCGGTTGCGCTGGTTGCGTTCAATTCCGTGCCTTCT\n",
            "GCGTAGTTTGCTGGCCAGCTCTTACATCGTATAAGGCCAAGCGTTATTGCTGATTCAGAA\n",
            "TCGACGAAAAACACTAACTGCAACCAAGACTATCAAACTGCGGGCGCATGCTAATCTAGG\n",
            "CCATGGTTACTCTAACATCTTAGAATCGCTGAACGTTTTTATCTAAAGTAGCTCCATCCT\n",
            "CAATGTCGACTCGAACGCTACCCTCAGTTGAGAGACTCGATAGAAATGCTGGTAGCAGAT\n",
            "CTAGCGGGTTAGCGCGAAATTTATAGACTGCATCGAGGATGAGAACCAACCGAACACGTC\n",
            "AGTTACTACCTCATAAACGATAGCGCTCCAGTGCGTCGGGCATTCACACGCGCTAGATTT\n",
            "TAGTTTGCATTATGAGCACTGGCTCCTCACTGGTTGCTGACCGGCAAACAAGATAGAAGT\n",
            "GACGTGCCACCATGGTTGTGCAGTGTCCCTTGTATAT\n",
            ">Rosalind_4854\n",
            "CTCGTTGCCTCTTGTGCCTAGTGCAGTATATCAAGGGTAGTCTCGCCTCTGACCATCTTA\n",
            "GACAAATGAGCCAATTTGTGCCAAAAAGGCCGCGCTCAGAACGTCGGAGTACCCACATTC\n",
            "GGACTCAAATGCTCGCGGTCGAGCGGGCCTCAGATTTCTCAGACTACCCATAGACCTGTT\n",
            "CACTCACCGATAGTTAAAACCGGTGGGCCTGACAATTTTATACTTGGATCTAGGACGCTA\n",
            "CCGGACCTCGAGCGGAAGGCTAGATTCTCAAGGATAGGTTTCATTATCCAGAATATATTC\n",
            "TGTATATTTTGCTAAGTCTATCATGGCGGGTATTGCGTCGATCTTCACAGACCCTAGCAG\n",
            "GTTCCGTGCTGTGTTAACCATCTCCCGCAGTGAGAAAGACACTCCCTCACCAAGGGCTCT\n",
            "CAATATGAGTCCCAGTGATCTCAACTAACTGAACCTCACTCCTGAGACGTGCCCCCAGAC\n",
            "TGTGAACGTTTGATTCTATTGTATCTGCCATATGAAGACACCCGCCGGAGATCGCCGGCG\n",
            "GTGAGGTAATTTCAGCCGAGTAAGCGTGTGTTATGGTGTTTGCTATGAGTTCGTTGGAAT\n",
            "GTTACTTTCATGCTATGACCGACATACGTCCGACATACACCATCCGAGAGCAATGAATAA\n",
            "AAAGCCAGGCCTACTGGTTGACGACCTTTGCGGCTGTTTGGTCGCCCATACACGTCGTGA\n",
            "TACGGCTTAGTGGTCTAAAAGGCGTGAGTTTCGTTTGGAACTAGGAATTGACGGTTCCTA\n",
            "ACGCTCTGACCAAAGAGCAGCTGTTCAATGCTTTCCACACCAGAAGAGCTGCTCGCTGTG\n",
            "ATTGTTGTTTTCATGTATTGCGGAGAGACACAGTCCGCCCTTAACTAACCAGAGAGTCGA\n",
            "CTTCAAGGAAGTACGAGTGCTGCACATTCCGGAGACCTTTGAGGTGTAGTAAACTCGGTC\n",
            "ATTGTTTATGGCTAGTGTAGTCACGCCTCAGTGGATA\n",
            ">Rosalind_0607\n",
            "CCTAGTCAGGGGATCTACGTCGGAATTAAATTCTGTTCTTCATCCCACTATACAAATCGA\n",
            "ACCCGATCCCCGTCTACTACATAACCACCGGAGAGATTGTTGGTTTGAAAGAACAGGATC\n",
            "CCTCCGGGCGCGTATCCGATCAATTGGGACATTGCATGGAAACTGAGATATATTGGATGG\n",
            "ACACGTCATGGCTACAGACCACCTTCGCGTATAATGCAACTAGTCTTCCCGGTGTCAGAT\n",
            "AGACCAAACAACAAGAGTAATAACCTGGATTCGGATTCGTTACTCATCGATTATATATTA\n",
            "CCGACCAGCCTTTCCTGCTATTCGCGGAGAACGACCCATATCGCGCGGAAACGACTTAAA\n",
            "AAAGCTAACTATACAGCGGACCCTCGGGAAGAGTGCTCTGCCGCGGGTCCCTTATCGTAT\n",
            "GCATTCTTAATTTTAAATTGCCATAAACTCCACAATACCCGCTCGATTTGTCGGGAGGTA\n",
            "CTCAATAAGATCATGCTGCTGCCTTACTATGAGGAGTGTGCTCCAGAGTGCTAGAAAAAC\n",
            "TGACCTCCGACGAACTCTTCCACCTTGTAGGGGTCTCAAGTTCTGACACTACAGGTGATA\n",
            "GTCCACAGAGGTAATATACGGTGATGCCAGGTGCCGTCTTAGCTCACCGGTTGGGGAAAT\n",
            "GAGCATACTCACCCTCGTGAGGCACGAACCGCTCTGACCCCGACGCAGACTAAATCAATT\n",
            "CGCGCGGGGCCGATACTTATGTGGTTTATAGGTGGCCGGTTGCTGTGATATAATCTTCCC\n",
            "CTACCTAAGCAAACAGACAGGTAAACGACTGTCAAGTCATCATCATGGATACGAGCAGAT\n",
            "GTCTCATGGTTGACCCGGGCGGTTCCCGGATTCGATGATCAGTGCTCAATATCTTGTAGT\n",
            "TAGATGAGCACCCCGATTACCGCGGATTGACACCCCGGATAATGGCATACCTGAGTCTAA\n",
            "GCCGCGACCTGGATGGCAATGACCTTAAGAGGGCCCA\n",
            ">Rosalind_0205\n",
            "GATCCCGAGCTCTCAAATAACATCTTTTCAACACACGGTGCATGCGTAATGCATGCGACT\n",
            "TCAATGAGTAGAAATCCTGCCACTCGTATGTCAGGTCCCGCAGCGTCCCCATTGTCACGC\n",
            "TACCCGGATCTATGTCTCATAAACGCGTGAGCATCTAAAAGTATGCCCTGCTCCCCACGC\n",
            "AGCACCGAGCGCCCCTCTATTTTATAGGAGCTGCCACCCGTCGTGCCAATAAGACGCAAT\n",
            "CTTTTATAAAGTGGCACTTGTAAGTTGGCGACTGAATCTACCCCCGATTGTTCATTAGTC\n",
            "GACGTATCCTTCTCGAGACTCATCGTGCAACACCTTCTCTAAGGGTTGACCGTATTTATA\n",
            "TTATTCGTGGGATACGAATGTCCATGGATTGGACATAGGTACGCTGGTTGTGCTTATTCG\n",
            "TGAAAGCTTGTGAGCTCTCCACTTTTCCCTACCTTGGGTATGTAATTTACTCGATCCTCG\n",
            "CGCCGTCCGCACTGCGATTACCCCATACATGCGAGAAGCTACTCCTTCTGACGAAGATCG\n",
            "GACCATTCCGAAAGGCTGGCACCACTTAGAAAGATTTCGGCAGACATCACGCACGCACTA\n",
            "ATTAACGGAGCTCTGTTTATCAGAGCCTGCCTTGAGATCTATTGCTCCGCTCTCAGAGGA\n",
            "AGTAGGTGGCTAAGTTTCCCTCGGGTGGCGCAGCCGCGGGTGTTTGGCCCGCGAGCCTTC\n",
            "TCATGGAAAGTCAGCTACCGTTAGTGGATAGTGTTTGGCGCGGGTCAATGCCAGCTCAGG\n",
            "CGCAAGTAAATTCATCTCAAGAAAGTGGTTAACAGATATAAAGTTAGTCCCGCCATGACT\n",
            "GGTCTTCATTTTGATATAAGCCAGGCAAGGTTTAGTTAGGTGGAAGAATTTCTTCCGGAC\n",
            "TAATGCTATCATACTCATCAATCTGCCGGCTTGATCAAATCCAGTGTTGTGGGACCCGCA\n",
            "ATTGTGATCTGCACCGGCTCCCTGGCTTGGCCGAAGT\n",
            ">Rosalind_7760\n",
            "AGCCGGCTAGGTGATTCGCGCTCATAAGCTTTCTTGTCACCGTGTCATTCACTGGGAGGC\n",
            "CTCATTTTAACTTACAGTAACTCCTACTGGCGAGGAATAGCGCACGCAGAGCCGACTGTG\n",
            "CTACAGGAGATAGGAGAGAGGATGCGGAGCAGGCGCTACGCCCATCCTCTCCTTTCCTCT\n",
            "TCAATGCTCACGTTAGGTCCCTGGTGCCGACGAGCTAAACAAAGAGTGTTAACACTTTGA\n",
            "ATTGTAAATCTCCAATCATCCTTCCACTAGTACTCGTCCGCTGATAACGCACCTCATAGG\n",
            "CGTATTCTCGTTCTTGCAGAGCTATCGGATACGGCTAGTCTGCATCGCGTAATGACGTGC\n",
            "ATTGGCCCATGCTCTGCGGGCCGAATTTTCAGATGCTATCATTTATTGCAGGCCAATAAC\n",
            "GTGCGTCACCGACCTAAGCTTCTACCGTGCCTGAGAAGCGACACGGCAATAAAAGATCAG\n",
            "AAGTATACCCGATACATAGACCGGACCTATGTATTATCGTACCCACGACGTATTAGTCTC\n",
            "AGCCTGGGTAAGCAGGTGTCCCCCCATATGAGTTGGTAACGGCCCGACGTTTGCACTAAC\n",
            "AAAGAATGCCACCCGTACCCCGCACGTTCAACGGTTGCGAGGGTTAAAATAATCCGTCAC\n",
            "GTACATACGCTGGGAAGTTCTTGAAACTTGGCCAAACCCCGGTCTGACGCAGCGCTGGCC\n",
            "CCCCGCCTTCGGCCTGGGGTGGTCAGTACTCATGTGCGTCCACCTCAATGTGTGCGGCTA\n",
            "GGTCTCGTGCCACAGAATGAGTTGTACGCATATTACTATTATGTCCCCCGGCGAATGAGG\n",
            "AAAGAATTTGCGCCTTAGCGCGACTGACGACAGCCGTAATTCGACCCAACGAGTAACCGA\n",
            "GGGGTGGGGTCAATTGCAATAGTCCGACTGTAGTTTGAAAAGCGCGACCGTGATCCGAAG\n",
            "AGACAAAGAGAGCGGATAGTTGCGACGCTTACTGCCT\n",
            ">Rosalind_9584\n",
            "CGATCAATGACGGTAGCCTGACAGTGCAGCAGGCGCCTACGGCTCCGATTCCGCTGTGGT\n",
            "GGACTGGCGTATACAGGACCAAACGCTATAAGGAATATATATCTACGGATAAAATAGGCA\n",
            "GGAACGTGTAGTTGAAGTCGCCTAAGCAGACGCGTAGCGCTCCGCTTTCTTTACGAAATT\n",
            "CGGAAGATCTAGCTCATGGACGGTTGAACGCCCTGCGCTCGCCAACGCGAGTCAACGAGG\n",
            "TGTTGTTTTTCGAAGAGAACGGTCCTACGGTCACTCGTTGAGGGTGAGTAAGGTGTGCCC\n",
            "CTCCTGCAACTCGTGCGATGAGAGTGCACGGACGATGTAACTTTACACCTATGGCCCTCC\n",
            "GTCATCGTTTGAGTCGGATTCAGCCCTAACCTAGAGCCTGCAGACCCATCTGGAATGATT\n",
            "TTTGTGCGTGGGGGAGATAGAGGCGGTTAGGGGTAGATGTCTGGGCATTGCGTAAACGTC\n",
            "TTGGGGAAGCATATTCGTCGGCCCGAATTGTGTCCTGGGCTATACCGCAGCAGCTGACCA\n",
            "TTATCAATTCCCTAGGGCAATTCACGTAGGCGCCGGCACGCTCTATTAGTATCGCGCGTA\n",
            "AACTCTCATTCCGACTATCACTCCGTTCATGTTAACACATCAATAAGAAGGTATGTGCTA\n",
            "AACTCTATATAGCCGTATGGAGTGGCTGGCGATGGCGCATACGGGTCCTCTCAAGGGCAA\n",
            "AATAGTTTAACATGTTTTGTTCGCGATACTAGGGGAGTAGCATTGCGTGGCACGCCGTCT\n",
            "CCACATACCTCTCTTTGCGCCCCCAAAGACGATACGAATGGAAATGGTCATGTTAAGACC\n",
            "CTGGTGTACGAGATCCTTCAATCGCGCACGCTCGATGTGGCAGTTCAGAAGTGAATCTTA\n",
            "ACGGGAAGGGGATTGGGCGACTGTGTGTTAATTCGAAACCTGGTCTCTAGTCCGCTTACT\n",
            "GGGCGAGTGTAACGTATAACTGGTATAGATCACGCGG\n",
            ">Rosalind_4999\n",
            "ACTTCCACCGTTTGAGGCCAGTCGGTCGTTCGAGCTTAAGTAGATTTTGGGGCTTATGAT\n",
            "TGGGTGGGTAGTGCCACGGGGGTAGATGGAACACTTGACAACCGCTAAGTACCAAACGCC\n",
            "ACCCGAACACATGCATGTACTGATTTAGTCATGGATGTGTCCAAACCGGACTGACTCGCG\n",
            "CCGGCCCCGTCAGAGAAATCGATCTAAACTTTGTCGTGGATTACCCGATGCAGAACTGAG\n",
            "CTCTAACTAGCCCAAGTATCTAAAGGGTTCTGGTTGGACGTAACCTTGATGGACGTTAGC\n",
            "ATATGCTTCCATCAGGGCATAAGGTTGCAGGCATGGAACAACACGACGGGCAATATCCCG\n",
            "TATAAGCTTCTCGAATCCTTGCGGCGGAGGTCGATTATACGAGTAATATGTATCCACATA\n",
            "ATTAAGCAACATAGTCCAAAAGCAAGCGACTGGCGGCAGCTCAAGCGCAGAACAGAATTG\n",
            "GCAACCTATCCCCTCGTACCTTGACTGCTCTCAGCGCCGCCGGCAACCTTTCCTAGAGTA\n",
            "AGGCGGGGGCGAACAATGGTGGGGCGGATCCGTGCTGTATTCCTCCAGCACTTTTATCCC\n",
            "TGTTGCTTAGCGAGCTTGATGCAACTCCACATTTGAAGGTGTAATATGCAGGGCCCCAAG\n",
            "AAGAATTGAGCGTGTTAATCCCCGGCATACGCGTCCCTTGGGGCGGTACTACTCTTACGC\n",
            "TTCTTATATGAAGGACACTCAGTCCACAATATAGCATACGATTCCGTAGAAGTGAAGGTC\n",
            "CGAAAGCCCCGAGAGCAGATTCCTCGTTGGTCGTTGCACGGCCAATCTTTATTTGCCCTT\n",
            "GCGAGCCGATCGATCCGCTAAGGATCAAATCCTGGATAGTAAAGGCGGCTAGATTCAAGT\n",
            "AATAAACTAGGGTTAGCACACCGTCGGACAGGACAACAGCTCAACTTGGTGAGTACTTCT\n",
            "TTTACCGATACTGTAGACAGCAATGATTAGTACTATA\n",
            ">Rosalind_6362\n",
            "GTGATGGCGTCAGTCCGTCGAGTTGCGCGAAGTTGTGCGTTGCTAAATACCCAGGACGGG\n",
            "GTCCCGACGATGATATCCCTCCGACCAACGTGGAATCGTTAATGCCGATACCTTAGCCCT\n",
            "AAAGCTCAGAGCAGAAGAAACGACACATGCGGTGCGGAAGCCGTGATAGGGGCCTGTGAT\n",
            "ATACGCTGACTACCACCTCCTTAGGCCGGGTACGATCTAAAGGAATCGCAAATGGTATTT\n",
            "CATCTGTTAAATGCCTGACCGAGCGATGAAACCTAGGTCAAGGCTCGTTCTCCCCCGAGT\n",
            "ACAAGACTCTTACAAGAATACGGACATGGGCTACTGTTCCCTATGAGGTAGTAGAAGATC\n",
            "GCCCAAGTGAGGTAGCCAATACAAGTATCCGCGGTAAAACGCTAAGTTGCATGTGCGGAT\n",
            "TCCCGACGCTTTCGGCGTTTATCGACCAGCGTCCGAGAAATGGCCCACAGGCTCCCGGAA\n",
            "ATGACACTGAAAGAGTGCGTGAAGGCATGTGGTGGTAAGAGGGCCAACCAATACTTGTCG\n",
            "CTGTATAGCCTTCGATCAGACTTTTAGAGTTGACAGCGCAGCCTGGACCGTATGTGAAGA\n",
            "AGAGGCTGCCAATTTACACCGCAGACTCCCTATGTAGGAAGAATCATGCATTAGGCGAGG\n",
            "CGCGGTAGACCTTCGTATCGCAAATCCTACGGGAATCTGAAGACGACTATTTTCCAGTTG\n",
            "CGCTATCTCATACTTTTCCCAGCCACTTCAGGGAAAGAATAGCACTCATTTCTTTACCAT\n",
            "TTAGGTCTGTGATCGACGCAGGTACCACGTAACTTCAGCACTGGAACCCGAGTTCGAGCG\n",
            "GATTCGCGAGCCATGGTGTTTACACCCCTCTATCGCGGGGCCATGGCGACGGAAGCTCAG\n",
            "GAAGCTAGGATTAAAATAACACGAGCTCGACATAATCGACCACAGTCCAACCTGTCCCCC\n",
            "CCAGGCGATCTATGATATATATCCGGATGATGTCGGA\n",
            ">Rosalind_2526\n",
            "GTTCCACTGAACGGCCACTGGACTCAATTTGGTTGTTAGTCGCGAAACGGGTGCAAATGT\n",
            "TTAGGGAGCTCAGGCTCTCTAGAATTACCCATCTCCAGTGATGATACGACAATGTGAAAA\n",
            "TCTGTCTTGCAGTGATGCTAGAGTGGTCATCCGTGGAGAACTTGCACCGCCCCCCCCACT\n",
            "CTCAAAGGTAAAATGTGGTATAATTGTAGATGTCCTCGGTGTGCCCCGATTAGCTCAAAT\n",
            "GCTTAGCCATAAGTCCTTAGATCATGGGCCTGTAACCGCCGCCTTGTACAGTCACTACGC\n",
            "AAGTCCTTGACTCAGCTACTAGTGGCTTGTTGGTAATCTACTCACCGCAGGTCGGATCAT\n",
            "GGCGAATACTGCGGTGAAATAAGGCGCGACGTGGGGGAAAAGACAAGAAGAATTTACCTA\n",
            "AGGTCCCGAAGGCCGACCCACCACTGCAATCCCTTTCCGTCCGCCTCCCGTGTCAGTGCC\n",
            "CGGGAGTGAAAACAACTAAGTCAATAGACGCCTCGCAGTATATCGCTTCGAACGGTACAG\n",
            "AGAGGTTGTGGCATACAACATGTTGCTCATTTAAATCATGGGAGAGGTCTTCAGGACATA\n",
            "CAGTTGTGCGAAATAAAGATTGGCTGCCTCGGGTTCCCTCGTTACTGTATCCGAGCAAGA\n",
            "GATCGTCCCGTTACCACTTATTTGCGCCTACCCTCCTTTGTATATGATGGGGCCGCAAAG\n",
            "AGGCTCACTCGACGATCCTTCGCTGGAGTGTTGTGACCACCAGGGATCTCTCGTGCACAG\n",
            "TCGGGTCCCCAACCCTACAATAGTACTCACCCGTGTTGTGCAAATGCTATCCGTGTTGTA\n",
            "TTGGAGCTCGCGAACTGATGCCTCCAGAAATTTTAGGCCCATATATATTCATACAGTGCA\n",
            "ACGAGGCGACTACAGCACAGCTCGAGGCCACTCCAGGTTTCCTACGACACGATAGCGTTG\n",
            "TAACTAAAGTCAGTGTTAGACCTTGGAGATATCTTAA\n",
            ">Rosalind_3974\n",
            "TAGTAGACGGCCAGGGCCCTTATGATTGGGTACTTCTATGATTGTCGCGCGAAATTCCCT\n",
            "TTGCCCATCCATCCACATAAGCGGACTCAGGTCAGTCGTGACCCTTTAGTTTGTAGGAGA\n",
            "AGTTCTCGCAACTATTCATTATGTCTTTACGCGAGCTTTTCAGCGGAGTTTGGCATTTTC\n",
            "GGTATAGAGTAATTAGCTCCGTAGGAAGGCCTTTCTCCGACGTGGCATCGGATCTGGAAG\n",
            "GGAAAAAGAGCTTCTTTTACGGTTTACTATATCTATCGTTACGGTAGTCGGAATCGCTTG\n",
            "TATGGCGCCATGCACCAGCTGCTCCGTACACACGGAACAGATTTTACTCAATCTGCCCGC\n",
            "GCGTTCCGTTGCGTTGAGCAAAAACCCACCATTCTCGAATTGTGTCCTTTGTTTCGGCGC\n",
            "CTCCTAAGGACAACAAGCGAGGTGGGTATAGCAGCTTCCACCCTAGACCATCGCACATCT\n",
            "GAAGTGGACCCCATCCCGTACAGCGTAACATTCCAGCACTAGAGGTCGGTAGGTCGAACT\n",
            "TCGAGGACAACAAACCTCATGTTACGCGACCCACTAGCAGGTGATACTCGTGTTGCAGAG\n",
            "TTTAACCAGGTTATATGTTTGGTTAATGTGTGACACTACGGCCTTTGGTCGATTTCAGAG\n",
            "AAACAGGTGTGCGAGAGGATGACCTAATCGATAGCAAAATCGTGATGGGCCAGTGTAGTT\n",
            "GAGCGATCGGTGCGTCGGAACGACATGTTCACCGCTCACTCAGATTGATCCTTCATTTTG\n",
            "CCTCTCCCATTCAATCACCCCCGCAGTCTGGACGGGCGGTAGACGTATTAAGGCACCACC\n",
            "AAGACGATTTGACGTTCGGTTCAATTCCATTCTCTAGTTTAGCCCGACCTCATCCGAGCC\n",
            "AAATTGACGTGGATGCAACCAACTAAGTTGTGTGCTCGTACCCCACAAAATTGCGTCAGA\n",
            "GACATCCGACCCGGGCCGACGTCGCCACCAGTGTCAG\n",
            "\n",
            "output =  CATACACCGGCTGGAGACCAATCGATTAGAAGATGCTAAGCGTGACATACGAACGACGGTTTCCTGAGAACTACCACTACCCAAACAAGGAGAAGTCTTGAACACTGAGTAACAAGAACCAAACCGCAAAACTGACGGAGCAATCGGGGCGGGGCTTAAACCCCGACCCACACCCCAGCTAGAAAACAGTAACTAACTCCCTATTAGGGACTCACTCCAATAGGCCGAATGAGATCGAAGCCTTAAAAAAACCACACAACTAACTTCGAGTCGTAAGGCGACGCTATCCAGTCTCTAAGCCATATCTTCATTCAGGGATTAATGGGGAGACACTCGATCAATATGCGCAGATCGACCCACGTCGACCTCTGCGTTGAATTACGACGGAACGCAGTCAAACACGCACTTTCGGTTGAGAATCTATAGCGAACGCGAACTTAACAAAGCAACCCCTATAACACCGCGCACAGTCGCGAAGTGCGGAAGAAGCACATCCTATAGCACGTATATGCTCAGAGGACGTCCCACTGAACGAGACCGAGGCGGTGTACAAAGCTGAACTCACGTAGGAGAAGGCAAGGCCTAAAACTTCAGGCAAAAATTAACTGAGACATATAACTGAAACACCACGTTCAAACATGAATCACGAGCTACGCAAAAAAACATAGACTCACTTATTCTAGACCCTCCGCGCCCCTTGAGTCGGACGCGCCCGCACTCCACTGCTTACTACGATACATCGCCAGTATTAGGGGACGAGCAGAGAAATGTCTGCTCCTGCCACATCCACAACAGAACAAGTATACACTGCACTGGTATTCAGAAGCTCTAGGTACCGCCATGGAGCTTTCGATCTAGTGCGAACCCAAATTTCGTGAGGAAATCCAAACAGATAGTCGAAAGATGAGAAGAATGGAAACAGCTCAGCCATGGCACCAATCCCGCGAAAAGAGACCCACAGAAGTAAAATCAGGGTTAACCACTGCATAAGGGGCAA\n",
            "A: 2 3 1 3 1 3 3 2 2 2 1 1 2 1 3 1 4 0 1 4 3 3 1 2 3 2 2 4 2 5 4 2 3 1 1 0 0 3 5 0 1 3 0 2 3 2 5 3 3 1 1 4 3 2 3 5 2 1 1 2 2 1 3 3 1 2 4 0 3 4 2 2 5 3 3 3 2 1 3 2 3 2 4 6 3 3 5 3 1 2 4 1 4 5 2 2 3 2 2 2 7 3 0 3 1 1 1 6 3 3 5 4 2 3 6 3 3 3 1 3 4 3 4 2 1 2 2 4 3 4 3 2 1 2 5 2 1 2 5 2 2 5 5 1 2 0 2 2 3 2 3 1 1 3 1 2 3 3 4 4 2 2 3 2 1 4 2 2 1 4 1 3 2 3 2 2 4 2 2 0 4 1 3 5 3 3 2 3 1 3 3 5 1 3 4 5 2 3 2 2 1 3 3 2 0 4 3 3 1 3 1 2 2 3 3 1 1 2 4 5 2 3 2 2 3 1 1 4 3 2 3 7 0 4 3 1 3 4 5 2 2 1 3 1 5 5 4 4 6 4 4 2 2 4 2 5 1 4 4 2 2 5 3 3 0 3 1 0 4 2 4 1 1 2 6 3 0 1 0 2 3 2 3 1 0 4 3 2 1 4 2 2 4 3 3 1 4 3 0 2 3 4 2 4 0 3 1 1 2 3 1 1 1 5 3 1 2 5 2 4 3 3 2 3 0 1 0 4 3 4 2 4 2 1 2 2 3 2 3 4 4 1 3 2 1 3 2 0 4 3 5 2 2 3 4 3 1 3 3 2 2 2 2 2 3 3 1 2 2 1 2 2 1 3 3 1 4 4 2 3 3 3 2 4 1 0 1 4 4 1 3 1 4 1 3 2 5 4 5 1 4 2 2 2 5 2 1 3 2 1 2 3 1 3 2 5 0 3 3 2 2 1 4 2 3 2 2 3 4 3 1 2 3 2 3 5 3 3 2 3 4 1 3 3 4 2 3 4 3 2 1 2 3 2 3 3 3 4 2 3 1 0 2 3 3 1 4 1 4 1 2 2 1 4 3 5 3 0 3 2 2 2 2 4 4 2 4 4 1 3 5 3 4 4 1 1 2 4 1 3 0 2 3 2 2 3 4 2 3 2 0 2 2 1 3 3 3 3 0 3 3 2 1 1 3 3 3 1 2 1 5 3 2 1 4 1 6 2 2 2 3 1 3 2 3 1 3 1 2 3 2 3 5 5 3 1 2 2 3 3 1 2 1 4 0 3 0 5 3 1 3 1 5 3 2 1 0 4 5 2 0 1 1 2 3 4 3 3 1 1 2 1 4 0 1 2 4 5 4 6 4 3 2 4 4 1 2 3 4 2 4 2 5 2 3 4 4 3 3 1 0 3 3 5 2 3 1 0 4 1 2 2 2 1 5 3 5 1 3 2 2 3 3 2 1 5 2 3 4 2 1 3 4 2 1 1 5 5 5 4 5 6 4 2 4 0 5 0 4 0 2 1 3 2 2 3 4 1 1 2 2 3 1 5 2 2 3 1 2 1 1 3 2 2 2 2 2 1 2 1 3 1 2 1 2 2 4 2 2 2 2 3 2 3 0 2 4 2 2 2 2 4 2 1 1 2 2 2 4 2 1 4 2 1 4 0 3 1 3 3 2 0 2 0 3 3 2 5 1 3 4 1 2 1 2 4 0 3 4 2 2 5 1 3 1 3 3 6 0 2 2 2 2 1 2 2 2 1 3 2 1 0 5 2 3 0 2 2 3 1 3 6 3 5 1 3 6 1 6 4 0 2 3 3 5 2 4 2 2 1 2 6 0 3 2 2 3 4 3 2 3 6 3 5 5 2 2 1 3 2 4 0 1 3 4 2 2 4 1 1 4 3 1 2 3 2 1 3 2 0 1 1 7 2 1 2 3 2 1 3 2 2 3 4 0 2 3 5 3 5 0 3 0 1 3 2 0 4 1 0 4 3 4 3 2 1 5 5 4 1 4 2 4 2 5 1 3 2 2 4 4 6 3 3 2 3 4 1 4 3 1 4 5 2 3 3 3 5 4 3 4 1 0 2 2 3 1 1 1 5 1 3 2 2 4 2 2 4 4 3 2 3 2 3 1 1 5 3 5 3 2 3 3 3 2 0 1 4 2 3 3 3 3 2 1 3 4 4 3 1 2 4 2 1 2 2 2 4 6 1 1 3 2 0 2 1 5 1 3 4 2 2 0 2 3 3 5\n",
            "C: 4 2 2 3 4 2 4 4 2 1 4 3 0 2 3 3 4 6 4 0 3 1 4 2 2 2 2 1 2 1 1 2 3 2 2 4 2 3 0 2 4 1 3 2 3 5 1 3 1 4 2 4 3 3 0 1 4 3 3 2 1 3 5 4 2 1 0 3 3 3 4 2 1 4 4 3 5 2 3 3 4 3 2 2 3 4 1 3 3 2 2 2 3 1 2 2 4 1 2 0 2 3 5 2 4 3 3 1 1 2 2 4 4 2 0 3 3 3 4 4 2 3 2 5 5 2 3 1 2 3 2 3 1 2 0 3 3 2 1 2 4 1 0 3 3 2 1 2 1 6 3 3 1 1 4 2 0 3 1 2 5 5 4 3 2 4 5 3 3 1 4 2 3 5 4 4 3 1 3 3 4 3 3 2 3 3 4 2 2 2 2 2 3 2 3 1 4 0 4 7 3 1 1 1 1 2 2 3 4 1 4 1 4 2 5 2 6 3 1 3 1 2 2 2 4 5 3 2 3 2 1 0 2 3 2 5 1 1 0 0 5 3 1 2 1 2 3 1 2 1 3 3 3 2 4 1 3 0 2 6 1 1 1 4 3 0 4 2 4 2 1 4 3 2 1 2 3 3 5 2 3 5 3 3 3 1 1 3 4 3 0 2 5 2 4 1 2 3 1 5 4 2 2 1 2 4 3 2 6 3 2 3 5 3 2 3 1 3 3 0 2 3 1 2 3 2 3 2 2 0 3 3 3 2 3 2 3 2 4 2 3 2 3 3 2 5 3 4 3 1 2 2 4 1 2 4 3 4 3 4 0 3 3 2 2 4 4 1 3 1 0 4 0 2 2 1 4 2 2 0 3 6 2 2 6 3 2 2 3 5 1 3 1 3 0 4 1 2 1 4 2 5 0 4 2 4 2 1 2 4 2 0 3 2 2 2 3 3 2 2 3 3 2 3 1 2 6 1 2 3 3 1 5 3 2 2 4 2 3 3 2 5 3 2 2 2 4 2 2 4 4 4 4 3 2 0 3 3 4 3 4 6 2 4 3 4 2 6 2 1 1 5 2 5 2 4 3 1 3 3 3 1 2 1 2 2 3 2 2 5 2 4 2 0 5 5 1 2 3 1 3 5 3 3 2 3 2 3 3 1 1 4 1 4 2 1 2 2 3 2 4 3 3 6 5 4 2 4 3 1 3 2 3 2 3 2 0 3 6 2 1 2 2 4 2 0 1 3 2 3 4 2 3 1 3 5 3 2 2 3 4 2 4 2 7 1 1 2 0 2 3 1 1 3 2 0 5 3 2 1 2 3 6 1 3 1 2 3 5 2 1 4 1 2 1 4 2 2 1 2 1 1 2 1 3 5 2 0 4 2 3 3 3 2 2 0 1 2 5 3 4 2 3 3 3 2 5 5 2 6 2 1 0 4 1 3 1 6 2 2 3 1 2 1 6 0 3 2 2 2 3 2 0 3 2 5 1 2 0 1 2 1 2 4 2 1 1 3 1 6 3 3 2 5 1 2 1 1 3 3 2 3 3 1 3 4 4 1 4 4 3 4 2 4 4 3 4 3 2 2 2 1 2 4 1 2 3 3 2 5 2 4 3 4 3 4 1 3 2 3 4 2 5 3 1 3 3 2 1 4 2 2 4 1 2 4 1 5 2 2 3 2 4 5 2 1 1 0 3 1 1 2 1 0 2 2 4 2 3 2 6 0 3 2 2 3 1 1 1 2 3 4 1 1 4 3 3 5 2 2 6 4 1 5 2 3 4 4 3 5 3 1 5 3 2 3 1 6 2 2 3 3 2 2 2 4 1 4 2 2 3 2 4 1 2 3 2 2 2 1 4 1 1 2 1 2 5 2 5 2 3 4 1 3 2 4 3 1 4 3 1 1 1 1 3 2 4 0 3 1 4 3 2 2 4 3 1 2 2 1 4 3 2 3 4 5 4 4 3 1 4 2 2 4 2 2 1 2 2 3 3 2 1 1 5 3 4 1 4 4 2 1 2 2 2 3 2 3 2 2 1 2 0 1 1 1 2 2 1 2 2 1 2 3 0 3 3 2 4 4 4 2 6 1 4 3 1 4 3 3 3 0 2 4 2 3 5 0 1 3 5 5 3 1 5 2 2 3 2 2 2 2 1 2 3 6 4 1 4 2 1 2 3 3 2 3 2 2 2 3 4 3 2 1 1 1 2 2 0 3 4 3 4 3 1 4 2 3 3 0 2 2 3 2 4 2 0\n",
            "G: 3 2 2 1 2 3 3 0 6 4 2 2 5 4 1 4 2 1 2 4 3 2 2 3 2 2 2 3 3 1 1 4 2 2 5 2 3 2 2 4 1 5 2 4 1 2 2 0 3 2 5 1 3 2 4 2 1 4 5 1 3 2 2 3 2 5 2 4 2 1 2 2 2 2 0 1 2 2 2 3 2 2 3 1 2 2 0 3 4 5 2 5 3 3 4 0 1 3 2 4 0 2 4 2 2 2 4 2 4 0 2 0 1 3 0 4 3 3 2 2 2 3 1 2 2 4 3 3 3 2 3 2 2 6 1 2 5 3 0 3 3 3 3 1 3 5 4 3 4 0 4 4 6 4 3 2 3 2 3 2 1 1 2 2 4 1 1 3 3 2 1 2 3 0 2 2 0 4 2 2 1 4 3 1 2 3 3 2 5 1 3 3 3 0 2 2 3 2 1 0 3 2 3 3 3 4 4 4 5 3 2 3 2 2 1 2 1 2 3 1 2 3 4 3 2 2 4 3 1 2 4 1 5 3 1 2 4 2 3 4 2 3 1 3 1 2 0 1 0 3 2 2 3 2 3 1 3 2 1 2 3 2 3 1 2 2 4 4 1 4 0 3 4 2 0 3 4 4 1 3 1 2 4 3 0 4 2 2 2 2 4 2 1 0 2 2 2 1 5 2 1 2 2 3 3 1 1 1 1 1 1 2 1 0 4 5 4 2 1 1 3 3 3 4 4 4 4 3 4 4 3 1 3 3 3 3 2 1 0 2 0 2 2 1 4 1 4 4 2 4 2 2 2 4 2 0 3 1 2 3 6 1 2 3 2 2 3 2 2 2 7 1 6 1 1 6 1 3 2 3 1 1 4 3 2 5 4 2 1 3 4 3 4 4 3 2 2 3 1 2 2 2 4 1 1 3 3 2 2 4 3 4 2 1 3 2 4 1 2 1 2 2 2 1 3 3 1 4 2 2 3 4 1 4 3 1 3 1 1 2 1 3 1 3 2 4 1 1 2 1 4 2 3 1 3 3 2 2 3 1 2 2 3 2 4 3 2 0 1 6 3 2 4 1 4 1 2 6 0 4 2 4 4 4 2 3 1 2 4 1 1 2 2 1 2 2 2 2 2 3 4 0 3 2 3 0 4 1 1 2 5 2 3 4 3 4 3 4 4 2 1 4 2 2 2 1 3 3 1 6 0 2 3 4 1 5 2 2 0 4 3 4 5 1 4 5 2 4 2 3 2 2 1 3 4 2 1 5 3 1 2 2 1 2 1 4 3 2 4 4 1 5 2 1 4 5 2 2 1 5 5 3 3 1 2 3 2 1 4 2 1 2 2 4 4 3 2 3 1 1 2 2 2 2 2 2 1 5 1 5 1 2 1 1 2 0 2 2 0 2 5 3 3 1 2 3 0 3 1 2 3 3 3 3 1 2 2 2 2 2 5 3 2 2 0 2 3 4 2 4 3 1 3 2 5 3 2 2 4 4 3 2 2 2 4 3 1 4 4 2 1 3 2 3 3 1 4 1 2 3 2 2 4 4 3 2 1 3 1 4 6 2 4 2 2 3 1 1 2 4 3 6 2 3 4 4 2 3 3 1 3 2 2 2 4 1 4 2 2 2 1 3 2 2 6 2 1 2 2 4 2 4 3 5 0 1 3 2 2 1 3 6 2 3 2 4 3 2 0 2 3 4 5 6 3 1 4 4 2 3 0 3 4 3 4 1 3 1 2 4 1 3 2 5 2 1 3 2 1 3 1 3 2 3 2 3 2 2 3 0 2 1 1 1 4 2 2 2 2 2 4 1 3 1 1 3 2 3 2 4 3 0 2 1 4 4 1 4 1 3 3 1 5 1 1 3 3 2 0 2 2 5 4 0 4 1 3 5 1 3 4 2 4 4 1 4 1 3 1 4 1 5 1 1 2 1 3 4 3 4 1 4 3 2 3 2 2 1 3 2 1 0 3 3 4 2 6 2 5 4 0 3 3 2 2 3 1 3 0 1 3 4 2 1 1 5 1 3 4 1 2 1 5 3 3 4 3 6 4 2 4 2 0 1 5 4 2 0 2 1 1 4 3 2 4 3 4 1 3 2 2 4 3 2 1 2 3 3 2 0 1 2 3 5 2 4 0 1 3 2 3 3 4 2 3 1 3 2 2 2 4 2 1 5 2 3 3 2 2 2 3 2 3 5 6 3 2 2 2 3 2 2 2 3 6 2 1 2 3 2 3 3 4 3 1 3 2\n",
            "T: 1 3 5 3 3 2 0 4 0 3 3 4 3 3 3 2 0 3 3 2 1 4 3 3 3 4 4 2 3 3 4 2 2 5 2 4 5 2 3 4 4 1 5 2 3 1 2 4 3 3 2 1 1 3 3 2 3 2 1 5 4 4 0 0 5 2 4 3 2 2 2 4 2 1 3 3 1 5 2 2 1 3 1 1 2 1 4 1 2 1 2 2 0 1 2 6 2 4 4 4 1 2 1 3 3 4 2 1 2 5 1 2 3 2 4 0 1 1 3 1 2 1 3 1 2 2 2 2 2 1 2 3 6 0 4 3 1 3 4 3 1 1 2 5 2 3 3 3 2 2 0 2 2 2 2 4 4 2 2 2 2 2 1 3 3 1 2 2 3 3 4 3 2 2 2 2 3 3 3 5 1 2 1 2 2 1 1 3 2 4 2 0 3 5 1 2 1 5 3 1 3 4 3 4 6 0 1 0 0 3 3 4 2 3 1 5 2 3 2 1 5 2 2 3 1 2 2 1 3 4 2 2 3 0 4 2 2 3 2 4 1 3 5 4 3 1 3 4 2 2 1 3 2 2 1 3 3 4 3 0 4 2 3 2 5 5 1 4 1 2 5 2 2 4 3 2 3 2 4 3 3 1 0 3 7 1 4 3 3 1 4 4 0 5 1 6 2 3 4 1 2 2 4 2 5 2 5 6 1 3 6 4 3 2 1 1 3 0 4 5 2 1 4 1 3 3 3 1 1 2 2 2 2 4 2 3 2 5 3 2 3 5 2 4 3 1 1 2 1 2 1 4 2 2 2 3 3 2 2 1 2 4 3 3 3 1 2 5 3 6 1 3 3 4 4 2 1 1 4 4 3 0 2 1 1 2 3 2 2 1 2 3 1 2 4 2 2 1 3 3 2 1 4 3 2 1 4 4 4 1 3 3 4 4 3 1 3 3 3 5 3 4 2 4 3 3 1 2 2 2 3 3 1 1 2 2 0 4 4 2 3 1 3 2 2 2 2 3 3 3 1 2 0 4 2 4 2 1 1 3 3 2 3 1 0 2 2 3 3 2 4 1 3 0 1 0 2 3 4 1 3 3 2 1 2 3 2 2 3 1 2 1 2 5 2 2 5 2 4 3 3 3 1 3 3 4 0 4 3 5 4 2 4 1 2 2 2 1 3 3 2 1 4 1 0 2 2 2 4 2 2 3 2 3 2 2 2 3 2 2 3 3 0 3 1 4 4 2 4 1 2 3 1 1 0 2 4 1 2 3 3 4 4 2 2 2 6 1 3 3 3 3 2 3 2 4 3 1 2 2 3 3 0 6 2 2 3 3 0 5 6 3 3 4 4 1 2 0 4 1 3 4 4 3 1 2 5 2 1 1 2 3 1 5 3 6 3 3 2 4 1 2 1 1 3 2 4 2 3 1 3 4 5 2 3 2 2 1 3 4 0 3 3 5 3 3 2 1 2 2 3 4 3 3 2 1 2 1 1 1 0 1 2 2 0 6 3 3 1 2 4 3 3 0 4 4 1 7 4 2 4 2 2 0 2 2 2 5 3 1 0 1 2 2 2 2 3 5 4 3 2 2 4 2 3 2 1 2 3 2 3 1 3 1 3 3 1 3 4 3 3 1 1 4 2 3 4 4 3 0 5 0 1 3 4 5 3 2 3 4 2 2 2 2 3 2 4 3 6 4 2 3 2 3 3 3 2 1 1 3 2 2 2 2 3 3 3 2 7 2 4 1 5 3 2 4 2 2 4 3 2 3 2 0 3 4 2 2 1 4 2 2 1 1 3 2 1 1 0 2 3 4 2 4 2 1 3 1 4 3 2 2 4 5 2 1 4 0 4 4 0 2 1 2 3 3 0 5 2 4 1 1 4 4 0 3 2 0 4 3 1 4 4 3 3 2 4 4 4 5 4 1 0 5 3 4 3 2 4 2 3 1 2 1 3 1 1 0 1 2 5 5 5 2 1 4 3 2 2 3 3 2 2 4 1 3 0 1 2 4 1 3 2 5 2 1 4 2 2 3 3 1 2 3 4 2 1 1 1 3 3 3 3 4 2 0 2 3 0 2 1 3 1 5 0 1 4 4 3 0 4 3 3 2 3 3 0 3 3 4 2 0 2 1 2 3 3 3 0 3 3 2 2 3 2 3 2 3 2 3 2 3 3 0 5 1 1 2 3 4 1 1 3 3 1 4 4 2 2 3 3 2 2 4 1 3 2 4 1 4 3 3 3 3 2 2 3\n",
            "Writen solution to file: rosalind_cons_output.txt\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_5cf2260b-90cb-4d06-834b-0ceb86627806\", \"rosalind_cons_output.txt\", 8985)"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### [PERM:Enumerating Gene Orders](https://rosalind.info/problems/perm/)\n",
        "A permutation of length n is an ordering of the positive integers {1,2,…,n}. For example, π=(5,3,2,1,4) is a permutation of length 5.\n",
        "\n",
        "Given: A positive integer n≤7.\n",
        "\n",
        "Return: The total number of permutations of length n,\n",
        "followed by a list of all such permutations (in any order)."
      ],
      "metadata": {
        "id": "BCen2rLbN5d6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def perm_alg(n):\n",
        "    initial_list = [i + 1 for i in range(n)]\n",
        "    in_list = initial_list.copy()  # Create a copy of the initial list\n",
        "    res_list = [in_list]\n",
        "    c = [0] * n\n",
        "    i = 0\n",
        "\n",
        "    while i < n:\n",
        "        if c[i] < i:\n",
        "            if i % 2 == 0:\n",
        "                initial_list[0], initial_list[i] = initial_list[i], initial_list[0]\n",
        "            else:\n",
        "                initial_list[c[i]], initial_list[i] = initial_list[i], initial_list[c[i]]\n",
        "            res_list.append(initial_list[:])\n",
        "            c[i] += 1\n",
        "            i = 0\n",
        "        else:\n",
        "            c[i] = 0\n",
        "            i += 1\n",
        "    return[len(res_list),res_list]\n",
        "\n",
        "# test\n",
        "#print(perm_alg(3))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "apcWaRP4YkKz",
        "outputId": "30b7f50c-bd59-40ee-84bf-c7fb819fa155"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[6, [[1, 2, 3], [2, 1, 3], [3, 1, 2], [1, 3, 2], [2, 3, 1], [3, 2, 1]]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def perm(input_string):\n",
        "  \"\"\"Solves https://rosalind.info/problems/perm/\n",
        "\n",
        "  Given: A positive integer n≤7.\n",
        "\n",
        "  Return: The total number of permutations of length n,\n",
        "  followed by a list of all such permutations (in any order).\n",
        "  \"\"\"\n",
        "\n",
        "  output_list = perm_alg(int(input_string))\n",
        "\n",
        "  no_permutations = str(output_list[0])\n",
        "  permutations = output_list[1]\n",
        "  out_permutation_str = \"\"\n",
        "\n",
        "\n",
        "  for permutation in permutations:\n",
        "    permutation_l_s = int_to_str(permutation)\n",
        "    permutation_str = \" \".join(permutation_l_s)\n",
        "    out_permutation_str+=f\"\\n{permutation_str}\"\n",
        "\n",
        "  output_string = no_permutations + out_permutation_str\n",
        "\n",
        "  return output_string\n",
        "\n",
        "# test\n",
        "#perm(\"3\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eqSy3bMCN5sW",
        "outputId": "a234ad22-d582-436e-867d-50e2d40e123f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'6\\n1 2 3\\n2 1 3\\n3 1 2\\n1 3 2\\n2 3 1\\n3 2 1'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rosalind(\"perm\")"
      ],
      "metadata": {
        "id": "r7z7eZLwN51J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### [REVP:Locating Restriction Sites](https://rosalind.info/problems/revp/)\n",
        "\n",
        "Given: A DNA string of length at most 1 kbp in FASTA format.\n",
        "\n",
        "Return: The position and length of every reverse palindrome in the string having length between 4 and 12. You may return these pairs in any order."
      ],
      "metadata": {
        "id": "cPWw9LRjhvWv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def revp_alg(seq):\n",
        "  res = []\n",
        "  n = len(seq)\n",
        "\n",
        "  for i in range(n):\n",
        "    if n <= i+ 12:\n",
        "      nn = n-i+1\n",
        "    else: nn = 13\n",
        "\n",
        "    for j in range(4,nn):\n",
        "      palindrome = seq[i:i+j]\n",
        "\n",
        "      if palindrome == revc_alg(palindrome):\n",
        "        res.append((i+1,j))\n",
        "\n",
        "  return(res)\n",
        "\n",
        "# test\n",
        "revp_alg(\"TCAATGCATGCGGGTCTATATGCAT\")"
      ],
      "metadata": {
        "id": "at68P6zghv4v"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def revp(input_string):\n",
        "  \"\"\"Solves https://rosalind.info/problems/revp/\n",
        "\n",
        "  Given: A DNA string of length at most 1 kbp in FASTA format.\n",
        "\n",
        "  Return: The position and length of every reverse palindrome in the string\n",
        "  having length between 4 and 12. You may return these pairs in any order.\n",
        "  \"\"\"\n",
        "  input_tup = read_fasta(input_string)[0]\n",
        "  seq = input_tup[1]\n",
        "  print(seq)\n",
        "  out_set = revp_alg(seq)\n",
        "  out_str = \"\"\n",
        "  for tup in out_set:\n",
        "    out_str += f\"{tup[0]} {tup[1]}\\n\"\n",
        "\n",
        "  return out_str.strip()"
      ],
      "metadata": {
        "id": "rUN2Qv9dhv--"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rosalind(\"revp\")"
      ],
      "metadata": {
        "id": "PmR3OiSohwFG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### [LSCM:Finding a Shared Motif](https://rosalind.info/problems/lcsm/)\n",
        "Given: A collection of k (k≤100) DNA strings of length at most 1 kbp each in FASTA format.\n",
        "\n",
        "Return: A longest common substring of the collection. (If multiple solutions exist, you may return any single solution.)"
      ],
      "metadata": {
        "id": "VqHpXScx10Gl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def is_in_every(motif,sequences):\n",
        "  for seq in sequences:\n",
        "    if motif not in seq:\n",
        "      return False\n",
        "  return True\n",
        "is_in_every(\"AC\",['GATTACA', 'TAGACCA', 'ATACA'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8xQi3SQH7qWA",
        "outputId": "c817902d-47f1-469c-e5cd-370b266b05e2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def lscm_alg(sequences):\n",
        "  shortest_len,shortest_id = find_shortest(sequences)\n",
        "  shortest_seq = sequences[shortest_id]\n",
        "  motifs = set()\n",
        "  for i in range(shortest_len):\n",
        "    for j in range(i+1,shortest_len+1):\n",
        "      motif = shortest_seq[i:j]\n",
        "      if is_in_every(motif,sequences):\n",
        "        motifs.add(motif)\n",
        "\n",
        "  longest_motif = max(motifs, key=len)\n",
        "  return(longest_motif)\n",
        "\n",
        "#test\n",
        "lscm_alg(['GATTACA', 'TAGACCA', 'ATACA'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "gU4LS8_010QE",
        "outputId": "e44efc1a-6109-450f-d292-9f7e13e991a4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'TA'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def lscm(input_string):\n",
        "  \"\"\"Solves: https://rosalind.info/problems/lcsm/\n",
        "  Given: A collection of k (k≤100) DNA strings of length at most 1 kbp each\n",
        "  in FASTA format.\n",
        "\n",
        "  Return: A longest common substring of the collection.\n",
        "  (If multiple solutions exist, you may return any single solution.)\n",
        "  \"\"\"\n",
        "  input_tup = read_fasta(input_string)\n",
        "  sequences = []\n",
        "  for _ , seq in input_tup:\n",
        "    sequences.append(seq)\n",
        "\n",
        "  shared_motif = lscm_alg(sequences)\n",
        "  return(shared_motif)"
      ],
      "metadata": {
        "id": "2VxLxMCu10WV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rosalind('lscm')"
      ],
      "metadata": {
        "id": "czIVpwAl10cH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "####[TRAN:Transitions and Transversions](https://rosalind.info/problems/tran/)\n",
        "Given: Two DNA strings s1 and s2 of equal length (at most 1 kbp).\n",
        "\n",
        "Return: The transition/transversion ratio R(s1,s2)."
      ],
      "metadata": {
        "id": "hgu2uRWlAQw9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def is_transition(nuc_p):\n",
        "  if (\"A\" in nuc_p and \"G\" in nuc_p) or (\"C\" in nuc_p and \"T\" in  nuc_p):\n",
        "    return True\n",
        "  else:\n",
        "     return False\n",
        "\n",
        "\n",
        "def tran_alg(sequence_1,sequence_2):\n",
        "  transitions = 0\n",
        "  transversions = 0\n",
        "  for loc in range(len(sequence_1)):\n",
        "    nuc_1 = sequence_1[loc]\n",
        "    nuc_2 = sequence_2[loc]\n",
        "    if nuc_1 == nuc_2:\n",
        "      continue\n",
        "    if is_transition([nuc_1,nuc_2]):\n",
        "      transitions += 1\n",
        "    else:\n",
        "      transversions +=1\n",
        "  ratio = transitions/transversions\n",
        "\n",
        "\n",
        "\n",
        "  return ratio\n",
        "# test\n",
        "tran_alg(\"GCAACGCACAACGAAAACCCTTAGGGACTGGATTATTTCGTGATCGTTGTAGTTATTGGAAGTACGGGCATCAACCCAGTT\",\"TTATCTGACAAAGAAAGCCGTCAACGGCTGGATAATTTCGCGATCGTGCTGGTTACTGGCGGTACGAGTGTTCCTTTGGGT\")"
      ],
      "metadata": {
        "id": "dgBXmYDzAPzh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e80363e8-36ac-4cc7-ebe9-90cb7fbc14a4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.2142857142857142"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def tran(input_string):\n",
        "  \"\"\"Solves: https://rosalind.info/problems/tran/\n",
        "  Given: Two DNA strings s1 and s2 of equal length (at most 1 kbp).\n",
        "\n",
        "  Return: The transition/transversion ratio R(s1,s2).\n",
        "  \"\"\"\n",
        "  input_list = read_fasta(input_string)\n",
        "  ratio = tran_alg(input_list[0][1],input_list[1][1])\n",
        "  return str(ratio)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "XlZt7JWIrJwP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rosalind(\"tran\")"
      ],
      "metadata": {
        "id": "HSuRfynRrJ1y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "####[MRNA:Inferring mRNA from Protein](https://rosalind.info/problems/mrna/)\n",
        "Given: A protein string of length at most 1000 aa.\n",
        "\n",
        "Return: The total number of different RNA strings from which the protein could have been translated, modulo 1,000,000. (Don't neglect the importance of the stop codon in protein translation.)"
      ],
      "metadata": {
        "id": "HI_Y5UUPpGIm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# we will utilise dictionary from PROT\n",
        "\n",
        "amino_dict = {'F': ['UUU', 'UUC'], 'L': ['UUA', 'UUG', 'CUU', 'CUC', 'CUA', 'CUG'],\n",
        "                'S': ['UCU', 'UCC', 'UCA', 'UCG', 'AGU', 'AGC'], 'Y': ['UAU', 'UAC'],\n",
        "                'STOP': ['UAA', 'UAG', 'UGA'], 'C': ['UGU', 'UGC'], 'W': ['UGG'],\n",
        "                'P': ['CCU', 'CCC', 'CCA', 'CCG'], 'H': ['CAU', 'CAC'], 'Q': ['CAA', 'CAG'],\n",
        "                'R': ['CGU', 'CGC', 'CGA', 'CGG', 'AGA', 'AGG'], 'I': ['AUU', 'AUC', 'AUA'],\n",
        "                'M': ['AUG'], 'T': ['ACU', 'ACC', 'ACA', 'ACG'], 'N': ['AAU', 'AAC'],\n",
        "                'K': ['AAA', 'AAG'], 'V': ['GUU', 'GUC', 'GUA', 'GUG'],\n",
        "                'A': ['GCU', 'GCC', 'GCA', 'GCG'], 'D': ['GAU', 'GAC'],\n",
        "                'E': ['GAA', 'GAG'], 'G': ['GGU', 'GGC', 'GGA', 'GGG']}\n",
        "\n",
        "amino_comb_dict = {}\n",
        "\n",
        "for key in amino_dict:\n",
        "  amino_comb_dict[key]=len(amino_dict[key])\n",
        "\n",
        "\n",
        "print(amino_comb_dict)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BMDoONeTpGd9",
        "outputId": "6788d1a5-34c9-4912-8ede-03d01706684e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'F': 2, 'L': 6, 'S': 6, 'Y': 2, 'STOP': 3, 'C': 2, 'W': 1, 'P': 4, 'H': 2, 'Q': 2, 'R': 6, 'I': 3, 'M': 1, 'T': 4, 'N': 2, 'K': 2, 'V': 4, 'A': 4, 'D': 2, 'E': 2, 'G': 4}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def mrna_alg(amino_seq):\n",
        "  result = 1\n",
        "  for amino in amino_seq:\n",
        "    result = result * amino_comb_dict[amino]\n",
        "  result *= 3\n",
        "  result %= 1000000\n",
        "  return result\n",
        "\n",
        "#test\n",
        "mrna_alg(\"MA\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zVF6vP-mqlpp",
        "outputId": "5bedcde8-f96a-4240-a3c4-a18aee1efe25"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def mrna(input_string):\n",
        "  \"\"\"Solves: https://rosalind.info/problems/mrna/\n",
        "  Given: A protein string of length at most 1000 aa.\n",
        "\n",
        "  Return: The total number of different RNA strings from\n",
        "  which the protein could have been translated, modulo 1,000,000.\n",
        "  (Don't neglect the importance of the stop codon in protein translation.)\n",
        "  \"\"\"\n",
        "  sequence = \"\".join(input_string.splitlines())\n",
        "  return str(mrna_alg(sequence))\n"
      ],
      "metadata": {
        "id": "aSx9ZKO5pGix"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rosalind(\"mrna\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 239
        },
        "id": "UWuIrD8ypGwl",
        "outputId": "9f8880dc-f584-419d-aa9c-697773d54d16"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "First download set from https://rosalind.info/problems/mrna\n",
            "Then upload file here by pressing choose file button below\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-55d7c7c8-731b-4050-bfad-05238cba1fcd\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-55d7c7c8-731b-4050-bfad-05238cba1fcd\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving rosalind_mrna.txt to rosalind_mrna (2).txt\n",
            "data got =  MFAGGSSKIAMDMVPSCSFKYHKIFLQRYNMCWHGLNGSTRACGRPTNWCVGNDGRIVHCVEIRPCLDRFPKAAKAPNTCWVPWYMTEMNMFTCFSKCAQMHRITTTTPSHYPMRMTWKGEMSNFAACDIHLRTKNAVIMTGCKWLDEEGKKSTIWLTQMDVYRRTHWLQFHNNEEWTFRAVDGKENIYVERIYGGGMCQFEGNHPCNKYKFPTFQALVQGVKKAMELHKQMMRSRAAIIEPCTRCMRNLLKCMLNSPPGGWIIADDYFCNRYCMINFGNIEVFYKFEPCVFWLSYCYMVQPKMMADYYMKCNLSHEGSFGDHENHWHGKLQGDKVYGCNAYQTRTDTQHVEWGTCAMLFGGTVKSAMGTPNRRPFPHDIWKNANVSAAVWQDKSHHFKVSGAHEVCKLPDMNDGQYGSWIKFWRSPFERACTSAQTVCMQDNNQHSPVIQKKLLRLMIINFVNDCPRMNKINIKWFLNSHNRIIISKQYGDCWHPRVALLRDRGNGVCKNHRLHMVDEVSQHCLEIDLIVKFMTGFNYFHIPDPVAVVCYPGTNYAKESYYQLHMLHVLSAKGVVISQKFHNPCTSDNHLYLVIYEYCSPNGHSRWCDAHEPVQRLAEGFKKWPGCRDMNGWDRPNKEGSSECVYKNIPYGIVCFTADTWMHDPCWIQKQYKFKICGIGLCKFPQIQSAINAARPSRTDEINGLHFVGKLHININNRHKQHYGWDPDFAGDVVMSNNMAGDEHYISPYYIKHTIADYDEPYHKRHCIPKSAHAYSTWYAFQGDPAEWNCLQWFCYYAHKGPKCQENSQKYDFKGYPNAEAFHFTTSNEPPFHTCSVYMMMGLWRNIFVSMKNANDKIMWHWRLEWTPCKYEGVYYPHHKCKNCTWINIHHRRGWGAIWTIKFAWAFFYKVTMHVRAPRHPKICTCKKGEVDNEKGPIGKQMHYFNFMKAIHACNISYTWGQLGRWSDFIATLRSRGGRPGVYTEQADKDELNDDLEV\r\n",
            "\n",
            "MFAGGSSKIAMDMVPSCSFKYHKIFLQRYNMCWHGLNGSTRACGRPTNWCVGNDGRIVHCVEIRPCLDRFPKAAKAPNTCWVPWYMTEMNMFTCFSKCAQMHRITTTTPSHYPMRMTWKGEMSNFAACDIHLRTKNAVIMTGCKWLDEEGKKSTIWLTQMDVYRRTHWLQFHNNEEWTFRAVDGKENIYVERIYGGGMCQFEGNHPCNKYKFPTFQALVQGVKKAMELHKQMMRSRAAIIEPCTRCMRNLLKCMLNSPPGGWIIADDYFCNRYCMINFGNIEVFYKFEPCVFWLSYCYMVQPKMMADYYMKCNLSHEGSFGDHENHWHGKLQGDKVYGCNAYQTRTDTQHVEWGTCAMLFGGTVKSAMGTPNRRPFPHDIWKNANVSAAVWQDKSHHFKVSGAHEVCKLPDMNDGQYGSWIKFWRSPFERACTSAQTVCMQDNNQHSPVIQKKLLRLMIINFVNDCPRMNKINIKWFLNSHNRIIISKQYGDCWHPRVALLRDRGNGVCKNHRLHMVDEVSQHCLEIDLIVKFMTGFNYFHIPDPVAVVCYPGTNYAKESYYQLHMLHVLSAKGVVISQKFHNPCTSDNHLYLVIYEYCSPNGHSRWCDAHEPVQRLAEGFKKWPGCRDMNGWDRPNKEGSSECVYKNIPYGIVCFTADTWMHDPCWIQKQYKFKICGIGLCKFPQIQSAINAARPSRTDEINGLHFVGKLHININNRHKQHYGWDPDFAGDVVMSNNMAGDEHYISPYYIKHTIADYDEPYHKRHCIPKSAHAYSTWYAFQGDPAEWNCLQWFCYYAHKGPKCQENSQKYDFKGYPNAEAFHFTTSNEPPFHTCSVYMMMGLWRNIFVSMKNANDKIMWHWRLEWTPCKYEGVYYPHHKCKNCTWINIHHRRGWGAIWTIKFAWAFFYKVTMHVRAPRHPKICTCKKGEVDNEKGPIGKQMHYFNFMKAIHACNISYTWGQLGRWSDFIATLRSRGGRPGVYTEQADKDELNDDLEV\n",
            "output =  605568\n",
            "Writen solution to file: rosalind_mrna_output.txt\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_351c65db-d09e-48fa-82a1-4b0c97fbe36a\", \"rosalind_mrna_output.txt\", 6)"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    }
  ]
}