rosalind.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-14T08:16:02.737268Z",
     "iopub.status.busy": "2023-06-14T08:16:02.736874Z",
     "iopub.status.idle": "2023-06-14T08:16:02.742849Z",
     "shell.execute_reply": "2023-06-14T08:16:02.741549Z",
     "shell.execute_reply.started": "2023-06-14T08:16:02.737239Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "# Exercise DNA\n",
    "\n",
    "# https://stackoverflow.com/questions/12282232/\n",
    "from collections import Counter\n",
    "\n",
    "# Exercise fib\n",
    "from functools import reduce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. [DNA](https://rosalind.info/problems/dna/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T08:49:06.323413Z",
     "iopub.status.busy": "2023-06-13T08:49:06.323033Z",
     "iopub.status.idle": "2023-06-13T08:49:06.328500Z",
     "shell.execute_reply": "2023-06-13T08:49:06.327476Z",
     "shell.execute_reply.started": "2023-06-13T08:49:06.323382Z"
    }
   },
   "outputs": [],
   "source": [
    "sample = 'AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T08:50:30.948154Z",
     "iopub.status.busy": "2023-06-13T08:50:30.947769Z",
     "iopub.status.idle": "2023-06-13T08:50:30.957876Z",
     "shell.execute_reply": "2023-06-13T08:50:30.956755Z",
     "shell.execute_reply.started": "2023-06-13T08:50:30.948125Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A',\n",
       " 'G',\n",
       " 'C',\n",
       " 'T',\n",
       " 'T',\n",
       " 'T',\n",
       " 'T',\n",
       " 'C',\n",
       " 'A',\n",
       " 'T',\n",
       " 'T',\n",
       " 'C',\n",
       " 'T',\n",
       " 'G',\n",
       " 'A',\n",
       " 'C',\n",
       " 'T',\n",
       " 'G',\n",
       " 'C',\n",
       " 'A',\n",
       " 'A',\n",
       " 'C',\n",
       " 'G',\n",
       " 'G',\n",
       " 'G',\n",
       " 'C',\n",
       " 'A',\n",
       " 'A',\n",
       " 'T',\n",
       " 'A',\n",
       " 'T',\n",
       " 'G',\n",
       " 'T',\n",
       " 'C',\n",
       " 'T',\n",
       " 'C',\n",
       " 'T',\n",
       " 'G',\n",
       " 'T',\n",
       " 'G',\n",
       " 'T',\n",
       " 'G',\n",
       " 'G',\n",
       " 'A',\n",
       " 'T',\n",
       " 'T',\n",
       " 'A',\n",
       " 'A',\n",
       " 'A',\n",
       " 'A',\n",
       " 'A',\n",
       " 'A',\n",
       " 'A',\n",
       " 'G',\n",
       " 'A',\n",
       " 'G',\n",
       " 'T',\n",
       " 'G',\n",
       " 'T',\n",
       " 'C',\n",
       " 'T',\n",
       " 'G',\n",
       " 'A',\n",
       " 'T',\n",
       " 'A',\n",
       " 'G',\n",
       " 'C',\n",
       " 'A',\n",
       " 'G',\n",
       " 'C']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(sample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T08:52:42.206520Z",
     "iopub.status.busy": "2023-06-13T08:52:42.206132Z",
     "iopub.status.idle": "2023-06-13T08:52:42.211286Z",
     "shell.execute_reply": "2023-06-13T08:52:42.210064Z",
     "shell.execute_reply.started": "2023-06-13T08:52:42.206492Z"
    }
   },
   "outputs": [],
   "source": [
    "count = Counter(list(sample))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T08:57:10.224644Z",
     "iopub.status.busy": "2023-06-13T08:57:10.224194Z",
     "iopub.status.idle": "2023-06-13T08:57:10.231441Z",
     "shell.execute_reply": "2023-06-13T08:57:10.230377Z",
     "shell.execute_reply.started": "2023-06-13T08:57:10.224613Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A', 20), ('C', 12), ('G', 17), ('T', 21)]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# https://stackoverflow.com/questions/17930814/\n",
    "sorted(count.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T08:59:16.187834Z",
     "iopub.status.busy": "2023-06-13T08:59:16.187434Z",
     "iopub.status.idle": "2023-06-13T08:59:16.195484Z",
     "shell.execute_reply": "2023-06-13T08:59:16.194281Z",
     "shell.execute_reply.started": "2023-06-13T08:59:16.187804Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'T': 21, 'A': 20, 'G': 17, 'C': 12})"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Counter(sample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T09:03:19.511543Z",
     "iopub.status.busy": "2023-06-13T09:03:19.511162Z",
     "iopub.status.idle": "2023-06-13T09:03:19.519219Z",
     "shell.execute_reply": "2023-06-13T09:03:19.518260Z",
     "shell.execute_reply.started": "2023-06-13T09:03:19.511516Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'20 12 17 21'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\" \".join(str(x[1]) for x in sorted(Counter(sample).items()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T09:06:09.835220Z",
     "iopub.status.busy": "2023-06-13T09:06:09.834878Z",
     "iopub.status.idle": "2023-06-13T09:06:09.840984Z",
     "shell.execute_reply": "2023-06-13T09:06:09.839789Z",
     "shell.execute_reply.started": "2023-06-13T09:06:09.835192Z"
    }
   },
   "outputs": [],
   "source": [
    "def nucleos(string: str) -> str:\n",
    "    return \" \".join(\n",
    "        str(x[1])\n",
    "        for x in sorted(Counter(string).items())\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T09:06:12.038490Z",
     "iopub.status.busy": "2023-06-13T09:06:12.038036Z",
     "iopub.status.idle": "2023-06-13T09:06:12.045363Z",
     "shell.execute_reply": "2023-06-13T09:06:12.044165Z",
     "shell.execute_reply.started": "2023-06-13T09:06:12.038446Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'20 12 17 21'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nucleos(sample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T09:11:10.022937Z",
     "iopub.status.busy": "2023-06-13T09:11:10.022565Z",
     "iopub.status.idle": "2023-06-13T09:11:10.030440Z",
     "shell.execute_reply": "2023-06-13T09:11:10.029788Z",
     "shell.execute_reply.started": "2023-06-13T09:11:10.022907Z"
    }
   },
   "outputs": [],
   "source": [
    "with open('/kaggle/input/rosalind-dna/rosalind_dna.txt') as f:\n",
    "    string = f.read().replace('\\n', '')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T09:11:12.708713Z",
     "iopub.status.busy": "2023-06-13T09:11:12.708368Z",
     "iopub.status.idle": "2023-06-13T09:11:12.715226Z",
     "shell.execute_reply": "2023-06-13T09:11:12.714205Z",
     "shell.execute_reply.started": "2023-06-13T09:11:12.708687Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'201 210 215 195'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nucleos(string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other Solution\n",
    "\n",
    "Better than mine because:\n",
    "1. Specifies what to count for i.e. 'ACGT'\n",
    "2. Uses faster map/count calls\n",
    "3. Shorter/less function calls\n",
    "4. Doesn't require importing collections\n",
    "\n",
    "Better performing solution would be iterate over the list only once instead of 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T09:20:23.018011Z",
     "iopub.status.busy": "2023-06-13T09:20:23.017577Z",
     "iopub.status.idle": "2023-06-13T09:20:23.023103Z",
     "shell.execute_reply": "2023-06-13T09:20:23.022129Z",
     "shell.execute_reply.started": "2023-06-13T09:20:23.017977Z"
    }
   },
   "outputs": [],
   "source": [
    "nucleos = lambda string: print(*map(string.count, 'ACGT'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T09:20:23.403512Z",
     "iopub.status.busy": "2023-06-13T09:20:23.402430Z",
     "iopub.status.idle": "2023-06-13T09:20:23.408844Z",
     "shell.execute_reply": "2023-06-13T09:20:23.407724Z",
     "shell.execute_reply.started": "2023-06-13T09:20:23.403470Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "201 210 215 195\n"
     ]
    }
   ],
   "source": [
    "nucleos(string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Transcribing DNA into RNA](https://rosalind.info/problems/rna/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T09:32:33.454776Z",
     "iopub.status.busy": "2023-06-13T09:32:33.454415Z",
     "iopub.status.idle": "2023-06-13T09:32:33.459372Z",
     "shell.execute_reply": "2023-06-13T09:32:33.458285Z",
     "shell.execute_reply.started": "2023-06-13T09:32:33.454749Z"
    }
   },
   "outputs": [],
   "source": [
    "sample = 'GATGGAACTTGACTACGTAAATT'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T09:32:43.157359Z",
     "iopub.status.busy": "2023-06-13T09:32:43.156205Z",
     "iopub.status.idle": "2023-06-13T09:32:43.163617Z",
     "shell.execute_reply": "2023-06-13T09:32:43.162622Z",
     "shell.execute_reply.started": "2023-06-13T09:32:43.157313Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'GAUGGAACUUGACUACGUAAAUU'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample.replace('T', 'U')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T09:35:22.158117Z",
     "iopub.status.busy": "2023-06-13T09:35:22.157718Z",
     "iopub.status.idle": "2023-06-13T09:35:22.163498Z",
     "shell.execute_reply": "2023-06-13T09:35:22.162426Z",
     "shell.execute_reply.started": "2023-06-13T09:35:22.158084Z"
    }
   },
   "outputs": [],
   "source": [
    "def transcribe(string: str) -> str:\n",
    "    return string.upper().replace('T', 'U')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T09:35:31.415770Z",
     "iopub.status.busy": "2023-06-13T09:35:31.415388Z",
     "iopub.status.idle": "2023-06-13T09:35:31.423141Z",
     "shell.execute_reply": "2023-06-13T09:35:31.422099Z",
     "shell.execute_reply.started": "2023-06-13T09:35:31.415743Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'GAUGGAACUUGACUACGUAAAUU'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "transcribe(sample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T09:37:11.799979Z",
     "iopub.status.busy": "2023-06-13T09:37:11.799597Z",
     "iopub.status.idle": "2023-06-13T09:37:11.808202Z",
     "shell.execute_reply": "2023-06-13T09:37:11.807284Z",
     "shell.execute_reply.started": "2023-06-13T09:37:11.799949Z"
    }
   },
   "outputs": [],
   "source": [
    "with open('/kaggle/input/rosalind-rna/rosalind_rna.txt') as f:\n",
    "    string = f.read().replace('\\n', '')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T09:37:37.226085Z",
     "iopub.status.busy": "2023-06-13T09:37:37.225453Z",
     "iopub.status.idle": "2023-06-13T09:37:37.233555Z",
     "shell.execute_reply": "2023-06-13T09:37:37.232583Z",
     "shell.execute_reply.started": "2023-06-13T09:37:37.226036Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AGAGUCUACGACUCGGGGUCGGAUGUUGGCGAUUAACAUCAGGGGUGACCAUCAUGACAUAGCAGAAACAUGGCUUAGCGGUAUCUCCCGUGUACUUUGCCUGUAUAACAGCCGAAAGGCCGCCGGUACGUUGCUUUGAUCGGCAUUCGCGCCCACUGUGUUUUAGACAUAGUGCCUCUCUCCAAAAAUUGGCACACUGCAAUCGAAAGGAUGGGUCUCGCGGGUAAGAGACCUAAUAAUUAACGUCGCAGAAAACGUGAUCUAGGCCCGCGCUAGAUCUACCGUUAAAUAAUCACCCAAAGUCAGCGAGACGCACAAACUCGGGUCAAAUGGUUAAAAUAUCCCGUAUUCACACUGCAAAUUACUAUAGGUGUUUGAUGUGUUCUUGUUUAACUCUGGACUUGCUUCUUUAAUCCAAUUUCCUGCAACGGGACAGAAUUACGUCUAUGCCUGUGGUUGGUAAAACCACAACGUCCUCCAACUCUUAUGAAGGUCCGUAUUCUUAUAACGCACGGUUGUGCAAUGAGACCCCUACUGUGAAAAAAGCUAAAGAAAGUGCUGGGUCAUGGUGCGUAACUUAACCCCCAUACCUGGGGGUUUCAGCAGGGGUUAGCCUAUCCCCUGACGUACGCUAAGUGUGGAACAAAUACCCCGGAGCGACGCAACCAGAGACACAGUGUGGCGGAUUAAUCCAUGAGUGUUUGAACACAAUGAGCGGUGUGUGAUUCCCCCGAGCGUAGUCCUCGAGGCACACACCACUGGUUAACGAUACCCUACCACAGGCUGUGUUGAUCCACCCGGUAGCAGCCUUAUAGAUUGGGGUCCGGCACAGGUGAUUGCCUAGUCGGUUCAGGUAAAGCCGCGUAUGCCCCUACCGCGGACGUGAGUUAUUGAAACACGAU'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "transcribe(string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Solution\n",
    "\n",
    "Use something like BioPython in-built utilities?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Complementing a Strand of DNA](https://rosalind.info/problems/revc/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T09:42:48.032402Z",
     "iopub.status.busy": "2023-06-13T09:42:48.031984Z",
     "iopub.status.idle": "2023-06-13T09:42:48.037187Z",
     "shell.execute_reply": "2023-06-13T09:42:48.036367Z",
     "shell.execute_reply.started": "2023-06-13T09:42:48.032358Z"
    }
   },
   "outputs": [],
   "source": [
    "sample = 'AAAACCCGGT'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T09:56:39.271013Z",
     "iopub.status.busy": "2023-06-13T09:56:39.270683Z",
     "iopub.status.idle": "2023-06-13T09:56:39.276287Z",
     "shell.execute_reply": "2023-06-13T09:56:39.275081Z",
     "shell.execute_reply.started": "2023-06-13T09:56:39.270990Z"
    }
   },
   "outputs": [],
   "source": [
    "c = ['AT', 'CG']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T10:02:27.440836Z",
     "iopub.status.busy": "2023-06-13T10:02:27.440353Z",
     "iopub.status.idle": "2023-06-13T10:02:27.447511Z",
     "shell.execute_reply": "2023-06-13T10:02:27.446108Z",
     "shell.execute_reply.started": "2023-06-13T10:02:27.440780Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'T'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "''.join(\"AT\".split('A'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T10:26:02.544763Z",
     "iopub.status.busy": "2023-06-13T10:26:02.544398Z",
     "iopub.status.idle": "2023-06-13T10:26:02.549433Z",
     "shell.execute_reply": "2023-06-13T10:26:02.548663Z",
     "shell.execute_reply.started": "2023-06-13T10:26:02.544735Z"
    }
   },
   "outputs": [],
   "source": [
    "embedding = dict(zip('ATCG', [1, -1, 1j, -1j]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T10:26:10.505947Z",
     "iopub.status.busy": "2023-06-13T10:26:10.505539Z",
     "iopub.status.idle": "2023-06-13T10:26:10.512258Z",
     "shell.execute_reply": "2023-06-13T10:26:10.511414Z",
     "shell.execute_reply.started": "2023-06-13T10:26:10.505915Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A': 1, 'T': -1, 'C': 1j, 'G': (-0-1j)}"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T10:30:46.531505Z",
     "iopub.status.busy": "2023-06-13T10:30:46.531100Z",
     "iopub.status.idle": "2023-06-13T10:30:46.537173Z",
     "shell.execute_reply": "2023-06-13T10:30:46.536021Z",
     "shell.execute_reply.started": "2023-06-13T10:30:46.531477Z"
    }
   },
   "outputs": [],
   "source": [
    "def complement(base):\n",
    "    match base:\n",
    "        case 'A': return 'T'\n",
    "        case 'T': return 'A'\n",
    "        case 'C': return 'G'\n",
    "        case 'G': return 'C'\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T10:33:12.121173Z",
     "iopub.status.busy": "2023-06-13T10:33:12.120811Z",
     "iopub.status.idle": "2023-06-13T10:33:12.127904Z",
     "shell.execute_reply": "2023-06-13T10:33:12.126875Z",
     "shell.execute_reply.started": "2023-06-13T10:33:12.121146Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ACCGGGTTTT'"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\".join(map(complement, sample[::-1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T10:34:48.211190Z",
     "iopub.status.busy": "2023-06-13T10:34:48.210769Z",
     "iopub.status.idle": "2023-06-13T10:34:48.218653Z",
     "shell.execute_reply": "2023-06-13T10:34:48.217254Z",
     "shell.execute_reply.started": "2023-06-13T10:34:48.211162Z"
    }
   },
   "outputs": [],
   "source": [
    "def revc(string: str) -> str:\n",
    "    def complement(base):\n",
    "        match base:\n",
    "            case 'A': return 'T'\n",
    "            case 'T': return 'A'\n",
    "            case 'C': return 'G'\n",
    "            case 'G': return 'C'\n",
    "    return \"\".join(map(complement, string[::-1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T10:34:53.581024Z",
     "iopub.status.busy": "2023-06-13T10:34:53.580454Z",
     "iopub.status.idle": "2023-06-13T10:34:53.587678Z",
     "shell.execute_reply": "2023-06-13T10:34:53.586642Z",
     "shell.execute_reply.started": "2023-06-13T10:34:53.580993Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ACCGGGTTTT'"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "revc(sample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-13T10:36:07.156138Z",
     "iopub.status.busy": "2023-06-13T10:36:07.155411Z",
     "iopub.status.idle": "2023-06-13T10:36:10.170803Z",
     "shell.execute_reply": "2023-06-13T10:36:10.170083Z",
     "shell.execute_reply.started": "2023-06-13T10:36:07.156098Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " GCTTCTTCATAACGCTAACACAGACAAGGACTTAGCATCGATTGGCCTCCATGATTTGCGAGCACGTCCCTTCTACCTTGTGAGGGAGGCTACGCCATAGCGTACACGGTAGGAACAATGACGCGGGTAGCCCAGTGCCTCATTCGATAGGTGCGTTTGACAGGGTCGGTGCTAGATAGTGATGGAGTGAATGCCGCATTAGCAGTCTGTTATGACTCTATATGAGCTCCCAAGCGTGAGGCAGGACTGTGCAAGGAATACCCCGTTTCCAGGACAAATTTTAAGCGAAGCAGGGCCAGTGAGCTCTGCTTCAACTAAAGGGTTTGTATCAGTGCTTATCATGCAACACATGATCCCGCAGTTGTTCTCGTACGTGTATATATATGTAGACTTAGTTACTAAACGGGTTGATCAGGCCCTCTTCCCTCCTCCCTCCTGGCAAAAAGAGCCTGACGCCTGAAACACGTGTCCTTGCTTTGAGAGTGAATAAGAGTGTCAGCGTTTGAACGGTAGCCCGATAATATTTTACTGCGTGGTCACACAAGCAGCTCCATTCTCAGCACGGTTCTGCTGACAACCAAAATCCTTAGATAAGGGTCCTTTGACAGATTTACCAGAGTGGCCGCCCCACGTCATGTCGCTTGTCGACGCGGCGGGGAAAGATCACAGCTCTGAACGGGTTCGGTACAGATCGTTCTTTCGTCGGATTGAAACCCGAGAAATAAAAAAAGGTCTTACGCTAAGGGCATGGTCATGAGCCCCCGGCGGTTTTACAGAGTGATAAGGAAGTAGGCAGGGAACACGAGATCCAAGGACACTGGCGCTAGAGTGATTCACGGTCTACAGGCTGCGTGTAGTTGCCCTGATAGTATCTATGAGAGCGACTCGTGAGGTTG\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'CAACCTCACGAGTCGCTCTCATAGATACTATCAGGGCAACTACACGCAGCCTGTAGACCGTGAATCACTCTAGCGCCAGTGTCCTTGGATCTCGTGTTCCCTGCCTACTTCCTTATCACTCTGTAAAACCGCCGGGGGCTCATGACCATGCCCTTAGCGTAAGACCTTTTTTTATTTCTCGGGTTTCAATCCGACGAAAGAACGATCTGTACCGAACCCGTTCAGAGCTGTGATCTTTCCCCGCCGCGTCGACAAGCGACATGACGTGGGGCGGCCACTCTGGTAAATCTGTCAAAGGACCCTTATCTAAGGATTTTGGTTGTCAGCAGAACCGTGCTGAGAATGGAGCTGCTTGTGTGACCACGCAGTAAAATATTATCGGGCTACCGTTCAAACGCTGACACTCTTATTCACTCTCAAAGCAAGGACACGTGTTTCAGGCGTCAGGCTCTTTTTGCCAGGAGGGAGGAGGGAAGAGGGCCTGATCAACCCGTTTAGTAACTAAGTCTACATATATATACACGTACGAGAACAACTGCGGGATCATGTGTTGCATGATAAGCACTGATACAAACCCTTTAGTTGAAGCAGAGCTCACTGGCCCTGCTTCGCTTAAAATTTGTCCTGGAAACGGGGTATTCCTTGCACAGTCCTGCCTCACGCTTGGGAGCTCATATAGAGTCATAACAGACTGCTAATGCGGCATTCACTCCATCACTATCTAGCACCGACCCTGTCAAACGCACCTATCGAATGAGGCACTGGGCTACCCGCGTCATTGTTCCTACCGTGTACGCTATGGCGTAGCCTCCCTCACAAGGTAGAAGGGACGTGCTCGCAAATCATGGAGGCCAATCGATGCTAAGTCCTTGTCTGTGTTAGCGTTATGAAGAAGC'"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "revc(input())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Solution\n",
    "\n",
    "- Not match case use dict instead\n",
    "- Use BioP util"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Rabbits and Recurrence Relations](https://rosalind.info/problems/fib/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-14T08:17:42.170089Z",
     "iopub.status.busy": "2023-06-14T08:17:42.169675Z",
     "iopub.status.idle": "2023-06-14T08:17:42.176327Z",
     "shell.execute_reply": "2023-06-14T08:17:42.174767Z",
     "shell.execute_reply.started": "2023-06-14T08:17:42.170060Z"
    }
   },
   "outputs": [],
   "source": [
    "fib = lambda n: reduce(lambda x, _: x + [x[-1] + x[-2]], range(n-2), [1, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-14T08:17:42.893316Z",
     "iopub.status.busy": "2023-06-14T08:17:42.892926Z",
     "iopub.status.idle": "2023-06-14T08:17:42.901876Z",
     "shell.execute_reply": "2023-06-14T08:17:42.900912Z",
     "shell.execute_reply.started": "2023-06-14T08:17:42.893285Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 2, 2, 4, 7, 12, 20, 33, 54, 88, 143, 232]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[sum(fib(x)) for x in range(12)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-14T08:21:32.261295Z",
     "iopub.status.busy": "2023-06-14T08:21:32.260903Z",
     "iopub.status.idle": "2023-06-14T08:21:32.268623Z",
     "shell.execute_reply": "2023-06-14T08:21:32.266937Z",
     "shell.execute_reply.started": "2023-06-14T08:21:32.261263Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-14T08:21:33.664375Z",
     "iopub.status.busy": "2023-06-14T08:21:33.663079Z",
     "iopub.status.idle": "2023-06-14T08:21:33.671689Z",
     "shell.execute_reply": "2023-06-14T08:21:33.670409Z",
     "shell.execute_reply.started": "2023-06-14T08:21:33.664327Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 2, 2, 6, 19]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[sum(fib(x, 3)) for x in range(5)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-14T08:21:48.338054Z",
     "iopub.status.busy": "2023-06-14T08:21:48.337641Z",
     "iopub.status.idle": "2023-06-14T08:21:48.345309Z",
     "shell.execute_reply": "2023-06-14T08:21:48.343824Z",
     "shell.execute_reply.started": "2023-06-14T08:21:48.338023Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(fib(5 - 1, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-06-14T10:55:52.525342Z",
     "iopub.status.busy": "2023-06-14T10:55:52.524644Z",
     "iopub.status.idle": "2023-06-14T10:55:52.563631Z",
     "shell.execute_reply": "2023-06-14T10:55:52.562488Z",
     "shell.execute_reply.started": "2023-06-14T10:55:52.525304Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "44560482149"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "\n",
    "def fib(n: int = 5, k: int = 3):\n",
    "    return sum(\n",
    "        reduce(lambda x, _: x + [k * x[-1] + x[-2]], range(n - 2 - 1), [1, 1])\n",
    "    )\n",
    "\n",
    "\n",
    "fib(30, 2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "from functools import reduce\n",
    "from operator import ne\n",
    "from typing import List\n",
    "import re\n",
    "from math import ceil\n",
    "import itertools as it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check whether string is valide nucleotide sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'acgt'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bases = \"acgt\"\n",
    "bases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "null = \"agctACGTagagagatatatcatcatcactcatctaccaggctgtcgcagcgac\" * 200\n",
    "alt = \"asdasdfjsda;fljsdaflk;fjl;asjdf;aksldjf;asljkdfsd;nf;askflj;sdfj\" * 200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Attempt 1 broken\n",
    "def validate(seqs: str):\n",
    "    for seq in seqs:\n",
    "        if seq not in bases:\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print(validate(null))\n",
    "print(validate(alt))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "233 ns ± 9.67 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit validate(null)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "151 ns ± 6.56 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit validate(alt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "49.5 µs ± 1.71 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "# Fastest\n",
    "%timeit not re.findall(r\"[^acgt]\", null.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "825 µs ± 39.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit not re.findall(r\"[^acgt]\", alt.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fixed with short circuit\n",
    "def validate(seqs: str) -> bool:\n",
    "    for seq in seqs.upper():\n",
    "        if seq not in bases:\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.84 µs ± 211 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "# Slower than regex\n",
    "%timeit validate(null)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50 µs ± 288 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit not next(re.finditer(r\"[^acgt]\", null.lower()), False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.55 µs ± 73.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit not next(re.finditer(r\"[^acgt]\", alt.lower()), False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def valid(seq: str) -> bool:\n",
    "    \"\"\"\n",
    "    seq[str]: String to check for valid nucleotide bases\n",
    "\n",
    "    returns: Sequence if valid nucleotide sequence else ''\n",
    "\n",
    "    >>>valid(null)\n",
    "    True\n",
    "    >>>valid(alt)\n",
    "    False\n",
    "    \"\"\"\n",
    "    seq = seq.lower()\n",
    "    return seq if not next(re.finditer(r\"[^acgt]\", seq.lower()), False) else ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean(seq: str, bases=bases) -> str:\n",
    "    \"\"\"\n",
    "    seq: Any string\n",
    "\n",
    "    returns: a valid nucleotide sequence\n",
    "    >>>valid(\"acgt\")\n",
    "    acgt\n",
    "    >>>valid(\"ACgt\")\n",
    "    acgt\n",
    "    >>>valid(\"addt\")\n",
    "    at\n",
    "    \"\"\"\n",
    "    return \"\".join(re.findall(re.compile(f\"[{bases}]\"), seq.lower()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Count number of bases in sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 3000, 'c': 2800, 'g': 2000, 't': 2200}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{base: null.count(base) for base in bases}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1600, 'c': 0, 'g': 0, 't': 0}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{base: clean(alt).count(base) for base in bases}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count(seq: str) -> dict:\n",
    "    \"\"\"\n",
    "    seq: Any string\n",
    "    returns: Count of bases a, c, g, t on cleaned string\n",
    "    \"\"\"\n",
    "    return {base: clean(alt).count(base) for base in bases}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "697 µs ± 27 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit count(null)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "666 µs ± 58.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit count(alt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count(seq: str) -> dict:\n",
    "    \"\"\"\n",
    "    seq: Any string\n",
    "    returns: Count of bases a, c, g, t on cleaned string\n",
    "    \"\"\"\n",
    "    return dict(Counter(clean(seq)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "985 µs ± 17.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit count(null)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "201 µs ± 8.42 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit count(alt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Find reverse complement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reverse_complement(seq: str) -> str:\n",
    "    complements = str.maketrans('acgt', 'tgca')\n",
    "    return clean(seq).translate(complements)[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tcgaacgt'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverse_complement('acgttcga')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Find gc content"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gc(seq: str, bases='gc') -> float:\n",
    "    return round(len(clean(seq, bases=bases)) / len(clean(seq)) * 100, ndigits=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48.148"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gc(null)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gc(alt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Find gc in kmer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "kmer=6\n",
    "stop = ceil(len(null) / kmer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import ceil"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1801"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ceil(len(null + 'a') / 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1800"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(null + 'l') // 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 1800, 6)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(0, stop, kmer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0,\n",
       " 6,\n",
       " 12,\n",
       " 18,\n",
       " 24,\n",
       " 30,\n",
       " 36,\n",
       " 42,\n",
       " 48,\n",
       " 54,\n",
       " 60,\n",
       " 66,\n",
       " 72,\n",
       " 78,\n",
       " 84,\n",
       " 90,\n",
       " 96,\n",
       " 102,\n",
       " 108,\n",
       " 114,\n",
       " 120,\n",
       " 126,\n",
       " 132,\n",
       " 138,\n",
       " 144,\n",
       " 150,\n",
       " 156,\n",
       " 162,\n",
       " 168,\n",
       " 174,\n",
       " 180,\n",
       " 186,\n",
       " 192,\n",
       " 198,\n",
       " 204,\n",
       " 210,\n",
       " 216,\n",
       " 222,\n",
       " 228,\n",
       " 234,\n",
       " 240,\n",
       " 246,\n",
       " 252,\n",
       " 258,\n",
       " 264,\n",
       " 270,\n",
       " 276,\n",
       " 282,\n",
       " 288,\n",
       " 294,\n",
       " 300,\n",
       " 306,\n",
       " 312,\n",
       " 318,\n",
       " 324,\n",
       " 330,\n",
       " 336,\n",
       " 342,\n",
       " 348,\n",
       " 354,\n",
       " 360,\n",
       " 366,\n",
       " 372,\n",
       " 378,\n",
       " 384,\n",
       " 390,\n",
       " 396,\n",
       " 402,\n",
       " 408,\n",
       " 414,\n",
       " 420,\n",
       " 426,\n",
       " 432,\n",
       " 438,\n",
       " 444,\n",
       " 450,\n",
       " 456,\n",
       " 462,\n",
       " 468,\n",
       " 474,\n",
       " 480,\n",
       " 486,\n",
       " 492,\n",
       " 498,\n",
       " 504,\n",
       " 510,\n",
       " 516,\n",
       " 522,\n",
       " 528,\n",
       " 534,\n",
       " 540,\n",
       " 546,\n",
       " 552,\n",
       " 558,\n",
       " 564,\n",
       " 570,\n",
       " 576,\n",
       " 582,\n",
       " 588,\n",
       " 594,\n",
       " 600,\n",
       " 606,\n",
       " 612,\n",
       " 618,\n",
       " 624,\n",
       " 630,\n",
       " 636,\n",
       " 642,\n",
       " 648,\n",
       " 654,\n",
       " 660,\n",
       " 666,\n",
       " 672,\n",
       " 678,\n",
       " 684,\n",
       " 690,\n",
       " 696,\n",
       " 702,\n",
       " 708,\n",
       " 714,\n",
       " 720,\n",
       " 726,\n",
       " 732,\n",
       " 738,\n",
       " 744,\n",
       " 750,\n",
       " 756,\n",
       " 762,\n",
       " 768,\n",
       " 774,\n",
       " 780,\n",
       " 786,\n",
       " 792,\n",
       " 798,\n",
       " 804,\n",
       " 810,\n",
       " 816,\n",
       " 822,\n",
       " 828,\n",
       " 834,\n",
       " 840,\n",
       " 846,\n",
       " 852,\n",
       " 858,\n",
       " 864,\n",
       " 870,\n",
       " 876,\n",
       " 882,\n",
       " 888,\n",
       " 894,\n",
       " 900,\n",
       " 906,\n",
       " 912,\n",
       " 918,\n",
       " 924,\n",
       " 930,\n",
       " 936,\n",
       " 942,\n",
       " 948,\n",
       " 954,\n",
       " 960,\n",
       " 966,\n",
       " 972,\n",
       " 978,\n",
       " 984,\n",
       " 990,\n",
       " 996,\n",
       " 1002,\n",
       " 1008,\n",
       " 1014,\n",
       " 1020,\n",
       " 1026,\n",
       " 1032,\n",
       " 1038,\n",
       " 1044,\n",
       " 1050,\n",
       " 1056,\n",
       " 1062,\n",
       " 1068,\n",
       " 1074,\n",
       " 1080,\n",
       " 1086,\n",
       " 1092,\n",
       " 1098,\n",
       " 1104,\n",
       " 1110,\n",
       " 1116,\n",
       " 1122,\n",
       " 1128,\n",
       " 1134,\n",
       " 1140,\n",
       " 1146,\n",
       " 1152,\n",
       " 1158,\n",
       " 1164,\n",
       " 1170,\n",
       " 1176,\n",
       " 1182,\n",
       " 1188,\n",
       " 1194,\n",
       " 1200,\n",
       " 1206,\n",
       " 1212,\n",
       " 1218,\n",
       " 1224,\n",
       " 1230,\n",
       " 1236,\n",
       " 1242,\n",
       " 1248,\n",
       " 1254,\n",
       " 1260,\n",
       " 1266,\n",
       " 1272,\n",
       " 1278,\n",
       " 1284,\n",
       " 1290,\n",
       " 1296,\n",
       " 1302,\n",
       " 1308,\n",
       " 1314,\n",
       " 1320,\n",
       " 1326,\n",
       " 1332,\n",
       " 1338,\n",
       " 1344,\n",
       " 1350,\n",
       " 1356,\n",
       " 1362,\n",
       " 1368,\n",
       " 1374,\n",
       " 1380,\n",
       " 1386,\n",
       " 1392,\n",
       " 1398,\n",
       " 1404,\n",
       " 1410,\n",
       " 1416,\n",
       " 1422,\n",
       " 1428,\n",
       " 1434,\n",
       " 1440,\n",
       " 1446,\n",
       " 1452,\n",
       " 1458,\n",
       " 1464,\n",
       " 1470,\n",
       " 1476,\n",
       " 1482,\n",
       " 1488,\n",
       " 1494,\n",
       " 1500,\n",
       " 1506,\n",
       " 1512,\n",
       " 1518,\n",
       " 1524,\n",
       " 1530,\n",
       " 1536,\n",
       " 1542,\n",
       " 1548,\n",
       " 1554,\n",
       " 1560,\n",
       " 1566,\n",
       " 1572,\n",
       " 1578,\n",
       " 1584,\n",
       " 1590,\n",
       " 1596,\n",
       " 1602,\n",
       " 1608,\n",
       " 1614,\n",
       " 1620,\n",
       " 1626,\n",
       " 1632,\n",
       " 1638,\n",
       " 1644,\n",
       " 1650,\n",
       " 1656,\n",
       " 1662,\n",
       " 1668,\n",
       " 1674,\n",
       " 1680,\n",
       " 1686,\n",
       " 1692,\n",
       " 1698,\n",
       " 1704,\n",
       " 1710,\n",
       " 1716,\n",
       " 1722,\n",
       " 1728,\n",
       " 1734,\n",
       " 1740,\n",
       " 1746,\n",
       " 1752,\n",
       " 1758,\n",
       " 1764,\n",
       " 1770,\n",
       " 1776,\n",
       " 1782,\n",
       " 1788,\n",
       " 1794]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(0, stop, kmer))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def kmers(seq: str, n: int = 6):\n",
    "    stop = ceil(len(seq) / n)\n",
    "    slices = range(0, stop, n)\n",
    "    subsets = zip(slices, slices[1:])\n",
    "    return [clean(seq)[start: stop] for start, stop in subsets]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag',\n",
       " 'agatat',\n",
       " 'atcatc',\n",
       " 'atcact',\n",
       " 'catcta',\n",
       " 'ccaggc',\n",
       " 'tgtcgc',\n",
       " 'agcgac',\n",
       " 'agctac',\n",
       " 'gtagag']"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kmers(null)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def kgc(seq: str, n: int = 6):\n",
    "    return [gc(kmer) for kmer in kmers(seq, n)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0,\n",
       " 16.667,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 33.333,\n",
       " 83.333,\n",
       " 66.667,\n",
       " 66.667,\n",
       " 50.0,\n",
       " 50.0]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kgc(null)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Find gc content of fasta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample= \"\"\"\n",
    ">Rosalind_6404\n",
    "CCTGCGGAAGATCGGCACTAGAATAGCCAGAACCGTTTCTCTGAGGCTTCCGGCCTTCCC\n",
    "TCCCACTAATAATTCTGAGG\n",
    ">Rosalind_5959\n",
    "CCATCGGTAGCGCATCCTTAGTCCAATTAAGTCCCTATCCAGGCGCTCCGCCGAAGGTCT\n",
    "ATATCCATTTGTCAGCAGACACGC\n",
    ">Rosalind_0808\n",
    "CCACCCTCGTGGTATGGCTAGGCATTCAGGAACCGGAGAACGCTTCAGACCAGCCCGGAC\n",
    "TGGGAACCTGCGGGCAGTAGGTGGAAT\n",
    "\"\"\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Rosalind_6404\\nCCTGCGGAAGATCGGCACTAGAATAGCCAGAACCGTTTCTCTGAGGCTTCCGGCCTTCCC\\nTCCCACTAATAATTCTGAGG\\n',\n",
       " 'Rosalind_5959\\nCCATCGGTAGCGCATCCTTAGTCCAATTAAGTCCCTATCCAGGCGCTCCGCCGAAGGTCT\\nATATCCATTTGTCAGCAGACACGC\\n',\n",
       " 'Rosalind_0808\\nCCACCCTCGTGGTATGGCTAGGCATTCAGGAACCGGAGAACGCTTCAGACCAGCCCGGAC\\nTGGGAACCTGCGGGCAGTAGGTGGAAT\\n']"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample.split(\">\")[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fasta_gc(fasta: str=sample) -> dict:\n",
    "    return { gc(seq): desc for desc, seq in [read.split(\"\\n\", 1) for read in fasta.split(\">\")[1:]] }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60.92"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(fasta_gc())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def max_gc(fasta: str=sample) -> str:\n",
    "    gcs = fasta_gc(fasta)\n",
    "    most = max(gcs)\n",
    "    print(f\"\"\"{gcs[most]}\\n{most}\"\"\")\n",
    "    return {gcs[most]: most}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rosalind_0808\n",
      "60.92\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'Rosalind_0808': 60.92}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max_gc()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "eg = \"\"\">Rosalind_0310\n",
    "TTTAGGCTCTATAGAATATGCCCTGACTAGGAAGAAATAGGGGCTGATCTGATTGATATC\n",
    "GATAGGATGGAATGGCTTGATAATAGGGATTAAGTTTAATAAGGTCCACAAGCCAGGCAG\n",
    "TTCTGGGCCGGGAGTCTTTGAGTATGCATCCCGGCTATGCAGTTTTATTACACTTATGCA\n",
    "TCAACAATTATTCGCGATTCCTTTGGGCTGCATGGCTGGGGGTCCTCATAAATCGACGGA\n",
    "AAATCGAAATCATACTGTCAAGGAGAAACGGGACAACTTTAACATACTCGATTACCCCAC\n",
    "GCCCCTCAGGAAGCCGGGACTCAGGCATGAGGCTTCTATATTCAGCAAACACGGGCGCCG\n",
    "TGTCAGGTGCGGACCAACTGCTGCGCATACATGCAGCCTCCCGGATCCCCGCGTTTGTTT\n",
    "TAATACGCCTGTCTTCCACGGTACCCGGGTATATTACTTCGTTGCGTTCCAGGGGTTAAA\n",
    "CGGCCCTGGTAGGAATTTGCAACCTCTATCGCGAATTCCCGACAACGTGGTCATGTTACG\n",
    "GCTCATTGATCCCCAACTGAAGGGTTAGAGTAAGTAGGCCGCCATTGTTTGACTACACCG\n",
    "CAGCTCTGTGGTTTGTGGCAAGGCTAAGGCCGCGAATCGCAGGTTTCTTCAGGTCACGTA\n",
    "GCCCGAGTCCCCGGATCTATCGTGCTTATACATCAAAATCCCGGTTGGGCAGTCTTAGGC\n",
    "TTAATAGTTTATCACGTCGAGAGTGAGACGATCGGAAACCATCCAATAAGCCGAAGAGAT\n",
    "GACAAAGCGTAAGCATAGTACTATGGGACAATGACTCACAACGTGCTTATGGAAGCACTA\n",
    "GGACGTTCCGGGTTGGTAAGATCTCGATGCTTCAAAAGGTCGTACAAGGGAAGTTAAGTA\n",
    "GCTACCGTCCATAAGGGACCCCAGGCCGCGATTGGAAAGGTCGTATTGCAAAGAAAAC\n",
    ">Rosalind_8377\n",
    "GTGGTATGACCACAGGGACTTGGTTTGGCGAAAAGGGCAAGGATATTGTGGGACATCTCT\n",
    "GGAAAGCTGAGCCGTACTGCTACCTGGACATTGGCAGTGTTGGGTCGCTGGCTACTGGTA\n",
    "AGTCTGCAGAAGATACCAAGCGCTATCGGTCCGGATGAGGCCCGGACGTACCTCATCCCG\n",
    "CAATCTTCTCTCTTTGGGCTGGACGTGGACTGTCGCGCCTCCAATGTTGGATGGGGCAAT\n",
    "AGGACGTAGTACACGGCACACCACTTATATTATTCTCAGGGCATCTGATGGATTCCGTTG\n",
    "TCCCCATCGAGACTACGAAGCTTAGAAGACCCGACCCTAGCCACAATTCTGAAGGTCAGG\n",
    "GGTCTCAGTCCTTAAACGACTCAGAGGCCCAGCCGCCCATAATTTGGACCATAAACTTGT\n",
    "CGAGACAGGCGCATGTTTTCGCTGTCAACTCAAAACCAACCGTTCAGACCCACGAGGCTT\n",
    "CGTACGGCCAGGTCTACTTCGAGTCGAAAGAGTAACTCATTGATTTCAGCTTTACACCAT\n",
    "GCATTTACCAGGTTAGAGCCCGCCTGGCTTAGAATACAAGATTCTATATGGGAAAAAGCG\n",
    "GGCCACCCCTTCTCGAATGTTACAACGCGCCATGCTGGTGAAAACATTCCCTCGTTAATC\n",
    "GCAATGGGTTCTTCGGTATGCGCACAAAAGTTGTGCGCCTGTAAGGGAAGTACCAGTTAT\n",
    "GTGTGGTCTGGTCTGAGTCCTCGGATCGATGAAATCACTTATATTGTGGTGCTGAAGCGG\n",
    "AGGACGCCACAATTACTTCATATGTAAGGAGACC\n",
    ">Rosalind_2099\n",
    "TCTTTCCACAAGACCCCCGTAGCAAGTCCGTGAACATTATTGTTAGACGTAACCCCGTTG\n",
    "CAATCAGATCTGGGCCCGGGCGTACACAGCCGCGCTCAAATAGCTTGAATATATGGGAAC\n",
    "GGAGACGTACGCTTGTACAATAGTTCAGAGAGGTCGATCGACTCTACCATTGCAATGGGG\n",
    "CGGTCGGGGACCCGATAGCGTACTTTCTTTTCATATCGGAATGATCCGACGTCCAGTGTT\n",
    "CACCGAAGGTTAAGAAACCAGTAGCTCAAGAGGTCTTGTTTTAGGACTCCCGTGGACCCC\n",
    "ATTCTCGGAAAGTCTCTTTAGACTTATTGTTTCACAGAGTATATCCCACGGCGGAACATA\n",
    "GCTTACTTTGGATAAACCTCTTCGTTGACGCTTCCTTGGCTCTCCGCAGCGGCAGTCAGG\n",
    "TAAATTTCTTGCGACTTTTGGCTTGACCGAAGCGGATTCGGTGAAATCACCATGCCCCAT\n",
    "TTACACTCGACTCGTAGTCTAGGATTCAATTAGTGATAGGCAGCCTCTGTTCTCAATAGA\n",
    "GGATTATGTTCCAATACTATACTTAGTGCAAAATGGAATAATGACGTGGAATATGTTCGC\n",
    "AGGTGCCACGTTCACCTGTACTTTATCCAAAGGTTCGGTAAAGGTAATGTTTTCTATCTG\n",
    "GGTGTGGCTCCAACGTACCAGTTACCGATATATGGGCAAGGACCAAGCATATAGTTATCC\n",
    "ACAAGTGACATGACAAGTGTGACCCCGCCAATACCACTAGCCACTCACACTCTATTCGCG\n",
    "AGGGAATCTGTATCTGTCGCACTAGATATTGCTACCCACGTGTTGACCATGGAGCAGGCT\n",
    "CGTTCTGTC\n",
    ">Rosalind_2387\n",
    "CCTCCAATCAGTTCGGACTTTTCGACTCATTAGCCGAAACATTAACATTCGAGACGTGAT\n",
    "GTGTTCCGACAAAGCCAGATGGCCATCAATAACTGGATTCACATCAACCCTATTCTAGAC\n",
    "CTTAATCAGACCGAAAACTGGCGATATCATTATGTATGTGTCAGCGACAGACCGTGTTGC\n",
    "ACTTCAAGGAGGCACTTCCATTCTACACTACTCGGTGTCACCAACTGGCCTCATCGGGAA\n",
    "GTGAACCACGCACTTGCTTACTTATCAATGCCTTGTGTTTTCCTAGGGCGAAGAGAGAGA\n",
    "TTGCGAAAGGGAGCCGCTCACCGCCATGAAGTAGACTGTAGCTTCCACTGGAACGGCATA\n",
    "GGCGATACTCTCGTTATGAACGGATTCGAGGGTTCTTGGATTGATTGTCGTCCGTGGGTC\n",
    "AACTTAAGTCTTATCTTACATGATGGACGGATGCCGACCCTGCTCCGACGACGAGCGATA\n",
    "TGGACATCTGACACCTCACCTCGATACATCCGATCTGTATGGTACGCCCGCGTTTCCACG\n",
    "TGGTTAGGTTGCTTATATTCAGCCTGTTTAGGAGTTGCTCGGCAATACGCCGGTATTGTC\n",
    "GGAGTCCCCAACTACTCATCCCCAAGTAATTACGCTACCCATGCCAGGCCGCACTTAACG\n",
    "CTAGTCCTACATGGATGGTGACGTGGTTGGCCCGGCGGCCAGGGAAGCGAACTCGCTCCG\n",
    "TCACCAGACATACCTTAACACCCGCGCAGCGATTGAAGAGATCCGGCTCATCGCTTTCGA\n",
    "GTTTCTAATCTGGCCTAGTTGTCGTGCGCCCTTTTCAGTTCACTCGCTACCTACTGGGAC\n",
    "TGTCAGTTTAG\n",
    ">Rosalind_3276\n",
    "ATCGGGACAGTTCCTAGCAATTCGCGGGTTATGTTGGTAGACAACAAGGCAACCGCACAA\n",
    "CATCTGTAGCCGGTCTACCTCGCGTCTCCTTACATCCAACCGTTGCGAAGGACACGAGCA\n",
    "GGGGATATTACGTTCCATCCCGGCTAGTCGGGAAGGCCTCCGGATTGTACCCGTAAGTAA\n",
    "TTGGGTAACAAAGGCTCAGTAGCGTATCCCCGTAGACTGCCTGCCCCCACACTATTCTTT\n",
    "ATCGTGAACCTAAGTTGACAACACAAAACGAGCGTTCATTTGAATAATAAAAGCACACGA\n",
    "ACAACTTCAAGCAGCTCGCAACTTTAGACCCCTTCCTTCGGCTTTATACTTCTGTACGTT\n",
    "TAGTAATAGCGCGAAACTCCGTTACACGGAGTTCTGTCCTGGCTTGAAAGCCGGCAACCT\n",
    "GAGGTACTTACAATCGAGCGGCAAATTGGTGATTATAAACTCCTAACCCTACGCCCCTTG\n",
    "TAAATTGTCCCGCTAAACCCTTAAAGGGCACAGATACCGTTTCCTGCGTGCTCGGCCAGA\n",
    "TTCTTGGATCATGTTTAAGTCTTAGTCCCCAGAGGTAGTCCGCCCTCGCGCGGTCCGTTC\n",
    "GCCTTGAGGTACTTAACCTCAATTAGATAGGGACACGCTCATACAAGATTTGCGACGCGG\n",
    "GGACATAATCATCTACTTTGAGCGAGGCCCTACGTAAAGGAAGACTCTTAGCTAACAAGT\n",
    "AATCGACACGGGGCTGTGTAGCTCCCGCTGGCGGGGCGCCGATCCTTTTCTGTATCTCGA\n",
    "ACGCGGACAGTGAGGTCCAGCTCCATCGGATAAGCTCATGTACACTCTCCCATAATATCT\n",
    "ATTGCGGTGCTCCTTCACACACACTCCTTAACGACTACACAACTGCCCCGGTCGGTTTTC\n",
    "ATCGCCCAACTTCGAAAATAGAAGGATTCGGACCCGAGGGGTCTTTGAAGAGTGTTCTCT\n",
    "GAGTCAAGATGAATCTTAATGAT\n",
    ">Rosalind_7396\n",
    "TAAATAAGAACTCGTGCCCGGCCCTTTCATCCCATTCCTTGAAGTGTGTACTGTGGCCCT\n",
    "AAGACCCACTGGCGTTGACTTATATTAGAAGCCACATGAATCATCGGTATAATTATTGAT\n",
    "ATCGATTGTCTCTCACGGAATATTGACGGGAGTCCCGCTAATAGGTCGACTGACGCACCA\n",
    "TTTTCCAGTTTGAGTACGCACATACCACGATTCACGGCATCGAGTCGGTCTTAACAAGCT\n",
    "AGTTCGGTCTTATCATGTTCGACTACATAAGTATCCAGGGAACGTACCCACCGGTACTGT\n",
    "TTAGCCTGCTTTGGCGCTTACTAATATAAATCATGATTCACTTCACACCGTTATTCCCCG\n",
    "TCGATTGTGCAAACTACGAAACACGTGCTTGAAAATTTCCTTAGTAGCCCCTAGAGACTG\n",
    "CCAGCTATGGGGATGCTTCCACGTTAGACCATGAGAGCACTAGGGGGCTGGTATTTTAGC\n",
    "GAGCAGTTAACTAACGGATAGCCGCTACGGGTTGACAGGCAGGCGGCTAAACGATCCAGA\n",
    "GACCCGGACACTGGCTAAAGGAACCGTAGGGTACGTGTTAAACAAACACAGATGCAGACG\n",
    "TCGGTCATTATGGGGAGCCACTCGTAACCCAGGATTATGTGACTCAAACCGGGAAGACGG\n",
    "TTTGAGGGTGTAATGTTGAGTGCTGCAGCCAGTCTAAAGCGTCGCTGGTAGCGAGCCAGA\n",
    "CCAAGTTTTAAAATATCCGACTATATGAACGGCTTAGCATGGAAGTCTGAGTAGCTAATG\n",
    "GTGACCTTGCACTCTCTTGTTTTCGGGGCGTAGGTGGTATGATTGCCAGACCCGTGACAT\n",
    "ACACGTTGACAGCCTCAGACTGGTGTGAATTGTTGGTGCGCGGGGCTCGCCTATAG\n",
    ">Rosalind_2351\n",
    "CATGCCGTTCCTCCCTGTGCATTAAGATACGACTGGGTCGTTGGGGTACCAAGCTCCAAG\n",
    "CACGCCCTGACGCGTGCCGGGTACATTCCCGTGCCCATAGTAAGGACCTGGGACTAGGGT\n",
    "CAGCAATCCAACCCCGGGCTTGACAGTTCGTTGGAAGTACTCGTGCCGCTGCACGACATC\n",
    "CGATTGACTAATGAGAAATCTAGTCAGGTTCTACCCGAGGTTCTCCTACGCGTGCACACT\n",
    "TACGTCCCCTGTGAAAAGGGGGCCGTCGGGCACACCATCGCCCATATTTTCGTTGACGCA\n",
    "CGGATCCTTAAAAGTCACGGAGTTACGGCACAATCTTTTCGGCATGTTCTTCCTACCGAT\n",
    "GGCGTACATGTGGGGAGGCATGCTGACTCCTAGCGTAAACTTGTCTAAAATCAGCTTGTC\n",
    "GAACCTCATCTATTGTACACCTTTGGAGGGGCGAATAACCCGTCTATAAATCCTTTTTAT\n",
    "TAGTTAGAAATCTGCACTCGTGGGGGACGTGACGAGGGATGTGGTACCCAACAACGCTAC\n",
    "CTTTGCGAGCGGAAACCGGAATACCAGTCGCAGCGGTGGACCTCTAGTCACCGATAGCAG\n",
    "TTTCACCCTAAGATGGTTTGATAAACATCTAGCCTATCTCAAAATGCCGGCGGCCTCCGC\n",
    "GGTACAGACCGGGGGCCGGGCTCGGTACCGGACACATCCTCTCACTTTCGGAAGCAATTA\n",
    "ATGCGTATTGCTCCCGTAACGATTAACACGAGCAAGGGTGGAACGATTGAGTAGCTGCTT\n",
    "AATTGCATCGCGCCGTCCCGAAC\n",
    ">Rosalind_7908\n",
    "AAGGGTACTATCGCTTAAAGTGACTCTGCGCTGTTGTATTTTGTGCGCGGAACGGCGTTT\n",
    "ACCAAAAACTTCGTATGGACCGTAATGTTAGTACGACCAGCGTTCCTTGTGGCATCCCCA\n",
    "TGAGGCGGACGCTATATGGATCAATAATGTTACCAGCATGAACTATTTTGCAACGCGCCT\n",
    "GATGCCTCCGTCACCGTGTCGGCCTGGACCAGACAAAGAGGCCCCGGGCAAGCTTGAAAC\n",
    "CTCGGGGTTATCTGTGCGTCCGTTTTTTATGTGAGGAGGAGGGCCCACCAGTAATCCTGG\n",
    "CTTATGTAAGCGATGTTTGCAGAAACAATAATTAGGCCCGGTTAACACGCCTAGTCAAAC\n",
    "CAATTGGGTATCTAAGCTTGTATCATCAGTACCGCATCGAAGTGAACAATCGACGTTTTA\n",
    "AGAAGGGAGGCGACTTCGGAATTTCCTACCCCCAACTGCTTTGTGGAATTGATATCCAAT\n",
    "TTTACACCCCCATAGATACCCCTCGCGCCTGAACGACACGGCCAAACTACCTGGCCAAAA\n",
    "AACAGGACACAGCGTAAGAGGAGACATTACGCCATAAAACGCGTTAGGGAGGATCGGAGA\n",
    "AGCATCTCCCGCTAAGACATCGGTCACTGATCACACTTCACTCTCGAGGCATAGTAACAC\n",
    "AGCCAGGGTAGGAATGTCTCCCCTTTGCTTTAGCAACGTAATACATACAATGTTCACCGT\n",
    "GTCATTCAAGGTTTGGGTACCTGTAAGGTGGCATCGGCTCTATTGGTCACCTATCAGTAC\n",
    "GCATACCTGTCCAATGACGCTTGACCGTGCTCTTGTCGTTAGCCGTCAGAT\n",
    ">Rosalind_8120\n",
    "TAAATCTATGTTCCGGCGCCGCCTTGTCCCGCAGAGGTCAGTAGGATCCTCTTGACCCGT\n",
    "CCCAGGTCTACCAGTATTCATAGCAATTATTCTCGTCTCCCCTCACATCTCATTTTAGGG\n",
    "ACAGTAATTAACCCTACTTTACCTACCGGCAATAGATCCATGAAGTCGGGTCAAGATCGA\n",
    "TAGAGGTTTTTTATCGATCGTGGTATACCCTCAGCTCCTAAGATTCGTTACTATCACTTT\n",
    "TAATCCCACCCCCATGGGAAGGGACGGTAGGCCCGTTAGTACGGGGATCAGTGCATGGCA\n",
    "ACCTACGCCCAAATTGCCATGTTTAGTCACTACTAAAACAGTTAAGGACTAGTAAATCCA\n",
    "CTGCTTGTCCGATCTCGATCAGTCCCGTAGCGATGGTTGCCGTTGGTGGGTGAAGATGTA\n",
    "ATGGACTTCTTAGAAGCTGCACTACTGACCATATAGGAACATTAGTTCGCATCTCCCCTT\n",
    "ACCTTCGCTCCCAGGGATTCCGCACGCCCGCCTCATTCGCCGATTCCATCGACCTGTCAG\n",
    "AGAGACCCTAGCGCCGTACGCTGGCGTGCCGTATGACCCGTTGGTTGCAAGCTTCTATAT\n",
    "AAGGGACGTTATGGGGTTGTTTGCCTCCGCATTTAGATAACGTGAGTCTATCAACTGTTA\n",
    "CGATAGGATGCGCAACTATTAAGCTGCGCGAGTTGCCCCCTTGCCGCCATGCGTAAGGCA\n",
    "GTGAACTGAGACTATGCCATCGTACCTTCGAATCCCCTTCGCTACCATCTTCCCACCGCA\n",
    "TCGATCTAAGCCTCTTATTTATCCACAAAAGACTGGCCCCACTGCTCGGGATGTTACCCA\n",
    "GCAGC\n",
    ">Rosalind_2490\n",
    "CCCGCAGCTTTCTGTCTTGTTATGGTGAATGGATACCTACCAGCTCAGAGGCTATATTTC\n",
    "AAACATCATTAGTTACGCTAGATCTAAGTGCTTGCTAACTTCAGGACCTCGGTGACCAGT\n",
    "GTTTGCCTACAACGGGGATTGCCATTGCGGCCACTCCGTCCTGGGATTAACCCTCTAGCG\n",
    "AGCAACAGCGAGGATTCCCTTACTCGGGCACCGGTGCTATCTCAAGCCATGTCGTGAGCT\n",
    "GTGATAGTACGTTCCGCTGAATGCTGGCCCATATAAGACTGGTTTTATTATACCTATGTC\n",
    "AGGGTCCAGAATTCTTACTAGGTAAGATAACCACTATATTACACAAAAGGCAAATCCGGT\n",
    "CTGCCCGAATTGATTCGTGGTTAGTTCATCAACGATGCCCACACAACTATTAGAGTACAT\n",
    "GTTACGAGTATATTCTTGCGCCAGTATAGCCTGGCCGTTTGCGGATAATCAGTGGTCTAG\n",
    "GCTGACGACTAGGATATGAATCAGTAACGTACGCGACAGCATTAGCCAGGGTCGTATCCA\n",
    "TCTGTTGGTATCCTCTCCAAACCGTCGCGCTGCCAAGAGACGCTAAAATATCCGTGGGCC\n",
    "TTACTATGGCTGGGGATTTGCTTCACTAAGACCGGTTTCGGGACTGACGTCCCCAAGGGA\n",
    "CCGCGCCGGCTTGCGATATCTTGAAGCCCCTAAGGAGCATGAGGTACTTCCAGGGGGTCC\n",
    "GAAATGGAAATCTGCGCATCAATAACCGTGCGAAGGTCCCTCGGTAACGATCGACCTGGA\n",
    "GGTAATCCTGGACGAAGGAACTGCGGAATTCGTTACACTTCTTTTCGTCGAAGTCACACT\n",
    "AGGTGTCACTGGTAGTCATGGCTCGTTTTGACCATCAGGTCGTAGGAAGCTTGACAGCAT\n",
    "TTGCGACAATAATACAATAACCCTTAGTCGAACTGCTTGCTCGGCGAACACTATAAATAC\n",
    "CTTGACTGGCTTCTTTTAGGAT\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rosalind_2351\n",
      "53.176\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'Rosalind_2351': 53.176}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max_gc(eg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate codons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "codons_tsv=\"\"\"\n",
    "name\tslc\tcodon\n",
    "Isoleucine \tI \tATT, ATC, ATA\n",
    "Leucine \tL \tCTT, CTC, CTA, CTG, TTA, TTG\n",
    "Valine \tV \tGTT, GTC, GTA, GTG\n",
    "Phenylalanine \tF \tTTT, TTC\n",
    "Methionine \tM \tATG\n",
    "Cysteine \tC \tTGT, TGC\n",
    "Alanine \tA \tGCT, GCC, GCA, GCG\n",
    "Glycine \tG \tGGT, GGC, GGA, GGG\n",
    "Proline \tP \tCCT, CCC, CCA, CCG\n",
    "Threonine \tT \tACT, ACC, ACA, ACG\n",
    "Serine \tS \tTCT, TCC, TCA, TCG, AGT, AGC\n",
    "Tyrosine \tY \tTAT, TAC\n",
    "Tryptophan \tW \tTGG\n",
    "Glutamine \tQ \tCAA, CAG\n",
    "Asparagine \tN \tAAT, AAC\n",
    "Histidine \tH \tCAT, CAC\n",
    "Glutamic acid \tE \tGAA, GAG\n",
    "Aspartic acid \tD \tGAT, GAC\n",
    "Lysine \tK \tAAA, AAG\n",
    "Arginine \tR \tCGT, CGC, CGA, CGG, AGA, AGG\n",
    "Stop codons \t* \tTAA, TAG, TGA\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "slc = {\n",
    "    slc.upper().strip(): codon.upper().replace(\" \", \"\").split(\",\")\n",
    "    for _, slc, codon in [\n",
    "        row.split(\"\\t\") for row in codons_tsv.splitlines()[2:]\n",
    "    ]\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('ATT', 'I'), ('ATC', 'I'), ('ATA', 'I')]"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(slc['I'], it.repeat('I', len(slc['I']))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class zip in module builtins:\n",
      "\n",
      "class zip(object)\n",
      " |  zip(*iterables) --> zip object\n",
      " |  \n",
      " |  Return a zip object whose .__next__() method returns a tuple where\n",
      " |  the i-th element comes from the i-th iterable argument.  The .__next__()\n",
      " |  method continues until the shortest iterable in the argument sequence\n",
      " |  is exhausted and then it raises StopIteration.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __next__(self, /)\n",
      " |      Implement next(self).\n",
      " |  \n",
      " |  __reduce__(...)\n",
      " |      Return state information for pickling.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(zip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in module itertools:\n",
      "\n",
      "NAME\n",
      "    itertools - Functional tools for creating and using iterators.\n",
      "\n",
      "DESCRIPTION\n",
      "    Infinite iterators:\n",
      "    count(start=0, step=1) --> start, start+step, start+2*step, ...\n",
      "    cycle(p) --> p0, p1, ... plast, p0, p1, ...\n",
      "    repeat(elem [,n]) --> elem, elem, elem, ... endlessly or up to n times\n",
      "    \n",
      "    Iterators terminating on the shortest input sequence:\n",
      "    accumulate(p[, func]) --> p0, p0+p1, p0+p1+p2\n",
      "    chain(p, q, ...) --> p0, p1, ... plast, q0, q1, ... \n",
      "    chain.from_iterable([p, q, ...]) --> p0, p1, ... plast, q0, q1, ... \n",
      "    compress(data, selectors) --> (d[0] if s[0]), (d[1] if s[1]), ...\n",
      "    dropwhile(pred, seq) --> seq[n], seq[n+1], starting when pred fails\n",
      "    groupby(iterable[, keyfunc]) --> sub-iterators grouped by value of keyfunc(v)\n",
      "    filterfalse(pred, seq) --> elements of seq where pred(elem) is False\n",
      "    islice(seq, [start,] stop [, step]) --> elements from\n",
      "           seq[start:stop:step]\n",
      "    starmap(fun, seq) --> fun(*seq[0]), fun(*seq[1]), ...\n",
      "    tee(it, n=2) --> (it1, it2 , ... itn) splits one iterator into n\n",
      "    takewhile(pred, seq) --> seq[0], seq[1], until pred fails\n",
      "    zip_longest(p, q, ...) --> (p[0], q[0]), (p[1], q[1]), ... \n",
      "    \n",
      "    Combinatoric generators:\n",
      "    product(p, q, ... [repeat=1]) --> cartesian product\n",
      "    permutations(p[, r])\n",
      "    combinations(p, r)\n",
      "    combinations_with_replacement(p, r)\n",
      "\n",
      "CLASSES\n",
      "    builtins.object\n",
      "        accumulate\n",
      "        chain\n",
      "        combinations\n",
      "        combinations_with_replacement\n",
      "        compress\n",
      "        count\n",
      "        cycle\n",
      "        dropwhile\n",
      "        filterfalse\n",
      "        groupby\n",
      "        islice\n",
      "        permutations\n",
      "        product\n",
      "        repeat\n",
      "        starmap\n",
      "        takewhile\n",
      "        zip_longest\n",
      "    \n",
      "    class accumulate(builtins.object)\n",
      "     |  accumulate(iterable[, func]) --> accumulate object\n",
      "     |  \n",
      "     |  Return series of accumulated sums (or other binary function results).\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class chain(builtins.object)\n",
      "     |  chain(*iterables) --> chain object\n",
      "     |  \n",
      "     |  Return a chain object whose .__next__() method returns elements from the\n",
      "     |  first iterable until it is exhausted, then elements from the next\n",
      "     |  iterable, until all of the iterables are exhausted.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Class methods defined here:\n",
      "     |  \n",
      "     |  from_iterable(...) from builtins.type\n",
      "     |      chain.from_iterable(iterable) --> chain object\n",
      "     |      \n",
      "     |      Alternate chain() constructor taking a single iterable argument\n",
      "     |      that evaluates lazily.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class combinations(builtins.object)\n",
      "     |  combinations(iterable, r) --> combinations object\n",
      "     |  \n",
      "     |  Return successive r-length combinations of elements in the iterable.\n",
      "     |  \n",
      "     |  combinations(range(4), 3) --> (0,1,2), (0,1,3), (0,2,3), (1,2,3)\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  __sizeof__(...)\n",
      "     |      Returns size in memory, in bytes.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class combinations_with_replacement(builtins.object)\n",
      "     |  combinations_with_replacement(iterable, r) --> combinations_with_replacement object\n",
      "     |  \n",
      "     |  Return successive r-length combinations of elements in the iterable\n",
      "     |  allowing individual elements to have successive repeats.\n",
      "     |  combinations_with_replacement('ABC', 2) --> AA AB AC BB BC CC\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  __sizeof__(...)\n",
      "     |      Returns size in memory, in bytes.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class compress(builtins.object)\n",
      "     |  compress(data, selectors) --> iterator over selected data\n",
      "     |  \n",
      "     |  Return data elements corresponding to true selector elements.\n",
      "     |  Forms a shorter iterator from selected data elements using the\n",
      "     |  selectors to choose the data elements.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class count(builtins.object)\n",
      "     |  count(start=0, step=1) --> count object\n",
      "     |  \n",
      "     |  Return a count object whose .__next__() method returns consecutive values.\n",
      "     |  Equivalent to:\n",
      "     |  \n",
      "     |      def count(firstval=0, step=1):\n",
      "     |          x = firstval\n",
      "     |          while 1:\n",
      "     |              yield x\n",
      "     |              x += step\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class cycle(builtins.object)\n",
      "     |  cycle(iterable) --> cycle object\n",
      "     |  \n",
      "     |  Return elements from the iterable until it is exhausted.\n",
      "     |  Then repeat the sequence indefinitely.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class dropwhile(builtins.object)\n",
      "     |  dropwhile(predicate, iterable) --> dropwhile object\n",
      "     |  \n",
      "     |  Drop items from the iterable while predicate(item) is true.\n",
      "     |  Afterwards, return every element until the iterable is exhausted.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class filterfalse(builtins.object)\n",
      "     |  filterfalse(function or None, sequence) --> filterfalse object\n",
      "     |  \n",
      "     |  Return those items of sequence for which function(item) is false.\n",
      "     |  If function is None, return the items that are false.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class groupby(builtins.object)\n",
      "     |  groupby(iterable, key=None) -> make an iterator that returns consecutive\n",
      "     |  keys and groups from the iterable.  If the key function is not specified or\n",
      "     |  is None, the element itself is used for grouping.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class islice(builtins.object)\n",
      "     |  islice(iterable, stop) --> islice object\n",
      "     |  islice(iterable, start, stop[, step]) --> islice object\n",
      "     |  \n",
      "     |  Return an iterator whose next() method returns selected values from an\n",
      "     |  iterable.  If start is specified, will skip all preceding elements;\n",
      "     |  otherwise, start defaults to zero.  Step defaults to one.  If\n",
      "     |  specified as another value, step determines how many values are \n",
      "     |  skipped between successive calls.  Works like a slice() on a list\n",
      "     |  but returns an iterator.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class permutations(builtins.object)\n",
      "     |  permutations(iterable[, r]) --> permutations object\n",
      "     |  \n",
      "     |  Return successive r-length permutations of elements in the iterable.\n",
      "     |  \n",
      "     |  permutations(range(3), 2) --> (0,1), (0,2), (1,0), (1,2), (2,0), (2,1)\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  __sizeof__(...)\n",
      "     |      Returns size in memory, in bytes.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class product(builtins.object)\n",
      "     |  product(*iterables, repeat=1) --> product object\n",
      "     |  \n",
      "     |  Cartesian product of input iterables.  Equivalent to nested for-loops.\n",
      "     |  \n",
      "     |  For example, product(A, B) returns the same as:  ((x,y) for x in A for y in B).\n",
      "     |  The leftmost iterators are in the outermost for-loop, so the output tuples\n",
      "     |  cycle in a manner similar to an odometer (with the rightmost element changing\n",
      "     |  on every iteration).\n",
      "     |  \n",
      "     |  To compute the product of an iterable with itself, specify the number\n",
      "     |  of repetitions with the optional repeat keyword argument. For example,\n",
      "     |  product(A, repeat=4) means the same as product(A, A, A, A).\n",
      "     |  \n",
      "     |  product('ab', range(3)) --> ('a',0) ('a',1) ('a',2) ('b',0) ('b',1) ('b',2)\n",
      "     |  product((0,1), (0,1), (0,1)) --> (0,0,0) (0,0,1) (0,1,0) (0,1,1) (1,0,0) ...\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  __sizeof__(...)\n",
      "     |      Returns size in memory, in bytes.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class repeat(builtins.object)\n",
      "     |  repeat(object [,times]) -> create an iterator which returns the object\n",
      "     |  for the specified number of times.  If not specified, returns the object\n",
      "     |  endlessly.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __length_hint__(...)\n",
      "     |      Private method returning an estimate of len(list(it)).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class starmap(builtins.object)\n",
      "     |  starmap(function, sequence) --> starmap object\n",
      "     |  \n",
      "     |  Return an iterator whose values are returned from the function evaluated\n",
      "     |  with an argument tuple taken from the given sequence.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class takewhile(builtins.object)\n",
      "     |  takewhile(predicate, iterable) --> takewhile object\n",
      "     |  \n",
      "     |  Return successive entries from an iterable as long as the \n",
      "     |  predicate evaluates to true for each entry.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class zip_longest(builtins.object)\n",
      "     |  zip_longest(iter1 [,iter2 [...]], [fillvalue=None]) --> zip_longest object\n",
      "     |  \n",
      "     |  Return a zip_longest object whose .__next__() method returns a tuple where\n",
      "     |  the i-th element comes from the i-th iterable argument.  The .__next__()\n",
      "     |  method continues until the longest iterable in the argument sequence\n",
      "     |  is exhausted and then it raises StopIteration.  When the shorter iterables\n",
      "     |  are exhausted, the fillvalue is substituted in their place.  The fillvalue\n",
      "     |  defaults to None or can be specified by a keyword argument.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "\n",
      "FUNCTIONS\n",
      "    tee(...)\n",
      "        tee(iterable, n=2) --> tuple of n independent iterators.\n",
      "\n",
      "FILE\n",
      "    (built-in)\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(itertools)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('ATT', 'I'), ('ATC', 'I'), ('ATA', 'I')]"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(slc['I'], it.cycle('I')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'I': ['ATT', 'ATC', 'ATA'],\n",
       " 'L': ['CTT', 'CTC', 'CTA', 'CTG', 'TTA', 'TTG'],\n",
       " 'V': ['GTT', 'GTC', 'GTA', 'GTG'],\n",
       " 'F': ['TTT', 'TTC'],\n",
       " 'M': ['ATG'],\n",
       " 'C': ['TGT', 'TGC'],\n",
       " 'A': ['GCT', 'GCC', 'GCA', 'GCG'],\n",
       " 'G': ['GGT', 'GGC', 'GGA', 'GGG'],\n",
       " 'P': ['CCT', 'CCC', 'CCA', 'CCG'],\n",
       " 'T': ['ACT', 'ACC', 'ACA', 'ACG'],\n",
       " 'S': ['TCT', 'TCC', 'TCA', 'TCG', 'AGT', 'AGC'],\n",
       " 'Y': ['TAT', 'TAC'],\n",
       " 'W': ['TGG'],\n",
       " 'Q': ['CAA', 'CAG'],\n",
       " 'N': ['AAT', 'AAC'],\n",
       " 'H': ['CAT', 'CAC'],\n",
       " 'E': ['GAA', 'GAG'],\n",
       " 'D': ['GAT', 'GAC'],\n",
       " 'K': ['AAA', 'AAG'],\n",
       " 'R': ['CGT', 'CGC', 'CGA', 'CGG', 'AGA', 'AGG'],\n",
       " '*': ['TAA', 'TAG', 'TGA']}"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function reduce in module _functools:\n",
      "\n",
      "reduce(...)\n",
      "    reduce(function, sequence[, initial]) -> value\n",
      "    \n",
      "    Apply a function of two arguments cumulatively to the items of a sequence,\n",
      "    from left to right, so as to reduce the sequence to a single value.\n",
      "    For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates\n",
      "    ((((1+2)+3)+4)+5).  If initial is present, it is placed before the items\n",
      "    of the sequence in the calculation, and serves as a default when the\n",
      "    sequence is empty.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(reduce)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ATT': 'I',\n",
       " 'ATC': 'I',\n",
       " 'ATA': 'I',\n",
       " 'CTT': 'L',\n",
       " 'CTC': 'L',\n",
       " 'CTA': 'L',\n",
       " 'CTG': 'L',\n",
       " 'TTA': 'L',\n",
       " 'TTG': 'L',\n",
       " 'GTT': 'V',\n",
       " 'GTC': 'V',\n",
       " 'GTA': 'V',\n",
       " 'GTG': 'V',\n",
       " 'TTT': 'F',\n",
       " 'TTC': 'F',\n",
       " 'ATG': 'M',\n",
       " 'TGT': 'C',\n",
       " 'TGC': 'C',\n",
       " 'GCT': 'A',\n",
       " 'GCC': 'A',\n",
       " 'GCA': 'A',\n",
       " 'GCG': 'A',\n",
       " 'GGT': 'G',\n",
       " 'GGC': 'G',\n",
       " 'GGA': 'G',\n",
       " 'GGG': 'G',\n",
       " 'CCT': 'P',\n",
       " 'CCC': 'P',\n",
       " 'CCA': 'P',\n",
       " 'CCG': 'P',\n",
       " 'ACT': 'T',\n",
       " 'ACC': 'T',\n",
       " 'ACA': 'T',\n",
       " 'ACG': 'T',\n",
       " 'TCT': 'S',\n",
       " 'TCC': 'S',\n",
       " 'TCA': 'S',\n",
       " 'TCG': 'S',\n",
       " 'AGT': 'S',\n",
       " 'AGC': 'S',\n",
       " 'TAT': 'Y',\n",
       " 'TAC': 'Y',\n",
       " 'TGG': 'W',\n",
       " 'CAA': 'Q',\n",
       " 'CAG': 'Q',\n",
       " 'AAT': 'N',\n",
       " 'AAC': 'N',\n",
       " 'CAT': 'H',\n",
       " 'CAC': 'H',\n",
       " 'GAA': 'E',\n",
       " 'GAG': 'E',\n",
       " 'GAT': 'D',\n",
       " 'GAC': 'D',\n",
       " 'AAA': 'K',\n",
       " 'AAG': 'K',\n",
       " 'CGT': 'R',\n",
       " 'CGC': 'R',\n",
       " 'CGA': 'R',\n",
       " 'CGG': 'R',\n",
       " 'AGA': 'R',\n",
       " 'AGG': 'R',\n",
       " 'TAA': '*',\n",
       " 'TAG': '*',\n",
       " 'TGA': '*'}"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict(reduce(lambda prev, next: prev + list(zip(next[1], it.cycle(next[0]))),\n",
    "    slc.items(),[]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('I', ['ATT', 'ATC', 'ATA']), ('L', ['CTT', 'CTC', 'CTA', 'CTG', 'TTA', 'TTG']), ('V', ['GTT', 'GTC', 'GTA', 'GTG']), ('F', ['TTT', 'TTC']), ('M', ['ATG']), ('C', ['TGT', 'TGC']), ('A', ['GCT', 'GCC', 'GCA', 'GCG']), ('G', ['GGT', 'GGC', 'GGA', 'GGG']), ('P', ['CCT', 'CCC', 'CCA', 'CCG']), ('T', ['ACT', 'ACC', 'ACA', 'ACG']), ('S', ['TCT', 'TCC', 'TCA', 'TCG', 'AGT', 'AGC']), ('Y', ['TAT', 'TAC']), ('W', ['TGG']), ('Q', ['CAA', 'CAG']), ('N', ['AAT', 'AAC']), ('H', ['CAT', 'CAC']), ('E', ['GAA', 'GAG']), ('D', ['GAT', 'GAC']), ('K', ['AAA', 'AAG']), ('R', ['CGT', 'CGC', 'CGA', 'CGG', 'AGA', 'AGG']), ('*', ['TAA', 'TAG', 'TGA'])])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slc.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "zip argument #1 must support iteration",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_21916/3965118156.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: zip argument #1 must support iteration"
     ]
    }
   ],
   "source": [
    "# [] + zip(1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate list (not \"zip\") to list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_21916/2641565.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m[\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate list (not \"zip\") to list"
     ]
    }
   ],
   "source": [
    "# [(2, 1)] + zip([1],[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ATT': 'I',\n",
       " 'ATC': 'I',\n",
       " 'ATA': 'I',\n",
       " 'CTT': 'L',\n",
       " 'CTC': 'L',\n",
       " 'CTA': 'L',\n",
       " 'CTG': 'L',\n",
       " 'TTA': 'L',\n",
       " 'TTG': 'L',\n",
       " 'GTT': 'V',\n",
       " 'GTC': 'V',\n",
       " 'GTA': 'V',\n",
       " 'GTG': 'V',\n",
       " 'TTT': 'F',\n",
       " 'TTC': 'F',\n",
       " 'ATG': 'M',\n",
       " 'TGT': 'C',\n",
       " 'TGC': 'C',\n",
       " 'GCT': 'A',\n",
       " 'GCC': 'A',\n",
       " 'GCA': 'A',\n",
       " 'GCG': 'A',\n",
       " 'GGT': 'G',\n",
       " 'GGC': 'G',\n",
       " 'GGA': 'G',\n",
       " 'GGG': 'G',\n",
       " 'CCT': 'P',\n",
       " 'CCC': 'P',\n",
       " 'CCA': 'P',\n",
       " 'CCG': 'P',\n",
       " 'ACT': 'T',\n",
       " 'ACC': 'T',\n",
       " 'ACA': 'T',\n",
       " 'ACG': 'T',\n",
       " 'TCT': 'S',\n",
       " 'TCC': 'S',\n",
       " 'TCA': 'S',\n",
       " 'TCG': 'S',\n",
       " 'AGT': 'S',\n",
       " 'AGC': 'S',\n",
       " 'TAT': 'Y',\n",
       " 'TAC': 'Y',\n",
       " 'TGG': 'W',\n",
       " 'CAA': 'Q',\n",
       " 'CAG': 'Q',\n",
       " 'AAT': 'N',\n",
       " 'AAC': 'N',\n",
       " 'CAT': 'H',\n",
       " 'CAC': 'H',\n",
       " 'GAA': 'E',\n",
       " 'GAG': 'E',\n",
       " 'GAT': 'D',\n",
       " 'GAC': 'D',\n",
       " 'AAA': 'K',\n",
       " 'AAG': 'K',\n",
       " 'CGT': 'R',\n",
       " 'CGC': 'R',\n",
       " 'CGA': 'R',\n",
       " 'CGG': 'R',\n",
       " 'AGA': 'R',\n",
       " 'AGG': 'R',\n",
       " 'TAA': '*',\n",
       " 'TAG': '*',\n",
       " 'TGA': '*'}"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict(\n",
    "    reduce(\n",
    "        lambda prev, next: prev + [(codon, next[0]) for codon in next[1]],\n",
    "        slc.items(),\n",
    "        []\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ATT': 'I',\n",
       " 'ATC': 'I',\n",
       " 'ATA': 'I',\n",
       " 'CTT': 'L',\n",
       " 'CTC': 'L',\n",
       " 'CTA': 'L',\n",
       " 'CTG': 'L',\n",
       " 'TTA': 'L',\n",
       " 'TTG': 'L',\n",
       " 'GTT': 'V',\n",
       " 'GTC': 'V',\n",
       " 'GTA': 'V',\n",
       " 'GTG': 'V',\n",
       " 'TTT': 'F',\n",
       " 'TTC': 'F',\n",
       " 'ATG': 'M',\n",
       " 'TGT': 'C',\n",
       " 'TGC': 'C',\n",
       " 'GCT': 'A',\n",
       " 'GCC': 'A',\n",
       " 'GCA': 'A',\n",
       " 'GCG': 'A',\n",
       " 'GGT': 'G',\n",
       " 'GGC': 'G',\n",
       " 'GGA': 'G',\n",
       " 'GGG': 'G',\n",
       " 'CCT': 'P',\n",
       " 'CCC': 'P',\n",
       " 'CCA': 'P',\n",
       " 'CCG': 'P',\n",
       " 'ACT': 'T',\n",
       " 'ACC': 'T',\n",
       " 'ACA': 'T',\n",
       " 'ACG': 'T',\n",
       " 'TCT': 'S',\n",
       " 'TCC': 'S',\n",
       " 'TCA': 'S',\n",
       " 'TCG': 'S',\n",
       " 'AGT': 'S',\n",
       " 'AGC': 'S',\n",
       " 'TAT': 'Y',\n",
       " 'TAC': 'Y',\n",
       " 'TGG': 'W',\n",
       " 'CAA': 'Q',\n",
       " 'CAG': 'Q',\n",
       " 'AAT': 'N',\n",
       " 'AAC': 'N',\n",
       " 'CAT': 'H',\n",
       " 'CAC': 'H',\n",
       " 'GAA': 'E',\n",
       " 'GAG': 'E',\n",
       " 'GAT': 'D',\n",
       " 'GAC': 'D',\n",
       " 'AAA': 'K',\n",
       " 'AAG': 'K',\n",
       " 'CGT': 'R',\n",
       " 'CGC': 'R',\n",
       " 'CGA': 'R',\n",
       " 'CGG': 'R',\n",
       " 'AGA': 'R',\n",
       " 'AGG': 'R',\n",
       " 'TAA': 'STOP',\n",
       " 'TAG': 'STOP',\n",
       " 'TGA': 'STOP'}"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict(\n",
    "    [(codon, amino) for amino, codons in slc.items() for codon in codons]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "codons = dict(\n",
    "    [(codon, amino) for amino, codons in slc.items() for codon in codons]\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Translate DNA sequence to protein"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean(seq: str, bases=bases, case=str.lower) -> str:\n",
    "    \"\"\"\n",
    "    seq: Any string\n",
    "\n",
    "    returns: a valid nucleotide sequence\n",
    "    >>>valid(\"acgt\")\n",
    "    acgt\n",
    "    >>>valid(\"ACgt\")\n",
    "    acgt\n",
    "    >>>valid(\"addt\")\n",
    "    at\n",
    "    \"\"\"\n",
    "    return \"\".join(re.findall(re.compile(f\"[{case(bases)}]\"), case(seq)))\n",
    "\n",
    "\n",
    "cleaned = clean(null, case=str.upper)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(x=str.upper):\n",
    "    return x(null)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AGCTACGTAG'"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cleaned[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "def translate(seq, start=0):\n",
    "    return ''.join([codons.get(seq[k-3: k], '-') for k in range(start + 3, len(seq))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Codon content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "prots = translate(cleaned)\n",
    "prots_1 = translate(cleaned, 1)\n",
    "prots_2 = translate(cleaned, 2)\n",
    "ports_3 = translate(cleaned, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AGCTACGTAGAGAGATATATCATCATCACT\n",
      "SALYTRV*RE\n",
      "ALYTRV*RER\n",
      "LYTRV*RERE\n"
     ]
    }
   ],
   "source": [
    "print(cleaned[:30])\n",
    "print(prots[:10])\n",
    "print(prots_1[:10])\n",
    "print(prots_2[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "xylo = \"\"\"ATAACGTTCAAGCTTGTGTTTCAGATAGTGGGGAGGAAGGAGAAAATAATTACATCATAGAGAAATAATT\n",
    "TGGTATTGTTTTTCGGATTAACTTTCCCCCAGAGATTTCAGAACAAGTAGTTGCTCCGCTTTAACAATGA\n",
    "TCGAGATCTATTATATAATCGCAGCAATATAATCTAAGACCTTTTCTTAACTTGAATAGCTACATTTAGT\n",
    "GCATATCGTTTTGAAAAGAAATTGCTAATAGCAAGTTATTGCCCCCAAAGAAAAAATCCCACAACTCGGA\n",
    "AAGACTTTCTATCTGCCTTGCGAAAAATCTCCCCCCTGAAATAATGTTTAAATTTTTCACTTCTCCAACA\n",
    "ACTATAAAGAGATCGACATTTCTCTTCAATTATTCTAGTGGTTTGTTTTCAAAATCATCAATTACATACT\n",
    "ATAGAACCATGTCTACTACTCCTACTATTCCTACCATTAAATTAAACTCTGGTTATGAAATGCCATTAGT\n",
    "TGGTTTCGGATGTTGGAAAGTCAATAATGAAACTGCTGCTGACCAAATCTACAATGCTATCAAAACTGGT\n",
    "TACAGATTATTTGATGGTGCTGAAGATTACGGTAATGAAAAAGAAGTTGGTGAAGGTATTAACAGAGCCA\n",
    "TTAAAGAAGGATTAGTTAAAAGAGAAGAATTATTCATCACTTCTAAATTATGGAACAATTTCCATGATCC\n",
    "AAAGAATGTTGAAACTGCTTTAAACAAAACTTTAAGTGACTTGAACTTGGACTATGTTGATTTATTCTTG\n",
    "ATTCATTTTCCAATTGCTTTTAAATTTGTTCCAATTGAAGAAAAATACCCACCTGGTTTCTACTGTGGTG\n",
    "ATGGTGATAACTTCCACTATGAAGATGTTCCATTATTAGATACTTGGAAAGCTTTGGAAAAATTGGTTGA\n",
    "AGCTGGTAAGATCAAATCTATTGGTATTTCCAATTTTACTGGTGCTTTGATTTACGATTTGATCAGAGGT\n",
    "GCTACTATCAAACCAGCTGTTTTACAAATTGAACATCACCCATACTTGCAACAACCAAAATTGATTGAAT\n",
    "ATGTTCAAAAAGCTGGTATTGCCATTACTGGTTACTCTTCATTTGGTCCACAATCATTCTTGGAATTGGA\n",
    "ATCCAAGAGAGCTTTGAACACCCCAACTTTATTTGAACATGAAACTATTAAATCAATTGCTGATAAACAT\n",
    "GGTAAATCTCCAGCTCAAGTTTTATTAAGATGGGCTACTCAAAGAAATATTGCTGTTATTCCAAAATCAA\n",
    "ACAATCCAGAAAGATTAGCTCAAAACTTGTCTGTTGTTGACTTTGACTTGACTAAGGATGATTTGGACAA\n",
    "TATTGCTAAATTGGACATTGGTTTGAGATTCAATGATCCATGGGACTGGGACAACATTCCAATCTTTGTT\n",
    "TAAATTCAATAAGATCTGTGTTTGTTTATTAATTAATAGATAGAAAATTTTTTTATATGGCATCTAAAAC\n",
    "AGTTTGTCTACCTAAAACTAATAATTTTAATCTACTTACAAAATCATCTCTTTCGATATAAGCACCACAT\n",
    "AATCTTCTTTTACCTGTAAATTCAGTTCTCAGGTGGAAACATCTCCAATTATCAAAAATCAAGCATTGGC\n",
    "CAGGCTTCAATTGATAAAAGATTTCATTTTCTGGAGAACTAATAATACTAACCCAATTACGAATAGCTTC\n",
    "ATAAAATTTTGGTACATCATTTGGATTCTCCCAATTATCCATTGTTGATCTATCACTTTGATTCCATCTA\n",
    "ACT\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I*NTRVFSQKSALLCVCVFFSQRDI*SVWGGGERGEKRGEREKKNI*NILYTHISHI*REREKNI*NI---WGVYILCVFFFFSRGDIL*NTLFFSPPPPQRERDIFFSQRENTQKSV*SVLCALSPRALFL*NTQNM*---SRERDISLYILYIYI*NISRAQSAQNIYI*NISL*KRDTPLFFFSLL*NTLL*ENI*SALYTHIFL*S---AHIYISRVFFL*EKKKREKNILCAL*NI*SAQKSVLYILCAPPPPQKKREKKKKNISPPHTQNTLSRG---KRDTLFFSLYISLCAPLLCAREKKKNISLSPPPPPL*EKNI*NMCVFL*KNIFFFFSHTLFSLSPQNT---TLYI*KKRERDISRDTHIFFSLSLFSQNILYIFSL*SVWGVFLCVFFFSQKKNISHISQNILYTHIYT---I*RENTPHMCVSLYTLYTLSPLYTLYIFSPLYTPHIL*KNIL*KNTLSLWGVLYM*EKNMCAPHIL*S---WGVFFSRGDMCVLWGEKKSVSQNI*NM*EKNTLCALCAL*DTPQKNISLYTQNMCALYISQKKNTLWG---YTQRDILYIFL*DMWGVCAL*EKRDILYTRGV*NM*EKKKKREKSVLWGV*EKRGVYIL*NTQRESAP---L*KKREKRGDIL*SVL*KKKREREKRENILYIFSHISHTLFSL*KNILYMWGENTQNIFFSPHM*DIS---KKRENMCVL*EKNTLCALFL*KNTQKKNTLFL*KSV*DTLL*ENTLLWGDTLYMCVL*DIFLYIFSLL---IFSHIFFFSPQNILCALFFL*KNIFLCVFSPQNIL*EKREKKKNIYTPPHTPLWGVFFSLYTLCVWGV---MWGV*DI*NTLFSPHTLYM*EKRDMCVFSPHILYIL*RDIYTLLWGEKKSALFLWGEKKKNILWGVL*---SALWGV*KRDISQKNISLYILWGVYIFFSPQNIFFLYTLWGVCALFL*DIFLYTRDIFL*DISQRERG---ALYTLYISQKNTPQSALCVFFLYTQKNIL*ENTHISHTPPHIYTLLCAQNTQNTPQKKNIL*DIL*EN---MCVFSQKKKKSALWGVYILCAPHILYTLWGVLYTLSLFSHIFLWGVSPHTQNISHIFSLLWGENILWG---ISPQKRERESALFL*ENTHTPPPQNTLFLYIFL*ENTHM*EKNTLYIL*KNISQNILCAL*DI*KNTH---GV*KNISLSPQSALSQKSVFFLYIL*KRDMWGGALYTLSQKKREKNIYILCALCVLYIFSPQKKNISQ---TQNISPQREKKRDIL*SALSQKKNTLLCVSLCVLCVL*DTLFL*DTLL*DTL*KRGDM*DIFLWGDTQ---YILCAL*KNILWGDTHILWGVFL*ERDIFSQNM*DISPHMWGGDTLWGGDTQNTHIFSPQNISLFLCV---*KNIFSQNI*KRDISLCVCVFLCVFLYIL*NIL*NI*RDI*REKKNIFFFFFLYIYMWGAHISL*KKN---SVFLCVSLYTPL*KKNTL*NI*NIFFL*NISLYTLLYTQKKNISHISLSLFFSRDIYI*KSAHTPHTH---NISLFSLFFLYTPLCV*KNIFSQSVFSLSQRGVWGEKNTHISLSPQNILYISQKKKNISQKSAHILWG---QRGALFSQNIL*DI*KKKRDIFFSHIFFFSLWGERENTL*NI*NIYTL*NTPPQNILYTRENI*SALF---I*KKNIFFLWGVYTHISHIFLWGDIFSLSPPQNILYISPHILCVL*DISLYISHTLFL*DIFSPHISL---T'"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "translate(xylo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NTRVFSQKSALLCVCVFFSQRDI*SVWGGGERGEKRGEREKKNI*NILYTHISHI*REREKNI*NI---WGVYILCVFFFFSRGDIL*NTLFFSPPPPQRERDIFFSQRENTQKSV*SVLCALSPRALFL*NTQNM*---SRERDISLYILYIYI*NISRAQSAQNIYI*NISL*KRDTPLFFFSLL*NTLL*ENI*SALYTHIFL*S---AHIYISRVFFL*EKKKREKNILCAL*NI*SAQKSVLYILCAPPPPQKKREKKKKNISPPHTQNTLSRG---KRDTLFFSLYISLCAPLLCAREKKKNISLSPPPPPL*EKNI*NMCVFL*KNIFFFFSHTLFSLSPQNT---TLYI*KKRERDISRDTHIFFSLSLFSQNILYIFSL*SVWGVFLCVFFFSQKKNISHISQNILYTHIYT---I*RENTPHMCVSLYTLYTLSPLYTLYIFSPLYTPHIL*KNIL*KNTLSLWGVLYM*EKNMCAPHIL*S---WGVFFSRGDMCVLWGEKKSVSQNI*NM*EKNTLCALCAL*DTPQKNISLYTQNMCALYISQKKNTLWG---YTQRDILYIFL*DMWGVCAL*EKRDILYTRGV*NM*EKKKKREKSVLWGV*EKRGVYIL*NTQRESAP---L*KKREKRGDIL*SVL*KKKREREKRENILYIFSHISHTLFSL*KNILYMWGENTQNIFFSPHM*DIS---KKRENMCVL*EKNTLCALFL*KNTQKKNTLFL*KSV*DTLL*ENTLLWGDTLYMCVL*DIFLYIFSLL---IFSHIFFFSPQNILCALFFL*KNIFLCVFSPQNIL*EKREKKKNIYTPPHTPLWGVFFSLYTLCVWGV---MWGV*DI*NTLFSPHTLYM*EKRDMCVFSPHILYIL*RDIYTLLWGEKKSALFLWGEKKKNILWGVL*---SALWGV*KRDISQKNISLYILWGVYIFFSPQNIFFLYTLWGVCALFL*DIFLYTRDIFL*DISQRERG---ALYTLYISQKNTPQSALCVFFLYTQKNIL*ENTHISHTPPHIYTLLCAQNTQNTPQKKNIL*DIL*EN---MCVFSQKKKKSALWGVYILCAPHILYTLWGVLYTLSLFSHIFLWGVSPHTQNISHIFSLLWGENILWG---ISPQKRERESALFL*ENTHTPPPQNTLFLYIFL*ENTHM*EKNTLYIL*KNISQNILCAL*DI*KNTH---GV*KNISLSPQSALSQKSVFFLYIL*KRDMWGGALYTLSQKKREKNIYILCALCVLYIFSPQKKNISQ---TQNISPQREKKRDIL*SALSQKKNTLLCVSLCVLCVL*DTLFL*DTLL*DTL*KRGDM*DIFLWGDTQ---YILCAL*KNILWGDTHILWGVFL*ERDIFSQNM*DISPHMWGGDTLWGGDTQNTHIFSPQNISLFLCV---*KNIFSQNI*KRDISLCVCVFLCVFLYIL*NIL*NI*RDI*REKKNIFFFFFLYIYMWGAHISL*KKN---SVFLCVSLYTPL*KKNTL*NI*NIFFL*NISLYTLLYTQKKNISHISLSLFFSRDIYI*KSAHTPHTH---NISLFSLFFLYTPLCV*KNIFSQSVFSLSQRGVWGEKNTHISLSPQNILYISQKKKNISQKSAHILWG---QRGALFSQNIL*DI*KKKRDIFFSHIFFFSLWGERENTL*NI*NIYTL*NTPPQNILYTRENI*SALF---I*KKNIFFLWGVYTHISHIFLWGDIFSLSPPQNILYISPHILCVL*DISLYISHTLFL*DIFSPHISL---T'"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "translate(xylo, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1600"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prots.count('S')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cc(seq, *codons):\n",
    "        return {codon: seq.count(codon) for codon in codons} if codons else Counter(seq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'S': 1600,\n",
       "         'A': 800,\n",
       "         'L': 800,\n",
       "         'Y': 800,\n",
       "         'T': 799,\n",
       "         'R': 1400,\n",
       "         'V': 400,\n",
       "         '*': 200,\n",
       "         'E': 400,\n",
       "         'D': 399,\n",
       "         'I': 1200,\n",
       "         'H': 800,\n",
       "         'P': 200,\n",
       "         'Q': 599,\n",
       "         'G': 200,\n",
       "         'C': 200})"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cc(prots)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [],
   "source": [
    "pattern = re.compile(r'''\n",
    "    (?=          # Positive lookahead assertion\n",
    "        (ATG     # Start codon \"ATG\"\n",
    "        (?:...)*? # Non-greedy matching of any three characters (nucleotides)\n",
    "        )         # End of capturing group for start codon and sequence\n",
    "        (?=TAG|TGA|TAA)  # Positive lookahead assertion for stop codons\n",
    "    )             # End of positive lookahead assertion\n",
    "''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'ATGTTGGAAAGTCAA', 'ATGCTTGATTTT', 'ATGAAATGCCAT', 'ATGGCAATACCAGCTTTT', 'ATGGAATCAAAG', 'ATGGAACAATTTCCA', 'ATGATTGTGGACCAAATGAAGAGTAACCAG', 'ATGATTTTG', 'ATGAAGAGTAACCAG', 'ATGTTCCATTAT', 'ATG', 'ATGGATCAT', 'ATGAAGATGTTCCATTAT', 'ATGTTGAAACTGCTT', 'ATGTTTATCAGCAAT', 'ATGGGTGATGTTCAATTTGTAAAACAGCTGGTT', 'ATGTTCAAA', 'ATGATG', 'ATGTTTCCACCTGAGAAC', 'ATGTTCAATTTG', 'ATGGTGATAACTTCCACTATGAAGATGTTCCATTAT', 'ATGTCGATCTCTTTA', 'ATGGCATTTCATAACCAGAGTTTAATT', 'ATGTGGTGCTTATATCGAAAGAGA', 'ATGATTTTGAAAACAAACCAC', 'ATGGAAATTGTTCCA', 'ATGAAATCTTTTATCAAT'}\n"
     ]
    }
   ],
   "source": [
    "pattern = re.compile(r'(?=(ATG(?:...)*?)(?=TAG|TGA|TAA))')\n",
    "\n",
    "def revcomp(dna_seq):\n",
    "    return dna_seq[::-1].translate(str.maketrans(\"ATGC\",\"TACG\"))\n",
    "\n",
    "def orfs(dna):\n",
    "    return set(pattern.findall(dna) + pattern.findall(revcomp(dna)))\n",
    "\n",
    "print(orfs(xylo))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['MCVLWGEKKSVS',\n",
       " 'MCALL*DIF',\n",
       " 'M*EKNMCAP',\n",
       " 'MWGAQNIYTPQSALF',\n",
       " 'MWGENISQK',\n",
       " 'MWGENTQNIFFS',\n",
       " 'M*DILCVWGDTPQKNM*EKRESV*NTP',\n",
       " 'M*DIFF',\n",
       " 'M*EKRESV*NTP',\n",
       " 'MCVFSPHIL',\n",
       " '',\n",
       " 'MWGDIS',\n",
       " 'M*EKRDMCVFSPHIL',\n",
       " 'MCVL*EKNTLCA',\n",
       " 'MCVFLYISQSAQ',\n",
       " 'MWGGV*DMCVFSQNIFLCV*KKNTQSALWG',\n",
       " 'MCVFSQ',\n",
       " 'M*D',\n",
       " 'MCVFFSPHTPL*ERE',\n",
       " 'MCVFSQNIF',\n",
       " 'MWGV*DI*NTLFSPHTLYM*EKRDMCVFSPHIL',\n",
       " 'MCVSRDISLSLF',\n",
       " 'MWGAHIFFSHI*NTPQRESVFL*N',\n",
       " 'MCVWGVCALLYIYISREKKRE',\n",
       " 'M*DIFFL*EKKNTQKNTP',\n",
       " 'MWGEKNILCVFS',\n",
       " 'M*EKNISLFFLYISQ']"
      ]
     },
     "execution_count": 217,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[translate(orf) for orf in orfs(xylo)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ATAACGTTCAAGCTTGTGTTTCAGATAGTGGGGAGGAAGGAGAAAATAATTACATCATAGAGAAATAATTTGGTATTGTTTTTCGGATTAACTTTCCCCCAGAGATTTCAGAACAAGTAGTTGCTCCGCTTTAACAATGATCGAGATCTATTATATAATCGCAGCAATATAATCTAAGACCTTTTCTTAACTTGAATAGCTACATTTAGTGCATATCGTTTTGAAAAGAAATTGCTAATAGCAAGTTATTGCCCCCAAAGAAAAAATCCCACAACTCGGAAAGACTTTCTATCTGCCTTGCGAAAAATCTCCCCCCTGAAATAATGTTTAAATTTTTCACTTCTCCAACAACTATAAAGAGATCGACATTTCTCTTCAATTATTCTAGTGGTTTGTTTTCAAAATCATCAATTACATACTATAGAACCATGTCTACTACTCCTACTATTCCTACCATTAAATTAAACTCTGGTTATGAAATGCCATTAGTTGGTTTCGGATGTTGGAAAGTCAATAATGAAACTGCTGCTGACCAAATCTACAATGCTATCAAAACTGGTTACAGATTATTTGATGGTGCTGAAGATTACGGTAATGAAAAAGAAGTTGGTGAAGGTATTAACAGAGCCATTAAAGAAGGATTAGTTAAAAGAGAAGAATTATTCATCACTTCTAAATTATGGAACAATTTCCATGATCCAAAGAATGTTGAAACTGCTTTAAACAAAACTTTAAGTGACTTGAACTTGGACTATGTTGATTTATTCTTGATTCATTTTCCAATTGCTTTTAAATTTGTTCCAATTGAAGAAAAATACCCACCTGGTTTCTACTGTGGTGATGGTGATAACTTCCACTATGAAGATGTTCCATTATTAGATACTTGGAAAGCTTTGGAAAAATTGGTTGAAGCTGGTAAGATCAAATCTATTGGTATTTCCAATTTTACTGGTGCTTTGATTTACGATTTGATCAGAGGTGCTACTATCAAACCAGCTGTTTTACAAATTGAACATCACCCATACTTGCAACAACCAAAATTGATTGAATATGTTCAAAAAGCTGGTATTGCCATTACTGGTTACTCTTCATTTGGTCCACAATCATTCTTGGAATTGGAATCCAAGAGAGCTTTGAACACCCCAACTTTATTTGAACATGAAACTATTAAATCAATTGCTGATAAACATGGTAAATCTCCAGCTCAAGTTTTATTAAGATGGGCTACTCAAAGAAATATTGCTGTTATTCCAAAATCAAACAATCCAGAAAGATTAGCTCAAAACTTGTCTGTTGTTGACTTTGACTTGACTAAGGATGATTTGGACAATATTGCTAAATTGGACATTGGTTTGAGATTCAATGATCCATGGGACTGGGACAACATTCCAATCTTTGTTTAAATTCAATAAGATCTGTGTTTGTTTATTAATTAATAGATAGAAAATTTTTTTATATGGCATCTAAAACAGTTTGTCTACCTAAAACTAATAATTTTAATCTACTTACAAAATCATCTCTTTCGATATAAGCACCACATAATCTTCTTTTACCTGTAAATTCAGTTCTCAGGTGGAAACATCTCCAATTATCAAAAATCAAGCATTGGCCAGGCTTCAATTGATAAAAGATTTCATTTTCTGGAGAACTAATAATACTAACCCAATTACGAATAGCTTCATAAAATTTTGGTACATCATTTGGATTCTCCCAATTATCCATTGTTGATCTATCACTTTGATTCCATCTAACT'"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clean(xylo, case=str.upper)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fibonnacci population growth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [],
   "source": [
    "def growth(months:int, offspring:int) -> int:\n",
    "    parent, child = 1, 1\n",
    "    for month in range(months - 1):\n",
    "        child, parent = parent, parent + (child * offspring)\n",
    "        print(f\"{child} - {parent}\")\n",
    "    return child"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1: 1\n",
      "1 - 3\n",
      "2: 1\n",
      "1 - 3\n",
      "3 - 5\n",
      "3: 3\n",
      "1 - 3\n",
      "3 - 5\n",
      "5 - 11\n",
      "4: 5\n",
      "1 - 3\n",
      "3 - 5\n",
      "5 - 11\n",
      "11 - 21\n",
      "5: 11\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 6):\n",
    "        print(f\"{i}: {growth(i, 2)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate Hamming distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hamming(obs: str, act: str) -> int:\n",
    "    return len(set(enumerate(obs)).difference(set(enumerate(act))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs = \"GAGCCTACTAACGGGAT\"\n",
    "act = \"CATCGTAATGACGGCCT\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "descriptor 'difference' requires a 'set' object but received a 'enumerate'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_21916/2330388217.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdifference\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mact\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: descriptor 'difference' requires a 'set' object but received a 'enumerate'"
     ]
    }
   ],
   "source": [
    "set.difference(enumerate(obs), enumerate(act))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(set(enumerate(obs)).difference(set(enumerate(act))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs = \"GCGTGAAACTTGGGTCTCGCCCCGAAACTACCAACAATCCTTTAGCCTAAATATTATCTTTGATCAGAGCAAACATGTACTCTCTGTATCAACGGCGTCCCCTCTCGAATTCCCGCGGCGTTAGGGCTCCCCCTCCCAAGGTGTAGTTAATAATTGCTTTAGTGCGATCCTTCGTTACCTCCAATCTTTCGGTCTTAAAAGTGATCAACATGAATCGGCGATTTCCCAGCTTACGGGATTCAAACTCTGATAAGGGGGAGTCGATTTCTGAACTGGAACCTGTCCGAGGAGGGGGTAGGACCAAGGGAGGATCTGCCTCATGTGACTTCGCGGTGGTGGCCGATTTAGTGTCGCGAGTTTCGAATCTCAGCCGTTTCTGATACGCTTGGATATATGTGTATTCGGCTGCGTGCTGCAAGCAACTAGACCGAAGTCGGCGGAGAGTTATAACGTTGGAAGATTGCCGAGGCCTTGATTCGGTTGACCAAATGGAGTGAGGCCTCATGCAATGAACCGAGATTGGACGTCTATAACCGTACCGATGGTCCCCCCCATTGCCACGAGTCGGATTGTCTCGACGCAATCGAGGCAGAGTTCCAGTAACTGGGATCACCGACGAGATGTTACCTGATCCGGTATGTCGAAATCGTTGCATACTACCCCCTCTCACTTCAAGACGCTTATCTCGTGTGCGCAGCGGAATAGCGTACAACCGTTGGATCCCTTCTTGGTATCCCTGGAGGAGCAATGAGCGTGTCCTTTACTAGACTGGTGGATGCACACACAGTAGACGTGGCGTGTCGAATCACTAAATATAGACTTTAAGAGGTCTTCAGTACGGTAGTTTTCTGGTTCTCCACACCTTGCCTAGAAGGGACCACCTCGCCTAGTTCAAGCTAGCCAGGGCTTAAGTCTAGATAGGTGCTTGTCACGGT\"\n",
    "act = \"GTGGATACAATTTGTCTAGGCGCGCGTGTGCTCACATGCCTTGACGGGAAGGACCATCGATTATAACCACAACGATATTGGCTCCCTCTCAACCCATTCCGCTCACTCATGACGCCGCAGTGAGGATTACCCCACGCCCTAAGTAACTAAAACACTACTTAGGGCGTTTATTAATTTAGCCGCCTCCCACGGCCGTAAGTGAACTCAGTATGTACGGTTGAGGAGATAGCTAGCGGGAAAAAAAATCTTAGAAAGGAGAGCGCCATTCTGAGTGGGCGGTACGCAAAGCAGGAGCTAGCACGCGGGGTGCATGTAACTGATGTTCGTTTTTCGACGGGTAGGGGTAATAGGCGCAAATGTTTAATCTCACAAGTTTGATAGAAGCGCCTTTGCATTCCTAGCAGCCTAAGTGCGGCAAAGAAATACAGTCGATACCGCCGAGACATTTACCTTGTCACTATTATCTAATGCGGCACGCGATATATCAAGCTCAGGGTGCCACCTGGCCACGATTTAATGTGGAACTTCTCCCTTCCTTACGAGAAGTACACGTTTCGGCCGGCGTCCACAACACTACCCGCAACACTGGGATAGGAACTGAAGGAACGATCCCAGGCAGGATGATCCCGGAACGGTTATCTCGTAATCCAAGGTAGTTACGCTCTCTGATTTCAATACGGTTGTCTATACTGCAGATCTGGAGATCGTTCTGTCTATAGATCCGCTATCTATTGCCGTTATGATGCCATGAGACTATAGACGAATGGACTCTACAAGGTAACCCCAGCAGCGTACGGGGTAGGGGTCAGGGCCTATGATCTGTATTTTATTTTCACAAAAGATGTCGACTTTTTGGATGCTGCTTTCATAGGACGTGTGGCTTGGTACACTCCCAGCTATCTGTCACTGGCCTACTGACATATTTCTAGCACTGT\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "479"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hamming(obs, act)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [],
   "source": [
    "def h2(obs,act):\n",
    "    return sum(map(ne, obs, act))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "479"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h2(obs, act)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "290 µs ± 6.86 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit hamming(obs, act)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "112 µs ± 4.19 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit h2(obs, act)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ATT': 'I',\n",
       " 'ATC': 'I',\n",
       " 'ATA': 'I',\n",
       " 'CTT': 'L',\n",
       " 'CTC': 'L',\n",
       " 'CTA': 'L',\n",
       " 'CTG': 'L',\n",
       " 'TTA': 'L',\n",
       " 'TTG': 'L',\n",
       " 'GTT': 'V',\n",
       " 'GTC': 'V',\n",
       " 'GTA': 'V',\n",
       " 'GTG': 'V',\n",
       " 'TTT': 'F',\n",
       " 'TTC': 'F',\n",
       " 'ATG': 'M',\n",
       " 'TGT': 'C',\n",
       " 'TGC': 'C',\n",
       " 'GCT': 'A',\n",
       " 'GCC': 'A',\n",
       " 'GCA': 'A',\n",
       " 'GCG': 'A',\n",
       " 'GGT': 'G',\n",
       " 'GGC': 'G',\n",
       " 'GGA': 'G',\n",
       " 'GGG': 'G',\n",
       " 'CCT': 'P',\n",
       " 'CCC': 'P',\n",
       " 'CCA': 'P',\n",
       " 'CCG': 'P',\n",
       " 'ACT': 'T',\n",
       " 'ACC': 'T',\n",
       " 'ACA': 'T',\n",
       " 'ACG': 'T',\n",
       " 'TCT': 'S',\n",
       " 'TCC': 'S',\n",
       " 'TCA': 'S',\n",
       " 'TCG': 'S',\n",
       " 'AGT': 'S',\n",
       " 'AGC': 'S',\n",
       " 'TAT': 'Y',\n",
       " 'TAC': 'Y',\n",
       " 'TGG': 'W',\n",
       " 'CAA': 'Q',\n",
       " 'CAG': 'Q',\n",
       " 'AAT': 'N',\n",
       " 'AAC': 'N',\n",
       " 'CAT': 'H',\n",
       " 'CAC': 'H',\n",
       " 'GAA': 'E',\n",
       " 'GAG': 'E',\n",
       " 'GAT': 'D',\n",
       " 'GAC': 'D',\n",
       " 'AAA': 'K',\n",
       " 'AAG': 'K',\n",
       " 'CGT': 'R',\n",
       " 'CGC': 'R',\n",
       " 'CGA': 'R',\n",
       " 'CGG': 'R',\n",
       " 'AGA': 'R',\n",
       " 'AGG': 'R',\n",
       " 'TAA': '*',\n",
       " 'TAG': '*',\n",
       " 'TGA': '*'}"
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "codons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = \"AUGGCCAUGGCGCCCAGAACUGAGAUCAAUAGUACCCGUAUUAACGGGUGA\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ATGGCCATGGCGCCCAGAACTGAGATCAATAGTACCCGTATTAACGGGTGA'"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq.replace(\"U\", \"T\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'MWGAPHMWGARAPPQRENTL*ERDISQNI*SVYTPPRVYIL*NTRGGV'"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "translate(seq.replace(\"U\", \"T\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ATT': 'I',\n",
       " 'ATC': 'I',\n",
       " 'ATA': 'I',\n",
       " 'CTT': 'L',\n",
       " 'CTC': 'L',\n",
       " 'CTA': 'L',\n",
       " 'CTG': 'L',\n",
       " 'TTA': 'L',\n",
       " 'TTG': 'L',\n",
       " 'GTT': 'V',\n",
       " 'GTC': 'V',\n",
       " 'GTA': 'V',\n",
       " 'GTG': 'V',\n",
       " 'TTT': 'F',\n",
       " 'TTC': 'F',\n",
       " 'ATG': 'M',\n",
       " 'TGT': 'C',\n",
       " 'TGC': 'C',\n",
       " 'GCT': 'A',\n",
       " 'GCC': 'A',\n",
       " 'GCA': 'A',\n",
       " 'GCG': 'A',\n",
       " 'GGT': 'G',\n",
       " 'GGC': 'G',\n",
       " 'GGA': 'G',\n",
       " 'GGG': 'G',\n",
       " 'CCT': 'P',\n",
       " 'CCC': 'P',\n",
       " 'CCA': 'P',\n",
       " 'CCG': 'P',\n",
       " 'ACT': 'T',\n",
       " 'ACC': 'T',\n",
       " 'ACA': 'T',\n",
       " 'ACG': 'T',\n",
       " 'TCT': 'S',\n",
       " 'TCC': 'S',\n",
       " 'TCA': 'S',\n",
       " 'TCG': 'S',\n",
       " 'AGT': 'S',\n",
       " 'AGC': 'S',\n",
       " 'TAT': 'Y',\n",
       " 'TAC': 'Y',\n",
       " 'TGG': 'W',\n",
       " 'CAA': 'Q',\n",
       " 'CAG': 'Q',\n",
       " 'AAT': 'N',\n",
       " 'AAC': 'N',\n",
       " 'CAT': 'H',\n",
       " 'CAC': 'H',\n",
       " 'GAA': 'E',\n",
       " 'GAG': 'E',\n",
       " 'GAT': 'D',\n",
       " 'GAC': 'D',\n",
       " 'AAA': 'K',\n",
       " 'AAG': 'K',\n",
       " 'CGT': 'R',\n",
       " 'CGC': 'R',\n",
       " 'CGA': 'R',\n",
       " 'CGG': 'R',\n",
       " 'AGA': 'R',\n",
       " 'AGG': 'R',\n",
       " 'TAA': '*',\n",
       " 'TAG': '*',\n",
       " 'TGA': '*'}"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "codons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A'"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "codons['GCC']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'MAMAPRTEINSTRING'"
      ]
     },
     "execution_count": 245,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dna = seq.replace(\"U\", \"T\")\n",
    "\"\".join([codons[dna[k:k+3]] for k in range(0, len(dna) - 3, 3)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [],
   "source": [
    "def translate(seq: str):\n",
    "    return \"\".join([codons[seq[k:k+3]] for k in range(0, len(seq) - 3, 3)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = \"AUGUCUUCGUCACAUUUGCCCUCCAAGCUCCCUGGUGCGCGCCCCCUUUACCCUUGGAUUACCCAGAUGUUCUCCUAUCUGGCAAACCCACUACCAGUGCGAUCCUUUAGCUCCCGCGGUUGUUGCUUGUCCCAGAAACGUCACUAUACAUCACACGGCAUGGGAGCCCAUCGUGAUCCCUCGACACGUGAGGCGAGGACCCUGGUUCGACCCUGUGAUCCAACGACACAAGGGUGCUUUCAAGAGAAUAUUUUCGCAGUAACGAUCCUGGUCGCAUCGAGCAGGAGCGUCCGACUAUACACACCGACGACUCCGUCGCAUUCAUGUAUGCACUGGGUGCUGUGGUAUUCAAAAGCGACUUAUCGUUGGUGCUUGUGUCAUCCGUUUUCAUACCUCAACCUGGACGAACUGCUACUGGAUUUACUGCGGGGCUCAAUCCGUAAUCGAAUGCACCAAAUCGUCGUCUGUAGAGGGAGUGCUUUUGUUGUUGGCCUCAAAAUCUACACAGCCCGCGCUACCCUGCGGCUCCCACCCCGAGCUCCUCCCUGUUCUACUGACUUACGAGUCGGGGGCAGCGACAAGACGAGAUCUGUUCUGUCUUUGUGGAUCGAUGGAAGCUUGAUGAUGUUAAUUUCAACUUUGUCAUACUAUCGUUGUCUAGCAAAAUAUCCCGAUACUCAGAAUGAUCGGAGCUCAGUUUCCAGUGCCCCGCGCGUAGCCACCGAUCUAACAAAGGUUGAAACACCGGGGUUAGGUUCGGUCGGUCCCUCCCGAGCGGCUUGUAUCUGCGGAAAAAGAUUGUCGAACCCGCACACGAUCGUUUCUGGUUUACCCGUAGCCGAACUGGACCUUGACUGUCCGAGGACUAAACGACUCGACUGUCAAAGGAGCUCCUGUGGCAUUCACCGGAUAGCUGUUACAGGCUUUCCACUUGAUCGUCUCUACGUUCUACAUUUGGAUUACAAAUAUACGAUAUUGCGCCUCGAGCAGACUAUGCCACCUAGAUGUCUCCACGCCGGUCGGAGAUCGUUUGUCCUCUACGCUCAGGGGAGCACCAGUCCUCACUUUAACUCCUCCAUAGCUCUGGGGACAGUCAUGCCUCUGCCGGGAUUUCUGAGGUGCCGUGGCUACGACUCUCGGUAUUAUCCCAUCGUCGUCCCAGCGUUGCUCCGAUCACCUCCGCGUCGCAUUUGGUGGUCACUCAAUUACGCAACCUGCAUUUUGCCAUUUGUUCCGACCAUUCGCAGCGCAUUGACUCACUUGAUUCCUGAUUCAGCACGGAUGGUUAAGACGAGGCCUCACCGAAACGCGGUAUUUCACGUAGGAACAGGACAUCGCAAUCAGCGAUCGGCCCAAACACAGAUUGAAGUAGUACUUCACUGCACACACGCUCGGGCCUAUACCGUUUACGGCUUUAAUAGCUCAACUCUUAAUGGGGAGACCGUGGACCCAUCAUCUCAAGUGUCUUACAAUUCGGGAACUGUGAUCUUUUGCUGCCCCCACCCGAGAAACUGCCUAUAUGUUCGUCUAUCUUCGAUAAUCCAUGGUAUCCGUAUCGCUGAGCCGGUAUGGAGAAGUAUAUACAGAGUACAAUUGCGUUGCUCUAUUAGAGUAGCAGUUGACGAGAGAUGUCCCUAUAGCCAAGACACGAUUGGUGUACCUUGCCUACGGCGAGAUAGCUUAAACACAAAUAAACCUUUGAUAGAUCGGAGUCUUCUAAAAUGCCACUAUGUUCCUGAGCUAAGGCUGAACCUUUGUCCGGUUGACAGGGUCGUAAACGCACGAGUCCACGUAAGGGAAAUAAAUGAAGGCCCAAUUGCCGUCGGCGUCGCGUUCCUAGGACCAAAGGGGAUCAGACCCGUCAUGUCGCAUAGGAGAGUAGUUUUUAUACCUCGGUCUUAUCUUAUACUCUACAUCUGCAUUCAGUGGGUGUGUAUUGGGAGGUGUUCGACAUGUCACUGGUUCUGGACACUUGGUCUCUUUGUAUGUAACGUGUAUGGAACCUCAACCCGACUGCGGGCACACGGCAGCAAUGGCGAGAUGACGGUGUAUAUGGGCAUUGGGUGCCGCAACAACAUAAUCAUGGAUGUGUUAUCUCUUAGAGGAGAGCUGACUACCCCGGCGACGGUGAUCUCCGCACUUGAAACGGGGGACACGUGUUUGAAAAACCGGAUACGGGCCCCCUUUUCAGGUGCACCAAGACGCAGGCUGUCCCAAAACGAAGUAAACCAUCACCUCUCCUGCAAUAUGAGGGUGACCGAUAGCCAUCUCAUCAACAAUAAUGCCUGUCUUCGAUGGAAAACAUCUCCAGUUGCCCGAUGUAGUUCAACACCUAUGGUUCGAAUAGUAAAAAAAACGCCCUCCCGAGAUAUGUUCUAUGCCCCGGAGCCCGAUCACAACGAGAGUGAACGUGGAUUUACCACGCCUGUGAGCUAUCCUGCCUUACUGGCGCAACCCUGUUGGUUUUGUAUAUCGAUUUUGUUGGAACAUAUUUCUAACAGGCCCCGAGCGGGGGAAUCCGAAUUAUACCACGAAUUUAUUACCCAUCGCGGCGUGUCGGCCCGGCAGCGAUGUACAGCGGAUCAAUUCGAUAGUGAGUCUCUCCAUCCGUUGGCGACAAUAGCGCACUCAGCUACGUGCGUCUCAUAUGUCGCGGAGCUCCUUACGCCUCAAUCAGAUAAGAGUACUCACGGUCGCCGUCAUAAAUCAGCAACUUCCAUAAGUAUUGGGGGGACUUCCAACUCCGCGUAUAGGCCGGAAGUAGGUAGCACAUCAACAGUCGGUGCGAUGGUCCUCGACUUGUUGAUCGUCCGAGACGCCUCGUGUCCGGUUGCACUGGCCGUACAAGGACAGCAGAGCCAAGUUUUCGGCGUGCAACGCGUUGCACCUUCGCUAGUUAGAAAUGGAGGCUGGUGUUGCUCAAGCAAAAGGGAUACCGGUAGACGCCCGACCAUAUCCACCCUUAGAGACCGCGUCGAAGACGUGUACUUUUCCACCCUUGUGCUAAACGUCAUACGGCGCGAUGUAUUCGUGAGCAGCAAGGCCGGAGGAGUCCGUGUACACUCUGUGCCCGCAACGGGUUGUCCAAUAAAUACCCCCAUAGUCAUUGGUCUAAGUUGGGAAAGUUUACAUAAACCGUUCGAUGUACGAAGCAAUUGUAUGUCUCCUUGCGAAUUGUCGAGGUUUCAGAAACUUUUCAGAUGGUCGAUCGUGAGACGACAGGAUCGAGAGUUCAUUCUGGGACAGUGUACCCACCCACCGCCUGACAUCCUUAGGGGAUACUAUCGCCCGCUGGCGUUUCUCAAAACAAAGUCAUUCAAUAUAAAUUCAAACCGUGCCGGAGUCCAACUGGUUAAAAAUAUUGGCCGCCAUUUACGUGUAACUCUGAGAGCCAUCGAUCUAUCAGAUUCCAGAGGCUCUAUUGGGCCCUCAGGAGCGAUAAUGCAAAAAUUCAACUGCAAUAGUAAUUACCGCGGAUUCAUUCAUGAGCAGUCAUUCGCGUGUCUCAUCAUGAACCGCGUGCCCAAGCAACUUCCAUUAAGGAGAUCGUCGCACGAUGAACCUGGUUGGAGUGUGUCACCGACCCGCUCAACGCCUCCAGUCCUCAUGCUGCCUCGCUUACUUCUUUGGUGCCCACAGUGCUUCCUUCGACACUCAGCUAUCCCACUUGUUCGGCAGAUACUACAGACAGGAAACAUAGGGGGUGCCUAUAAAUCAGUCUGUAUGUCCUACAUUCCACGGGGCUACGGUCAUCACCAUAGAGAACUGUACCGAAAUGCCUAUUGGGGACAGUUUAGGAAAUACGUCACUAGCUACGGUCGCGUAGAGCUCAAGACUGGUGUCUUGGGAUUAGCAAUUGCGAUCUUCUGCGAAUAUGAUGACGUGCCCGUCAUCAGACCCCCUAACAGCACGACGCCCUUCACACAUUCGUCUAAACAUUGCAUGCGCCUGUCAUUCCCUUCUACUGAAGAUGCUCAAUUGAAACAUUACUUACGUGUCUGUCCAUUGAGCUUCCUUCGAACAGCGAUGGUUCAGGGUAAUCGCCCCUCAAAACUGUCUCGUAGCUCGCGGAAACUAGUCACGAGCUUUCGCCAGACUCGGCAGCAGAGUGAAGUCCAACGAAUACAUGGCGUUGUACUCGGAUUUGAAGGUGUCGUGAUCUGGCUAGAAUCUCUGGCGGGUUCCUUAUUGGCAUCAACCAGCUAUUGGCGUCGAGGACUCGAUGCUAUAACGAGAAAGCAGAUGGAUGGGCUCUCUAUGCAUAGCAGUAGAGCCAUAGGGUGUCCAUUAUACCAAUGGCCGACAUGUAUCCCCAGGUCCUACCGCGAAGCGUGCGUCACGUGGCGCAGUAACUCAGUGAGGCCAACAAGAACCGAUGUUUCAAUGAAGUCUGUCGGCCACCGGGGCCUCCUACCCCGCCAGUUAUCGAGAAAAUCCUCAAUUGGGAACAUAAGACCACAACCGCAGACCUGGUCGACGACGCAUGUUGCUAGACCCGCACAACGCGGAGGCAAAUCGCGCACUGGACAACUCAUCCACCUCAGGGCUCCCCUAAACCGGACGUUCGGCUCCGAUUUGCAGCUGUUAGACCAGCGUCGAAAUGUGGAACGUGGUGGGUCUAGUGCAGCAUUAUACUGGGGUUCAGUACGCGGCACAGUGGUUACGAGGAUUCCCGCAACUCGGAUCUCCUGGCACCGCCCAAAGAAUCCGUUUUUAGAAUUGCCAACUGCCCAGAGUUCGGGGGCGGAUAGAGAACAGCAAGCCGAGGGUGCAGGGUACAGCUUACAUCUAGUAGUGCGCAUCACUCGGAAUGUCGAUACGCCAAUAGCUUGUGGCCUCCUCCUCCCGUUGCUCACGCCUCUCGUCUCCCAUGUUAGCUCAUGUACGUCAUUCAGGGUUCUCAAGCCGUUGGUGCCUUACAUUAUGAUGUCAACCCUCGUCUCCAGGAAAGGUGGCUCAUUUGUGUUCCACACAACUACUUUUGGUAUGGGUGCAGACAUGCGAGGCUUAAAUAGCCGAUUACAGACCUGGCCCACUUUUUGUGGAGUUUCGAUCUCUUGCGAAUCCAAUAUUACAAUUUGUCAACGCGUGCUGUCCACUGCAAGUACCAAUACCCUACUAAUUUUUCAUACUUGCCAUCCUAGCCGCGCACAGAAACCAUCGCCUGACGCAGAUCCCGCAAAAGAACUGGUUAUGGCCAGAGUAUCCCUCUCAUUACGCAAGAGCUCAAGACCGAGAUUCGUGGAUCCAAAGGGCUCGACAGUUGCUAAACAUUCCGUAACCCUAAGGGGAGUACCUCCCAACCCACCUGCUAGACUGUACGAAUGUAUGCACGCGCGACGGUUGACUGCAAUAAUGAACAUCCGUGAAUUUCGAAGAUGCUGGCAUUCGACGAUCUUAUUUAGAGAUGGAGGUAUUAGUCAAGGUCUCAGGUACCAGCUACCAGAAAAACCAGGAUCGAGCGUGAAUUUAACCGGCUAUGGACGGCAUGAGGCCACCUUGCAUGCGAAUGUAUCCCGAUAUCGGGUGGUUGGCCAAAUGAUCUCAGUGUUCUCAUUAUUCAUCCGGGGUGGUCGACGCUUUUCCUUGUCUGAUAGUGCGGAUUGUCAUGAGGACGGGCCUUGUAAAAAUAACAAGGCUCGUAGGGCACUGUCGGCGGAUUCGGAUCGUCCGGGGGUGGUCUACCUAUCAUGCAGAAAUUGGCCUUCUCUCGCUAGAUGCAACAUGGCUUCACUCUAUUCUACAUCAGCAACUAGGAGUCCUGGACAAAUAGACUGCGUUAUGCACAUUCAACCCUUGUUACAUUCCGAGUUGGGGCCGCUUGCGCUUGUGUACAAGGUCGCCGUGGGAGAGCAUACACGUACCUCUAAAGGAUCCGAAGCGAAUCUGCGCAGUGUUGAGCGACGCCCAUGCUUAGUAGUGGCGGGUGUAAUUUCGACCGAGGACCGGCGGAUGUUCUCACGUGGGGAUAGCCCCGAUCAGCCUCAGAGUUUAAGGCAGCCCUUACUGCACGCGCACUGUGGCCUAACACAGGCAGUUUCGCACCACGAUGAGAUAGAAUCAGUGCGUAGCCGCAGUGUUUUUUUUAAGUCGCUACGUCAGGCUGAGAUAUUUUUAUUUGAAGGGUCGGGCCUUGGCGCAGGUGCUCCACAUGCGCUUCAUGUACAGGGUGGGCUUCAACAUGAGUUACGCAGCCAGGCCCCGUUCGAGCCCCAGUUACAGGAGGGGGUCUCGUGGAGACGAAGAAAGGAUCAUCCUUCUGGUAGCAUUUCCGGAAUUAACGCGGCUGAUGAGUCGAGACUUUGGGGUGCGUACGUAGGAUCGAUAAUUCCGCUACUUCGUACUCGGAUUAGCAGUCCUUGCACGGUUGAUGCCCGAGGAACCCGGCGGUACGUACCCAUCGUCUCCUAUUACAGCGAAUCAGCGCGCCUUCUAGCACGCGGUUUGCAGCAAAACUGCCCAAAACGCCGCCUAAACGCAGCACUCGGCUUAGCGGUACCCGCGUUACCAACCGUGACGAGUAGUACCAGUAUGGAGCUCAAUUUUAAACGUACUCAUUGUUAUGGGGCGGUGGUGCGUCAAGUCGGGAGGCGCCCCCGGGAUCUGAACAUUCGUCAUCGGCGACUUAUGUGCCUAGAUCUGUGUAUACCACGUGGCAACCAUGCUCCGAGUGCGGUCGUCGGUGAGUUAAGGCGAAGUGAUCCACCGCACGCCUUAAAGUUAGCUUGUAAGUAUGGGGUCAGUUAUGCGGAUCGUAUUCUGGCAGGUUUAGUACCACCACCGCCGCCCGCUCAAUUAGCACAGCGAUGGGCAAUAAAUAGAGUCUGUUGCGACAAAAAGGCACCGCUAUUGGGCUUUAGACUGGACUACUUGAGGUGUUGCAUAAAAGGUAGGUCUCAGUCGAGGCGACGACUGAAACACCAUAACGUUCGCCCAACAACGUUUUCCUCCAGAGGUACAAAUUUUGAGCACCAUAGAACUUGUAGCUCCGUCACACUUGGGUGGACACGAACAUCGUUGCGCCAGUUUUAUCAACGAUAUAGGAUCCAGGGGUGUGGCCAUAAUCGCCCGGGGGCCUGUAAUACUUGGUCACGGGAAAGCCAUAAGCCAGUGACCAGGUCUCAACUUUGGCACUACAAGAUGGAUAUGCCCGUUGUAAAUGGUUCUGAUCAUCCGCGAGCCAAAACGACGGCAAGUACGCCGUACUCCAUGUACGACUGGUUGAGUCCAUGGCGGAAGCUUCUUGAGCGGUGGGAGUUCGGUCAUUAUUUGGCGGAGAGAGACAUUCGGGGCACGAUCAGUCACCUGACAUCCAAUGCGAGGUCAAUUGAUCAGCUUAUGUCGACCUCGUCCCUUGUAUCAGGGCUCGCUUCCACGGUAUACGACCUCUCGGUCUCUGCGCAGGUCCGUGCUUUGAUUUCUCCUCUAGGCUUAGCAAGCGCUCAAUGCUUAGUCGCGGCGAUCUAUCAUUGGCCUUCCGACGGCGUCUCGCUACUCGAAUACCAACACGGGCGAAAAUCGUGCAAACGGUGCACAGUCUGCUCGGUAAUGAUCAAGUGUAGGGAACUUUUCUUUGGGAAAUACCCGGCGUGGACCGACAUUAUUCACCUGGGCCGGGUGUGUACCACACGGAAUCAUACUAGCUUGUCAAGUAGGCGAUUGAUCCUAUUCCGGGGAGCAACUAAAACGCAGCAGAAGAGACGGGCUCUGUUAGUGAGAACUCUCCGUACUUGCUCACGGAUCAACCGUUUUAAGACCAUACUCCGUCACUUUAGUGUUCGAAUAGUCACUGUCAAUAGCAGGGCCAGAAUUAAGGGCGCGGAAGAGAUACAUGAGGAGGCUGGCGGAUCAAGACUGCCCUAUUUCAUGAUCGAGCCCAUCAUAAGCAUCAAACCCCCCACAUGUGCAGCGCGUCUGUCAGAACGUUAUCCAGUUUUCUACCCUAUACCUCAGGAAUGGGUCUCUAUCGUAAUCAUGUAUGCCGUAACCUCUCAUAAGUCUAUUAGUCAAUCAAACCCGCUCGCAGGACUAAAUGUGCGAGAGUUGACAGGCAAAUCAGGUAGGCUGCGAGGGCGCUCUGUCCCCACACCACCGAGCCGUGCCAGGGACUCUUUUUCAAGGCUAAUCAAAUGUCUCAGUGAGCGAGCAGCGGUUGGAGUCAUGUCUCAGAUAAGUGAUCACGUCACGGAAAGAGGCAAGACAGUAACCCCAUCUAGAUACCCUAAAAUUGCAAUUCGCAAACUUUGGGCGCCCUGUACCCUCAAACUCGUUGUAACAUCGGCGAGGGGUUUGGAAUCUCCCACCUCGAGGCUACUCUGGAGGGCACCAUUGAAUCCCAGGCUAAAAGGGACUACUGAAGACCUUAGAUUGAUCGAAUGCCCUCAAUCGAAUAUUUUCCCACGUCCCCUGAUGCCGCUUUGUAUCAUCCACGAGGGCACUUUCCAGUGCUCUAUCCAGUGGAAGUCAGGCGCGGGCACUGGGGCAGCUCCUCCCACCAAUUUGGACUCACUUGUUUGUCAUGACGUACGUAAUAGUGUGCGCUCCAAAGACAGCCCUGGCGUUUGUAAACGCCCUGGCUGUAACAUAGAAGUGCUACCCGGUCCGCAGAGUAGAUCGUUACCAGGAACACGGGACAUGAGAUAUCCGUCACGCCGGGAACUGAACAUGACCUCUGCCGAGAUUCAAAGAGGUAUUGACGUGUCCACCAUACGAUUUACAUUCGCCGAACGCCGCCCGAAUGUCUGCCCCGGAUUCGGUAUUGCCAUCUUAGUGCGUAGAACUGAAAAAGUGGUAGGUUCGGGAAAGAGAUGGGCGCCCCUUGUGGUCUGGGCGUCAAGAGAACAGUUGGUGUGGAGUAACAAAGUUCGCGUUAUUUACUUCGCUUAUGGGCAAUGUGUGGAACCACGCCGUGCAGCCGGUCGCUUGUGCUUCCUACAAAGGGAUCUACGCCGCAAACCCGCCUACAUAAAGCUUGCACUCCAGACCCGUGGGCCCAUGGCGGACCAUCCCUAUAUCGGUCGAAUCUUCCUGCUCAACUGCAGACACUGCAGGAGUCCUACUUUAUUGCAGGACUCCGCAGCCCGGCUGUGCGAUAAGCAUAGCUACGUUUCGACGGCUCUGCUAUGGGUUCGACGAAGCACCAUACUGACCCUCCAAACGAACUCCCUGUGCUAUCCUCGUUCCCGCUCUGCAGGGGAACCUCAGGAAAGAGCGUCCAUGCUCGCGCUACGCUUACGUAAGGCCCCCCAUAUUUGUGCGUAG\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'MSSSHLPSKLPGARPLYPWITQMFSYLANPLPVRSFSSRGCCLSQKRHYTSHGMGAHRDPSTREARTLVRPCDPTTQGCFQENIFAVTILVASSRSVRLYTPTTPSHSCMHWVLWYSKATYRWCLCHPFSYLNLDELLLDLLRGSIRNRMHQIVVCRGSAFVVGLKIYTARATLRLPPRAPPCSTDLRVGGSDKTRSVLSLWIDGSLMMLISTLSYYRCLAKYPDTQNDRSSVSSAPRVATDLTKVETPGLGSVGPSRAACICGKRLSNPHTIVSGLPVAELDLDCPRTKRLDCQRSSCGIHRIAVTGFPLDRLYVLHLDYKYTILRLEQTMPPRCLHAGRRSFVLYAQGSTSPHFNSSIALGTVMPLPGFLRCRGYDSRYYPIVVPALLRSPPRRIWWSLNYATCILPFVPTIRSALTHLIPDSARMVKTRPHRNAVFHVGTGHRNQRSAQTQIEVVLHCTHARAYTVYGFNSSTLNGETVDPSSQVSYNSGTVIFCCPHPRNCLYVRLSSIIHGIRIAEPVWRSIYRVQLRCSIRVAVDERCPYSQDTIGVPCLRRDSLNTNKPLIDRSLLKCHYVPELRLNLCPVDRVVNARVHVREINEGPIAVGVAFLGPKGIRPVMSHRRVVFIPRSYLILYICIQWVCIGRCSTCHWFWTLGLFVCNVYGTSTRLRAHGSNGEMTVYMGIGCRNNIIMDVLSLRGELTTPATVISALETGDTCLKNRIRAPFSGAPRRRLSQNEVNHHLSCNMRVTDSHLINNNACLRWKTSPVARCSSTPMVRIVKKTPSRDMFYAPEPDHNESERGFTTPVSYPALLAQPCWFCISILLEHISNRPRAGESELYHEFITHRGVSARQRCTADQFDSESLHPLATIAHSATCVSYVAELLTPQSDKSTHGRRHKSATSISIGGTSNSAYRPEVGSTSTVGAMVLDLLIVRDASCPVALAVQGQQSQVFGVQRVAPSLVRNGGWCCSSKRDTGRRPTISTLRDRVEDVYFSTLVLNVIRRDVFVSSKAGGVRVHSVPATGCPINTPIVIGLSWESLHKPFDVRSNCMSPCELSRFQKLFRWSIVRRQDREFILGQCTHPPPDILRGYYRPLAFLKTKSFNINSNRAGVQLVKNIGRHLRVTLRAIDLSDSRGSIGPSGAIMQKFNCNSNYRGFIHEQSFACLIMNRVPKQLPLRRSSHDEPGWSVSPTRSTPPVLMLPRLLLWCPQCFLRHSAIPLVRQILQTGNIGGAYKSVCMSYIPRGYGHHHRELYRNAYWGQFRKYVTSYGRVELKTGVLGLAIAIFCEYDDVPVIRPPNSTTPFTHSSKHCMRLSFPSTEDAQLKHYLRVCPLSFLRTAMVQGNRPSKLSRSSRKLVTSFRQTRQQSEVQRIHGVVLGFEGVVIWLESLAGSLLASTSYWRRGLDAITRKQMDGLSMHSSRAIGCPLYQWPTCIPRSYREACVTWRSNSVRPTRTDVSMKSVGHRGLLPRQLSRKSSIGNIRPQPQTWSTTHVARPAQRGGKSRTGQLIHLRAPLNRTFGSDLQLLDQRRNVERGGSSAALYWGSVRGTVVTRIPATRISWHRPKNPFLELPTAQSSGADREQQAEGAGYSLHLVVRITRNVDTPIACGLLLPLLTPLVSHVSSCTSFRVLKPLVPYIMMSTLVSRKGGSFVFHTTTFGMGADMRGLNSRLQTWPTFCGVSISCESNITICQRVLSTASTNTLLIFHTCHPSRAQKPSPDADPAKELVMARVSLSLRKSSRPRFVDPKGSTVAKHSVTLRGVPPNPPARLYECMHARRLTAIMNIREFRRCWHSTILFRDGGISQGLRYQLPEKPGSSVNLTGYGRHEATLHANVSRYRVVGQMISVFSLFIRGGRRFSLSDSADCHEDGPCKNNKARRALSADSDRPGVVYLSCRNWPSLARCNMASLYSTSATRSPGQIDCVMHIQPLLHSELGPLALVYKVAVGEHTRTSKGSEANLRSVERRPCLVVAGVISTEDRRMFSRGDSPDQPQSLRQPLLHAHCGLTQAVSHHDEIESVRSRSVFFKSLRQAEIFLFEGSGLGAGAPHALHVQGGLQHELRSQAPFEPQLQEGVSWRRRKDHPSGSISGINAADESRLWGAYVGSIIPLLRTRISSPCTVDARGTRRYVPIVSYYSESARLLARGLQQNCPKRRLNAALGLAVPALPTVTSSTSMELNFKRTHCYGAVVRQVGRRPRDLNIRHRRLMCLDLCIPRGNHAPSAVVGELRRSDPPHALKLACKYGVSYADRILAGLVPPPPPAQLAQRWAINRVCCDKKAPLLGFRLDYLRCCIKGRSQSRRRLKHHNVRPTTFSSRGTNFEHHRTCSSVTLGWTRTSLRQFYQRYRIQGCGHNRPGACNTWSRESHKPVTRSQLWHYKMDMPVVNGSDHPRAKTTASTPYSMYDWLSPWRKLLERWEFGHYLAERDIRGTISHLTSNARSIDQLMSTSSLVSGLASTVYDLSVSAQVRALISPLGLASAQCLVAAIYHWPSDGVSLLEYQHGRKSCKRCTVCSVMIKCRELFFGKYPAWTDIIHLGRVCTTRNHTSLSSRRLILFRGATKTQQKRRALLVRTLRTCSRINRFKTILRHFSVRIVTVNSRARIKGAEEIHEEAGGSRLPYFMIEPIISIKPPTCAARLSERYPVFYPIPQEWVSIVIMYAVTSHKSISQSNPLAGLNVRELTGKSGRLRGRSVPTPPSRARDSFSRLIKCLSERAAVGVMSQISDHVTERGKTVTPSRYPKIAIRKLWAPCTLKLVVTSARGLESPTSRLLWRAPLNPRLKGTTEDLRLIECPQSNIFPRPLMPLCIIHEGTFQCSIQWKSGAGTGAAPPTNLDSLVCHDVRNSVRSKDSPGVCKRPGCNIEVLPGPQSRSLPGTRDMRYPSRRELNMTSAEIQRGIDVSTIRFTFAERRPNVCPGFGIAILVRRTEKVVGSGKRWAPLVVWASREQLVWSNKVRVIYFAYGQCVEPRRAAGRLCFLQRDLRRKPAYIKLALQTRGPMADHPYIGRIFLLNCRHCRSPTLLQDSAARLCDKHSYVSTALLWVRRSTILTLQTNSLCYPRSRSAGEPQERASMLALRLRKAPHICA'"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "translate(seq.replace(\"U\", \"T\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Haystack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [],
   "source": [
    "h = \"GATATATGCATATACTT\"\n",
    "n = \"ATAT\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [],
   "source": [
    "def kmers(seq, n=4):\n",
    "    return [(k + 1, seq[k:k+n]) for k in range(0, len(seq) - n)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find(hay: str, pin: str) -> List[int]:\n",
    "    pos = [pos for pos, kmer in kmers(hay, len(pin)) if kmer == pin]\n",
    "    print(\" \".join([str(loc) for loc in pos]))\n",
    "    return pos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 4 10\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[2, 4, 10]"
      ]
     },
     "execution_count": 278,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find(h, n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {},
   "outputs": [],
   "source": [
    "h = \"TACTACAGTAGACTACAGTGCATCCAACGCTACAGTCTACAGTGGCCTACAGTCGCGCTACAGTGGCCACTACAGTGACCTACAGTACGAGCTACAGTCTACAGTCTACAGTGCACTACAGTTCTACAGTCAGCTACAGTACTACAGTTATAGACACTACAGTTTGCGTTTCTACAGTTCTCTACAGTTAGGCTACAGTCCTACAGTCTACAGTGTTTACTACAGTTTCTACAGTCTACAGTGCTCGGGCTACAGTCTACAGTATGTCTACAGTCGCTACAGTTCAGCTACAGTTCCTACAGTTCCCGCTACAGTTCTACAGTATGCCCCTACAGTGCATACTACAGTTCTACAGTTGCTACAGTCTACAGTCTACAGTGCTACAGTCTACAGTCTACAGTCGTCTACAGTGCTCTACAGTCTACAGTCTACAGTTCCCTACAGTCGACCTACAGTGAAACGATACTACAGTACTACAGTACCTACAGTCCATAGCCTACAGTACTACAGTTCCAAACTTAATCAATGCTACAGTTACGCTACAGTCTACAGTCTACAGTTCTACAGTTACGCTACAGTTCTACAGTCGCCCTACAGTACTACAGTCTACAGTCAACTACAGTCTACAGTTCTACAGTCGCTACAGTCTCTACAGTCTACAGTGCCTACAGTGAATCTACAGTCTACAGTCTACAGTTCTCTACAGTCCCTACAGTCCTACAGTGCCTGACTGGTTCTACAGTACGCCTACAGTCTACAGTTGACTACAGTGACTACAGTCTACAGTCTACAGTAGGGG\"\n",
    "n = \"CTACAGTCT\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30 92 99 201 229 250 359 366 381 388 415 422 540 547 600 617 641 650 677 684 748 774 781\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[30,\n",
       " 92,\n",
       " 99,\n",
       " 201,\n",
       " 229,\n",
       " 250,\n",
       " 359,\n",
       " 366,\n",
       " 381,\n",
       " 388,\n",
       " 415,\n",
       " 422,\n",
       " 540,\n",
       " 547,\n",
       " 600,\n",
       " 617,\n",
       " 641,\n",
       " 650,\n",
       " 677,\n",
       " 684,\n",
       " 748,\n",
       " 774,\n",
       " 781]"
      ]
     },
     "execution_count": 280,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find(h, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate consensus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "fa = \"\"\">Rosalind_1\n",
    "ATCCAGCT\n",
    ">Rosalind_2\n",
    "GGGCAACT\n",
    ">Rosalind_3\n",
    "ATGGATCT\n",
    ">Rosalind_4\n",
    "AAGCAACC\n",
    ">Rosalind_5\n",
    "TTGGAACT\n",
    ">Rosalind_6\n",
    "ATGCCATT\n",
    ">Rosalind_7\n",
    "ATGGCACT\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fa2seq(fa: str) -> str:\n",
    "    return [seq.replace(\"\\n\", \"\") for read, seq in [read.split(\"\\n\", 1) for read in fa.split(\">\")[1:]]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = fa2seq(fa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A', 'G', 'A', 'A', 'T', 'A', 'A'),\n",
       " ('T', 'G', 'T', 'A', 'T', 'T', 'T'),\n",
       " ('C', 'G', 'G', 'G', 'G', 'G', 'G'),\n",
       " ('C', 'C', 'G', 'C', 'G', 'C', 'G'),\n",
       " ('A', 'A', 'A', 'A', 'A', 'C', 'C'),\n",
       " ('G', 'A', 'T', 'A', 'A', 'A', 'A'),\n",
       " ('C', 'C', 'C', 'C', 'C', 'T', 'C'),\n",
       " ('T', 'T', 'T', 'C', 'T', 'T', 'T')]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(*seq))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<zip at 0x7f7320f6f040>]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[ zip(*seq)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def consmat(seqs: List[str]):\n",
    "    return { base: [seq.count(base) for seq in zip(*seqs)] for base in \"ACGT\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cons(seqs: List[str]) -> str:\n",
    "    return \"\".join([Counter(seq).most_common(1)[0][0] for seq in zip(*seqs)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ATGCAACT\n",
      "A: 5 1 0 0 5 5 0 0\n",
      "C: 0 0 1 4 2 0 6 1\n",
      "G: 1 1 6 3 0 1 0 0\n",
      "T: 1 5 0 0 0 1 1 6\n"
     ]
    }
   ],
   "source": [
    "fa = \"\"\">Rosalind_1\n",
    "ATCCAGCT\n",
    ">Rosalind_2\n",
    "GGGCAACT\n",
    ">Rosalind_3\n",
    "ATGGATCT\n",
    ">Rosalind_4\n",
    "AAGCAACC\n",
    ">Rosalind_5\n",
    "TTGGAACT\n",
    ">Rosalind_6\n",
    "ATGCCATT\n",
    ">Rosalind_7\n",
    "ATGGCACT\n",
    "\"\"\"\n",
    "\n",
    "seqs = fa2seq(fa)\n",
    "\n",
    "mat = consmat(seqs)\n",
    "\n",
    "string = cons(seqs)\n",
    "\n",
    "print(string)\n",
    "print(\"\\n\".join([(f\"{base}: {' '.join(map(str, counts))}\") for base, counts in mat.items()]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A: 5 1 0 0 5 5 0 0\n",
      "C: 0 0 1 4 2 0 6 1\n",
      "G: 1 1 6 3 0 1 0 0\n",
      "T: 1 5 0 0 0 1 1 6\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n\".join([(f\"{base}: {' '.join(map(str, counts))}\") for base, counts in mat.items()]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22.5 µs ± 2.13 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit \"\".join([Counter(seq).most_common(1)[0][0] for seq in zip(*seqs)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Counter in module collections:\n",
      "\n",
      "class Counter(builtins.dict)\n",
      " |  Counter(iterable=None, /, **kwds)\n",
      " |  \n",
      " |  Dict subclass for counting hashable items.  Sometimes called a bag\n",
      " |  or multiset.  Elements are stored as dictionary keys and their counts\n",
      " |  are stored as dictionary values.\n",
      " |  \n",
      " |  >>> c = Counter('abcdeabcdabcaba')  # count elements from a string\n",
      " |  \n",
      " |  >>> c.most_common(3)                # three most common elements\n",
      " |  [('a', 5), ('b', 4), ('c', 3)]\n",
      " |  >>> sorted(c)                       # list all unique elements\n",
      " |  ['a', 'b', 'c', 'd', 'e']\n",
      " |  >>> ''.join(sorted(c.elements()))   # list elements with repetitions\n",
      " |  'aaaaabbbbcccdde'\n",
      " |  >>> sum(c.values())                 # total of all counts\n",
      " |  15\n",
      " |  \n",
      " |  >>> c['a']                          # count of letter 'a'\n",
      " |  5\n",
      " |  >>> for elem in 'shazam':           # update counts from an iterable\n",
      " |  ...     c[elem] += 1                # by adding 1 to each element's count\n",
      " |  >>> c['a']                          # now there are seven 'a'\n",
      " |  7\n",
      " |  >>> del c['b']                      # remove all 'b'\n",
      " |  >>> c['b']                          # now there are zero 'b'\n",
      " |  0\n",
      " |  \n",
      " |  >>> d = Counter('simsalabim')       # make another counter\n",
      " |  >>> c.update(d)                     # add in the second counter\n",
      " |  >>> c['a']                          # now there are nine 'a'\n",
      " |  9\n",
      " |  \n",
      " |  >>> c.clear()                       # empty the counter\n",
      " |  >>> c\n",
      " |  Counter()\n",
      " |  \n",
      " |  Note:  If a count is set to zero or reduced to zero, it will remain\n",
      " |  in the counter until the entry is deleted or the counter is cleared:\n",
      " |  \n",
      " |  >>> c = Counter('aaabbc')\n",
      " |  >>> c['b'] -= 2                     # reduce the count of 'b' by two\n",
      " |  >>> c.most_common()                 # 'b' is still in, but its count is zero\n",
      " |  [('a', 3), ('c', 1), ('b', 0)]\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Counter\n",
      " |      builtins.dict\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |      Add counts from two counters.\n",
      " |      \n",
      " |      >>> Counter('abbb') + Counter('bcc')\n",
      " |      Counter({'b': 4, 'c': 2, 'a': 1})\n",
      " |  \n",
      " |  __and__(self, other)\n",
      " |      Intersection is the minimum of corresponding counts.\n",
      " |      \n",
      " |      >>> Counter('abbb') & Counter('bcc')\n",
      " |      Counter({'b': 1})\n",
      " |  \n",
      " |  __delitem__(self, elem)\n",
      " |      Like dict.__delitem__() but does not raise KeyError for missing values.\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      True if all counts agree. Missing counts are treated as zero.\n",
      " |  \n",
      " |  __ge__(self, other)\n",
      " |      True if all counts in self are a superset of those in other.\n",
      " |  \n",
      " |  __gt__(self, other)\n",
      " |      True if all counts in self are a proper superset of those in other.\n",
      " |  \n",
      " |  __iadd__(self, other)\n",
      " |      Inplace add from another counter, keeping only positive counts.\n",
      " |      \n",
      " |      >>> c = Counter('abbb')\n",
      " |      >>> c += Counter('bcc')\n",
      " |      >>> c\n",
      " |      Counter({'b': 4, 'c': 2, 'a': 1})\n",
      " |  \n",
      " |  __iand__(self, other)\n",
      " |      Inplace intersection is the minimum of corresponding counts.\n",
      " |      \n",
      " |      >>> c = Counter('abbb')\n",
      " |      >>> c &= Counter('bcc')\n",
      " |      >>> c\n",
      " |      Counter({'b': 1})\n",
      " |  \n",
      " |  __init__(self, iterable=None, /, **kwds)\n",
      " |      Create a new, empty Counter object.  And if given, count elements\n",
      " |      from an input iterable.  Or, initialize the count from another mapping\n",
      " |      of elements to their counts.\n",
      " |      \n",
      " |      >>> c = Counter()                           # a new, empty counter\n",
      " |      >>> c = Counter('gallahad')                 # a new counter from an iterable\n",
      " |      >>> c = Counter({'a': 4, 'b': 2})           # a new counter from a mapping\n",
      " |      >>> c = Counter(a=4, b=2)                   # a new counter from keyword args\n",
      " |  \n",
      " |  __ior__(self, other)\n",
      " |      Inplace union is the maximum of value from either counter.\n",
      " |      \n",
      " |      >>> c = Counter('abbb')\n",
      " |      >>> c |= Counter('bcc')\n",
      " |      >>> c\n",
      " |      Counter({'b': 3, 'c': 2, 'a': 1})\n",
      " |  \n",
      " |  __isub__(self, other)\n",
      " |      Inplace subtract counter, but keep only results with positive counts.\n",
      " |      \n",
      " |      >>> c = Counter('abbbc')\n",
      " |      >>> c -= Counter('bccd')\n",
      " |      >>> c\n",
      " |      Counter({'b': 2, 'a': 1})\n",
      " |  \n",
      " |  __le__(self, other)\n",
      " |      True if all counts in self are a subset of those in other.\n",
      " |  \n",
      " |  __lt__(self, other)\n",
      " |      True if all counts in self are a proper subset of those in other.\n",
      " |  \n",
      " |  __missing__(self, key)\n",
      " |      The count of elements not in the Counter is zero.\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      True if any counts disagree. Missing counts are treated as zero.\n",
      " |  \n",
      " |  __neg__(self)\n",
      " |      Subtracts from an empty counter.  Strips positive and zero counts,\n",
      " |      and flips the sign on negative counts.\n",
      " |  \n",
      " |  __or__(self, other)\n",
      " |      Union is the maximum of value in either of the input counters.\n",
      " |      \n",
      " |      >>> Counter('abbb') | Counter('bcc')\n",
      " |      Counter({'b': 3, 'c': 2, 'a': 1})\n",
      " |  \n",
      " |  __pos__(self)\n",
      " |      Adds an empty counter, effectively stripping negative and zero counts\n",
      " |  \n",
      " |  __reduce__(self)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __repr__(self)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |      Subtract count, but keep only results with positive counts.\n",
      " |      \n",
      " |      >>> Counter('abbbc') - Counter('bccd')\n",
      " |      Counter({'b': 2, 'a': 1})\n",
      " |  \n",
      " |  copy(self)\n",
      " |      Return a shallow copy.\n",
      " |  \n",
      " |  elements(self)\n",
      " |      Iterator over elements repeating each as many times as its count.\n",
      " |      \n",
      " |      >>> c = Counter('ABCABC')\n",
      " |      >>> sorted(c.elements())\n",
      " |      ['A', 'A', 'B', 'B', 'C', 'C']\n",
      " |      \n",
      " |      # Knuth's example for prime factors of 1836:  2**2 * 3**3 * 17**1\n",
      " |      >>> import math\n",
      " |      >>> prime_factors = Counter({2: 2, 3: 3, 17: 1})\n",
      " |      >>> math.prod(prime_factors.elements())\n",
      " |      1836\n",
      " |      \n",
      " |      Note, if an element's count has been set to zero or is a negative\n",
      " |      number, elements() will ignore it.\n",
      " |  \n",
      " |  most_common(self, n=None)\n",
      " |      List the n most common elements and their counts from the most\n",
      " |      common to the least.  If n is None, then list all element counts.\n",
      " |      \n",
      " |      >>> Counter('abracadabra').most_common(3)\n",
      " |      [('a', 5), ('b', 2), ('r', 2)]\n",
      " |  \n",
      " |  subtract(self, iterable=None, /, **kwds)\n",
      " |      Like dict.update() but subtracts counts instead of replacing them.\n",
      " |      Counts can be reduced below zero.  Both the inputs and outputs are\n",
      " |      allowed to contain zero and negative counts.\n",
      " |      \n",
      " |      Source can be an iterable, a dictionary, or another Counter instance.\n",
      " |      \n",
      " |      >>> c = Counter('which')\n",
      " |      >>> c.subtract('witch')             # subtract elements from another iterable\n",
      " |      >>> c.subtract(Counter('watch'))    # subtract elements from another counter\n",
      " |      >>> c['h']                          # 2 in which, minus 1 in witch, minus 1 in watch\n",
      " |      0\n",
      " |      >>> c['w']                          # 1 in which, minus 1 in witch, minus 1 in watch\n",
      " |      -1\n",
      " |  \n",
      " |  total(self)\n",
      " |      Sum of the counts\n",
      " |  \n",
      " |  update(self, iterable=None, /, **kwds)\n",
      " |      Like dict.update() but add counts instead of replacing them.\n",
      " |      \n",
      " |      Source can be an iterable, a dictionary, or another Counter instance.\n",
      " |      \n",
      " |      >>> c = Counter('which')\n",
      " |      >>> c.update('witch')           # add elements from another iterable\n",
      " |      >>> d = Counter('watch')\n",
      " |      >>> c.update(d)                 # add elements from another counter\n",
      " |      >>> c['h']                      # four 'h' in which, witch, and watch\n",
      " |      4\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  fromkeys(iterable, v=None) from builtins.type\n",
      " |      Create a new dictionary with keys from iterable and values set to value.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __hash__ = None\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from builtins.dict:\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      True if the dictionary has the specified key, else False.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(...)\n",
      " |      x.__getitem__(y) <==> x[y]\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __reversed__(self, /)\n",
      " |      Return a reverse iterator over the dict keys.\n",
      " |  \n",
      " |  __ror__(self, value, /)\n",
      " |      Return value|self.\n",
      " |  \n",
      " |  __setitem__(self, key, value, /)\n",
      " |      Set self[key] to value.\n",
      " |  \n",
      " |  __sizeof__(...)\n",
      " |      D.__sizeof__() -> size of D in memory, in bytes\n",
      " |  \n",
      " |  clear(...)\n",
      " |      D.clear() -> None.  Remove all items from D.\n",
      " |  \n",
      " |  get(self, key, default=None, /)\n",
      " |      Return the value for key if key is in the dictionary, else default.\n",
      " |  \n",
      " |  items(...)\n",
      " |      D.items() -> a set-like object providing a view on D's items\n",
      " |  \n",
      " |  keys(...)\n",
      " |      D.keys() -> a set-like object providing a view on D's keys\n",
      " |  \n",
      " |  pop(...)\n",
      " |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n",
      " |      \n",
      " |      If the key is not found, return the default if given; otherwise,\n",
      " |      raise a KeyError.\n",
      " |  \n",
      " |  popitem(self, /)\n",
      " |      Remove and return a (key, value) pair as a 2-tuple.\n",
      " |      \n",
      " |      Pairs are returned in LIFO (last-in, first-out) order.\n",
      " |      Raises KeyError if the dict is empty.\n",
      " |  \n",
      " |  setdefault(self, key, default=None, /)\n",
      " |      Insert key with a value of default if key is not in the dictionary.\n",
      " |      \n",
      " |      Return the value for key if key is in the dictionary, else default.\n",
      " |  \n",
      " |  values(...)\n",
      " |      D.values() -> an object providing a view on D's values\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from builtins.dict:\n",
      " |  \n",
      " |  __class_getitem__(...) from builtins.type\n",
      " |      See PEP 585\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from builtins.dict:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "f\"\"\"\n",
    "{cons(seqs)}\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A': [5, 1, 0, 0, 5, 5, 0, 0],\n",
       " 'C': [0, 0, 1, 4, 2, 0, 6, 1],\n",
       " 'G': [1, 1, 6, 3, 0, 1, 0, 0],\n",
       " 'T': [1, 5, 0, 0, 0, 1, 1, 6]}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[35], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m consmat(seqs)\n",
      "Cell \u001b[0;32mIn[14], line 2\u001b[0m, in \u001b[0;36mconsmat\u001b[0;34m(seqs)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mconsmat\u001b[39m(seqs: List[\u001b[39mstr\u001b[39m]):\n\u001b[0;32m----> 2\u001b[0m     \u001b[39mreturn\u001b[39;00m { base: [(count \u001b[39m:=\u001b[39;49m seq\u001b[39m.\u001b[39;49mcount(base), \u001b[39mmax\u001b[39;49m(count)) \u001b[39mfor\u001b[39;49;00m seq \u001b[39min\u001b[39;49;00m \u001b[39mzip\u001b[39;49m(\u001b[39m*\u001b[39;49mseqs)] \u001b[39mfor\u001b[39;49;00m base \u001b[39min\u001b[39;49;00m \u001b[39m\"\u001b[39;49m\u001b[39mACGT\u001b[39;49m\u001b[39m\"\u001b[39;49m}\n",
      "Cell \u001b[0;32mIn[14], line 2\u001b[0m, in \u001b[0;36m<dictcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mconsmat\u001b[39m(seqs: List[\u001b[39mstr\u001b[39m]):\n\u001b[0;32m----> 2\u001b[0m     \u001b[39mreturn\u001b[39;00m { base: [(count \u001b[39m:=\u001b[39;49m seq\u001b[39m.\u001b[39;49mcount(base), \u001b[39mmax\u001b[39;49m(count)) \u001b[39mfor\u001b[39;49;00m seq \u001b[39min\u001b[39;49;00m \u001b[39mzip\u001b[39;49m(\u001b[39m*\u001b[39;49mseqs)] \u001b[39mfor\u001b[39;00m base \u001b[39min\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mACGT\u001b[39m\u001b[39m\"\u001b[39m}\n",
      "Cell \u001b[0;32mIn[14], line 2\u001b[0m, in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mconsmat\u001b[39m(seqs: List[\u001b[39mstr\u001b[39m]):\n\u001b[0;32m----> 2\u001b[0m     \u001b[39mreturn\u001b[39;00m { base: [(count \u001b[39m:=\u001b[39m seq\u001b[39m.\u001b[39mcount(base), \u001b[39mmax\u001b[39;49m(count)) \u001b[39mfor\u001b[39;00m seq \u001b[39min\u001b[39;00m \u001b[39mzip\u001b[39m(\u001b[39m*\u001b[39mseqs)] \u001b[39mfor\u001b[39;00m base \u001b[39min\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mACGT\u001b[39m\u001b[39m\"\u001b[39m}\n",
      "\u001b[0;31mTypeError\u001b[0m: 'int' object is not iterable"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'5 1 0 0 5 5 0 0'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\" \".join(map(str, [5, 1, 0, 0, 5, 5, 0, 0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CCTAGGTTAGTAGATTCAATGGGGAAGCCTATGGTTCTGGTACGTTATTTATGAACCCGTCCCTTCATATGAAACCTTACGCTTACTTCGGTGTGAGAGCCTCGGTTCGTTCCTCACTCGGCTGCCACGTAAGAGCGCGGTCTGCCAACCCATCAGGGAGTGAAAGCTTCGTGAGGCTAAACTATTAAAGATGTTTGCCAGTGCATATGTGTAAGATCTCTTACTTAGCGACGAGCACCGGCCCAAGTGGAGAATTACTTAAGGGTACAGTATAGGATTTATGGAACCGTGCTTATCACACAGAAGGAAGTCGCGCTATCCCTCTGATGGGTCTTAGATCATCCATCCGTCCGGGAGTACGCTAACCTAAGTCTAGAAGAAGCGAAGTCTCTCTGGGCCATCCGATTGCTCCACAACCTGCCGAAACCACGAATAACGATTGTTATGAATTTTGTGGAAGTGTTGAATAGCTGAGAGAATGAAACGCGGCTGTCGCTGGCGGTTTCGGTGTAACAATCGGATATATCATCATACCCGCCGTCCGCTTGCGTGAGTATTGCAGGCCATTATGGCAAGAATCGATTGGTAATCCTGACGCACGGCTAAGCTCAAGCAGCTTTTATTCTGCACGAATCCCGAGGTGTTGGGACCTACGCCTTACGAAGCTGAAGGAAGTTTACCGGGGCTGAGTACGACGAGAATGGCCAACCTTGGGTGCGATGTGGGACGGAAATCAATTCGCTAGCAAACGACAATAGCTTGCAAGTGTAGCCGTCATCGCGATTTATCGGGATACACCGCCCTTATCGTAGTAAGTAAACACTATAGTTTATGCTACGACAGGTGCTCGGGCTGCCTCTAATCAAGTGCACGGCTCATAGGCGCGAATCCGCGGCGCAGGCGTGAAACGCTAATCAGTGGGATAGGGACACACGCGATGGCTTCGAGACTGAGAATGTTACCACGAATGCTCCCGAAGTGCG\n",
      "A: 2 1 2 3 1 3 2 1 5 2 2 3 2 4 2 1 3 4 4 2 2 3 4 2 4 4 3 2 3 1 4 3 2 3 2 2 1 0 1 4 0 3 3 1 2 2 5 1 2 3 4 3 2 5 7 2 2 3 0 3 2 2 0 4 3 3 5 3 3 1 1 3 4 5 3 0 3 3 4 0 0 3 3 3 5 0 2 2 3 1 0 2 3 1 3 4 2 4 1 3 2 2 4 2 3 2 1 4 2 1 3 1 1 3 2 5 0 1 0 3 2 3 3 1 1 2 5 2 2 2 3 4 4 5 2 2 1 3 1 1 1 3 0 0 1 2 6 3 2 1 1 4 3 2 5 1 1 2 3 2 3 1 3 4 4 3 2 2 1 2 3 3 1 4 1 1 1 2 6 3 4 1 3 4 2 1 4 3 4 3 5 1 3 0 2 2 3 1 3 6 3 2 2 3 6 2 3 2 1 3 2 1 5 4 0 4 2 2 3 2 3 1 4 1 1 2 3 3 0 1 4 0 0 4 3 2 4 1 3 0 3 2 2 4 5 4 1 2 2 2 3 1 4 4 2 3 5 3 3 4 3 4 0 3 2 2 4 3 6 3 2 4 3 3 2 2 6 2 1 3 3 0 3 0 3 5 3 1 0 1 2 2 2 3 4 3 1 4 2 4 1 6 1 4 4 3 2 4 6 0 2 3 2 2 2 1 2 5 1 1 3 2 1 2 2 4 4 3 1 2 0 1 2 0 3 3 2 3 1 2 3 2 1 3 5 2 0 2 2 3 2 3 2 1 3 5 3 2 4 3 0 1 2 4 3 2 3 1 5 4 4 2 3 2 6 3 5 4 3 5 5 3 2 3 3 3 2 1 1 2 0 2 4 3 3 3 2 2 2 5 2 3 3 1 4 2 3 3 3 2 3 3 3 2 3 3 1 1 1 3 2 3 3 4 4 3 3 2 4 2 3 5 4 3 5 3 3 0 3 3 3 2 1 3 7 1 1 5 4 3 1 2 2 3 3 1 3 4 5 2 1 3 2 3 1 4 4 1 5 3 2 0 2 4 0 3 2 4 4 2 2 5 4 6 2 1 2 0 2 1 3 3 3 2 3 3 4 1 0 3 0 2 1 3 3 3 0 3 1 3 3 4 4 2 3 4 3 2 2 4 4 2 5 2 6 2 3 4 3 3 5 2 4 0 3 2 1 4 1 2 2 2 3 2 2 2 3 2 1 3 3 1 6 1 4 3 2 2 1 3 4 0 3 1 1 4 2 2 4 1 3 1 2 3 4 1 4 3 1 0 2 4 1 2 2 1 2 4 5 0 2 2 3 1 4 3 3 1 4 1 0 2 2 2 4 4 2 2 2 3 5 3 1 1 4 3 1 2 3 1 2 4 2 2 3 2 3 3 4 2 1 5 3 3 2 2 0 1 4 1 2 1 1 2 3 2 2 2 4 3 3 3 6 2 2 0 2 2 2 3 2 2 6 5 1 2 3 2 3 5 3 2 5 7 2 1 0 2 6 3 4 1 1 0 2 3 2 2 5 2 2 4 2 1 3 3 1 4 1 4 5 1 1 1 1 3 4 4 3 3 3 3 3 1 1 2 1 1 3 3 2 4 1 1 3 2 4 2 1 0 4 3 4 0 3 7 3 1 1 1 3 3 1 4 1 1 5 4 4 3 3 4 2 5 4 4 3 2 2 3 1 1 3 4 5 3 3 3 3 6 1 3 2 2 3 4 4 2 2 3 1 3 3 2 3 1 3 3 3 1 3 2 3 3 3 2 4 3 3 1 2 3 2 2 3 4 1 1 3 2 3 3 2 4 3 3 0 4 4 4 2 3 0 3 3 2 4 2 3 1 2 6 2 3 1 3 4 3 2 4 2 4 3 2 2 2 3 0 3 1 1 1 3 2 2 3 2 2 2 3 4 5 2 3 3 4 2 1 1 0 4 2 1 0 1 1 2 5 2 4 1 1 3 2 1 0 5 4 2 2 2 3 2 1 3 1 2 3 5 3 1 2 2 2 0 5 5 4 3 1 2 2 4 4 2 1 4 1 0 0 3 2 3 3 8 3 1 2 5 2 4 0 5 3 3 2 2 5 1 2 2 2 2 1 3 3 4 2 4 2 3 1 5 3 3 5 3 0 1 1 4 2 0 5 3 2 3 4 2 2 3 3 2 3 2 3 5 4 2 1 1 2 2\n",
      "C: 5 3 2 2 1 2 3 1 2 1 2 2 2 3 1 0 5 3 2 2 2 1 1 2 1 3 1 4 4 3 2 3 3 1 2 2 5 3 2 2 3 2 3 2 2 3 2 2 3 1 4 2 3 1 2 4 3 3 3 3 4 4 4 0 3 4 2 0 2 2 1 3 2 0 3 4 2 2 3 5 3 4 3 0 1 5 3 2 4 3 3 3 2 1 1 1 2 0 3 4 4 2 4 2 2 3 3 4 2 2 3 4 5 1 4 2 6 4 5 0 1 4 2 1 4 5 3 4 1 2 3 3 1 2 1 4 3 3 3 3 0 4 1 4 5 4 3 3 3 4 4 3 3 3 1 2 1 2 2 2 1 3 2 4 1 2 4 1 2 3 1 1 3 3 3 2 4 3 3 3 3 5 2 2 2 3 2 2 2 2 3 3 1 1 1 1 0 5 3 0 1 2 2 3 1 2 3 2 2 2 2 2 4 4 3 1 1 5 2 4 1 1 2 3 2 1 2 2 5 2 2 5 3 1 2 3 2 3 4 3 1 4 4 4 3 2 0 2 1 2 3 1 2 1 0 1 2 4 1 0 3 3 3 1 2 2 2 4 1 0 3 3 2 3 2 2 1 3 3 0 3 2 0 4 3 3 3 4 1 4 4 6 2 2 0 3 4 2 3 4 4 3 2 3 3 1 1 3 0 2 2 3 1 4 2 5 3 0 2 4 4 3 3 3 1 1 3 2 2 1 3 1 5 2 2 1 1 2 2 5 1 1 6 4 1 2 5 5 3 1 3 4 2 3 2 2 1 1 2 4 1 4 1 1 3 4 3 2 1 1 0 1 3 2 2 0 2 3 1 2 3 3 4 1 2 2 2 1 6 2 4 3 4 2 2 1 2 3 3 1 3 3 3 2 3 1 2 2 4 2 4 5 2 7 3 3 5 7 2 2 3 5 0 2 4 3 5 5 3 4 1 2 3 2 3 2 4 3 2 2 1 2 3 2 1 2 4 2 1 2 1 2 2 3 3 2 1 2 1 3 3 2 0 1 2 1 0 2 2 2 4 2 1 2 4 3 1 3 1 2 3 0 3 1 4 1 4 2 1 5 2 0 2 3 1 3 0 3 3 4 1 2 1 2 2 3 2 0 2 3 2 1 1 3 2 1 3 5 1 1 2 1 2 2 1 1 4 2 1 4 2 1 1 5 3 3 2 4 5 3 3 3 4 1 4 2 2 2 5 0 1 1 0 1 1 3 2 3 3 4 3 2 2 4 4 1 2 2 2 4 1 3 4 2 1 4 1 2 2 4 1 3 3 3 3 2 2 2 2 4 3 4 1 1 3 4 3 3 0 5 1 0 5 2 3 1 2 4 1 3 2 2 2 4 2 1 5 3 3 1 2 1 3 3 3 2 3 4 1 5 2 1 2 2 4 4 4 1 2 3 1 1 4 1 3 2 3 1 2 4 3 2 3 4 2 5 4 3 1 2 5 3 1 2 2 4 2 2 2 4 2 3 2 1 2 2 2 2 1 3 4 1 4 3 2 3 2 3 1 3 1 2 4 3 2 4 3 3 3 2 2 2 1 3 4 3 3 3 4 4 2 2 1 2 2 0 0 4 3 2 0 1 3 0 1 2 2 5 2 3 3 3 2 2 3 1 3 2 2 5 1 4 2 2 1 4 0 2 2 4 1 1 4 2 1 2 3 2 4 1 4 3 4 2 1 0 2 2 3 2 4 4 4 1 2 4 1 3 4 2 5 1 3 2 1 4 3 1 3 4 1 1 2 1 2 3 3 3 3 3 4 5 3 1 2 1 4 5 0 2 2 2 1 1 3 1 2 3 3 1 4 2 5 0 2 2 2 1 2 3 2 1 3 2 4 2 2 4 1 2 3 2 2 1 0 3 3 4 4 2 2 0 4 3 1 4 5 3 4 1 1 2 1 4 2 3 2 2 3 6 3 5 2 3 5 1 5 3 2 3 3 1 3 2 4 3 3 1 3 6 4 3 3 3 2 5 2 4 2 2 4 5 2 3 5 2 2 2 4 1 4 2 2 2 2 6 3 3 1 1 2 3 3 2 0 1 2 2 1 4 3 7 3 4 1 4 3 4 2 3 1 4 3 3 3 1 1 1 3 5 1 3 3 1 3 1 0 3 0 3 4 3 6 1 4 1 2 4 0 3 4 0 5 6 4 1 1 1 3 2 2 4 2\n",
      "G: 2 3 3 3 4 4 2 4 1 5 1 2 4 2 2 3 1 2 2 2 4 4 4 4 1 2 4 2 1 2 1 0 3 5 2 2 2 3 5 4 3 2 3 4 3 1 3 1 1 3 2 1 4 0 1 3 2 2 4 1 1 1 3 2 0 1 2 2 3 3 8 3 2 3 2 3 1 2 2 1 6 2 0 3 1 4 2 1 3 3 4 2 4 3 4 3 4 4 4 2 3 1 0 3 4 1 2 1 5 2 1 3 3 1 1 3 0 1 2 6 5 1 1 5 3 2 2 3 7 2 2 2 4 2 4 1 4 3 5 4 2 2 4 4 1 3 0 1 2 2 3 3 1 2 1 5 5 3 2 3 1 4 3 1 2 4 2 0 3 3 3 2 3 2 5 4 3 0 1 2 1 3 0 2 1 2 2 3 3 3 0 1 5 2 2 3 4 4 2 1 4 3 5 2 3 1 1 1 4 2 3 3 1 2 4 2 2 2 2 2 2 4 2 3 3 3 3 3 1 6 2 2 4 2 5 3 2 3 1 5 5 3 2 1 1 3 5 3 5 3 1 5 2 4 4 2 3 2 2 1 3 0 4 3 3 2 2 2 2 5 2 2 1 1 4 4 0 1 2 2 3 4 5 4 3 0 2 3 6 1 4 1 3 2 4 1 2 2 3 0 2 1 6 1 3 6 7 2 2 5 3 3 5 4 4 2 1 4 2 2 3 2 2 3 3 5 1 2 5 6 4 4 2 3 2 3 4 2 3 2 3 3 1 2 2 3 2 1 3 2 2 2 4 3 3 2 4 3 3 2 6 2 3 3 1 3 2 2 2 3 4 3 1 2 1 4 1 1 3 1 1 3 1 3 3 2 3 2 1 3 3 1 2 1 4 6 4 2 2 4 1 3 1 6 1 2 2 3 1 2 1 2 3 1 2 2 1 1 3 4 3 0 5 2 1 2 1 1 1 2 4 0 2 1 1 2 2 5 3 2 2 4 2 2 1 1 4 0 2 1 3 2 3 3 0 6 5 1 4 3 2 3 4 0 4 1 3 3 0 4 3 2 4 3 4 1 4 2 2 1 3 4 3 0 1 5 3 6 4 2 1 5 0 2 3 2 2 3 6 1 6 3 3 1 0 1 5 4 3 4 1 2 4 2 3 2 1 2 6 4 2 3 0 2 2 3 0 1 1 1 2 3 2 1 2 2 4 0 2 4 2 2 2 7 2 3 2 4 1 5 2 5 2 4 1 1 3 2 3 3 1 5 3 2 3 4 2 3 2 1 3 3 4 3 2 4 3 3 1 2 4 0 2 2 5 4 1 1 0 2 3 1 3 4 2 1 3 3 4 1 6 4 3 2 2 3 3 2 2 2 1 2 5 3 2 3 2 0 0 2 2 2 1 1 3 3 3 0 2 1 5 0 3 2 2 2 3 4 1 3 4 3 4 3 1 5 5 5 3 1 1 2 1 2 3 2 1 2 2 2 2 3 0 3 6 3 1 4 2 1 5 4 2 0 4 1 3 3 3 3 1 5 5 4 3 2 3 4 1 4 3 1 1 4 3 3 4 2 5 2 2 0 5 4 1 3 3 1 2 2 0 2 6 5 5 3 5 2 3 2 3 4 2 5 4 4 2 1 5 4 3 1 3 3 2 2 3 3 3 3 3 2 3 2 7 3 2 1 2 1 5 2 2 0 2 0 3 5 2 3 1 5 0 2 1 5 2 4 0 1 4 2 1 5 2 0 1 2 1 3 1 3 2 2 2 1 2 2 2 4 4 4 2 1 3 3 2 2 2 3 1 0 3 3 2 2 0 3 4 2 2 3 1 1 2 5 4 1 3 2 2 3 0 2 3 1 2 4 2 2 3 0 2 5 1 0 2 0 5 1 3 1 4 5 4 3 2 2 2 4 4 6 2 2 4 1 2 1 3 2 1 1 3 2 2 2 4 2 4 2 2 2 4 4 3 3 1 0 2 2 5 4 3 4 2 4 1 3 1 2 3 4 2 5 4 1 4 2 1 4 4 2 3 1 5 1 1 3 2 7 3 3 2 2 2 2 2 3 3 5 3 3 3 2 1 3 4 4 1 2 0 2 2 1 5 2 3 1 2 4 5 3 2 3 2 4 2 4 2 1 3 4 1 3 2 1 3 4 3 2 0 2 2 4 2 5 3 1 3 3 2 3 2 0 1 5 3 1 3 3 7 2 6\n",
      "T: 1 3 3 2 4 1 3 4 2 2 5 3 2 1 5 6 1 1 2 4 2 2 1 2 4 1 2 2 2 4 3 4 2 1 4 4 2 4 2 0 4 3 1 3 3 4 0 6 4 3 0 4 1 4 0 1 3 2 3 3 3 3 3 4 4 2 1 5 2 4 0 1 2 2 2 3 4 3 1 4 1 1 4 4 3 1 3 5 0 3 3 3 1 5 2 2 2 2 2 1 1 5 2 3 1 4 4 1 1 5 3 2 1 5 3 0 4 4 3 1 2 2 4 3 2 1 0 1 0 4 2 1 1 1 3 3 2 1 1 2 7 1 5 2 3 1 1 3 3 3 2 0 3 3 3 2 3 3 3 3 5 2 2 1 3 1 2 7 4 2 3 4 3 1 1 3 2 5 0 2 2 1 5 2 5 4 2 2 1 2 2 5 1 7 5 4 3 0 2 3 2 3 1 2 0 5 3 5 3 3 3 4 0 0 3 3 5 1 3 2 4 4 2 3 4 4 2 2 4 1 2 3 3 3 0 2 2 3 2 2 1 1 2 1 1 1 4 3 2 3 3 3 2 1 4 4 0 1 4 5 1 3 3 3 3 4 2 1 1 2 3 1 4 3 2 2 3 4 4 5 1 4 2 2 1 2 2 2 3 4 0 1 3 3 2 3 3 2 2 2 3 0 1 2 0 0 0 1 2 3 3 1 2 0 2 2 4 1 5 3 0 3 4 2 4 0 2 3 2 1 3 4 1 5 3 3 3 3 4 1 3 4 2 1 2 3 3 2 2 4 3 1 2 3 2 1 2 4 1 1 3 3 4 2 3 1 2 5 2 2 2 4 3 4 1 3 2 2 3 2 1 1 3 3 2 3 3 6 2 3 3 4 0 4 1 0 2 3 3 0 4 1 3 1 2 5 3 2 2 4 2 0 2 0 2 2 3 1 4 1 2 2 2 2 1 2 1 2 2 2 2 3 1 4 1 3 1 2 2 3 4 2 4 3 1 6 1 3 3 4 5 4 3 1 4 1 1 3 0 2 4 2 4 6 3 4 3 4 3 1 1 6 3 1 2 3 3 1 3 5 2 1 0 3 3 3 1 2 3 2 4 2 5 3 3 2 4 3 1 2 3 3 5 4 5 3 3 3 4 0 4 3 1 3 2 3 3 1 1 1 2 4 3 4 1 4 3 3 5 2 1 4 3 4 2 3 3 2 2 1 3 3 1 0 2 3 3 2 3 2 4 3 2 4 4 3 3 3 3 0 2 3 2 3 2 1 4 3 2 4 3 3 0 2 3 1 2 2 6 4 3 3 4 3 0 3 5 3 3 4 2 3 3 4 1 2 1 3 2 3 3 4 0 4 1 2 3 2 5 2 2 3 2 2 2 3 2 5 4 6 4 3 4 4 1 3 1 3 3 2 2 4 2 3 2 2 3 4 3 3 3 5 1 4 3 1 0 2 1 2 3 3 0 2 3 3 3 3 5 3 1 2 3 0 1 1 4 2 3 0 0 1 1 2 2 6 5 3 0 1 1 3 0 3 3 2 3 1 3 1 4 3 3 2 2 0 2 1 1 2 1 7 3 2 4 1 0 2 1 1 5 3 0 2 2 5 4 3 1 3 5 1 4 4 2 2 2 2 2 3 0 3 1 5 2 0 1 4 4 1 3 1 4 2 1 2 3 3 2 2 1 3 2 3 3 4 1 1 2 3 4 1 3 2 3 2 3 1 4 1 1 1 3 2 3 2 4 3 3 2 3 3 2 4 4 4 2 4 2 1 2 3 3 5 2 2 1 2 2 3 3 2 2 4 3 3 5 1 3 4 3 2 6 4 2 1 4 2 0 3 2 2 5 5 2 5 2 3 3 4 3 3 3 0 4 5 2 3 2 3 2 3 1 2 4 2 2 4 1 3 3 3 1 3 3 2 1 4 1 4 4 2 4 1 3 1 2 5 2 2 1 1 3 3 1 5 2 2 4 1 1 4 1 2 3 3 1 2 4 0 1 0 3 1 1 3 2 1 2 1 1 1 3 4 0 2 2 1 1 1 1 3 2 2 4 1 1 3 6 4 2 2 1 3 1 3 3 2 3 2 3 1 0 2 1 2 2 0 5 1 2 1 3 3 2 2 3 3 1 2 3 2 1 3 2 3 4 3 6 4 2 3 2 0 1 2 2 1 5 2 1 4 1 1 3 1 1 4 2 4 0 2 0\n"
     ]
    }
   ],
   "source": [
    "fa = \"\"\">Rosalind_4135\n",
    "ACTAGAGTAGTCGAATACACGGGGACGGCCTAGAGTCCGCTACTTCAATTATGAAAACCT\n",
    "CCCGTCAACTAATGGGAGGCGCCTACTTGGGTCGGAGATCGACGCCTTCGTTGGCGCTCG\n",
    "TAGGCCATGGATGAAACCGGTCGTTTAACCGCTCATTGAGTCCATGGTTAGAGAGGCACA\n",
    "ACTATGGCCGTTGCTAAGCAATGCGTATTTCGGGGGGATGTTCCCTATGGACCTCCGCTG\n",
    "AACCAAGTGGAGAATGACATATCGCGGAGGTCGACTATTAACTGAACTGGGAATATTGTA\n",
    "GCACAACAAGCCACTCAGCTCCTATATTGATTCGGAGCGCAAGATACCGCACGGGAGTCC\n",
    "GTGTACGTATGGCACAAAGTGGTGACAAGACGCCTGTACCCCCAAACTAGTCTGGGCCAA\n",
    "CCATAGCTGTAACTCCCTTTGATCATATAATTTGTGGAAGTGTTGCATTTCTGATAGGCA\n",
    "AACATTCTGCTGCAGTTGGCGGATTCCTCAAAAGAATAGGAGCTGGCTAAAGCTTCGCGA\n",
    "TCAGCCGCCTTCGATATTGATGGCCATTCTGGCCGGTATGTAGTGGTAATCTTGAGGCAC\n",
    "GGATATCCCCAGCGACCCTTTTTTCAGCTACTCTATGCTGTGGTTGGAAACGAGGGCGGC\n",
    "AAAGGGTGCGGGCAAAGTACCCGGGTTAACTCTCTCGAGAATGTCCAGCCTTGAGATATA\n",
    "TGCTAAACCCAGTCCATGTAGGCTACTTCAGTCAGTAGTTTGCGAATGAAGATGTCATCC\n",
    "TGAGTTAGGGGTGATTGGGGTTATTATCAGAGCATGTACTGACGAGAATCCATACTACGA\n",
    "CCGAAGCGTATGCTGGGCAAAAGAAAGTCCTGCGCCAATGGCCCCGGCGCCCCGGTAAAA\n",
    "GCAAGAGATGGTATGCTGGGGAACAGGGACACGCGCGCTGTCTTCATTGCTGTGGAATTA\n",
    "ACCGCGAAGGGTGATTGAATGTG\n",
    ">Rosalind_1266\n",
    "CTCCAATGAAACTGTTCTGCTAAATAGTTTTTAGTTTTGGCGTGGAACTCGGGAAGCGTA\n",
    "CTGTATCAACGCAGCCTTATGCATTCATCCTGGTGTTGGAGTCCATACAAGGGTAACCGG\n",
    "GGTGGCAAGAGAGGGGACCATCGGCCATAACCATTGGACACTACTAACGCCTGGGTTTAT\n",
    "ATTACTTAACAAGTTGTGAAGCGACACTCGGTAATTTCGCGTTGTGTGCGCTGGGGATAG\n",
    "GCGGACTGTCCGAGGGACATTTGCGTCGTACAACGAATTTATACCCCCTTCGTTAGCGAC\n",
    "ACCACAGCTTTATGGTAAGTCTTTAACAGGCTGTGGTCTGAGCGATCTAACCCGTATGCA\n",
    "GCAGAGCTGAAAGGAAATTCAACAAAGGTTGCAAGGCCTGCGGGATGGCACATCAGGCTC\n",
    "CCGGCTCCCATCGCGAATAATTCTATGACCTAGACGCAAGCCAATAGCACACGGGTTAAG\n",
    "GAAACGTGTAAACCTCATCCCGCCTGGTGGAAAACACCAAGGTCAATATTTTGCCTGACG\n",
    "ATCGTTTGCGTGAGATACACCCGGACTACCGGATCGGCTCGTTGAAATAGGTGAGACGGC\n",
    "GTCTAGGTAAAATGGGCACTATACGTGACCGTATACCGGTGCCGATCGCCATACGTGTTC\n",
    "CTAAGATCAACATACTTTACAAATGGAGACTACACCGCGACTTTCAGCCACAGGTTAGGC\n",
    "TACGGTCCTGCAATCCAGCCTGTCGTATTAGAACGCGACGTGCTTGGGTTCGTAACAGTG\n",
    "TACGATCTCGCACTACAGCTACCCAACGGCTTTGAACAACCACGTCTCCTTAACTTCTTT\n",
    "CTAGTCCTGTCGACATGTCTCTCGGTGAATACAGGTCCCCCGTTCTTGTGCCGATCGAGG\n",
    "CCCTGTTACCAAAATGATGGTGTGATTATCCGATGAAAATGCCCCGATCTACAAAATGTT\n",
    "TATAATGGGTAGTCGGCGGGCGC\n",
    ">Rosalind_6660\n",
    "GCGGGGCAAGGAGGTTGCGATAGGAAGCAGCAAGCTTCGGTAGTCTATCAGCTAAGCAGT\n",
    "TCTTTTCTCGCTCACCCGATGGAAACGAACTTCAAGCTAGACTTGCCCGGACGTTATTCA\n",
    "GCTTCGACGTCGGATCGGGTTTTTCCAAATTGCTACGTCTTGAGGTCAAAAACTCCGCAC\n",
    "GCCTTTCCGGCTCTGGACGATTACGCCTGCACCACATCATTTCCGAGCTGGCGGGGCTCG\n",
    "TGCACGTACATTTGATGCTACATTTAACGGTCCTGTATCTCTGCATCGTCCCGAACGAAT\n",
    "CCGCAGGGATGAGGCCCTGCATCCTAAAGTGTCTCGTACTTGCCCTTAGAGTGTGGGAGC\n",
    "CATCTCCCAATGATCGCGTCATCAGATTCCGTGTCCGGGGAATGTGTGCTCCAATAACTT\n",
    "GCAAAAACAGGTAAAGTGCTGGCTATGTATTGAGCGGCCCCTGTGATTACCGGCTCGCTT\n",
    "CAGAAGCGAGAATTAGGTGATCGATCTGGGTTGAACCCCGAAATTCATACAGATGGCTCC\n",
    "TTCGCCGATGCGAGACCTTGCTCTGTAGACATCAAGCTTGTCGTCCGATTGCTTGCTTGA\n",
    "TTGAACCGTATCTATTGCTACACGGCATTCCTGACGGTTCTTGGCCGGTCAACCCGATTG\n",
    "AGAGGCCTGCGCAAGTTGGGATGCTCCATGCAAGCCCTCGTTGGTCCAATACCTGGTCCG\n",
    "ATTATGACGGGACCGGCTTCAAGAGGTAAGGGCAATTCAACGTAAGAAAAGCCTCTTCGA\n",
    "CTCATCGTGAAGATGATCGCACTGTTCCGTAAATGGGTATCCTTGTATTTCTCGTTACGG\n",
    "TTATGTGCAGCTCAGAATCAGTGCCCGCCCGGGGCTAAACCGGAGGCACCCCTCGCGCAC\n",
    "TAGCGCTTAGCTGCCACTTGTTCTTGTCTTTGACGACACAATAGATAGCCTGAACCAGTC\n",
    "CTCGCGCATACACTCGATACCCG\n",
    ">Rosalind_1157\n",
    "GGACTGAGAATATTCTCACTGACTAAAATCTAGGTCCTCGGTAATCCTATCCGAACATGA\n",
    "CCGGAAGTGTGAGAAGACTTCCCGAGCTGACAATGAGGGCCTACTCTCACTACTTATGCG\n",
    "TCTGGCCGCCTCCAGTTCGCTGTGTGCCTTTCCCATTTTCTCCAAGCATCGTAGCATCCA\n",
    "CATACGAGAGCTGGCCGCGTCGCGACTAATTGAGTGTCCTTGGTTCTGCGACTTGCTTCC\n",
    "CCCAAATGGAGACCGTAGTTACGAAGGAATCAAGCGCATAGGGTGCAGCAGAGGGACTCA\n",
    "TAGCGGGCAGAGTGAGCGTCCCACGCAGGGGGCGTTAAGCCAAGAGCAAATAGTGGATTA\n",
    "GCGAAAGGAAGTATAGACTACAAGCGTTTGCCAAAGAAGAGTAGGTTACCTGACAACCGG\n",
    "CTTAACTCTCTTTTACGGACTTCGTTCATATCCACCGTATTATTTTGTCAATACGATGTT\n",
    "CAGTTTGTTTTGATAGACGTTGTCTTTATACAGCAGAGTCTTACAGCAACCATCATAAAC\n",
    "TAGGCGACCATTATTCCATCTGTCCACGGTAAACAGGGTTCCTAGGACCGAAAGATGTGG\n",
    "GGCGTAAGTTCTGCCGACCTGACCTGCCACGAGAGCTTACAGCGTGGGAGTTAAACCCAA\n",
    "CAAGCGTGCAAGAACCGCCACGCGTTGGCAGAACAGTACAACGCTAGCACCAGCGTGCAT\n",
    "TGGTACAACTACATAACCTCTCGTTCAACCATGTTAAGCCACACTGAAAACCAGGTTGCG\n",
    "CATTACAGCGAATATGAAAGGAGTTTTCGATGGCATGTAACTTACTAGACGTAATACCGC\n",
    "TACGTTCTCGGAAGGCTTAGTATCTCATGCACCGAACTCGGTAGTCCAAAGGTGAATGAG\n",
    "CCTCGAAACGCGCCAGACCTCGCTACCGCGTCCCGCGATGGGCGCAATTTCGATATGTTT\n",
    "CGCGGTTCTACTACCGATGTGAG\n",
    ">Rosalind_3528\n",
    "CTCTGGTCCGAACCTTCGATGGAGGTTTCTGCCCTCCGGACAGCTTAGGAAACCACGTCC\n",
    "CACAACAGGGGATATTACCCCACTAGATGCGCGTAGAACACTAACTCCTTCGCACATCGG\n",
    "ATATCAGCGTAATTTCTGGTTCGCTAACCGCACCTGTTTAAGACAAATTTTCTCGCATAT\n",
    "TCATTTTGAAAGGGGTTGTGTTTAAAACTAGTCAGATAGAAGACTGATTTTCTAATGCAT\n",
    "GGAACCGTGTTGGTTAATGTACCTTTCTCGTGATAGACATGGTCGTAATTCTTATCTAGC\n",
    "CAGTCCGAGGATGAATTGTCAACCTGACCGCACCTTTATCATTAGTGTCTTATACCGGAG\n",
    "GGTGTAATTTATCTAGTAAATCTCGCATCTTCCTCGAGCAAACCCGATTAACCCGCTGCA\n",
    "GAGATCAACCCAATATGCGTTGTAGCTCTACTGGTAGTGTGTGTCTGGAGCCTACCCCGT\n",
    "CGACCAGGGGCGATTTTTTTGATGTAGATCAGATGTAAGGCTATAGCTTAACTGGTCTCA\n",
    "CAAATAATCATTGGTAGGCCACACCATGATTGGGAAGACCAAACATTACCAAGGCCCTAC\n",
    "GGCGGAAATGACGTCATTACGATACTCTATGATACATGATGTTTCGCTACCAGGTCCGTT\n",
    "CCTCGCGTACGGAAATTAGGAGGCCCGCAGTGTTTCACGTAAGCTAATCATTATCTTCAT\n",
    "AATTATATGTATGTGAATGGCCCCGGGCGCTCTAATAAGTGACCAACCCGAACTCCTTTT\n",
    "CCTTTCAAACTCTGCCCTTCCCGGCGAGTTACTACGCCCAGGTTGTGAATGACACCGCGA\n",
    "GCCTGCACCCGTGCTCCGCAAAACCAATGCCCGCGGCTGACTGCACAATCGGCGATTACC\n",
    "CCAAGACGATCGAACTGGGCCCGAAACGACTCGAAGTCCGAATTGGGGACAGCGATTGGC\n",
    "AGCAGAGCTTAGCCAAAACGGCA\n",
    ">Rosalind_1703\n",
    "ATTTTTATGGCTGCTGCATAATATTCACACCTTATGCCAATTCGCCCTTAATATAATGGA\n",
    "AGCATAATTCGGAGATGAATCAAGATGGCGCCGGTAGTTCCGCAATGAGCACTTGGCTCA\n",
    "ATCGTCCAGGCAACGTGGTCTATCCCAGGGAATAAAGGGCAAGAAGTTGTGTTAGTGTGA\n",
    "CGACTCAATAACATATGCCTGAGAATTTGGGCCCGACGCCGTGACTGACCAGGAAAAGTC\n",
    "GCGTGTGCATTCTGATAATAGTTAGAAAAAGCCTTAAAGATTGGTAGCGCACACTTCCTT\n",
    "CATGGGGCACGGGCGCGATTGCTGGGTAACGCCCAAGGTCGTCCAGGCGTCAGCACCTGA\n",
    "TCGACGATAGGATCATTCAGCCTTTTCTCAGTCTGGGTCATAAGAAAGCCCAACCTCCTC\n",
    "ATGCGTGTAAAACTCTCGAAAGTCATCAGTGTACTGTGGCACGTGTAGAGTTGACAATAA\n",
    "TGCACCAGTCGGTGGATGCAGTGTATGGTGTTTTTTACAACTTTATACTCCAATCATCCC\n",
    "CGGGATATCGAGTTATTGGGAGCGGGCTGCTCGAGCACGCGTCCCGTATCGCAGTCCCAC\n",
    "TTGCCGGCTTTGGCAAGTTGTCCTAAACGTGAACTCCACGAGCAGAGCCAGTACCTTTAT\n",
    "CGCACCAGTACTCCTGTCAAGGCTCGTGAGACCCAGTAGCATTCCCAAGGTAGGCGGGGA\n",
    "TAGTGGGCGCGAAGTAGTCCGATGGGATTCGTCCAAGGCATCTTTACCTACATGTAGTCC\n",
    "CGACAAGACTATTAAGCACATCCAAATGTTCCTTCAGCGGATTAACCGGGTTCGCTAACC\n",
    "AATGGGGTCCAGTTTACCGTTATGAGCTGTGCTTCGGATAAACGGTAATCGGATCTCCAA\n",
    "AGCTCTCCAGTCTATCCGTGACGGAATTAGACATACTCTCGGTTACTCACGTATCTTCAG\n",
    "CTCAAGAATGCACACGTTTCGGC\n",
    ">Rosalind_6778\n",
    "CATGTGGTCGCTAAAGACTTGCGCTCACATATGTATGGGAGGCCGTGTTGAACTACTCTT\n",
    "TACTTATTTGGGGTGTCTCCGGTATGCTATTGTTTTGGCGACAGGTTAGTCCCTCCCCTT\n",
    "CATCGGACATAAAGTCCACGACTGCCCCTTCGTATGGAATTGGCTGTTGGTAGACGCTAC\n",
    "CGCGTTAGGCCCGTTTTCATGAGTGTGGGACTACCTACTGCATTTTAACATGCCCTAACG\n",
    "AGCAAAGGGGAGAGGCGAGTGAGGTCTGAAAATAGGTCTTCGAGACGTGCACCCGCCACC\n",
    "CACAGGGTATTCCGGCTGAGAACATAGTGGTGTTTTGTGATTCCTCCCTGGCTCTAATAC\n",
    "TTTAGTAGGGTCTCGTCCGAACAACGGGCCTTATAATCAGTCTGATAATTCAGCCCTCTG\n",
    "GATGCGCGACATAAAGACGGCCAAAGGATTTCTAAGATGCTGTAATACTGGTTAGTTAGC\n",
    "AGAAGGACGCTTTGTCACGCTATACAGGCCTGATTGTTGAGTAAATAGTCAGTCACTCCG\n",
    "GCAGGTTGGGAGAGCCTTTAGTATCGATAGTCCGTCAGTTAACCGTTCACCCTTACAGTT\n",
    "GTCCGAGTGGGTCTGTCTCTTATTAGTTACAAGGCGGGCGCTGAACATGCAGCTGCAACA\n",
    "TCTATTTCTAGAAATTCAATCTCGAACGTTGTGGGAGGCCCTGACGGATATGACGTGTCA\n",
    "GAAGGCCCGTCTGTAACAAGACAGGAGGATAAAAAACCGATGAACGTGCCCGGGAAACAT\n",
    "CTGTTCCTTCTTGTGGGTACCATGCCTCAATATAGAGCCTTACTTATTTGTATCCATTAT\n",
    "CAGGAGACCTTGCTTCCAGTACTCGGCTCCATGCCTTATTGTATCGCGCCCACCACCTTT\n",
    "GGTTCAAACGCACGTCACTTATGAGTGCAACCACACAAGCGGCCTGGGAGTAAAGATGTT\n",
    "TTTGCGCTACGTACCAACGTGCG\n",
    ">Rosalind_5056\n",
    "CCGACCCGTCTGGATGCAATCTGCTATGCAACCGCAGTCCTTATGGGCCTCTGTCCGAGC\n",
    "GTTTCCAGGTGCAACGTAACGATGTGCCCTGAACGGCGGCTTTTAATGGTCTCAAGCCTG\n",
    "GCATCTACACTCAAGCGAGCGATCAGTACCGAATACGGGGTCTTCCCTCGTGTAGGCCCG\n",
    "TCAAAAGTCTATATAAGCAAAGCGATCACATGAAGAAGTAAGAGGAGGTGATCAGGCGAC\n",
    "GATCCAATATCTAAGAGAAGCACGCCTCAGAGTCGCATGGGGATGAAGGTGCTTGATCGC\n",
    "GAGAAGAAGGCGGCGGTATGGGTGGGATCGGGATAACTCGGGCCGATCCTAGATCAGCAT\n",
    "GGCGTCCTCAATATAAAAGTCGCTGACTATCACGGAGTTACGTCCTGCGTAGGCACTAGA\n",
    "TCGACACATCGACGCACGCCTCGAAACAGCGACTTGGAGGCGGAGATATAGTCGGTAAAT\n",
    "GAAATTCGCCTTTCGATACCGCGTACGAGGTAGGCTTCGATATGAATATTGTACTCTAGG\n",
    "CCCACACAAGGATTAAGCCGATATTGTCTAGTCATTATCTTATGGTCTATTTGCCAAGAT\n",
    "CGGTCTTATCAAACTGCTATATGAGGCAGATAATCACTATGTATCGGGAATCAATTTCTG\n",
    "CGACGGCGGCACGTGTGGAGTGGCACGCTCGTTGAACCGGGCAGGTCTGGTTGGTGGTAT\n",
    "GGTGCGTTTGGTGTAAGGTCGATAGCACGCGACTCTCGCGCTAGAGGTCCGCCCAAACCG\n",
    "GAGAGTCAACGGCTCCCCTGTAAAAATCAGCATTCGTGGACCCTCTGGACAAGGTTGATA\n",
    "AGGCGCTTGGGGCACACAGTTAGTTCGGTGCATCCGCCTATGCGTTATACAGTGGCGGTA\n",
    "GAGGCGACGGATATACCATTGGATAAGTGAATAATTCATGTAGGGGAAGAGTGCCAGCTG\n",
    "ACGCCATCACAGCATGAATAGAA\n",
    ">Rosalind_0448\n",
    "TGGGTATGTTTGCCGATACGCGTAAGGACGACTGGGATTGGCAGATATAGCTAAGTCCCC\n",
    "ACTACGGAAAGCCAACTTCGTTTTGCTCATGTATAAAAGACTCGGAGACTACAATCTACA\n",
    "GAAGACCGGACCGAATGTAGTACCGACTGCGAAGGGACTGATGCAACTTGATCCATGAAG\n",
    "AGTGACAAATTCATTGGACAAGGTAGACGTTTACCTTTACTCATAGCCTGCTTTAAACGT\n",
    "ATTCTGGCGGCTCATACGTACCGAATACATCATAACTGCTCTGCCATCGCCCCAGTGACA\n",
    "TAGACAAAAGGCGATCCATCGTGTAGCGTGTTATAGGTTAGCCAAGCGCTTGCGATTAGC\n",
    "TTTACGTATCGGTAATGTAAAAGTATTTCGTTAAGGCTAGTGAGTTCCATGCCATACTGG\n",
    "ACACACACCGGCACTTACTGAATGATGCATGGGCACACAAGATTCGTGCGGTTTCGGCTC\n",
    "TGCTCGCGGTAATAACAGGGGTTACATGACGCCCGACCGGAGAGCTCCGGGTGCCGGATT\n",
    "GTTGGGTGTAGTATTGACGAAGTCTAGATCCTGGTCTGACGCTAGCTTTTTCATCTAATT\n",
    "GAATCATCACCAGCATCAATCGACCTGATCGTCCGTTGTCGTGTAACGGTCACTACCATT\n",
    "GTAAGAAAACACAAGTCTGAAGCTTAACGGAACTGGGGTTGTTGAGCAACAGGGATTTGC\n",
    "GGCGTAGGAGACCGCGGTGTTCGAGCAAAACATTTACGATCGTAGTAGTAGCCGTCCATA\n",
    "AGATCTTTACGGACAAACCTCTCTGTCTGCGGAATGTAAAAGTAAAAGCAAAGGGAATAA\n",
    "GTAATAAGATTTACGTCTTGACTAAATCTGCATTTTTAAAGTAACGAGCGTAAGGCGCAG\n",
    "GTGTCAAGCAGGTAGCGCTGGCCCAGAAATCCCACGGCTACCACTTTACAGCCGTAGCGC\n",
    "AAGAAGAAGGCAGCTAGACGATG\n",
    ">Rosalind_0713\n",
    "CGAAGCCTATTTAAGTAGAGAGAGCGCCGTATCAAACGTACCGGAAGTCGCACTCGTATG\n",
    "TTGACCATATGGATTCTAGCGCTACCTACGCCGGCCTACTGAATGGCAGTTGCCCACTTG\n",
    "GCCATAGGGTGGACCACACGGGGGCGATTCCGGGCGCCATGGTAGCGTCCAGCCTGCTAC\n",
    "ACTCGCCTGAATTTTTAGTAGCACATTTTCAACCTCGCACAGAGGTCACCGCGAGCTGCG\n",
    "GCACAGTATCAGGATTCCCAGATTGTACAGGTTCTGTCCGACGGCATCGTGCGGAAATGA\n",
    "TGGTAGGGTCTAACCATACACGGGCGCCTACGGGCCAGACTTTTACTCTGCCACAAAGAG\n",
    "GCATCCTCAGATCGTGAACAAGCGTTGCCGCAGCAAGCTATCCTCCTAAGACGCCTCCCG\n",
    "TAGTCACCATGAGAAACGGAAGGTCCCTAGATTCATAAAATAACTAATAACGAGCCGAAT\n",
    "GTGTAGGCACCGACCAGCGAGTTTATCTTACTGCGAGGGTACCAGTTACAATATAAGCTG\n",
    "AGCCAGCGTTAGACGTGACCCGGAGGGCATACGTACAATTGTCTCGCGACCGCTAAGCGC\n",
    "TACAAGTCGAATGGAATTTGTGTTACACAGTCTGTCCTAATACCTGAAGTTCACTCTCGA\n",
    "GCTAACAATAGGGTGCTGACCTGGGATTAATTCGGACAAAATCGTGACCCACAGGAGCCG\n",
    "TCTGGGTAGCCCAGTAACGGATTACTTAATAGGATCGTTGCCCAATTATATTAAGATAAA\n",
    "TTCCGGTCTGGGATGTAAATCCGTGGCATTGTTTACTAGGTGCTGTCTGTGCTGACTAGT\n",
    "GAGGTATCAGGGGGACACCCTGAATATGGCACGTGTCCGCGGGGTCATTAAAGCCGACCG\n",
    "CCTCCCAGGGGCGGTCATTTAAAAATGGTCACCGGTCGGCGCGAAACGACACCTTGATGT\n",
    "CCCATCGCTCTTCCACGTCTGCG\n",
    "\"\"\"\n",
    "\n",
    "seqs = fa2seq(fa)\n",
    "\n",
    "mat = consmat(seqs)\n",
    "\n",
    "string = cons(seqs)\n",
    "\n",
    "print(string)\n",
    "print(\"\\n\".join([(f\"{base}: {' '.join(map(str, counts))}\") for base, counts in mat.items()]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['TCAGGGCGTTCACTTATAAGGAGTTAAACCCTAAACGTGGGATTGTTGGCCGCGCGCGGT\\nGCTTTGCCTATTCTTAGTCTGGCAGCGTCCGTTAGCCCTAAACATGTCTGGTGATTGAGA\\nCGAACCTCCCCCTACAGTCCCGAAATACGCAGATATAGGTTTGCATATTACTCTTCCAAA\\nTGCGGCTCTTACAGGTCAGCCTGCTCCTCTATTAATGCTTTAGCACGTTCTGGTGTTAGT\\nGTGTTGTCTGATGTTACTGTCGCGGTGCGCAATAAGGATCACGACAACCCGGGCCATTAG\\nCGTATCCTCTCCGTGGCGCTCCTAACCGCCATTAGGACCGTACAACAAAATAATCGAGCT\\nGACTCTGCATGTGAAATCCGAGATGATGGACCTAGCGTCCTGCGCGCTGCCTCCGAATAG\\nAGTGTTATTGTCAGGCGTAGGTTAGGGGTTCCCGACCACAGCCCTCATCTAGTCCGACGA\\nGAAGACCACACCGAGCACAGGACATTTTGCTTCAAAATAGTCTGCATTGCCGCGTGAACG\\nAACTTCGTGTGCCCCCAATGATGGACGATGGTAATAGCTTCTGTGCCTTTCATAGTCCTG\\nGCAATTGAAGCTTCTCCTGGCTTGCAGCAGAAGGCGCTACATTGCTGTAGGATCTCAATC\\nTTCCATGCACGTTAACCATACAAAGACGGTGAACTTTCATGTTGTGAGTCCACCGAAAGT\\nGTGGTCAACACAGGCTCCAGGATACCCAGACGACCTCGATAAAGACCGACGACTTCTGGA\\nCCGTTTTCAATATTGATTCGCGATACTCCACTTCGAGCCGGCAGACTGGCTTACGCACGC\\nAACCTAGTACATTTCGAATTTGCGCCCGCTTGTCCTGAACGGTCGCTGCTGGCTCACTGC\\nAGTACATCCCTTCCCAGTCTCTACACGTAGACTGTAAAGGCCCGCGCAGCCACACAAGGG\\nGGCGATTTGCCCATAC',\n",
       " 'GTTCGTAAAATCCGCATGATGGACTTATGCACTTAGACCGAGATGATGGGTCATAAAGGG\\nATCTTCCGCCTATAAGGCCTTCCTGGAGCGATGCCCTTCGTGTACTATACCTAATCAGCC\\nCAAGCCCCTGGGAAAATCTATACACGATGAGGAAATTTCTTACTGTTCACACCACTCCTG\\nCAATCCTGTTATGCCCCCGAAGTTTTTAGAGCGAGCAAACACGTGACACTCCAATGGGGG\\nGCCCATATCTGAACTACATGTACGCAAAATGGGCCGACTCGGCTCTGCCGCACAACCCTA\\nAGGTCGATCTAGGTTGACATCGTCGTCGATGGAGCTACCAAACCCAGTCTTAGTCCCCGA\\nTGACGCGTTTTTCCGCCCAGCCGGACTCCGCCTCTAGAACTCGTAGAACCTACCATAAGT\\nACGGTGGGGGTACAGCATCATCGTGCATCTTCGAGAAAGTTGTCTCTCTGGAGACGATGG\\nTGGCGCCGTCCACGGATCGGCCCTGCTATTCAATGTGACTCCTGCCACATTGACGGTCAA\\nACGGACCGCGCAGCCGGGTATAGAGCGTCCCTGCCGTCTTTTGTGGAAAGATACCGTAGG\\nTGGTCACTTGACAGTAAGTTCACTGTATGAAACTATTCTAAATCGTGTAGGACCCGTAAC\\nCGTGTCGACACTACCATAGAACCATCTGCCGCATTAGAAAGTACGCCCTACCGGCTGGAA\\nTTGATCCGCGCTTAGGCACTGTTATCCGCTAGAATCGCCCCGTTTAATACCACCAACTAC\\nAGAGAATTCGTAGCGTGCCTTGAAAATCTCAACGCACCATTAGCGACGCTGGATCTACCC\\nAGGGCTGGTCATCGACCAAGGGATTACGTACTCGACAAGAGGTCGTGCATATCGCCCGGC\\nAACCGTTGCAATGATGGGAACCGCGCGGTAGGGACGACGGAAGACCAGGCTGTGCCTTCA\\nAATATTTGAACGTGCC',\n",
       " 'TAAAACATCGCCCCGGCTTTAATTAACGTACAACTGCAGATCAGGACGGTCCGATCTCCA\\nCTGTCATAAGCAGTCTACTGACGGTTCGCAGAATTAAAGGGAGTAGACCGCCAGTTACAT\\nCCAGAAACGCTTTAAGACCAAGTGTCGCCTGGTTTGGAGTTGGCGTGAAAGTGGGTAAGC\\nTATTAACAGACGATCTCTTCTGTAACGTATTGGATGTGGGTCATAGAATCCAGGTTCAGC\\nAATGATTCGTTTGTTGAGTCACTAATACGAGCCGCGAGATAGTACTCAGTTCTATAACGG\\nTGCTGTGGTGTGCCCGTTGGGGATTGTACCTATTCCATGTTCAATGGATAGATAAACGAA\\nCAGCTCGGACCCAGCAATGAAGGGCGTGGGGTTGAGGCATTTTCCCACTCCATCAATACA\\nTTATTTTTCCGATTATTAATCCAGTAACCCGAGTATACGTCCTACACGCTCTTTGACAGC\\nTGCACGTAGATGGGGGTAAAGTTCGCGACTGGCCACAACCACTTCATGAACAGGTGAGGT\\nCCGGATTGTACGTCAGGCACCTAGTCCCTCGACGAGAACTTACTGATTACAGAGCCATCG\\nGGCGGGTGCGGACGTCAAATAACGGATTGCCCGAGACCATATAAACTCCCCGGACTAGCC\\nGTTCAACCTTCATCTACCTTTTATGCACCTGTTGAACCTGGAGGACTATCTGCCCCGAGC\\nGTTTGAGTTGAACTTGGGTTTCCATGAGCCAAATGGACACTGGTTCTAAGGCCACTAGCG\\nTATGCATCGGTGGATAGGCCGCCTTGTTGAGTCATCGAGTAGTGGGTTAGTGTGCGTAGC\\nCTTAAACAAGTAACCTTGACGAGGAAGAGAACGGGAAGACGAACTTCCCGGCCAAAGACT\\nTCATTCCACTGTATCAGAAGAAATAGAGAAAGTGAGGTTCAGCCTGGTCAGGCAGCATTC\\nGAATCATGAACATAGC',\n",
       " 'GTTTGCCTTTAAAATACGGAAATGCAAGACTCAAGGAACATTCTGATTTTAACATGGTTG\\nAGGGTCTTAACGGACGGCAAGGTCGGAGGCTTTTATCATCGCGTGCTGGCCGAAGACACT\\nCGTCCAAATCAACAACTAGGTGAGGTCGTCTAGCCCAGTGTGACCCCGTTGGACGTCAGA\\nCGTGAGATACCCGCTACTTGGTCTAGGAAGCGTCCCGACTGTATAGTATCAACCATTGGC\\nTGTCTCATCATGAAGCTCTCGCTTCTCTAGACGGTTCTCGTACCATAGTGGGCCCATGCA\\nGTAATTGAACAGATGTGACAGGAGGTTGTTAGACACCATGCCGGGGTGACCTACACTCGG\\nGTTGGGATACGCAGATGTCACCCAAGGATCCACGACACTATAAATAGCAACCACAACGAT\\nCATTATCCGAGGCACACCTAGCAAGCCGGTCAAGACTAAGAGGTTGGGCACGACGGTGGT\\nGCTGGACAAACATTTCCCTTAGCCGCGTCCGTTGAGCACTTGCATGGCCGAAGTGAAGGA\\nTTGGCTAGATTAGAGGGTTTGTTTAACTACATCGATGGACGTCTAAACCTTCCCCGCGAG\\nGCGGCATGAGCCTAATTTACCGGTTCACATGTTACATCAAGTAACAAGTCCCGTCCAGTC\\nATCCGACACAATCGTCGACGAGGAATGACTTATATCTCTGTCATCTCTCTTGGGCATTCC\\nCAATCCAAAGGGATTGTCCATCGGACAACACCTCAAGAACGTCCCCATGTGGTTGCCTGC\\nGGTAGACACAAATCTGTCGGCTTTGTACAAGTTTAGAATATAAACTTCAGAATGACTACT\\nTATAGTCAGCTTTGAAACCGCCCAATGCATAGCGAAGCGCGGCGCGACATTAGTCACAAC\\nACTTACGCCTACAACAAGACACGTGCATACGACTAGGTCTCCAGTGGAGATTCTTGACCC\\nGCACGACCCCAGAGTA',\n",
       " 'AACCTTAGCGAACCTATTTCAATCGCGCAGTTACCACTGTAACCCCCCGTAATGCCCGTT\\nTAGAGAGCTGCCCCGGTTAGATTACATGTGATATATAAGAGAATCTCAGTCCGTACGTGA\\nAGCAGTCCACGTGCCCCCACGGGCGTACAGGGAGCACGGGGGCCACCCCTCGTGGCCGTG\\nATTATGAAAACCAACAGATTCTCCCACGGTGTTCCACATCGTAGTATGTGCACTAAAGTC\\nATTTTGCGATACCTCGGGTCATTATTCTGATCGCACCCTGTAGGGGACGAGCACACGGTT\\nTCACTTTGCGCCGTCCCGTTTCCAACGCGACCAAAAGGTACGAGATACCCTGGTTGGCTG\\nAAGGCACGGCGTAAAAATGGAATAGCCGAAGTCAATATGGTACCAGTGTTGGGAGCACTC\\nATCTATCTTCTATGTACCGAGGTGGGCCCGTGCCAGCAGTCACAAGAGTCATAGGCAGTC\\nCTGCTTTACGTATATTACGGGCCCCTCCCAGATCAGAGAACATCGGTATACATACTTGCT\\nGCTCTTGTGTGGCCTCGACCCTTCGACCACCGCATACTGAGAACTGCTGCACGAAAACTT\\nGTAGCGCTCCGAGTAAAGCCCTCCAACACTACATCCCTGACCCACAAGTACTGACGCGGA\\nCTTCTGGAGAGGGCAATCTTTCATTCGTATACGAACCGCCTTACAAACGGATGCGGGGCC\\nTGGACCCTAATCGAACTGGCTTTCGAATCGATGTGGCTTACTCTTATCCGCGGTGTGTCC\\nAACACTTGCTGTCCTCTAAGAGTGTTTCGAATGTTCGGTAGGAATCTAGAACATTTCGTC\\nCAATCTTCCCGACCAGAACGTGTTCTATATTCTGCGGATACCCACCGAGACGCAAGGCAA\\nCGTACACCCGGACTATACGGCTCCTTACTCACGGGCTTGCCTGTGCACATGGTGACATTG\\nTTGAGGACTTTGCTAC',\n",
       " 'AATAAGGCCCCCGGTAAGATGACATACACTTACAGAGATGGTCCCGGCGAAGAGCGCTCA\\nCACTAGTGCACACGATTTATTAAAACAGGATACGCGGGCATCATAAGGCACCTGCCTTGC\\nAAAGAGAATTATAATCCACGCGGTGGACATGCAGTTCTCCCAATTCGTATCCGCGACATG\\nCGTTTTTCTAAACGGGCACCAGGCTTTACGAAGTGTTCAGCCATTCTAGAGCCATAGCTA\\nAATTAGCCCTACCTCGTTTCATGCGGCTGCAGGCCCGCCTCGTGCAATTCGGCATGCAAC\\nAGGCTGGCCGCAACATCGGTGTGTATAGACACAACAGCTTTCGCGTTGGATATTAACTTC\\nACAGTACGCCATGTCATCGAAGTGGGCGAAAATTTCAGCTAGGGCTATCACTTACCGCGT\\nACTTGTGTTGGGCGCGTCGTGACTGAAGTGCGGGACTAGCGGCTGGTTCTCCTAGCACTA\\nCGAGGGAGCGAGGTCTTGACTTTTCGTTTAGGGCACTCCCCAGTATTGACGATTCCAAGC\\nAGTCACGCACGCATATTTACTCTGGAAGAGATCCACCGCTCTGTGATCTTTGAGCTAGAC\\nCAATTGCAGACCGTACCGCTAAAGTTCTACAGTCTGGGCGAGCGGCAAACTATCTAAGAT\\nAGTCAACATTAATGCTCACGGACTCGTGCGCACAGTGATAGGATGGGCACACTGGCATCC\\nGAACCATATCGACGCCTATACTTTCTACTCGCATGATCGTCACTATCCTGAGACACTCGG\\nCAGCGGCTGCGTCTACCCCCTACGCTAAGCCTGTTCAGCTGCCTCACGTGTACAACCCAA\\nATAGACTGTCTGCTGTGTCAGGACACTCAGAGCATATGGTAGAACGTCGGTAGGTTATCT\\nCCCACGATGAGAGCCCTAGCTCCAATTTCATAGACACCTTTCTTTCAATTGCCTGAGGTG\\nATGGTTAATTTCTTCG',\n",
       " 'CTGTACAATAGCGCCTCCAGAACTTACTGGTATAAGAGCGTCCCTGTTACTTTTCTGATG\\nTACAGTCAAGCTTCAGAGTTACCTATATTTAGCTCCCGGGCACCGGCGGGGACGATTACT\\nTCCAAAGTTAACAAGAGTTGGGATCGCGGCGGGTCTGCATGCGAGTGGCCGGCGCCTAGT\\nGAGGTTCCTCTAATAATATTGATCAGAATATCGTAAGGAGGCTCGATGGCAAAGTTCCAT\\nTTACCCCTTTCCGTGGGTCGCCGAGTAAAGCAGTGGTCAAATATTTTCCACACACACCAA\\nGTCCCGCGTCACCAATGCGGGGACTCGGGGAAGGGAGGACCTCGTATCGCTGAATACTAC\\nTTCCCGCGCCATAAAACGCTGATTGAAGTAGCTCGTTCTGGAATCCGCGCGCCCTGGACT\\nACATTGCTCAATTGATAGATGCTCGAATACAAATTCCCTCGTCACCTGGAGAGATCGGTA\\nGGTCGAACTTAAGCCCAGTTTATAAAACGAACTGCACGCGCTGGAAGGAAAAGAGGCAGG\\nGGGCATCTGGGAAGTCCACTACGGCCAGACGAATTGTATTGCGCAACTGGGAAGAAACTG\\nACCGGCTTTCTTATTTTCTACTACAGCCCAAAAGTGCTGAGATAATGTTCGGGAAATATG\\nCTTTGTGGTTCGCGAGCCTATGCTGCCCGTTTATACACTACATATGTCATTAGTAAAGCC\\nATACTGGGTCGGTAAAAACTGGTCGCCCCCGATTACAGCAAGGGGGCGTCTAGCTTTAGG\\nTACTTCGATAGACCCCAAGAAAGCTTCACCACTCGTAGGAATTTGGCCGTTATCAATCCT\\nGCAGACTGAGGGACACCACCGTTCTGAGTATAGGTATTTTATAAACCACATGCTCCTTAT\\nAGATTTCCGCTTTCCCGGCCGCCTATTCCAAGGGATACTAGGGAGACGTGCGCAAACTAT\\nTCTGCCCGTGGCTAGC',\n",
       " 'CTCTCTTTGCGGAGTTAAACCACGTCCACCGCCGTTACTCAGCGTCGGATTTCACTCAGC\\nCATTTAAGTTACTATCAGGTCAGCCAGCATAAGCATATAAATACTGCAGCAGATGCCCCC\\nCAGGTGTTCTCTGTGGTGTACTTACTACTCACAAACCACTATCTAGACATAGCCTCTTAC\\nGAATTCCGTCGCATACACCTCCAGGACCAGAGTGTTAAAACCATAGGCACATTCATCGGC\\nCGACTGGCTGGCCCGAAAAAGGCCATGGTTAGTGGTCGTCTTGCCATACCCAACACTCGG\\nTGCGGCTTTTTAGCTTATCCTTCAATTGGCTGTGTTTCCTTCCCGGATCCTGTCAATTGG\\nGCTGAAATTCGCGTAGCATAACTCTGCCCAGGGAAAGGCCTGGTTAGGTCCGGGAACGGC\\nGGTACTCATCCACCCTGTATACTGTGCCGCGCAGGTCGTTCGGAGTCGCCGGTCGGTAGT\\nTACTTGGTTTCTGCGGCATGCACAGCTAAGGACACCATCCACAGCTAGCGGCAGAACTGG\\nAGGCGACGATGGAGGTGGAATGTTCGGGTTCAGAAGCTCATCTAATTCCCGCAGCCAAAC\\nTACTCCGATCTGCAACAAAACATATGACGATTGCTCAGCTACCTTGAACCCAAGGACGAA\\nCAGTCCCAATACAAGTGGTCGGAGAATTCTGCGCACGTTTATGTTACTACTACCCAGGGT\\nGAGTCGAGGGATTACTTAGGCCATGATGACCGAAGAAATAGTTTGGCTGAAAGGGGACAG\\nTCGCACCGTTTCGCCGGAGCACGACGAGAACCCCTTACGTTTCCTAAACCCTCGGACAAC\\nGCAGCATTCTCGAGCCGGACTACTAGATGTACTACGCGGAGCCAATAGTCTGTAAGTACA\\nGGTTTATTCTCATCACAACGGCAGGGGCCTAAGGCCTAGTTGCTTCCCCGGACATCCTTA\\nCCCTTTATACTTTTCT',\n",
       " 'ACTTAGTAGCGCGGCTGGCTCCTTTAGCCGACGTTTGAGACCCCGGGGCCAACTGAGCAG\\nTGCGGAGCAGTGCTGACATAAATTGTTACTAGAAGTGCCCATAAATCAGGTAGATGCTAT\\nTCATGTCGGGACTACCGTAGTATCACACCATACCCGGAAAGAAAACCTATTACCCGCATG\\nCTCTCTCCGGCAGCCATTTGCATAACTTAGCGCCGTCAAGGTCACATAAAACTCGATTGA\\nGGATTCGGGTTACCGATTTTCTCCGTCAGTTACTAGCTGCTTTTGCCGATATTGGCTAGC\\nCAAGATACCGTGTTATTCAGCATATCCCAAGACGCTGAGTTATTATGCAGTATTTCCGTT\\nTAGCGGTCATGCGCTTAGACGAGGCGAACGGCCTAGTACTGGGCGGAACGTGTCGATTCA\\nTAGAAGATGCCAATAAGCTTTGTCCCTGCGGCCTCCTGCTCGCTGGCAGACTGTGACCTT\\nTTCTAGCCGTGCTCTAGCTAAGGCGGATCTTAGGAGCTGTTTGAGAATCTTCTCGAGAAA\\nCCCGTATGATATCTTGCAGAACAAACCAGTCCTCGTAGAGCGTCAGCCTTCAAACAGTGT\\nTTTCGGACGGTCTCTGAAAAATTGGCTAAACTTCGTCGACTCCTGCATTACTCGCGTAGC\\nACTCGGGGCATACTTTCGAACCATTATCACGCGTGTCAAAGGTAGGCCCAGGTTCGTGTT\\nAATTACGCGATTCTCGTCATCGACGGTATGGGAAAGCCACTCCGCTCTTTCCTTTTATCG\\nTGAGACGGCTCTGGACGAAACAATATCACCCTGGTAGATAAGCTGGCTGATTATGAGCTT\\nAGTTGATCTGAGAATCTAGCTGTTGGCGAGCCTGATACATCTTAGACCTACGTCCTTATG\\nCGTTGCACATTTGCCGTAGCCAATGTTAGCCTTTCATCATCTGTGCGGGTATCGGTAGGG\\nGAGTAGACCGCGGAGT',\n",
       " 'AGTCATAAACTTCCTGAACAATACCCAACAAAGTTAGGGCTCAGAACTCCCCAACGAGAG\\nTATTCCAATATCGGAGAAGAATTGCACAATCCACTACTTTTAGGTAGCCTGGTATATACT\\nGGTCTCAAAAAGCTGGGAATACGCCAGGTTCAACTCAGGCTATGCCTCCTCATGGTGTTA\\nTCGCCATTCCTTCAAGTGCCACGAGGGGGTGAGCGATAGAAGAGTGAAGTTAGCCGTCAG\\nTCCTTGGATTCGTACCAGCGTTATGGTTGATTTGTCTAATAAGCCGTATGACGAAGTATA\\nTCGTTGCCTAAACGGCACGGGTCGCGGAGCTACTCTTTGGACGGCACGGCAGAGACACGG\\nCCGTCACTTAGCAAAAAGACCTCTTCTTCCCGCTGATTTGGATGTTTGCCACTGCTACAT\\nGTCAGTTCAAATAAATCATTAGGAGTCCACGGGTGGTTCACTGACCCATTTTTCTAGATC\\nGCGGGCCGCACCCTAGGGGGAATTACGGTGGTGCCGAGGACCTCATCTGAATCCATCTTG\\nGCCATTAGGGGTATCTAGCCTACAGAAGGGTGCGCTATAGCTACATGTGATTACCAGGTC\\nCTGGAGTTTTTCGAACTAGTTCCTTAGAGTATACTCTACTGGCTTGATAAATTGTATCTG\\nAACGGTGTTTCTCTATATGATAAAACATTCACAAGTGAATTCAACTGCATGTACCTTGTC\\nAGGGAATGGAACAACCAGGCTAATTCTAACGCGACGGATAGCCTTTCCTTTGCTGGCTCA\\nTTGCTGGGCGAGGATGGCCGCTCCAAACGGAGGTAATATCGAATCATATCGGGATAGTCC\\nGTCGCGCGGTCTCTCTCAGGGAGATATTATACTTCCATCCAGGTGGCCAGAGTGGGAATG\\nCGGGTTCAATGTGTGTAAAGCTACATACCCAGGCATTCGTCAGGAATTACAGATCACGAA\\nAGCCGTTAAGTAGATC']"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seqs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mendel's First Law"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dom(k: int, m: int, n: int):\n",
    "    # Pick the first k and second as k for DD\n",
    "    kk = k * (k - 1)\n",
    "    # Pick the first as k and second as m/n for Dd\n",
    "    # Or pick m/n first then k\n",
    "    kmn = 2 * k * m + 2 * k * n\n",
    "\n",
    "    # Pick the first m and then second as m for Dd\n",
    "    # Multiply by 0.75 for 3/4 chance in Punnett square\n",
    "    mm = m * (m - 1) * 0.75 \n",
    "\n",
    "    # Pick the first m and then second as n\n",
    "    # Or pick n first and then m\n",
    "    # Multiply by 0.5 for 1/2 chance in Punnett square\n",
    "    mn = 2 * 0.5 * m * n\n",
    "\n",
    "    # Add all the probabilites together\n",
    "    num = kk + kmn + mm + mn\n",
    "\n",
    "    # Divided by the common denominator\n",
    "    # For picking first option there are k+m+n choices\n",
    "    # For picking the second option there are k+m+n-1 choices\n",
    "    denom = (k + m + n) * (k + m + n - 1)\n",
    "\n",
    "    # Return the probability\n",
    "    return num / denom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7833333333333333"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dom(2,2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8354124748490945"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dom(30, 24, 17)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.753030303030303"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dom(18, 19, 18)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import comb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Same as above but using combinatorics a bit algebraic for my taste\n",
    "# Stolen from SO\n",
    "def domc(k: int, m: int, n: int) -> float:\n",
    "    DD = comb(k, 2)\n",
    "    Dd = k * m + k * n + 0.75 * comb(m, 2) + 0.5 * m * n\n",
    "    total = comb(k + m + n, 2)\n",
    "    return (DD + Dd) / total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7833333333333333"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "domc(2, 2, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8354124748490945"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "domc(30, 24, 17)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7403996865203761"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dom(28, 30, 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7403996865203761"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "domc(28, 30, 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  },
  "vscode": {
   "interpreter": {
    "hash": "c2010a96dc1131647254dc9d17089ca18d8a8993901f6835d02aed957ea2759c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}