Rosalind_Finding_a_Shared_Motif.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Problem\n",
    "\n",
    "A common substring of a collection of strings is a substring of every member of the collection. We say that a common substring is a longest common substring if there does not exist a longer common substring. For example, \"CG\" is a common substring of \"ACGTACGT\" and \"AACCGTATA\", but it is not as long as possible; in this case, \"CGTA\" is a longest common substring of \"ACGTACGT\" and \"AACCGTATA\".\n",
    "\n",
    "Note that the longest common substring is not necessarily unique; for a simple example, \"AA\" and \"CC\" are both longest common substrings of \"AACC\" and \"CCAA\".\n",
    "\n",
    "Given: A collection of k\n",
    "(k≤100) DNA strings of length at most 1 kbp each in FASTA format.\n",
    "\n",
    "Return: A longest common substring of the collection. (If multiple solutions exist, you may return any single solution.)\n",
    "Sample Dataset\n",
    "\n",
    ">Rosalind_1\n",
    "GATTACA\n",
    ">Rosalind_2\n",
    "TAGACCA\n",
    ">Rosalind_3\n",
    "ATACA\n",
    "\n",
    "Sample Output\n",
    "\n",
    "AC\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GATTACA\n"
     ]
    }
   ],
   "source": [
    "r1 = 'GATTACA'\n",
    "r2 = 'TAGACCA'\n",
    "r3 = 'ATACA'\n",
    "\n",
    "print (r1[:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "5\n",
      "5\n",
      "7\n",
      "2\n",
      "{0: 'CA', 1: 'CA'}\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "y = 2\n",
    "l = 0\n",
    "j = 2\n",
    "z = 0\n",
    "round1 = {}\n",
    "\n",
    "for i in r1:\n",
    "    if r1[x:y + z] == r2[l:j + z]:\n",
    "        round1[z] = r1[x:y + z]\n",
    "        z = z + 1\n",
    "    elif r1[x:y + z] != r2 [l:j + z]:\n",
    "        x = x + 1\n",
    "        y = y + 1\n",
    "        j = j + 1\n",
    "        l = l + 1\n",
    "        z = 0\n",
    "\n",
    "print (y)\n",
    "print (x)\n",
    "print (l)\n",
    "print (j)\n",
    "print (z)\n",
    "print (round1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'G': 0, 'GA': 1, 'GAT': 2, 'GATT': 3, 'GATTA': 4, 'GATTAC': 5, 'GATTACA': 6, '': 6, 'A': 6, 'AT': 2, 'ATT': 3, 'ATTA': 4, 'ATTAC': 5, 'ATTACA': 6, 'T': 3, 'TT': 3, 'TTA': 4, 'TTAC': 5, 'TTACA': 6, 'TA': 4, 'TAC': 5, 'TACA': 6, 'AC': 5, 'ACA': 6, 'C': 5, 'CA': 6}\n",
      "0\n",
      "1250\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "r1 = 'GATTACA'\n",
    "r1_dict = {}\n",
    "x = 0\n",
    "y = 0\n",
    "\n",
    "for z in range (0, 10000):\n",
    "    if y < len (r1):\n",
    "        r1_dict[r1[x:y + 1]] = y\n",
    "        y = y + 1\n",
    "    elif y >= len (r1)-1:\n",
    "        x = x + 1\n",
    "        y = 0\n",
    "    \n",
    "print (r1_dict)\n",
    "\n",
    "print (y)\n",
    "print (x)\n",
    "print (len(r1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 'G', 1: 'GA', 2: 'GAT', 3: 'GATT', 4: 'GATTA', 5: 'GATTAC', 6: 'GATTACA'}\n",
      "6\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "r1 = 'GATTACA'\n",
    "r1_dict = {}\n",
    "x = 0\n",
    "y = 0\n",
    "\n",
    "for y in range (0, len (r1)):\n",
    "    r1_dict.update( {y - x : r1[x:y + 1]} )\n",
    "    x = x + 1\n",
    "print (r1_dict)\n",
    "\n",
    "print (y)\n",
    "print (x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'G': 1, 'GA': 2, 'GAT': 3, 'GATT': 4, 'GATTA': 5, 'GATTAC': 6, 'GATTACA': 7, '': 0, 'A': 1, 'AT': 2, 'ATT': 3, 'ATTA': 4, 'ATTAC': 5, 'ATTACA': 6, 'T': 1, 'TT': 2, 'TTA': 3, 'TTAC': 4, 'TTACA': 5, 'TA': 2, 'TAC': 3, 'TACA': 4, 'AC': 2, 'ACA': 3, 'C': 1, 'CA': 2}\n",
      "0\n",
      "1250\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "r1 = 'GATTACA'\n",
    "r1_dict = {}\n",
    "x = 0\n",
    "y = 0\n",
    "\n",
    "for z in range (0, 10000):\n",
    "    if y < len (r1):\n",
    "        r1_dict[r1[x:y + 1]] = len (r1[x:y + 1])\n",
    "        y = y + 1\n",
    "    elif y >= len (r1)-1:\n",
    "        x = x + 1\n",
    "        y = 0\n",
    "    \n",
    "print (r1_dict)\n",
    "\n",
    "print (y)\n",
    "print (x)\n",
    "print (len(r1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'A', 2: 'CA', 3: 'ACA', 4: 'TACA', 5: 'TTACA', 6: 'ATTACA', 7: 'GATTACA', 0: ''}\n",
      "0\n",
      "1250\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "r1 = 'GATTACA'\n",
    "r1_dict = {}\n",
    "x = 0\n",
    "y = 0\n",
    "\n",
    "for z in range (0, 10000):\n",
    "    if y < len (r1):\n",
    "        r1_dict[len (r1[x:y + 1])] = r1[x:y + 1]\n",
    "        y = y + 1\n",
    "    elif y >= len (r1)-1:\n",
    "        x = x + 1\n",
    "        y = 0\n",
    "    \n",
    "print (r1_dict)\n",
    "\n",
    "print (y)\n",
    "print (x)\n",
    "print (len(r1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['G', 'GA', 'GAT', 'GATT', 'GATTA', 'GATTAC', 'GATTACA', 'A', 'AT', 'ATT', 'ATTA', 'ATTAC', 'ATTACA', 'T', 'TT', 'TTA', 'TTAC', 'TTACA', 'T', 'TA', 'TAC', 'TACA', 'A', 'AC', 'ACA', 'C', 'CA', 'A']\n",
      "0\n",
      "1250\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "r1 = 'GATTACA'\n",
    "r1_list = []\n",
    "x = 0\n",
    "y = 0\n",
    "\n",
    "for z in range (0, 10000):\n",
    "    if y < len (r1):\n",
    "        if r1[x:y + 1] != '':\n",
    "            r1_list.append(r1[x:y + 1])\n",
    "        y = y + 1\n",
    "    elif y >= len (r1)-1:\n",
    "        x = x + 1\n",
    "        y = 0\n",
    "    \n",
    "print (r1_list)\n",
    "\n",
    "print (y)\n",
    "print (x)\n",
    "print (len(r1))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "GATTACA\n",
      "0\n",
      "10000\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "r_list = ['GATTACA', 'TAGACCA', 'ATACA']\n",
    "r_list_O = {}\n",
    "for sequence in r_list:\n",
    "    sequence = []\n",
    "    x = 0\n",
    "    y = 0\n",
    "    for z in range (0, 10000):\n",
    "        if y < len (sequence):\n",
    "            if sequence[x:y + 1] != '':\n",
    "                sequence.append(sequence[x:y + 1])\n",
    "            y = y + 1\n",
    "        elif y >= len (sequence)-1:\n",
    "            x = x + 1\n",
    "            y = 0\n",
    "    \n",
    "print (sequence)\n",
    "print ('GATTACA')\n",
    "\n",
    "print (y)\n",
    "print (x)\n",
    "print (len(r1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'GATTACA': {'G': 1, 'GA': 2, 'GAT': 3, 'GATT': 4, 'GATTA': 5, 'GATTAC': 6, 'GATTACA': 7, 'A': 1, 'AT': 2, 'ATT': 3, 'ATTA': 4, 'ATTAC': 5, 'ATTACA': 6, 'T': 1, 'TT': 2, 'TTA': 3, 'TTAC': 4, 'TTACA': 5, 'TA': 2, 'TAC': 3, 'TACA': 4, 'AC': 2, 'ACA': 3, 'C': 1, 'CA': 2}, 'TAGACCA': {'G': 1, 'GA': 2, 'GAT': 3, 'GATT': 4, 'GATTA': 5, 'GATTAC': 6, 'GATTACA': 7, 'A': 1, 'AT': 2, 'ATT': 3, 'ATTA': 4, 'ATTAC': 5, 'ATTACA': 6, 'T': 1, 'TT': 2, 'TTA': 3, 'TTAC': 4, 'TTACA': 5, 'TA': 2, 'TAC': 3, 'TACA': 4, 'AC': 2, 'ACA': 3, 'C': 1, 'CA': 2}, 'ATACA': {'G': 1, 'GA': 2, 'GAT': 3, 'GATT': 4, 'GATTA': 5, 'GATTAC': 6, 'GATTACA': 7, 'A': 1, 'AT': 2, 'ATT': 3, 'ATTA': 4, 'ATTAC': 5, 'ATTACA': 6, 'T': 1, 'TT': 2, 'TTA': 3, 'TTAC': 4, 'TTACA': 5, 'TA': 2, 'TAC': 3, 'TACA': 4, 'AC': 2, 'ACA': 3}}\n",
      "0\n",
      "1250\n",
      "7\n",
      "ATACA\n",
      "0\n",
      "1250\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "r_list = ['GATTACA', 'TAGACCA', 'ATACA']\n",
    "r1_dict = {}\n",
    "for sequence in r_list:\n",
    "    r1_dict[sequence] = {}\n",
    "    x = 0\n",
    "    y = 0\n",
    "\n",
    "    for z in range (0, 10000):\n",
    "        if y < len (r1):\n",
    "            if sequence[x:y + 1] != '':\n",
    "                r1_dict[sequence][r1[x:y + 1]] = len (r1[x:y + 1])\n",
    "            y = y + 1\n",
    "        elif y >= len (r1)-1:\n",
    "            x = x + 1\n",
    "            y = 0\n",
    "    \n",
    "print (r1_dict)\n",
    "\n",
    "print (y)\n",
    "print (x)\n",
    "print (len(r1))\n",
    "\n",
    "    \n",
    "print (sequence)\n",
    "\n",
    "print (y)\n",
    "print (x)\n",
    "print (len(r1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A nested dict is a dictionary within a dictionary. A very simple thing.\n",
    "\n",
    ">>> d = {}\n",
    ">>> d['dict1'] = {}\n",
    ">>> d['dict1']['innerkey'] = 'value'\n",
    ">>> d\n",
    "{'dict1': {'innerkey': 'value'}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r_list = ['GATTACA', 'TAGACCA', 'ATACA']\n",
    "r_list_O = {}\n",
    "for sequence in r_list:\n",
    "    r1_dict[sequence] = {}\n",
    "    x = 0\n",
    "    y = 0\n",
    "\n",
    "    for z in range (0, 10000):\n",
    "        if y < len (r1):\n",
    "            r1_dict[r1[x:y + 1]] = len (r1[x:y + 1])\n",
    "            y = y + 1\n",
    "        elif y >= len (r1)-1:\n",
    "            x = x + 1\n",
    "            y = 0\n",
    "    \n",
    "print (r1_dict)\n",
    "\n",
    "print (y)\n",
    "print (x)\n",
    "print (len(r1))\n",
    "\n",
    "    \n",
    "print (sequence)\n",
    "\n",
    "print (y)\n",
    "print (x)\n",
    "print (len(r1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'GATTACA': {'G': 1, 'GA': 2, 'GAT': 3, 'GATT': 4, 'GATTA': 5, 'GATTAC': 6, 'GATTACA': 7, 'A': 1, 'AT': 2, 'ATT': 3, 'ATTA': 4, 'ATTAC': 5, 'ATTACA': 6, 'T': 1, 'TT': 2, 'TTA': 3, 'TTAC': 4, 'TTACA': 5, 'TA': 2, 'TAC': 3, 'TACA': 4, 'AC': 2, 'ACA': 3, 'C': 1, 'CA': 2}, 'TAGACCA': {'G': 1, 'GA': 2, 'GAT': 3, 'GATT': 4, 'GATTA': 5, 'GATTAC': 6, 'GATTACA': 7, 'A': 1, 'AT': 2, 'ATT': 3, 'ATTA': 4, 'ATTAC': 5, 'ATTACA': 6, 'T': 1, 'TT': 2, 'TTA': 3, 'TTAC': 4, 'TTACA': 5, 'TA': 2, 'TAC': 3, 'TACA': 4, 'AC': 2, 'ACA': 3, 'C': 1, 'CA': 2}, 'ATACA': {'G': 1, 'GA': 2, 'GAT': 3, 'GATT': 4, 'GATTA': 5, 'GATTAC': 6, 'GATTACA': 7, 'A': 1, 'AT': 2, 'ATT': 3, 'ATTA': 4, 'ATTAC': 5, 'ATTACA': 6, 'T': 1, 'TT': 2, 'TTA': 3, 'TTAC': 4, 'TTACA': 5, 'TA': 2, 'TAC': 3, 'TACA': 4, 'AC': 2, 'ACA': 3}}\n",
      "0\n",
      "1250\n",
      "7\n",
      "ATACA\n",
      "0\n",
      "1250\n",
      "7\n",
      "{'G': 1, 'GA': 2, 'GAT': 3, 'GATT': 4, 'GATTA': 5, 'GATTAC': 6, 'GATTACA': 7, 'A': 1, 'AT': 2, 'ATT': 3, 'ATTA': 4, 'ATTAC': 5, 'ATTACA': 6, 'T': 1, 'TT': 2, 'TTA': 3, 'TTAC': 4, 'TTACA': 5, 'TA': 2, 'TAC': 3, 'TACA': 4, 'AC': 2, 'ACA': 3, 'C': 1, 'CA': 2}\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "r_list = ['GATTACA', 'TAGACCA', 'ATACA']\n",
    "r1_dict = {}\n",
    "j = 0\n",
    "for sequence in r_list:\n",
    "    r1_dict[sequence] = {}\n",
    "    x = 0\n",
    "    y = 0\n",
    "    j = j + 1\n",
    "\n",
    "    for z in range (0, 10000):\n",
    "        if y < len (r1):\n",
    "            if sequence[x:y + 1] != '':\n",
    "                r1_dict[sequence][r1[x:y + 1]] = len (r1[x:y + 1])\n",
    "            y = y + 1\n",
    "        elif y >= len (r1)-1:\n",
    "            x = x + 1\n",
    "            y = 0\n",
    "\n",
    "    \n",
    "print (r1_dict)\n",
    "\n",
    "print (y)\n",
    "print (x)\n",
    "print (len(r1))\n",
    "\n",
    "    \n",
    "print (sequence)\n",
    "\n",
    "print (y)\n",
    "print (x)\n",
    "print (len(r1))\n",
    "\n",
    "\n",
    "print (r1_dict[r_list[0]])\n",
    "print (j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'G': 1, 'GA': 2, 'GAT': 3, 'GATT': 4, 'GATTA': 5, 'GATTAC': 6, 'GATTACA': 7, 'A': 1, 'AT': 2, 'ATT': 3, 'ATTA': 4, 'ATTAC': 5, 'ATTACA': 6, 'T': 1, 'TT': 2, 'TTA': 3, 'TTAC': 4, 'TTACA': 5, 'TA': 2, 'TAC': 3, 'TACA': 4, 'AC': 2, 'ACA': 3, 'C': 1, 'CA': 2}\n",
      "{'G': 1, 'GA': 2, 'GAT': 3, 'GATT': 4, 'GATTA': 5, 'GATTAC': 6, 'GATTACA': 7, 'A': 1, 'AT': 2, 'ATT': 3, 'ATTA': 4, 'ATTAC': 5, 'ATTACA': 6, 'T': 1, 'TT': 2, 'TTA': 3, 'TTAC': 4, 'TTACA': 5, 'TA': 2, 'TAC': 3, 'TACA': 4, 'AC': 2, 'ACA': 3, 'C': 1, 'CA': 2}\n",
      "{'G': 1, 'GA': 2, 'GAT': 3, 'GATT': 4, 'GATTA': 5, 'GATTAC': 6, 'GATTACA': 7, 'A': 1, 'AT': 2, 'ATT': 3, 'ATTA': 4, 'ATTAC': 5, 'ATTACA': 6, 'T': 1, 'TT': 2, 'TTA': 3, 'TTAC': 4, 'TTACA': 5, 'TA': 2, 'TAC': 3, 'TACA': 4, 'AC': 2, 'ACA': 3}\n"
     ]
    }
   ],
   "source": [
    "l = 0\n",
    "for i in range (0, j):\n",
    "    print (r1_dict[r_list[i]])\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-87-5f371fc2bcfc>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-87-5f371fc2bcfc>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    print (r1_dict[r_list[i][6])\u001b[0m\n\u001b[0m                               ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "for i in range (0, j):\n",
    "    e = 0\n",
    "    print (r1_dict[r_list[i][6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'GATTACA': ['G', 'GA', 'GAT', 'GATT', 'GATTA', 'GATTAC', 'GATTACA', 'A', 'AT', 'ATT', 'ATTA', 'ATTAC', 'ATTACA', 'T', 'TT', 'TTA', 'TTAC', 'TTACA', 'T', 'TA', 'TAC', 'TACA', 'A', 'AC', 'ACA', 'C', 'CA', 'A'], 'TAGACCA': ['G', 'GA', 'GAT', 'GATT', 'GATTA', 'GATTAC', 'GATTACA', 'A', 'AT', 'ATT', 'ATTA', 'ATTAC', 'ATTACA', 'T', 'TT', 'TTA', 'TTAC', 'TTACA', 'T', 'TA', 'TAC', 'TACA', 'A', 'AC', 'ACA', 'C', 'CA', 'A'], 'ATACA': ['G', 'GA', 'GAT', 'GATT', 'GATTA', 'GATTAC', 'GATTACA', 'A', 'AT', 'ATT', 'ATTA', 'ATTAC', 'ATTACA', 'T', 'TT', 'TTA', 'TTAC', 'TTACA', 'T', 'TA', 'TAC', 'TACA', 'A', 'AC', 'ACA']}\n",
      "0\n",
      "1250\n",
      "7\n",
      "ATACA\n",
      "0\n",
      "1250\n",
      "7\n",
      "['G', 'GA', 'GAT', 'GATT', 'GATTA', 'GATTAC', 'GATTACA', 'A', 'AT', 'ATT', 'ATTA', 'ATTAC', 'ATTACA', 'T', 'TT', 'TTA', 'TTAC', 'TTACA', 'T', 'TA', 'TAC', 'TACA', 'A', 'AC', 'ACA', 'C', 'CA', 'A']\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "r_list = ['GATTACA', 'TAGACCA', 'ATACA']\n",
    "r1_dict = {}\n",
    "j = 0\n",
    "for sequence in r_list:\n",
    "    r1_dict[sequence] = []\n",
    "    x = 0\n",
    "    y = 0\n",
    "    j = j + 1\n",
    "\n",
    "    for z in range (0, 10000):\n",
    "        if y < len (r1):\n",
    "            if sequence[x:y + 1] != '':\n",
    "                r1_dict[sequence].append(r1[x:y + 1])\n",
    "            y = y + 1\n",
    "        elif y >= len (r1)-1:\n",
    "            x = x + 1\n",
    "            y = 0\n",
    "\n",
    "    \n",
    "print (r1_dict)\n",
    "\n",
    "print (y)\n",
    "print (x)\n",
    "print (len(r1))\n",
    "\n",
    "    \n",
    "print (sequence)\n",
    "\n",
    "print (y)\n",
    "print (x)\n",
    "print (len(r1))\n",
    "\n",
    "\n",
    "print (r1_dict[r_list[0]])\n",
    "print (j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['G', 'GA', 'GAT', 'GATT', 'GATTA', 'GATTAC', 'GATTACA', 'A', 'AT', 'ATT', 'ATTA', 'ATTAC', 'ATTACA', 'T', 'TT', 'TTA', 'TTAC', 'TTACA', 'T', 'TA', 'TAC', 'TACA', 'A', 'AC', 'ACA', 'C', 'CA', 'A']\n",
      "['G', 'GA', 'GAT', 'GATT', 'GATTA', 'GATTAC', 'GATTACA', 'A', 'AT', 'ATT', 'ATTA', 'ATTAC', 'ATTACA', 'T', 'TT', 'TTA', 'TTAC', 'TTACA', 'T', 'TA', 'TAC', 'TACA', 'A', 'AC', 'ACA', 'C', 'CA', 'A']\n",
      "['G', 'GA', 'GAT', 'GATT', 'GATTA', 'GATTAC', 'GATTACA', 'A', 'AT', 'ATT', 'ATTA', 'ATTAC', 'ATTACA', 'T', 'TT', 'TTA', 'TTAC', 'TTACA', 'T', 'TA', 'TAC', 'TACA', 'A', 'AC', 'ACA', 'C', 'CA', 'A']\n"
     ]
    }
   ],
   "source": [
    "for i in range (0, j):\n",
    "    e = 0\n",
    "    print (r1_dict[r_list[0]])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'GATTACA': {'G': 1, 'GA': 2, 'GAT': 3, 'GATT': 4, 'GATTA': 5, 'GATTAC': 6, 'GATTACA': 7, 'A': 1, 'AT': 2, 'ATT': 3, 'ATTA': 4, 'ATTAC': 5, 'ATTACA': 6, 'T': 1, 'TT': 2, 'TTA': 3, 'TTAC': 4, 'TTACA': 5, 'TA': 2, 'TAC': 3, 'TACA': 4, 'AC': 2, 'ACA': 3, 'C': 1, 'CA': 2}, 'TAGACCA': {'G': 1, 'GA': 2, 'GAT': 3, 'GATT': 4, 'GATTA': 5, 'GATTAC': 6, 'GATTACA': 7, 'A': 1, 'AT': 2, 'ATT': 3, 'ATTA': 4, 'ATTAC': 5, 'ATTACA': 6, 'T': 1, 'TT': 2, 'TTA': 3, 'TTAC': 4, 'TTACA': 5, 'TA': 2, 'TAC': 3, 'TACA': 4, 'AC': 2, 'ACA': 3, 'C': 1, 'CA': 2}, 'ATACA': {'G': 1, 'GA': 2, 'GAT': 3, 'GATT': 4, 'GATTA': 5, 'GATTAC': 6, 'GATTACA': 7, 'A': 1, 'AT': 2, 'ATT': 3, 'ATTA': 4, 'ATTAC': 5, 'ATTACA': 6, 'T': 1, 'TT': 2, 'TTA': 3, 'TTAC': 4, 'TTACA': 5, 'TA': 2, 'TAC': 3, 'TACA': 4, 'AC': 2, 'ACA': 3}}\n",
      "{'G': 1, 'GA': 2, 'GAT': 3, 'GATT': 4, 'GATTA': 5, 'GATTAC': 6, 'GATTACA': 7, 'A': 1, 'AT': 2, 'ATT': 3, 'ATTA': 4, 'ATTAC': 5, 'ATTACA': 6, 'T': 1, 'TT': 2, 'TTA': 3, 'TTAC': 4, 'TTACA': 5, 'TA': 2, 'TAC': 3, 'TACA': 4, 'AC': 2, 'ACA': 3, 'C': 1, 'CA': 2}\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "r_list = ['GATTACA', 'TAGACCA', 'ATACA'] #make list of all sequences\n",
    "r_dict = {} #make empty dictionary to contain sequence contents\n",
    "j = 0 #iterate from start point\n",
    "for sequence in r_list: #iterate over the values in r_list and for each do the following:\n",
    "    r_dict[sequence] = {} #create key value pair in r_dict where Key= sequence ('GATT...') value = empty dict {} \n",
    "    x = 0 #each time you iterate x starts at 1\n",
    "    y = 0 #so does y\n",
    "    \n",
    "\n",
    "    for z in range (0, 10000): #for a variable in the range of 0 to a big number\n",
    "        r = r_list[0]\n",
    "        if y < len (r): # while y is less than the length of the value in the list \n",
    "            if sequence[x:y + 1] != '': #if the entry is a value not empty\n",
    "                r_dict[sequence][r[x:y + 1]] = len (r[x:y + 1]) #make \n",
    "            y = y + 1 #increase y by one and repeat\n",
    "        elif y >= len (r)-1: #else when y is greater than the length \n",
    "            x = x + 1 #increase x (to iterate) increasing the start value\n",
    "            y = 0 #and set y back to zero \n",
    "    j = j + 1 # and j increases by 1 (i.e. 0,1,2,3....) i.e. iterate up\n",
    "    \n",
    "print (r_dict)\n",
    "print (r_dict[r_list[0]])\n",
    "print (j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r_list = ['GATTACA', 'TAGACCA', 'ATACA'] #make list of all sequences\n",
    "r_dict = {} #make empty dictionary to contain sequence contents\n",
    "j = 0 #iterate from start point\n",
    "k = 0\n",
    "x = 0\n",
    "y = 0\n",
    "for z in range (0, 100): #for a variable in the range of 0 to a big number\n",
    "    rz = r_list[z] #the first entry in the sequences\n",
    "    rk = r_list[k] #subsequent entries starting with number 2\n",
    "    if y < len (rz): # while y is less than the length of the value in the list \n",
    "        if rz[x:y + 1] != '' and rz[x:y + 1]: #if the entry is a value not empty\n",
    "            r_dict[sequence][r[x:y + 1]] = len (r[x:y + 1]) #make \n",
    "        y = y + 1 #increase y by one and repeat\n",
    "    elif y >= len (r)-1: #else when y is greater than the length \n",
    "        x = x + 1 #increase x (to iterate) increasing the start value\n",
    "        y = 0 #and set y back to zero \n",
    "    j = j + 1 # and j increases by 1 (i.e. 0,1,2,3....) i.e. iterate up\n",
    "    \n",
    "print (r_dict)\n",
    "print (r_dict[r_list[0]])\n",
    "print (j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'builtin_function_or_method' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-11-a1392247b708>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     13\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0msequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0my\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[0;31m#if the entry is a value not empty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m                 \u001b[0mseq\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mr_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msequence\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m                 \u001b[0mseq\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0my\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m  \u001b[0;31m#make\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     16\u001b[0m             \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;31m#increase y by one and repeat\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0mlen\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m#else when y is greater than the length\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'builtin_function_or_method' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "r_list = ['GATTACA', 'TAGACCA', 'ATACA'] #make list of all sequences\n",
    "r_dict = {} #make empty dictionary to contain sequence contents\n",
    "j = 0 #iterate from start point\n",
    "for sequence in r_list: #iterate over the values in r_list and for each do the following:\n",
    "    r_dict[sequence] = [] #create key value pair in r_dict where Key= sequence ('GATT...') value = empty dict {} \n",
    "    x = 0 #each time you iterate x starts at 1\n",
    "    y = 0 #so does y\n",
    "    \n",
    "\n",
    "    for z in range (0, 10000): #for a variable in the range of 0 to a big number\n",
    "        r = r_list[0]\n",
    "        if y < len (r): # while y is less than the length of the value in the list \n",
    "            if sequence[x:y + 1] != '': #if the entry is a value not empty\n",
    "                seq = r_dict[sequence]\n",
    "                seq.append[sequence[x:y + 1]]  #make \n",
    "            y = y + 1 #increase y by one and repeat\n",
    "        elif y >= len (r)-1: #else when y is greater than the length \n",
    "            x = x + 1 #increase x (to iterate) increasing the start value\n",
    "            y = 0 #and set y back to zero \n",
    "    j = j + 1 # and j increases by 1 (i.e. 0,1,2,3....) i.e. iterate up\n",
    "    \n",
    "print (r_dict)\n",
    "print (r_dict[r_list[0]])\n",
    "print (j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2: 'CA'}\n"
     ]
    }
   ],
   "source": [
    "sequences = ['GATTACA', 'TAGACCA', 'ATACA'] #make list of all sequences\n",
    "substrings = ['ACTT', 'CA', 'A'] #make list of all substrings in r_list[0]\n",
    "substring_dict = {}\n",
    "x = 0\n",
    "j = 0\n",
    "for i in sequences: # for the strings in the list of sequences\n",
    "    if substrings[x] in i: # if the substring is found in the sequences\n",
    "        j = j + 1 # keep track of which substring and iterate upwards\n",
    "        if j == len (sequences)-1: # if you have gone through the entire list of sequences and substring is in all\n",
    "            size = len (substrings[x])\n",
    "            substring_dict[size] = substrings[x] # print the substring and its length\n",
    "            x = x + 1 #move to the next substring\n",
    "            j = 0 #set j back to 0 to start over iterating\n",
    "    else: #if this isn't the case\n",
    "        x = x + 1 #move to the next substring\n",
    "        \n",
    "len (sequences)\n",
    "print (substring_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "{1: 'C'}\n",
      "GATTACA\n",
      "2\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "sequences = ['GATTACA', 'TAGACCA', 'ATACA'] #make list of all sequences\n",
    "substrings = ['CA', 'C', 'TA'] #make list of all substrings in sequences[0]\n",
    "substring_dict = {}\n",
    "x = 0 #start of tracking substrings\n",
    "j = 0 #start of tracking sequences\n",
    "for x in range (0, len(substrings)-1):\n",
    "    if substrings[x] in sequences[j]: # if the substring is found in the sequences\n",
    "        j = j + 1 # keep track of which substring and iterate upwards\n",
    "        if j == len (sequences)-1: # if you have gone through the entire list of sequences and substring is in all\n",
    "            size = len (substrings[x])\n",
    "            substring_dict[size] = substrings[x] # print the substring and its length\n",
    "            x = x + 1 #move to the next substring\n",
    "            j = 0 #set j back to 0 to start over iterating\n",
    "        else: #if this isn't the case\n",
    "            x = x + 1 #move to the next substring\n",
    "    else: #if this isn't the case\n",
    "        x = x + 1 #move to the next substring \n",
    "        j = 0\n",
    "print (len (substrings[1]))\n",
    "print (substring_dict)\n",
    "print (sequences[j])\n",
    "print (x)\n",
    "print (j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "{2: 'C', 1: 'CA'}\n",
      "GATTACA\n",
      "3\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "sequences = ['GATTACA', 'TAGACCA', 'ATACA'] #make list of all sequences\n",
    "substrings = ['CA', 'C', 'TA', 'A'] #make list of all substrings in sequences[0]\n",
    "substring_dict = {}\n",
    "x = 0 #start of tracking substrings\n",
    "j = 0 #start of tracking sequences\n",
    "for x in range (0, len(substrings)-1):\n",
    "    if substrings[x] in sequences[j]: # if the substring is found in the sequences\n",
    "        while j < len (sequences)-1: \n",
    "            if substrings[x] in sequences[j]:\n",
    "                j = j + 1 # keep track of which substring and iterate upwards\n",
    "            else:\n",
    "                j = 0\n",
    "                x = x + 1\n",
    "        if j == len (sequences)-1: # if you have gone through the entire list of sequences and substring is in all\n",
    "            size = len (substrings[x])\n",
    "            substring_dict[size] = substrings[x] # print the substring and its length\n",
    "            x = x + 1 #move to the next substring\n",
    "            j = 0 #set j back to 0 to start over iterating\n",
    "        else: #if this isn't the case\n",
    "            x = x + 1 #move to the next substring\n",
    "    else: #if this isn't the case\n",
    "        x = x + 1 #move to the next substring \n",
    "        j = 0\n",
    "print (len (substrings[1]))\n",
    "print (substring_dict)\n",
    "print (sequences[j])\n",
    "print (x)\n",
    "print (j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-101-3e7769e1bc4c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\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[1;32m      7\u001b[0m     \u001b[0;32mwhile\u001b[0m \u001b[0mj\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mlen\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0msequences\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m#while j < len (sequences)-1:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m         \u001b[0;32mif\u001b[0m \u001b[0msubstrings\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msequences\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# if the substring is found in the sequences\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m             \u001b[0mj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mj\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;31m# keep track of which substring and iterate upwards\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mj\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mlen\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0msequences\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# if you have gone through the entire list of sequences and substring is in all\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "sequences = ['GATTACA', 'TAGACCA', 'ATACA'] #make list of all sequences\n",
    "substrings = ['CA', 'C', 'TA', 'A'] #make list of all substrings in sequences[0]\n",
    "substring_dict = {}\n",
    "x = 0 #start of tracking substrings\n",
    "j = 0 #start of tracking sequences\n",
    "for x in range (0, 3):\n",
    "    while j in range (0,2): #while j < len (sequences)-1:\n",
    "        if substrings[x] in sequences[j]: # if the substring is found in the sequences\n",
    "            j = j + 1 # keep track of which substring and iterate upwards\n",
    "            if j == len (sequences)-1: # if you have gone through the entire list of sequences and substring is in all\n",
    "                size = len (substrings[x])\n",
    "                substring_dict[size] = substrings[x] # print the substring and its length\n",
    "                x = x + 1 #move to the next substring\n",
    "                j = 0 #set j back to 0 to start over iterating\n",
    "        elif substrings[x] not in sequences[j]: #if this isn't the case\n",
    "            x = x + 1 #move to the next substring \n",
    "            j = 0\n",
    "print (len (substrings[1]))\n",
    "print (substring_dict)\n",
    "print (sequences[j])\n",
    "print (x)\n",
    "print (j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-70196189cb0a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\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[1;32m      7\u001b[0m     \u001b[0;32mwhile\u001b[0m \u001b[0mj\u001b[0m \u001b[0;34m<=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m         \u001b[0;32mif\u001b[0m \u001b[0msubstrings\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msequences\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# if the substring is found in the sequences\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m             \u001b[0mj\u001b[0m \u001b[0;34m=\u001b[0m  \u001b[0mj\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mj\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mlen\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0msequences\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# if you have gone through the entire list of sequences and substring is in all\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "sequences = ['GATTACA', 'TAGACCA', 'ATAA'] #make list of all sequences\n",
    "substrings = ['CA', 'C', 'TA', 'A'] #make list of all substrings in sequences[0]\n",
    "substring_dict = {}\n",
    "x = 0 #start of tracking substrings\n",
    "j = 0 #start of tracking sequences\n",
    "for x in range (0, 2):\n",
    "    while j <= 2: \n",
    "        if substrings[x] in sequences[j]: # if the substring is found in the sequences\n",
    "            j =  j + 1\n",
    "            if j == len (sequences)-1: # if you have gone through the entire list of sequences and substring is in all\n",
    "                size = len (substrings[x])\n",
    "                substring_dict[size] = substrings[x] # print the substring and its length\n",
    "                x = x + 1 #move to the next substring\n",
    "                j = 0 #set j back to 0 to start over iterating        \n",
    "        else: #if this isn't the case\n",
    "            continue\n",
    "\n",
    "print (len (substrings[1]))\n",
    "print (substring_dict)\n",
    "print (sequences[j])\n",
    "print (x)\n",
    "print (j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'T', 'G', 'C', 'G', 'GA', 'GAT', 'GATT', 'GATTA', 'GATTAC', 'GATTACA', 'A', 'AT', 'ATT', 'ATTA', 'ATTAC', 'ATTACA', 'T', 'TT', 'TTA', 'TTAC', 'TTACA', 'T', 'TA', 'TAC', 'TACA', 'A', 'AC', 'ACA', 'C', 'CA', 'A', 'T', 'TA', 'TAG', 'TAGA', 'TAGAC', 'TAGACC', 'TAGACCA', 'A', 'AG', 'AGA', 'AGAC', 'AGACC', 'AGACCA', 'G', 'GA', 'GAC', 'GACC', 'GACCA', 'A', 'AC', 'ACC', 'ACCA', 'C', 'CC', 'CCA', 'C', 'CA', 'A', 'A', 'AT', 'ATA', 'ATAC', 'ATACA', 'T', 'TA', 'TAC', 'TACA', 'A', 'AC', 'ACA', 'C', 'CA', 'A']\n",
      "4\n",
      "1666\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "r_list = ['GATTACA', 'TAGACCA', 'ATACA']\n",
    "r1_dict = ['A','T','G','C']\n",
    "j = 0\n",
    "for sequence in r_list:\n",
    "    x = 0\n",
    "    y = 0\n",
    "    j = j + 1\n",
    "\n",
    "    for z in range (0, 10000):\n",
    "        if y < len  (sequence):\n",
    "            if sequence[x:y + 1] != '':\n",
    "                r1_dict.append(sequence[x:y + 1])\n",
    "            y = y + 1\n",
    "        elif y >= len (sequence)-1:\n",
    "            x = x + 1\n",
    "            y = 0\n",
    "\n",
    "    \n",
    "print (r1_dict)\n",
    "\n",
    "print (y)\n",
    "print (x)\n",
    "print (len(sequence))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'T', 'C', 'G', 'GAT', 'GATT', 'GATTAC', 'GATTACA', 'AT', 'ATT', 'ATTAC', 'ATTACA', 'TT', 'TTA', 'TTAC', 'T', 'TA', 'TACA', 'A', 'ACA', 'C', 'A', 'T', 'TAG', 'TAGA', 'TAGACC', 'TAGACCA', 'A', 'AG', 'AGAC', 'AGACC', 'AGACCA', 'GA', 'GAC', 'GACCA', 'A', 'AC', 'ACC', 'C', 'CC', 'C', 'CA', 'A', 'AT', 'ATAC', 'ATACA', 'T', 'TAC', 'TACA', 'AC', 'ACA', 'CA', 'A']\n",
      "['G', 'GAT', 'GATT', 'GATTAC', 'GATTACA', 'ATT', 'ATTAC', 'ATTACA', 'TT', 'TTA', 'TTAC', 'TAG', 'TAGA', 'TAGACC', 'TAGACCA', 'AG', 'AGAC', 'AGACC', 'AGACCA', 'GA', 'GAC', 'GACCA', 'ACC', 'CC']\n"
     ]
    }
   ],
   "source": [
    "sequences = ['GATTACA', 'TAGACCA', 'ATACA'] #make list of all sequences\n",
    "z=0\n",
    "notin = []\n",
    "for i in r1_dict:\n",
    "    if i in sequences[z] and z in range (0, len (sequences) -1):\n",
    "        z = z + 1\n",
    "    elif i not in sequences[z]:\n",
    "        notin.append(i)\n",
    "\n",
    "\n",
    "print (r1_dict)\n",
    "print (notin)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'T', 'C', 'AT', 'T', 'TA', 'TACA', 'A', 'ACA', 'C', 'A', 'T', 'A', 'A', 'AC', 'C', 'C', 'CA', 'A', 'AT', 'ATAC', 'ATACA', 'T', 'TAC', 'TACA', 'AC', 'ACA', 'CA', 'A']\n"
     ]
    }
   ],
   "source": [
    "lst3 = [value for value in r1_dict if value not in notin] \n",
    "\n",
    "print (lst3)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the above code is stating that the list iterates and adds a value to the new list for each value in R1_dict that is not present in the notin list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "{2: 'TA', 1: 'C'}\n",
      "GATTACA\n",
      "3\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "sequences = ['GATTACA', 'TAGACCA', 'ATACA'] #make list of all sequences\n",
    "substrings = ['CA', 'C', 'TA', 'A'] #make list of all substrings in sequences[0]\n",
    "substring_dict = {}\n",
    "x = 0 #start of tracking substrings\n",
    "j = 0 #start of tracking sequences\n",
    "for x in range (0, len(substrings)-1):\n",
    "    if substrings[x] in sequences[j]: # if the substring is found in the sequences\n",
    "        while j < len (sequences)-1: \n",
    "            if substrings[x] in sequences[j]:\n",
    "                j = j + 1 # keep track of which substring and iterate upwards\n",
    "            else:\n",
    "                j = 0\n",
    "                x = x + 1\n",
    "        if j == len (sequences)-1: # if you have gone through the entire list of sequences and substring is in all\n",
    "            size = len (substrings[x])\n",
    "            substring_dict[size] = substrings[x] # print the substring and its length\n",
    "            x = x + 1 #move to the next substring\n",
    "            j = 0 #set j back to 0 to start over iterating\n",
    "        else: #if this isn't the case\n",
    "            x = x + 1 #move to the next substring\n",
    "    else: #if this isn't the case\n",
    "        x = x + 1 #move to the next substring \n",
    "        j = 0\n",
    "print (len (substrings[1]))\n",
    "print (substring_dict)\n",
    "print (sequences[j])\n",
    "print (x)\n",
    "print (j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 TA\n",
      "1\n",
      "{2: 'TA'}\n",
      "TAGACCA\n",
      "A\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "sequences = ['GATTACA', 'TAGACCA', 'ATACA'] #make list of all sequences\n",
    "substrings = ['CA', 'C', 'TA', 'A'] #make list of all substrings in sequences[0]\n",
    "substring_dict = {}\n",
    "j = 0 #start of tracking sequences\n",
    "for x in substrings:\n",
    "    if x in sequences[j]: # if the substring is found in the sequences\n",
    "        j = j + 1\n",
    "        if j < len (sequences):\n",
    "            continue\n",
    "        elif j == len (sequences)-1: # if you have gone through the entire list of sequences and substring is in all\n",
    "            size = len (x)\n",
    "            print (size, x)\n",
    "            substring_dict[size] = x # print the substring and its length\n",
    "            j = 0 #set j back to 0 to start over iterating\n",
    "            break # move to next substring\n",
    "    elif x not in sequences[j]:\n",
    "        j = 0\n",
    "        continue\n",
    "           \n",
    "print (len (substrings[1]))\n",
    "print (substring_dict)\n",
    "print (sequences[j])\n",
    "print (x)\n",
    "print (j)"
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}