Assignement 3 Sequencing By Hybridization _ Diego Serra.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6c6466f1",
   "metadata": {},
   "source": [
    "# Algorithms in Computational Biology | Diego Serra\n",
    "# Assignment 3: Sequencing by hybridization"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6833f93f",
   "metadata": {},
   "source": [
    "### Sequencing by hybridization"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e79614c7",
   "metadata": {},
   "source": [
    "Given an unknown DNA sequence, an array provides information about\n",
    "all strings of length l that the sequence contains, but does not provide information about their positions in the sequence. For a string $s$ of length $l$, the $l$-mer composition or $spectrum$ is the multiset of $n-l + 1 l$-mers in $s$ and is written $Spectrum(s, l)$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "331fe40b",
   "metadata": {},
   "source": [
    "#### The objective of this code will be to to sequence a target DNA fragment from its DNA array data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e999f090",
   "metadata": {},
   "source": [
    "To solve this problem, I will based my approach on Graph theory and Eulerian path. Therefore, this work will be divided in 4 main steps :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c7bc51e",
   "metadata": {},
   "source": [
    "1) Write a spectrum(s,l) function that will return a dictionnary that maps each length-l DNA sequence to the number of times it appears in s.\n",
    "\n",
    "2) Write a graphFromSpectrum(A) function that will maps the (names of) the vertices to a list of the destinations of the directed edges that begin in that vertex. --> directed multigraph\n",
    "\n",
    "3) Write a function EulerPath(G) that will find an Eulerian path in the constructed graph. \n",
    "\n",
    "4) Write a function stringFromPath(P) that will reconstruct the DNA sequence from the Eulerian path"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e85e4d05",
   "metadata": {},
   "source": [
    "### Step 1: $Spectrum(l,s)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a8afdbc1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "eaa5f14a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def spectrum(l, s):\n",
    "    \"\"\" This function is used to return a dictionarry that maps all the possible l-mer to the number of times they appear \n",
    "        in the string.\n",
    "        ::paramater:: l is the length of the desired l-mer. \n",
    "        ::parameter:: s is the original string from which the l-mer are derived.\n",
    "        ::output:: spectrum is a dictionnary.\n",
    "    \"\"\"\n",
    "    # Generation of the dictionnary with all possibe length-l DNA fragments.\n",
    "    spectrum = {} \n",
    "    combinations = [''.join(i) for i in itertools.product('atgc', repeat = l)]\n",
    "    \n",
    "    for i in combinations:\n",
    "        spectrum[i] = 0\n",
    "    \n",
    "    # Fill the dictionnary with the length-l s fragments.\n",
    "    \n",
    "    j = 0\n",
    "    \n",
    "    while j < len(s) - l + 1: # Max number of l-mer = len(s)-l+1\n",
    "        \n",
    "        spectrum[s[j:j+l]] += 1\n",
    "        j+= 1\n",
    "        \n",
    "    return spectrum\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b5987dcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def printSpectrum(spectrum): \n",
    "    \"\"\" This function is used to print out nicely the spectrum.\n",
    "        ::param:: spectrum is a dictionnary that maps all the possible l-mer to the number of times they appear \n",
    "        in a string.\n",
    "    \"\"\" \n",
    "        \n",
    "    spacing = 0\n",
    "    \n",
    "    for key, val in spectrum.items():\n",
    "            \n",
    "        if spacing == 4: # 4 columns\n",
    "            print('\\n')\n",
    "            spacing = 0\n",
    "            \n",
    "        print(key,val, end='  ')\n",
    "        spacing += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9f7e189c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def randomDNA(length):\n",
    "    \"\"\" This function is used to return a random DNA sequence of length: lenght.\n",
    "        ::param:: length is the length of the desired random sequence\n",
    "        ::output:: random DNA sequence.\n",
    "    \"\"\"\n",
    "    random_dna = \"\".join(random.choice('atgc') for i in range(length))\n",
    "    \n",
    "    return random_dna"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b57f5c3",
   "metadata": {},
   "source": [
    "<b>Function Test :</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d4f238df",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original string:  tgacatgtgaattacatgtt\n",
      "\n",
      "aaaa 0  aaat 0  aaag 0  aaac 0  \n",
      "\n",
      "aata 0  aatt 1  aatg 0  aatc 0  \n",
      "\n",
      "aaga 0  aagt 0  aagg 0  aagc 0  \n",
      "\n",
      "aaca 0  aact 0  aacg 0  aacc 0  \n",
      "\n",
      "ataa 0  atat 0  atag 0  atac 0  \n",
      "\n",
      "atta 1  attt 0  attg 0  attc 0  \n",
      "\n",
      "atga 0  atgt 2  atgg 0  atgc 0  \n",
      "\n",
      "atca 0  atct 0  atcg 0  atcc 0  \n",
      "\n",
      "agaa 0  agat 0  agag 0  agac 0  \n",
      "\n",
      "agta 0  agtt 0  agtg 0  agtc 0  \n",
      "\n",
      "agga 0  aggt 0  aggg 0  aggc 0  \n",
      "\n",
      "agca 0  agct 0  agcg 0  agcc 0  \n",
      "\n",
      "acaa 0  acat 2  acag 0  acac 0  \n",
      "\n",
      "acta 0  actt 0  actg 0  actc 0  \n",
      "\n",
      "acga 0  acgt 0  acgg 0  acgc 0  \n",
      "\n",
      "acca 0  acct 0  accg 0  accc 0  \n",
      "\n",
      "taaa 0  taat 0  taag 0  taac 0  \n",
      "\n",
      "tata 0  tatt 0  tatg 0  tatc 0  \n",
      "\n",
      "taga 0  tagt 0  tagg 0  tagc 0  \n",
      "\n",
      "taca 1  tact 0  tacg 0  tacc 0  \n",
      "\n",
      "ttaa 0  ttat 0  ttag 0  ttac 1  \n",
      "\n",
      "ttta 0  tttt 0  tttg 0  tttc 0  \n",
      "\n",
      "ttga 0  ttgt 0  ttgg 0  ttgc 0  \n",
      "\n",
      "ttca 0  ttct 0  ttcg 0  ttcc 0  \n",
      "\n",
      "tgaa 1  tgat 0  tgag 0  tgac 1  \n",
      "\n",
      "tgta 0  tgtt 1  tgtg 1  tgtc 0  \n",
      "\n",
      "tgga 0  tggt 0  tggg 0  tggc 0  \n",
      "\n",
      "tgca 0  tgct 0  tgcg 0  tgcc 0  \n",
      "\n",
      "tcaa 0  tcat 0  tcag 0  tcac 0  \n",
      "\n",
      "tcta 0  tctt 0  tctg 0  tctc 0  \n",
      "\n",
      "tcga 0  tcgt 0  tcgg 0  tcgc 0  \n",
      "\n",
      "tcca 0  tcct 0  tccg 0  tccc 0  \n",
      "\n",
      "gaaa 0  gaat 1  gaag 0  gaac 0  \n",
      "\n",
      "gata 0  gatt 0  gatg 0  gatc 0  \n",
      "\n",
      "gaga 0  gagt 0  gagg 0  gagc 0  \n",
      "\n",
      "gaca 1  gact 0  gacg 0  gacc 0  \n",
      "\n",
      "gtaa 0  gtat 0  gtag 0  gtac 0  \n",
      "\n",
      "gtta 0  gttt 0  gttg 0  gttc 0  \n",
      "\n",
      "gtga 1  gtgt 0  gtgg 0  gtgc 0  \n",
      "\n",
      "gtca 0  gtct 0  gtcg 0  gtcc 0  \n",
      "\n",
      "ggaa 0  ggat 0  ggag 0  ggac 0  \n",
      "\n",
      "ggta 0  ggtt 0  ggtg 0  ggtc 0  \n",
      "\n",
      "ggga 0  gggt 0  gggg 0  gggc 0  \n",
      "\n",
      "ggca 0  ggct 0  ggcg 0  ggcc 0  \n",
      "\n",
      "gcaa 0  gcat 0  gcag 0  gcac 0  \n",
      "\n",
      "gcta 0  gctt 0  gctg 0  gctc 0  \n",
      "\n",
      "gcga 0  gcgt 0  gcgg 0  gcgc 0  \n",
      "\n",
      "gcca 0  gcct 0  gccg 0  gccc 0  \n",
      "\n",
      "caaa 0  caat 0  caag 0  caac 0  \n",
      "\n",
      "cata 0  catt 0  catg 2  catc 0  \n",
      "\n",
      "caga 0  cagt 0  cagg 0  cagc 0  \n",
      "\n",
      "caca 0  cact 0  cacg 0  cacc 0  \n",
      "\n",
      "ctaa 0  ctat 0  ctag 0  ctac 0  \n",
      "\n",
      "ctta 0  cttt 0  cttg 0  cttc 0  \n",
      "\n",
      "ctga 0  ctgt 0  ctgg 0  ctgc 0  \n",
      "\n",
      "ctca 0  ctct 0  ctcg 0  ctcc 0  \n",
      "\n",
      "cgaa 0  cgat 0  cgag 0  cgac 0  \n",
      "\n",
      "cgta 0  cgtt 0  cgtg 0  cgtc 0  \n",
      "\n",
      "cgga 0  cggt 0  cggg 0  cggc 0  \n",
      "\n",
      "cgca 0  cgct 0  cgcg 0  cgcc 0  \n",
      "\n",
      "ccaa 0  ccat 0  ccag 0  ccac 0  \n",
      "\n",
      "ccta 0  cctt 0  cctg 0  cctc 0  \n",
      "\n",
      "ccga 0  ccgt 0  ccgg 0  ccgc 0  \n",
      "\n",
      "ccca 0  ccct 0  cccg 0  cccc 0  "
     ]
    }
   ],
   "source": [
    "random_dna = randomDNA(20)\n",
    "print('Original string: ', random_dna)\n",
    "print('')\n",
    "S = spectrum(4, random_dna)\n",
    "printSpectrum(S)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "279fc50f",
   "metadata": {},
   "source": [
    "### Step 2: $graphFromSpectrum(A)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9040862b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def graphFromSpectrum(spectrum):\n",
    "    \"\"\" This function is used to return a dictionnary that will maps the (names of) the vertices to a list of \n",
    "        the destinations of the directed edges that begin in that vertex.\n",
    "        ::param:: spectrum  is a dictionnary that maps  all the possible l-mer to the number of times they appear \n",
    "        in a string.\n",
    "        ::output:: a Graph that maps the vertices to a list of adjencent vertices.\n",
    "    \"\"\"\n",
    "    lmer = len(list(spectrum.keys())[0])-1 # Vertices are l-1 mer.  \n",
    "    \n",
    "    # All possible l-1 mer.\n",
    "    \n",
    "    lmer_list = [''.join(i) for i in itertools.product('atgc', repeat = lmer)]\n",
    "    Graph = {i:[] for i in lmer_list}\n",
    "    \n",
    "    # Taking only the k-mer that are present at least 1x in the strings\n",
    "    \n",
    "    kmer_list = [] # list of tuples containing the kmer divided in their respective k-1mer 'ATG' --> ('AT', 'TG')\n",
    "    \n",
    "    for kmer in spectrum: \n",
    "            for i in range (spectrum[kmer]): # Number of times the kmer is present\n",
    "                kmer_list.append((kmer[:len(kmer)-1], kmer[1:len(kmer)]))\n",
    "    \n",
    "    \n",
    "    for el in range(len(kmer_list)): # Maps a vertex with its adjacent vertex 'ATG' --> ('AT', 'TG') --> {'AT': ['TG']}\n",
    "        Graph[kmer_list[el][0]].append(kmer_list[el][1])\n",
    "    \n",
    "    return Graph\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1592a81a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def printGraph(graph): \n",
    "    \"\"\" This function is used to print out nicely the graph.\n",
    "    \"\"\"\n",
    "    \n",
    "    for key, val in graph.items(): \n",
    "        \n",
    "        print(key, ':', val, '\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c7c40a3",
   "metadata": {},
   "source": [
    "<b>Function Test :</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ffd622a3",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aaa : [] \n",
      "\n",
      "aat : ['att'] \n",
      "\n",
      "aag : [] \n",
      "\n",
      "aac : [] \n",
      "\n",
      "ata : [] \n",
      "\n",
      "att : ['tta'] \n",
      "\n",
      "atg : ['tgt', 'tgt'] \n",
      "\n",
      "atc : [] \n",
      "\n",
      "aga : [] \n",
      "\n",
      "agt : [] \n",
      "\n",
      "agg : [] \n",
      "\n",
      "agc : [] \n",
      "\n",
      "aca : ['cat', 'cat'] \n",
      "\n",
      "act : [] \n",
      "\n",
      "acg : [] \n",
      "\n",
      "acc : [] \n",
      "\n",
      "taa : [] \n",
      "\n",
      "tat : [] \n",
      "\n",
      "tag : [] \n",
      "\n",
      "tac : ['aca'] \n",
      "\n",
      "tta : ['tac'] \n",
      "\n",
      "ttt : [] \n",
      "\n",
      "ttg : [] \n",
      "\n",
      "ttc : [] \n",
      "\n",
      "tga : ['gaa', 'gac'] \n",
      "\n",
      "tgt : ['gtt', 'gtg'] \n",
      "\n",
      "tgg : [] \n",
      "\n",
      "tgc : [] \n",
      "\n",
      "tca : [] \n",
      "\n",
      "tct : [] \n",
      "\n",
      "tcg : [] \n",
      "\n",
      "tcc : [] \n",
      "\n",
      "gaa : ['aat'] \n",
      "\n",
      "gat : [] \n",
      "\n",
      "gag : [] \n",
      "\n",
      "gac : ['aca'] \n",
      "\n",
      "gta : [] \n",
      "\n",
      "gtt : [] \n",
      "\n",
      "gtg : ['tga'] \n",
      "\n",
      "gtc : [] \n",
      "\n",
      "gga : [] \n",
      "\n",
      "ggt : [] \n",
      "\n",
      "ggg : [] \n",
      "\n",
      "ggc : [] \n",
      "\n",
      "gca : [] \n",
      "\n",
      "gct : [] \n",
      "\n",
      "gcg : [] \n",
      "\n",
      "gcc : [] \n",
      "\n",
      "caa : [] \n",
      "\n",
      "cat : ['atg', 'atg'] \n",
      "\n",
      "cag : [] \n",
      "\n",
      "cac : [] \n",
      "\n",
      "cta : [] \n",
      "\n",
      "ctt : [] \n",
      "\n",
      "ctg : [] \n",
      "\n",
      "ctc : [] \n",
      "\n",
      "cga : [] \n",
      "\n",
      "cgt : [] \n",
      "\n",
      "cgg : [] \n",
      "\n",
      "cgc : [] \n",
      "\n",
      "cca : [] \n",
      "\n",
      "cct : [] \n",
      "\n",
      "ccg : [] \n",
      "\n",
      "ccc : [] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "G = graphFromSpectrum(S)\n",
    "printGraph(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34e7a2df",
   "metadata": {},
   "source": [
    "### Step 2: $EulerPath(G)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6a457a86",
   "metadata": {},
   "outputs": [],
   "source": [
    "from copy import deepcopy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c7e20c7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def CheckEulerian(graph): \n",
    "    \"\"\" This function is used to return if there is a possible eulerian path in a graph. Moreover, if it detects\n",
    "        semibalanced vertex, it will return them (at most 2 which are starting and ending vertex).\n",
    "        ::param:: a graph that maps the vertices to a list of adjencent vertices.\n",
    "        ::output:: True/False if the graph contains an Euler path.\n",
    "        ::output:: start/end if the graph has starting or ending vertex.\n",
    "    \"\"\"\n",
    "    # Taking only the vertex that are present in the graph\n",
    "    \n",
    "    keys_dic  = [el for el in graph.keys() if graph[el] != []]\n",
    "    values_dic = [el[::] for el in graph.values() if el != []]\n",
    "    values_list =[]\n",
    "    \n",
    "    for el in  values_dic:\n",
    "        for el2 in el:\n",
    "            \n",
    "            values_list.append(el2)\n",
    "    \n",
    "    # start and end are the vertex that might be semibalanced (there must be only one)\n",
    "    \n",
    "    start = []  # start has one more outdegree than indegree\n",
    "    end = [] # end has one more indegree than outdegree\n",
    "    \n",
    "    # Balance --> The vertex has the same amount of outgoing edges (dic[key]) and incoming edges (number of times the vertex appear in values).\n",
    "    # Semibalance --> the vertex has either one more outgoing edge or incoming edge. At most 2 for Euler path, the rest should be balanced.\n",
    "    for el in keys_dic:\n",
    "        \n",
    "        indegree = values_list.count(el)\n",
    "        outdegree = len(graph[el])\n",
    "        \n",
    "        if indegree != outdegree:\n",
    "            \n",
    "            if indegree - outdegree == 1: \n",
    "                \n",
    "                end.append(el)\n",
    "                \n",
    "                if len(end) > 1:\n",
    "                    \n",
    "                    return False\n",
    "                \n",
    "            elif outdegree - indegree == 1:\n",
    "                \n",
    "                start.append(el)\n",
    "                \n",
    "                if len(start) > 1:\n",
    "                    \n",
    "                    return False\n",
    "            else:\n",
    "                \n",
    "                return False\n",
    "    \n",
    "    \n",
    "    return True, start, end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "cdb7b10c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def EulerPath(graph): \n",
    "    \"\"\" This function is used to return an Eulerian path from a graph.\n",
    "        ::parameter:: a graph that maps the vertices to a list of adjencent vertices.\n",
    "        ::output:: 'No Euler path found' or Euler path.\n",
    "    \"\"\"\n",
    "    \n",
    "    Graph = deepcopy(graph) # Avoid modifying the initial graph if you want to reuse\n",
    "    \n",
    "    Euler, start, end = CheckEulerian(Graph)\n",
    "    \n",
    "     \n",
    "    if Euler == True: # If it exists and eulerian path (see conditions)\n",
    "        \n",
    "    \n",
    "        if len(start) == 0:\n",
    "            start_v = random.choice(list(Graph.keys()))\n",
    "        \n",
    "        else: \n",
    "            start_v = start[0]\n",
    "            \n",
    "            \n",
    "        temporary_path = [start_v]\n",
    "        \n",
    "        final_path = [] \n",
    "\n",
    "        while temporary_path != []:\n",
    "                \n",
    "            next_node = temporary_path[-1]\n",
    "                \n",
    "            if Graph[next_node] != []:\n",
    "                    \n",
    "                temporary_path.append(Graph[next_node][0])\n",
    "                Graph[next_node].remove(Graph[next_node][0])\n",
    "                \n",
    "                    \n",
    "            else:\n",
    "                    \n",
    "                temporary_path.pop(-1)\n",
    "                final_path.insert(0, next_node)\n",
    "                    \n",
    "    \n",
    "        return final_path\n",
    "\n",
    "    \n",
    "    else:\n",
    "        \n",
    "        return 'No Euler path possible'\n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa957e68",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>Algorithm:</b>  The algorithm is based on the Hierholzer’s Algorithm.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08c3f71b",
   "metadata": {},
   "source": [
    "<b>Function Test :</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8323e6e9",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['tga', 'gaa', 'aat', 'att', 'tta', 'tac', 'aca', 'cat', 'atg', 'tgt', 'gtg', 'tga', 'gac', 'aca', 'cat', 'atg', 'tgt', 'gtt']\n"
     ]
    }
   ],
   "source": [
    "P=EulerPath(G)\n",
    "print(P)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70a5829b",
   "metadata": {},
   "source": [
    "### Step 4: $stringFromPath(P)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "7349a31b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def stringFromPath(path):\n",
    "    \"\"\" Function used to return the concatenated string from the Euler path.\n",
    "        ::param:: An Euler path. (i.e., list of strings)\n",
    "        ::output:: the reconstructed DNA string.\n",
    "    \"\"\"\n",
    "    \n",
    "    string = path[0]\n",
    "    \n",
    "    for el in path[1::]:\n",
    "        \n",
    "        string += el[-1]\n",
    "    return string   "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4ac630c",
   "metadata": {},
   "source": [
    "<b>Function Test :</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "920b4afe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tgaattacatgtgacatgtt\n"
     ]
    }
   ],
   "source": [
    "string = stringFromPath(P)\n",
    "print(string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11906347",
   "metadata": {},
   "source": [
    "## Final Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "537f7475",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Orginal Sequence  ccgtcggtgaattgatgagc\n",
      "\n",
      "Spectrum\n",
      "aaaa 0  aaat 0  aaag 0  aaac 0  \n",
      "\n",
      "aata 0  aatt 1  aatg 0  aatc 0  \n",
      "\n",
      "aaga 0  aagt 0  aagg 0  aagc 0  \n",
      "\n",
      "aaca 0  aact 0  aacg 0  aacc 0  \n",
      "\n",
      "ataa 0  atat 0  atag 0  atac 0  \n",
      "\n",
      "atta 0  attt 0  attg 1  attc 0  \n",
      "\n",
      "atga 1  atgt 0  atgg 0  atgc 0  \n",
      "\n",
      "atca 0  atct 0  atcg 0  atcc 0  \n",
      "\n",
      "agaa 0  agat 0  agag 0  agac 0  \n",
      "\n",
      "agta 0  agtt 0  agtg 0  agtc 0  \n",
      "\n",
      "agga 0  aggt 0  aggg 0  aggc 0  \n",
      "\n",
      "agca 0  agct 0  agcg 0  agcc 0  \n",
      "\n",
      "acaa 0  acat 0  acag 0  acac 0  \n",
      "\n",
      "acta 0  actt 0  actg 0  actc 0  \n",
      "\n",
      "acga 0  acgt 0  acgg 0  acgc 0  \n",
      "\n",
      "acca 0  acct 0  accg 0  accc 0  \n",
      "\n",
      "taaa 0  taat 0  taag 0  taac 0  \n",
      "\n",
      "tata 0  tatt 0  tatg 0  tatc 0  \n",
      "\n",
      "taga 0  tagt 0  tagg 0  tagc 0  \n",
      "\n",
      "taca 0  tact 0  tacg 0  tacc 0  \n",
      "\n",
      "ttaa 0  ttat 0  ttag 0  ttac 0  \n",
      "\n",
      "ttta 0  tttt 0  tttg 0  tttc 0  \n",
      "\n",
      "ttga 1  ttgt 0  ttgg 0  ttgc 0  \n",
      "\n",
      "ttca 0  ttct 0  ttcg 0  ttcc 0  \n",
      "\n",
      "tgaa 1  tgat 1  tgag 1  tgac 0  \n",
      "\n",
      "tgta 0  tgtt 0  tgtg 0  tgtc 0  \n",
      "\n",
      "tgga 0  tggt 0  tggg 0  tggc 0  \n",
      "\n",
      "tgca 0  tgct 0  tgcg 0  tgcc 0  \n",
      "\n",
      "tcaa 0  tcat 0  tcag 0  tcac 0  \n",
      "\n",
      "tcta 0  tctt 0  tctg 0  tctc 0  \n",
      "\n",
      "tcga 0  tcgt 0  tcgg 1  tcgc 0  \n",
      "\n",
      "tcca 0  tcct 0  tccg 0  tccc 0  \n",
      "\n",
      "gaaa 0  gaat 1  gaag 0  gaac 0  \n",
      "\n",
      "gata 0  gatt 0  gatg 1  gatc 0  \n",
      "\n",
      "gaga 0  gagt 0  gagg 0  gagc 1  \n",
      "\n",
      "gaca 0  gact 0  gacg 0  gacc 0  \n",
      "\n",
      "gtaa 0  gtat 0  gtag 0  gtac 0  \n",
      "\n",
      "gtta 0  gttt 0  gttg 0  gttc 0  \n",
      "\n",
      "gtga 1  gtgt 0  gtgg 0  gtgc 0  \n",
      "\n",
      "gtca 0  gtct 0  gtcg 1  gtcc 0  \n",
      "\n",
      "ggaa 0  ggat 0  ggag 0  ggac 0  \n",
      "\n",
      "ggta 0  ggtt 0  ggtg 1  ggtc 0  \n",
      "\n",
      "ggga 0  gggt 0  gggg 0  gggc 0  \n",
      "\n",
      "ggca 0  ggct 0  ggcg 0  ggcc 0  \n",
      "\n",
      "gcaa 0  gcat 0  gcag 0  gcac 0  \n",
      "\n",
      "gcta 0  gctt 0  gctg 0  gctc 0  \n",
      "\n",
      "gcga 0  gcgt 0  gcgg 0  gcgc 0  \n",
      "\n",
      "gcca 0  gcct 0  gccg 0  gccc 0  \n",
      "\n",
      "caaa 0  caat 0  caag 0  caac 0  \n",
      "\n",
      "cata 0  catt 0  catg 0  catc 0  \n",
      "\n",
      "caga 0  cagt 0  cagg 0  cagc 0  \n",
      "\n",
      "caca 0  cact 0  cacg 0  cacc 0  \n",
      "\n",
      "ctaa 0  ctat 0  ctag 0  ctac 0  \n",
      "\n",
      "ctta 0  cttt 0  cttg 0  cttc 0  \n",
      "\n",
      "ctga 0  ctgt 0  ctgg 0  ctgc 0  \n",
      "\n",
      "ctca 0  ctct 0  ctcg 0  ctcc 0  \n",
      "\n",
      "cgaa 0  cgat 0  cgag 0  cgac 0  \n",
      "\n",
      "cgta 0  cgtt 0  cgtg 0  cgtc 1  \n",
      "\n",
      "cgga 0  cggt 1  cggg 0  cggc 0  \n",
      "\n",
      "cgca 0  cgct 0  cgcg 0  cgcc 0  \n",
      "\n",
      "ccaa 0  ccat 0  ccag 0  ccac 0  \n",
      "\n",
      "ccta 0  cctt 0  cctg 0  cctc 0  \n",
      "\n",
      "ccga 0  ccgt 1  ccgg 0  ccgc 0  \n",
      "\n",
      "ccca 0  ccct 0  cccg 0  cccc 0  \n",
      "\n",
      "Graph\n",
      "aaa : [] \n",
      "\n",
      "aat : ['att'] \n",
      "\n",
      "aag : [] \n",
      "\n",
      "aac : [] \n",
      "\n",
      "ata : [] \n",
      "\n",
      "att : ['ttg'] \n",
      "\n",
      "atg : ['tga'] \n",
      "\n",
      "atc : [] \n",
      "\n",
      "aga : [] \n",
      "\n",
      "agt : [] \n",
      "\n",
      "agg : [] \n",
      "\n",
      "agc : [] \n",
      "\n",
      "aca : [] \n",
      "\n",
      "act : [] \n",
      "\n",
      "acg : [] \n",
      "\n",
      "acc : [] \n",
      "\n",
      "taa : [] \n",
      "\n",
      "tat : [] \n",
      "\n",
      "tag : [] \n",
      "\n",
      "tac : [] \n",
      "\n",
      "tta : [] \n",
      "\n",
      "ttt : [] \n",
      "\n",
      "ttg : ['tga'] \n",
      "\n",
      "ttc : [] \n",
      "\n",
      "tga : ['gaa', 'gat', 'gag'] \n",
      "\n",
      "tgt : [] \n",
      "\n",
      "tgg : [] \n",
      "\n",
      "tgc : [] \n",
      "\n",
      "tca : [] \n",
      "\n",
      "tct : [] \n",
      "\n",
      "tcg : ['cgg'] \n",
      "\n",
      "tcc : [] \n",
      "\n",
      "gaa : ['aat'] \n",
      "\n",
      "gat : ['atg'] \n",
      "\n",
      "gag : ['agc'] \n",
      "\n",
      "gac : [] \n",
      "\n",
      "gta : [] \n",
      "\n",
      "gtt : [] \n",
      "\n",
      "gtg : ['tga'] \n",
      "\n",
      "gtc : ['tcg'] \n",
      "\n",
      "gga : [] \n",
      "\n",
      "ggt : ['gtg'] \n",
      "\n",
      "ggg : [] \n",
      "\n",
      "ggc : [] \n",
      "\n",
      "gca : [] \n",
      "\n",
      "gct : [] \n",
      "\n",
      "gcg : [] \n",
      "\n",
      "gcc : [] \n",
      "\n",
      "caa : [] \n",
      "\n",
      "cat : [] \n",
      "\n",
      "cag : [] \n",
      "\n",
      "cac : [] \n",
      "\n",
      "cta : [] \n",
      "\n",
      "ctt : [] \n",
      "\n",
      "ctg : [] \n",
      "\n",
      "ctc : [] \n",
      "\n",
      "cga : [] \n",
      "\n",
      "cgt : ['gtc'] \n",
      "\n",
      "cgg : ['ggt'] \n",
      "\n",
      "cgc : [] \n",
      "\n",
      "cca : [] \n",
      "\n",
      "cct : [] \n",
      "\n",
      "ccg : ['cgt'] \n",
      "\n",
      "ccc : [] \n",
      "\n",
      "\n",
      "\n",
      "Euler Path\n",
      "['ccg', 'cgt', 'gtc', 'tcg', 'cgg', 'ggt', 'gtg', 'tga', 'gaa', 'aat', 'att', 'ttg', 'tga', 'gat', 'atg', 'tga', 'gag', 'agc']\n",
      "\n",
      "Reconstructed string: ccgtcggtgaattgatgagc\n",
      "Are the reconstructed string and the Original string the same ?  True\n",
      "Do the reconstructed string and the Original string have the same length ?  True\n"
     ]
    }
   ],
   "source": [
    "random_dnatest = randomDNA(20)\n",
    "print('Orginal Sequence ', random_dnatest)\n",
    "print('\\nSpectrum')\n",
    "spectrumtest = spectrum(4, random_dnatest)\n",
    "printSpectrum(spectrumtest)\n",
    "print('')\n",
    "print('\\nGraph')\n",
    "Graphtest = graphFromSpectrum(spectrumtest)\n",
    "printGraph(Graphtest)\n",
    "print('')\n",
    "print('\\nEuler Path')\n",
    "E = EulerPath(Graphtest)\n",
    "print(E)\n",
    "print('')\n",
    "String = stringFromPath(E)\n",
    "print('Reconstructed string: ', end='')\n",
    "print(String)\n",
    "print('Are the reconstructed string and the Original string the same ?  ', end='')\n",
    "print(random_dnatest == String)\n",
    "print('Do the reconstructed string and the Original string have the same length ?  ', end='')\n",
    "print(len(random_dnatest) == len(String))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba909902",
   "metadata": {},
   "source": [
    "### Question 1: Is your code guaranteed to reconstruct the original string?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24b6782c",
   "metadata": {},
   "source": [
    "The answer is no, my code does not guarantee to reconstruct the original string. This is inherent to the approach itself rather than the code. However, as the goal of an Eulerian path is to pass through every edges only once, the reconstructed string and the original string will always have the same lentgh."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "266f5e25",
   "metadata": {},
   "source": [
    "To represent the case where the reconstructed string and the original string are not the same I decided to use the NetworkX module in python. Please make sure that your decorator has the latest version. You can use ``pip install decorator --upgrade``. Otherwise, please skip this part and refer at the png file added to the work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "623195ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "893fe4cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "Graphic = nx.DiGraph()\n",
    "node = [('A', {\"color\": \"green\"}),\n",
    "       ('B', {\"color\": \"red\"}),\n",
    "       ('C', {\"color\": \"red\"}),\n",
    "       ('D', {\"color\": \"red\"}),\n",
    "       ('E', {\"color\": \"red\"})]\n",
    "\n",
    "\n",
    "Graphic.add_nodes_from(node)\n",
    "\n",
    "edges = [('A','B'), ('B', 'C'), ('C', 'B'), ('B', 'D'), ('D','B'), ('B', 'E')]\n",
    "\n",
    "Graphic.add_edges_from(edges)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "24f3502e",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADnCAYAAAC9roUQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAnRUlEQVR4nO3deXxU1f3/8de9M1kmgewLsphNSQgEQlik9qtCVaRqsWIttlW0P1FbalFa5GG/tn5F/dEWVBDR1mpRlIoLRfmKS7EGRaQgW1AMCUIWELKQELJNlknmfv+4ZMwkmcnKzL34eT4e82Byl8mZ4eSdk3PPOVfRNA0hhBC+ofq7AEII8W0ioSuEED4koSuEED4koSuEED4koSuEED5k9bYzJiZGS0xM9FFRhBDi3LBnz54KTdNiu9rnNXQTExPZvXv32SmVEEKcoxRFKfa0T7oXhBDChyR0hRDChyR0hRDCh7z26Qohzj3Nzc0cOXIEu93u76KYXkhICCkpKQQGBvb4HAldIb5ljhw5QkREBKmpqaiq/LHbV06nk7KyMg4fPkx6enqPz5NPXIhvGbvdTnx8vARuP6mqSnx8PHa7ne3bt9PTxcPkUxfiW0gCd2CoqoqiKOzYsYPiYo+jxNzPOctlEkKIc56iKNTW1vboWAldYS6NFZD/NOz6FWy/Wf83/2loqvR3yUxryJAhKIoyYI8hQ4b06Pu++eabKIpCXl4eAEVFRdhsNjIzMxk3bhwXX3wx+fn5AHz00UeEh4czfvx4UlNTufTSS9m0aZPrtR566CGGDRtGZmYmaWlp/PKXv8TpdALgcDi4//77ufDCCxkzZgyTJ0/mvffeA/QJYBkZGWRmZpKRkcHGjRtdr2mxWMjMzHQ9/vSnPw3I5y0X0oQ5VOVA3pNw4h1AA6cDFAU0DdQAOLAYhl0DqfdAZKafC2suZWVlfnm9devW8V//9V+8+uqrPPTQQwCkpKSQk5MDwLPPPsuSJUtYs2YNAJdccokraHNycvjhD3+IzWbj8ssvB2DBggUsXLgQp9PJpZdeyscff8y0adP4wx/+QElJCQcOHCAoKIiysjI+/vhjVzm2bNlCTEwM+fn5TJ8+neuuuw4Am83mKstAkpauML6CNZB9FRx/CxRVD1lrCFhs+r9qgL7967f04wrW+LvEoht1dXV8+umn/P3vf+fVV1/t8piamhoiIyO73JeZmcmDDz7IqlWrOu1rbm6msbGRyMhI7HY7zz33HE899RRBQUEAxMfH8+Mf/7hX328gSUtXGFvBGti3EFD0kPVEUfX9zpYzxwPJt/qkiKL33nrrLWbMmMHIkSOJiopi7969REVFceTIETIzM6mtrcVut7Nz506Pr5GVlcWyZctcXy9fvpy1a9dSXFzM97//fTIzM/n88885//zzCQsL8/g606ZNQ9M0CgoKeP31113bGxoayMzMdH39u9/9jtmzZ/fvjSMtXWFkVTmwbxGggNrD9oFq1Y/PWQRV+89i4UR/rFu3jptuugmAm266iXXr1gHfdC8cOXKEFStWcOedd3p8jY5DtBYsWEBOTg7l5eXU19d7bEF3tGXLFg4cOMAXX3zB3XffTV1dHfBN90LbYyACF6SlK4ws70nQmju1cN/c0cizm+0cLm1hULDC6BFW7rk2lMkXnpkVpFqhtQHyn4Qpq/1QcOFNZWUl2dnZHDhwAEVRaG1tRVEU5s2b53bczJkz+fnPf+7xdfbt28eoUaM6bQ8ICGDGjBls3bqVmTNncvToUWpraxk8eLDXcqWkpBAfH09ubi6TJ0/u25vrAWnpCmNqrNAvmqlBbpuf/Vc9D75ay/xrQvh8eSy7lsZw27QQ/rWvyf18NQiOb5JRDQa0fv165syZQ3FxMUVFRRw7doykpCS+/vprt+O2bdtGSkpKl6/x+eef88gjj/CrX/2q0z5N09i+fTspKSmEhIRw++23M3/+fJqbmwEoKSlh7dq1nc4rLy+nsLCQhISEAXiXnklLVxhT8WuApvfVnlFjd7JsYz3Lfx7G1ROCXduvzAziykz3cEZRQWvVX2ekewtKuIuPjx/QEQzx8fFe969bt47777/fbdsNN9zAkiVLXH26mqYRGBjI888/7zrmk08+Yfz48djtduLi4li5cqVr5AJ806frcDgYO3asq+X86KOP8vvf/5709HSCg4MJDQ3l4Ycfdp03bdo0LBYLDoeDP/3pT67yd+zTnTFjxoAMG1O8TV2bOHGiJouYC7/Y9Sso+oc+OuGMLV80MWflaQr/GofVonT/Gi12SLwZJnW+wv1ttmfPHiZMmODvYpwz9uzZw9atW7niiivIyMgAQFGUPZqmTezqeOleEMbkqNbH4bZTVe8kapDas8AF/XxH9VkonBB9J6ErjCkgXJ/40E5kqMqpOictrT1bWARN019HCAOR0BXGFJauT3poZ0JKAEEBCu93vGjmiRoA4T1fck8IX5DQFcaUMBtQQHO6NoWFqNx3XSj//Y9a3t/bSEOThqNFI/uLJh59o8NiI5pTPz9hYMZWCjFQZPSCMKbgGBh6jT71t9043buuCiU2XGXFJju/eq6GQcEKYxMDuOeaEPfznU0w/HoIivZtuYXohoSuMK60e+DEu/rU3nYz0mZNsTFripcpwc4WUAP1xW+EMBjpXhDGFZkJ45eiryrW0rNznC368ZlLIXLcWSzcucMMSzsCvPfee0ycOJFRo0aRlpbGwoX6GhvelnW87bbbSEpKYty4cYwcOZI5c+Zw/Phx12v6Y2lHCV1hbMm3wvjHAEWf2tuuj9eN5oSWBn2Y2PjHZLGbXjDC0o5t2tZe2L9/P7feeitLliwB4MCBA9x9992sXbuWgwcPcuDAAZKTk13nta27kJubyxdffOG2dOOyZcvYv38/+fn5jB8/nmnTprlmp4G+9kJOTg7r169n/vz5ru0d117oOKGjryR0hfEl3wrf2wzDr6exwU5zo12f+NDaoP/rdOihO+J6mLZZAtcEeru049KlS3nggQdIS0sDwGq1dlqrAdyXdexIURQWLFjAkCFDXIuYe/p+Z5P06QpziBwHU1Yz9/ESfvOj4WQlBlF+/CtyDx9n6sx5+igFuWhmGr1d2vHAgQP89re/9fh6XS3r6ElWVhZ5eXmuxcplaUchvNj1eQFBY+6FSauYt3Yw0+77ko9LRkvgmsxALO3YXm+Wdey49IGvl3aU0BWm0dzcTHFxMRdccAGaprFlyxYAbrzxRqqrZbqvWbQt7Th37lwSExNZtmwZr732WqcwnDlzJlu3bgVg9OjR7Nmzp9vXbr+soyeeloRsv7Tj2SShK0zjyJEjnH/++QQFBbF3716amvSZaTU1NcydO9fPpRM91ZelHe+77z6WLFnCoUOHAHA6nTzxxBOdXrv9so5d7Vu5ciUlJSXMmDGj035Z2lGIDvLy8lwXUl555RUaGhpQFAWLxcL69espKioiMTHRv4U0ITMs7Th27FhWrFjBT37yE+x2O4qicM0117jO97SsI+iB/cgjj2C325kyZQpbtmwhMDDQtV+WdhTCgz/+8Y9UVVWxdOlS1q5dy/79+3n33Xe5/fbbueWWW4iNjfV3EU1BlnYcWL1d2lFausI08vLyuOyyywC4+eabufnmmzl9+jQhISESuMI0pE9XmEb77oU2SUlJFBYW+qlEQvSehK4wBU3TyMvLIzU11W17YmIiRUVF/imUibVNkxX905fPUUJXmEJtbS2tra1ER7uPx01KSpLQ7aWQkBBKS0slePvJ6XRSWlqKw+Ho1XnSpytMoaSkhPPOO6/T9tjYWCoqKvxQIvNqm4Bw4sQJFKWHtz4SXXI4HBw9ehRFUVDVnrVhJXSFKXgK3cjISKqqqvxQIvMKDAzEZrPxwQcfEB4e3uOwEF1rbm5GVVXi4uJ6dLyErjCF0tLSLpcMDA8Pp6amBqfTKeHRC2PGjMHhcHDw4MFe/3ks3EVERDBlypQej6CR0BWm4Kmla7VaCQkJoaamhoiICN8XzKQURSErK4usrCx/F+VbR5oGwhQ8hS7oXQynT5/2bYGE6CMJXWEK3YWu9OsKs5DQFabgqU8X9D41CV1hFhK6whSke0GcKyR0hSlI94I4V0joCsNramqitra202y0NtK9IMxEQlcYXmlpKXFxcR7H4Ur3gjATCV1heKWlpR67FkC6F4S5SOgKw/PWnwsSusJcJHSF4XUXuhEREdK9IExDQlcYnrR0xblEQlcYnreJESChK8xFQlcYXklJidfQlSFjwkwkdIXh2e12Bg8e7HF/eHg41dXVPiyREH0noSsMz+FwYLV6XoVU0zRZS1eYhtRUYXgtLS1eQ7elpYWAgAAflkiIvpPQFYbXXah2F8pCGInUVOFT2dnZfPnll4B+y5hp06Z1e05PWroSusIspKUrfKK0tJTvfOc7LF68mKKiIoqKili8eDEXX3wxZWVlXs/tb+g2NjZy8uTJTtvLy8tpbGzs+ZsQYgBI80D4xD333MPcuXO5/fbb3bY/99xz3Hvvvaxbt87jud1dSOtu//z585kxYwazZs1y2/7BBx+wbds2/vKXv/TwXQjRf9LSFT6xZ8+eToELcMcdd7Br1y6v5/a3pbtt27ZOgQvws5/9jK1bt3r93kIMNAld4RM2m83jvuDgYK/n9uRCmrf9mqZ53Od0Or1+byEGmoSu8InExER2797dafvnn39OYmKi13P729KNi4vjs88+67R9165dxMbGev3eQgw06dMVPrF8+XJOnDhBcXGx2/aamhqWL1/u9dz+hu6yZcv48Y9/zG233caECRMA2L17Ny+99BKvvvpqL96FEP0noSt8Yty4cSQnJ6MoCgCHDx8mJSUFRVE4fPgwdrvd47n9Dd3Jkyezc+dOnnnmGV588UUARo8ezc6dO4mLi+vbGxKijyR0hU+kpqayd+9e19dZWVmur7Oysrye29/RCwDx8fEsXrzY9XVFRYXHe64JcTZJn67wiY4XrGpqajzu66i/F9J27NjB1KlTmTVrFvv27WPMmDGMGTOG+Ph43n///R6+AyEGhrR0hU8EBQXxwQcfcMkll/D222/T0NDAY489RlhYGIMGDfJ6bn+7F+6++26WLFlCdXU13/ve93jvvfeYMmUKeXl5/OQnP2HGjBl9fl9C9Ja0dIVPrFq1ioULFxIdHc3q1avZuXMnJ06cYPv27bzwwgtez+1v6La0tDB9+nRuvPFGhgwZwpQpUwBIS0vr25sRoh+kpSt8YtKkSezfv99t2xNPPNHteZqm0draisVi8XhMd6HbftnHjuOF2y7sCeErErrC0FpbW1FV1Ws4dnchbf/+/YSFhaFpGg0NDYSFhQF6oMvaC8LXJHSFoVksFiwWC42NjR5nrjU1NREYGOjxNVpbW89W8YToNenTFYamKAqRkZFeb7FeVlZGfHy87wolRD9I6ArD6+5uv93dol0II5HQFYYXERHhtaUroSvMREJXGF5PWrrebtEuhJFI6ArD6y50S0tLpaUrTENCVxiedC+Ic4mErjA8by3dlpYWKisrZbUwYRoSusLwvIVueXk50dHRcjdgYRoSusLwvI3Tla4FYTYSusLwIiIiPLZ0S0tLZeSCMBUJXWF43roXpKUrzEZCVxiedC+Ic4mErjA8b90LErrCbCR0heFJS1ecSyR0heGFhYVRV1fX5RKNErrCbCR0heGpqsrgwYOprq7utE9GLwizkdAVphAVFUVlZaXbNk3TZN0FYToSusIUzj//fI4ePeq2rbKyEpvN1um+Z0IYmYSuMIXExESKiorctuXn5zNy5Ej/FEiIPpLQFaaQlJREYWGh27a8vDy5jbowHQldYQoJCQnk5eWxfft2CgoKAD10R40a5eeSCdE7ErrC0AoLCxkzZgx33XUXGzZs4LLLLmP58uWAtHSFOcl6eMLQ4uLiOHXqFE1NTQDYbDZmzZoFSOgKc5KWrjC00NBQ3nzzTdcIBU3TuOSSS2hqauLYsWOkpKT4uYRC9I6ErjC8iy66iHvvvReAyy+/HKvVyuHDh0lMTCQgIMC/hROilyR0hSksXryYYcOGceONNwLStSDMyxh9uo0VUPwa1OSCoxoCwiEsHRJvgqBof5euT5qbm3n44Yepq6tjxYoVAOzatYsdO3aQmJhIREQEqampcm+vHgporebrD38HNdth+3uMrDnGHVMHQVOlaetIm8bGRurr6zl9+jRhYWHExsYC8Mknn/DJJ5/gdDo5ceIESUlJ3HzzzTIDrycMnCn+Dd2qHMh7Ek68A2jgdICigKaBGgAHFsOwayD1HojM9GtRe0rTNBRFYefOnWzcuJGoqCiKiopITEzk5ZdfZt26dcyePZu9e/cyceJEHn30UcLCwvxdbOPyUEfGDNIYExYAm0aZro60l52dzRVXXMG0adMoKyvju9/9Lr/5zW9ITU3lueeeY/v27SxcuBCbzUZGRgaDBw/2d5GNzQSZ4r/uhYI1kH0VHH8LFFX/QKwhYLHp/6oB+vav39KPK1jjt6L2xT//+U+uuOIKJkyYwL///W8AWltbeeqpp1i1ahXvv/8+tbW1vPvuu4Ae1qIDL3VEsYagmLyOgD4a47bbbuPDDz/kwIED2Gw2XnzxRUCf+jx//nx+8Ytf8Nvf/pbp06czaNAg/xbYyEySKf5p6RasgX0LAUX/QDxRVH2/s+XM8UDyrT4pYl8pisKhQ4coLy/nnnvu4Z///CclJSUAVFRU8OabbzJixAg++ugjBg0aRGpqqus80c45XEfaCw8P58SJEwB8/PHHOBwOLr30Ute+559/npaWFvLy8khISOAXv/gF0dHm7k45K0xUX3wfulU5sG8RoIDq/u1vWFrFl8ccfP5ELIEB7UJIteofUs4i/U+CyHG+LHGv/eMf/2DChAlcdNFFNDQ0sGXLFsrLy2lsbKS6uprVq1eTnZ3NokWLGD9+vL+Lazxd1JHJiyo4WePEooLVApMuCOTPtwxmaJRFP8dkdaRNREQEmzdv5vLLL+fIkSOkpqYyf/58177Tp08TGhrK6NGjSU1NJSQkxM8lNqBu6kub2d8N5v//7ExXnh/ri+9DN+9J0Jo7/TY6VtHKzkPNDLYp/CuniR9MCnY/T7VCawPkPwlTVvuwwL23efNmDh06xMaNG2lqaqK8vJxZs2bhdDp5+umnGT16NDU1NVx99dVkZWVx0UUX+bvIxuKhjrw0P4JL0gNpcmjc/3ItD/yjlhd+HfHNASaqI22CgoIYO3YsH374IQCvvPIKt9xyC5999hmDBg1i0qRJ3HXXXX4upcF1U1888lN98W2fbmOF3sGtBnXa9cb2BrKSA5j9XRtvbG/s+nw1CI5v0q9YG9RHH31EYmIib7/9No8//jhPPPGEa2B/U1MT4eHhgH43hKKiIlRVRu258VJH2gQFKFw7MYhDJ1o67zRBHWkvODiYuro619cZGRmUl5cDeku3oaHBX0Uzhx7UF6/8UF9829Itfg3Q9H6VDtb/p5E7rwwhKzmAa5ec4mR1K7HhFveDFBW0Vv11Rs7zTZl76fnnn2f69OlcfPHFrm2zZs3ihRdeYNu2baxfv56MjAy++uorRo4cSUJCgh9La0Be6kibhiaN/93VyISULiZGmKCOtBcYGEhNTQ2grzPxySefuPr5g4ODyc7OZvny5Rw9epSmpiauvfZarr76an8W2Vh6UF+88kN98W3o1uTqQzhU9x+Wz75q5uvKVmZOCiZqsEpCrIU3dzZx5/Qu+q+cDqjO9VGBe2/Nmm+uiLaNSLjjjjv49NNPsdls5Ofns2PHDpqbm1m1apWM0+3IQx0B+Pmq01gtUN+oEROm8sqCiK5fw+B1pD2LxUJFRQUXX3wxmqYRFxfHs88+C8CFF17InXfeSWNjIxdeeCFRUVGuQBZn9KC+tPnDjwbzs8u6uMjm4/ri29B1VOtj5jp4/dNGLhsdRNRg/bfV9RcF8/r2hq5DV1H01zEoi+Wb/+W2EQkJCQnSou3A6XQyevRoMjIymD17NldeeaU+XtlDHQF44W69j661VeNfOU3M+nMVHz8STVxEx7+IjF1H2lNVFafT2eW+4cOHs3LlSh+XyJg2btzI/fffzw033MAPf/hDsrKy9K65HtSXbvm4vvg2dAPC9UHK7TQ2a7y9u5FWJ4xbcBKAphaNGrtG7jEH6SPcf4M1NDTywftb2bphIenp6aSnpzNq1ChXX6kwB1VVKS0tJS8vj02bNtHc3ExsbCwHX/oeEd2MWbZYFK6eEMyil2r57LCDaye6h25TYxPvv/cRW16/l/T0dEaPHk16ejqRkZFn8y2Js0hVVYqKivjzn//M448/jqZpXH755bzzUGKnTOk1TdOzyUd8G7ph6Z3+DHh/XxOqAtmPRBPQ7mfnrr9W88b2Rv5ntvvxQcEhJIz9PjGHY/joo4945plnOHjwIJGRkaSnp5OWlkZKSgrJyckkJSWRlJREaGioL96d8KCmpoaCggIKCws5fPgwBw8eJDc319WX2dDQgNVqJTo6mqC48VCz2evraZrG5pxmqu1OLjyvcxUOCAohZfwP+KpgODt27GD16tXk5uYSGhrq+iV9wQUXkJyc7KonUkeMoe1mo4WFhRQUFJCXl0dubi779++nsVG/wN7S0oLVamXChAkQFt9l10KvqAEQnj4Ape8ZxdtMqIkTJ2q7d+8euO/WWAHvpOud12c6vn+6vIrUoVb+Z7b79Mb//ayRP6yrZc9jMVgtZ/580Jz649qDbvOnnU4nR48eJTc3l7y8PAoKClw/5EVFRYSHh7t+wNp+yNqeDx061K1LQPRec3MzR48edf2gdPy3sbHR7TNv+wvl5Zdf5m9/+xs2m41ly5Yxb948lKbKTnUE3MddKgoMj7bw66tDmDWlQx+dhzqiaRpff/01ubm5HDx40FVH2srZsY60fwwdOlRGmQyguro6V93oWF8KCwsJDQ11/ZympqYyevRoRo0axaRJk1AUhWHDhrFp0yZ9waMuMgW6Hqd7aXogq++OcC+Mh/rSX4qi7NE0bWKX+3waugD/+bk+Tc/brBFPWhtg+PW9GlPndDopKSnp9EPW9vzUqVMkJCSQlJREQkIC8fHxbo+4uDji4+MJDw//1s0a0zSN2tpaysvL3R6lpaUUFRW5PsfS0lKGDh3qCtb2/yYlJREXF9flZ7dhwwbuu+8+NmzYwLhx7Qan+6GOlJaWutWR9nWlsrKShIQEVwgPGzbMVS/aP4KDg7v/ZucwTdOoq6tz1ZOysjLKyso4evSo2+dZV1fnqhtd1RdP60tMnTqVxMRE/vKXv7jfAdrH9aUnjBW6VTn6vGe0TjPSvHK26E2caZsHdPaI3W53BUhxcTFlZWVuFabt6+bmZuLi4tx+2No/j46OZtCgQQwaNIjQ0FDX85CQEL+3kjRNc61kZbfbqa+vp76+nsrKyk6B2vbe254HBAS43mv7R1sIJSUlMWLEiIFd19ZgdaShoYGioiJXcJw4ccKtbrQ9DwoK6vIXdvtHVFSUWx0JDOzBhR4/cTgc1NfXU1dXR0VFhdd60vawWCyd6sv555/vFq7x8fED24AxWH0Bo4UuuM+T7smH5GwBNBj/mN/m1dvtdreK1vGHrrKy0lVB6+rqXM8bGhqw2WxuP2jtQzk0NJSgoCBXJWxfGXuyrbm5uVOYtj3attntdgICAggNDXU9QkJCiI6OdvtF0jFYY2Nj/Tft1GR1RNM0qqurO/3C7lhfTp065fr/qa2tBej0y9pTPbHZbH2uJ5qmea0jXT00TXPVl5iYmC7rSPttsbGx/usbN1h9MV7owpkPaZE+fU8N6npws+aE1iawBELmUlMtZNLG6XRit9vdgrjjv233/2r/f9H23Ns2TdMIDAx0hWj7UG0friEhIVitxlg6uVe+BXWk7Zdmx1/Wnn6BQ+/rSZuOdcRbnQkNDSUwMNBcXWoGqi/GDF2Aqv36vOfjm+hy7UsUGHbtmbUvzbGAiRhg7eqIvcGOVYXAwACpI6JrBskU44Zum6ZKfRpedbtV3sPTIWG231d5FwbRVMlf/3saV04eRsqIGA4freCNzV9y/zN7UYJj/F06YTR+zhRvoWuMvzmDok0xT174UVA0z3wAF928BMaP5/crb+K1144RkP4iCxcu9HfphNEYOFNk8KEwBU3TXLc90jSNLVu2APDggw+ya9cuP5dOiJ6T0BWmcOrUKVRVJTIykkOHDrmWQ2xoaOAHP/gB1dXmWGtBCAldYQqFhYUkJSUB8M4779Dc3IzVakVVVaxWK4WFhX4uoRA9Y4w+XSG60T50r7zySqKiovj3v//NqFGjeOCBB/xcOiF6TkJXmEL70M3IyCAjIwOHw8F//vMfP5dMiN6R7gVhCm0X0dpLS0sjLy/PPwUSoo8kdIUpeAtdb2PNhTAaCV1hCidPniQ+Pt5tW0xMDJqmUVlpjptQCgESusIkTp06RVRUlNu2trVVS0pK/FQqIXpPQleYQlehCxAfH09paakfSiRE30joCsNrbW2ltra2y/vgDRkyhLKyMj+USoi+kdAVhlddXc3gwYO7vK3SkCFDpKUrTEVCVxiep64FkNAV5iOhKwyvqqrK4+3TJXSF2UjoCsPz1tKVC2nCbCR0heF1170gF9KEmUjoCsOT7gVxLpHQFYbnraUbHR3N6dOncTgcPi6VEH0joSsMz1voWiwWYmNjKS8v93GphOgbCV1heN66F0AupglzkdAVhuetpQtyMU2Yi4SuMLyehK60dIVZSOgKw+uue0FCV5iJhK4wPGnpinOJhK4wPLmQJs4lErrC8FpaWrBaPd9DNTo6mlOnTvmwREL0nYSuMDyLxUJra6vH/VarlZaWFh+WSIi+k9AVhtdd6KqqitPp9GGJhOg7CV1heN2Fbnf7hTASzx1lQgywgIAAgoODURQFALvdjs1mQ1EU6uvrPQanhK44l0hLV/hMRkYGtbW11NTUUFNTw9ixY11fjxs3zuN5FovFa/dBd6FbUVHB4sWLWblyJXV1dfzyl79kzJgxXHfddRw+fLhf70mI3pLQFT6jaZrb1w0NDa7n3kJVVdV+tXR/+tOf0tTUxFdffcXkyZNJTk5m/fr1XHvttcydO7cX70CI/pPuBeFTeXl5pKWlsWPHDkpLS3njjTcIDw/3OiSsv90LZWVlLFmyBE3TSEhI4L777gMgLS2Np59+uu9vRog+kNAVPvPHP/6RSy+9FFVViYmJITs7m0ceeYRTp06xatUqj+f1N3Tb7iKsKAoxMTFu+1RV/tgTviWhK3xmxowZlJWVUVlZ6Qq/DRs2dHtef0O3oKCAmTNnomma6zno3R2FhYW9fBdC9I+ErvCZ4uJi1/P6+vpO+xMSEro8r7+hu3HjRtfzhQsXuu3r+LUQZ5uErvCZ9PR0kpOTXUPG2jt8+DB2u73L8/obupdddpnr+cmTJwGIjY3tabGFGFASusJn0tLS2LNnT5f7JkyY4PG8noSut9EPmqbx8MMP89RTT6FpGk6nE6vVyq9//WsefPDBnr8BIQaAXEUQPtN+iFhv9vVkGrC3/StWrGDbtm3s2rWLyspKqqqq2LlzJ59++inLly/vWeGFGCASusJnwsLCKCoq6rS9qKiIsLAwj+f1t3vhpZdeYt26dSQlJbm2JScns3btWl566aWeFV6IASKhK3xm3rx53HDDDWRnZ3P69Gmqq6vZsmUL119/PfPmzfN4Xn9D1+FwdBoqBnq/rty6Xfia9OkKn5kzZw4AixYt4uDBgwCkpqZy7733uvZ1pbtVxLoL3cDAwD7tE+JskNAVPjVnzhyvAduV7tbL7S509+/f32X3haZpNDY29qosQvSXhK4wvKioKK93hmhpaXHNOuuKrEAmjET6dIXhdXfjyaqqKq83rhTCSCR0heH1JHS93bhSCCOR0BWG113odneLdiGMREJXGJ6ErjiXSOgKw4uPj5fuBXHOkNAVhictXXEukdAVhjdkyBDKyso87pfQFWYioSsMLzw8nKamJo9LP0r3gjATCV1heIqieG3tSktXmImErjAFb/260tIVZiKhK0zBW+hKS1eYiYSuMAVvw8YkdIWZSOgKU/DUp6tpmnQvCFOR0BWm4Kl7oa6ujqCgIFkXV5iGhK4wBU+hK61cYTYSusIUPIWu9OcKs5HQFaZw3nnncfz48U7bJXSF2UjoClMYMWIEFRUV1NfXu20vLy/v8qaTQhiVhK4wBYvFwgUXXMBXX33ltr2oqIjExET/FEqIPpDQFaaRlpZGXl6e27bCwkKSkpL8VCIhek9CV5hGSkoK2dnZvPjii+Tn5wMSusJ85G7AwvB27NjBj370I0pKSlBVlRdeeIFVq1aRmpoqoStMR1q6wvBSUlKw2+04nU7X7davueYaWltbOXbsmPTpClOR0BWGFxsby4YNG7DZbAAMGzaM4cOHc+LECaKioggODvZzCYXoOQldYQpTp05lwYIFAFx11VWA9OcKc5LQFabx8MMPk56ezvXXXw9I6ApzkgtpwjQsFgtf7vkYil+DXW8xNegLJl6hQv7TkHgTBEX7u4hCdEtCV5hDVQ7kPQkn3gE0cDpIsCoQqsGBL+HAYhh2DaTeA5GZfi6sEJ5J94IwvoI1kH0VHH8LFBXUALCGgMWm/6sG6Nu/fks/rmCNv0sshEcSusLYCtbAvoWApoes4qHKKqq+H00/XoJXGJR0LwjjqsqBfYsABVQrkxdVcLLGidUCFhUuPM/Kjd8J5ubLbKiqop+jWsHZAjmL9G6GyHF+fANCdCahK4wr70nQms+0YHUvzY/gkvRAauxOdhxy8Id1tewrbGH5/wv75jzVCq0NkP8kTFnth4IL4Zl0LwhjaqzQL5qpQV3uDgtRmZ4ZxF/vCuf17Q3kfd3ifoAaBMc3QVOlDworRM9J6ApjKn4N0Dz34Z4xPjmA8yIt7Pyq2X2HournF7921oooRF9I6ApjqskFp6NHhw6JUDldr3Xe4XRAde4AF0yI/pHQFcbkqAZF6dGhJVWtRIR2cayi6K8jhIFI6ApjCggHrYvWawc5hQ5KTzuZfGFA552apr+OEAYioxeEMYWl65MePKhtcLIj38GDr9Zyw5RgRg3v4lg1AMLTz2Ihheg9CV1hTAmz9am9mtPtYtqclaexWkBVYORQK3deGcKcqbbO52tOQNFfRwgDkdAVxhQcA0Ov0af+nhmn+9nSXtz119kEw6+XRXCE4UifrjCutHtACdRnmPWGswXUQH3xGyEMRkJXGFdkJoxfir6qWA+D19miH5+5VKYAC0OS0BXGlnwrjH8MUPSpvZqz6+M0J7Q06MPExj+mnyeEAUmfrjC+5Fv1Vm/+k/rUXq1Vn/igKPqwMDUAUGDE9WfW05UWrjAuCV1hDpHj9MVrmir1qb3VufrEh4BwfVhYwmy5aCZMQUJXmEtQNIyc5+9SCNFn0qcrhBA+JKErhBA+JKErhBA+JKErhBA+JKErhBA+JKErhBA+JKErhBA+JKErhBA+pGheVudXFOUkUOy74gghxDkhQdO02K52eA1dIYQQA0u6F4QQwockdIUQwockdIUQwockdIUQwockdIUQwof+D8XWZr0Idy2aAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = plt.subplot()\n",
    "\n",
    "nx.draw_networkx(Graphic, pos= {'A': [0,2], 'B': [1.982,2], 'C':[2,4], 'D':[2,0], 'E':[4,2]}, with_labels=True, \n",
    "                 node_color = 'orange', alpha = 0.9, edgelist = [])\n",
    "nx.draw_networkx_edges(Graphic, pos= {'A': [0,2], 'B': [1.982,2], 'C':[2,4], 'D':[2,0], 'E':[4,2]}, \n",
    "                       connectionstyle='arc3, rad=0.1')\n",
    "nx.draw_networkx_edge_labels(Graphic,pos={'A': [0,2], 'B': [2.15,2], 'C':[2.15,4], 'D':[2.15,0], 'E':[4,2]},\n",
    "                             edge_labels= {('D', 'B'): 'DB', ('B','C'): 'BC'}, horizontalalignment='left')\n",
    "nx.draw_networkx_edge_labels(Graphic,pos={'A': [0,2.2], 'B': [1.8,2], 'C':[1.8,4], 'D':[1.8,0], 'E':[4,2.2]},\n",
    "                             edge_labels= {('C', 'B'): 'CB', ('B','D'):'BD', ('A', 'B'): 'AB', ('B','E'): 'BE'}, horizontalalignment='right')\n",
    "\n",
    "plt.legend(['ABDBCBE', 'ABCBDBE'], shadow = True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d02cafe",
   "metadata": {},
   "source": [
    "As we can notice on this graph two Euler path can be computed, these are different following the chosen path, either from B to C first or B to D first. At the end, we have the computed string have the same size."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24a4c723",
   "metadata": {},
   "source": [
    "### Question 2: What would happen if we did not allow edges to appear multiple times?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65ce6ae0",
   "metadata": {},
   "source": [
    "In the work we have a directed multigraph, this means that edges can appear multiple time. In the case where we would not allow the edges appearing multiple times, the algorithm would not reconstruct the original string. As we allow a single edge to appear, this means that there is only one connection between two similar nodes possible, therefore this would hinder the kmer repetitions in a string to be reconstructed. We would have a much shorter string than the original string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee7c39a1",
   "metadata": {},
   "source": [
    " - Example : orignal string 'ATAT' in a graph where nodes length would be then 1 and edges of length 2. The reconstructed string would be 'ATA'."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f04a30fd",
   "metadata": {},
   "source": [
    "### Question 3: What is the runtime of your functions ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "be9369e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import timeit\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5b4cbe28",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotruntime(f,n, lmer,lmertest, ntest, trials = 1, figsize = [5,5]):\n",
    "    \"\"\" This function plots the runtime of a method in function of two parameters, either the length of the l-mer or \n",
    "        the lenght of the original string.\n",
    "        ::param:: f is the method that will be tested (i.e., spectrum, graphFromSpectrum, EulerPath).\n",
    "        ::param:: n is the length of the original string. range(starting_val, ending_val, stepsize) OR None\n",
    "        ::param:: lmer is the length of the lmer. range(starting_val, ending_val, stepsize) OR None\n",
    "        ::param:: lmertest (bool), True if you want to test for a fixed string length value and increasing lmer values.\n",
    "        ::param:: ntest (bool), True if you want to test for a fixed lmer value and increasing string length values.\n",
    "        ::param:: trials(int), used to repeat the time calculation, the time value will be averaged.\n",
    "        ::output:: Plot y = runtime, x= length of the string OR length of the lmer.\n",
    "    \"\"\"\n",
    "\n",
    "    \n",
    "   # Spectrum(s,l) testing\n",
    "\n",
    "    if f == spectrum and ntest == True:\n",
    "        \n",
    "        S= [randomDNA(m) for m in n]\n",
    "        Times=[timeit.timeit(lambda:f(3,elem),number=trials)/trials for elem in S]\n",
    "        fig, ax = plt.subplots(figsize=figsize)\n",
    "        ax.plot(n,Times, 'r')\n",
    "        ax.set_xlabel(\"string length\")\n",
    "        ax.set_ylabel(\"Runtime\")\n",
    "        plt.title('Runtime of spectrum for 4-lmer')\n",
    "        \n",
    "    if f == spectrum and lmertest == True:    \n",
    "        S= randomDNA(1000)\n",
    "        Times=[timeit.timeit(lambda:f(elem,S),number=trials)/trials for elem in lmer]\n",
    "        fig, ax = plt.subplots(figsize=figsize)\n",
    "        ax.plot(lmer,Times, 'r')\n",
    "        ax.set_xlabel(\"lmer length\")\n",
    "        ax.set_ylabel(\"Runtime [s]\")\n",
    "        plt.title('Runtime of spectrum for a string of length 1000') \n",
    "            \n",
    "            \n",
    "    # graphFromSpectrum(A) testing\n",
    "    \n",
    "    if f == graphFromSpectrum and ntest == True:\n",
    "        S= [randomDNA(m) for m in n]\n",
    "        A = [spectrum(4, elem) for elem in S]\n",
    "        Times=[timeit.timeit(lambda:f(i),number=trials)/trials for i in A ]\n",
    "        fig, ax = plt.subplots(figsize=figsize)\n",
    "        ax.plot(n,Times,'r')\n",
    "        ax.set_xlabel(\"string length\")\n",
    "        ax.set_ylabel(\"Runtime [s]\")\n",
    "        plt.title('Runtime of EulerPath for 4-lmer')\n",
    "            \n",
    "    \n",
    "    if f == graphFromSpectrum and lmertest == True:    \n",
    "        S= randomDNA(1000)\n",
    "        A = [spectrum(elem,S) for elem in lmer]\n",
    "        Times=[timeit.timeit(lambda:f(i),number=trials)/trials for i in A ]\n",
    "        fig, ax = plt.subplots(figsize=figsize)\n",
    "        ax.plot(lmer,Times,'r')\n",
    "        ax.set_xlabel(\"lmer length\")\n",
    "        ax.set_ylabel(\"Runtime [s]\")\n",
    "        plt.title('Runtime of graphFromSpectrum for a string of length 1000')  \n",
    "        \n",
    "        \n",
    "    #EulerPath(G) testing\n",
    "    \n",
    "    if f == EulerPath and ntest == True:\n",
    "        S= [randomDNA(m) for m in n]\n",
    "        A = [spectrum(4, elem) for elem in S]\n",
    "        G = [graphFromSpectrum(i) for i in A]\n",
    "        Times=[timeit.timeit(lambda:f(j),number=trials)/trials for j in G ]\n",
    "        fig, ax = plt.subplots(figsize=figsize)\n",
    "        ax.plot(n,Times,'r')\n",
    "        ax.set_xlabel(\"string length\")\n",
    "        ax.set_ylabel(\"Runtime [s]\")\n",
    "        plt.title('Runtime of EulerPath for 4-lmer')   \n",
    "    \n",
    "        \n",
    "    if f == EulerPath and lmertest == True:    \n",
    "        S= randomDNA(1000)\n",
    "        A = [spectrum(elem,S) for elem in lmer]\n",
    "        G = [graphFromSpectrum(i) for i in A]\n",
    "        Times=[timeit.timeit(lambda:f(j),number=trials)/trials for j in G ]\n",
    "        fig, ax = plt.subplots(figsize=figsize)\n",
    "        ax.plot(lmer,Times,'r')\n",
    "        ax.set_xlabel(\"lmer length\")\n",
    "        ax.set_ylabel(\"Runtime [s]\")\n",
    "        plt.title('Runtime of EulerPath for a string of length 1000')    \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6da49003",
   "metadata": {},
   "source": [
    "### 1) $spectrum(l,s)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "01a473f2",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Increasing string size\n",
    "plotruntime(spectrum, n=range(10,1000,10), lmer=None ,lmertest = False, ntest = True, trials=30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59204963",
   "metadata": {},
   "source": [
    "Increasing the length of the strings do not affect the computation of the spectrum for a fixed l-mer value. The runtime is <b>Linear </b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1d66ce74",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Increasing l-mer size\n",
    "plotruntime(spectrum, n=None, lmer=range(1,10,1),lmertest = True, ntest = False, trials=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d64b18b",
   "metadata": {},
   "source": [
    "However, increasing the size of the l-mer we observe that the runtime is increasing <b> exponentially </b>."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44397f25",
   "metadata": {},
   "source": [
    "### 2) $graphFromSpectrum(A)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e9d6a943",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Increasing string size\n",
    "plotruntime(graphFromSpectrum, n=range(10,1000,10), lmer=None ,lmertest = False, ntest = True, trials=30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cf6cc07",
   "metadata": {},
   "source": [
    "Increasing the length of the strings do not affect the computation of the graphFromSpectrum for a fixed l-mer value. The runtime is <b>Linear </b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "021d1abe",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Increasing l-mer size\n",
    "plotruntime(graphFromSpectrum, n=None, lmer=range(1,10,1) ,lmertest = True , ntest = False, trials=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac719983",
   "metadata": {},
   "source": [
    "However, increasing the size of the l-mer we observe that the runtime is increasing <b> exponentially </b>."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e5c45b3",
   "metadata": {},
   "source": [
    "### 3) $EulerPath(G)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9f863850",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Increasing string size\n",
    "plotruntime(EulerPath, n=range(10,1000,10), lmer=None ,lmertest = False, ntest = True, trials=30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e449238",
   "metadata": {},
   "source": [
    "Increasing the length of the strings do not affect the computation of the EulerPath for a fixed l-mer value. The runtime is <b>Linear </b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "255ff8c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Increasing lmer size\n",
    "plotruntime(graphFromSpectrum, n=None, lmer=range(1,10,1) ,lmertest = True, ntest = False, trials=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e9abfa4",
   "metadata": {},
   "source": [
    "However, increasing the size of the l-mer we observe that the runtime is increasing <b> exponentially </b>."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e49ebf7",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78d70b28",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f07717d",
   "metadata": {},
   "source": [
    "To conclude this work, I can notice that for a fixed l-mer value which I can assume being much smaller than the length of the string, no matter the length of the original string, my implemented algorithm will have a linear runtime. I can therefore conclude that the algorithm is efficient. However, a drawback of the algorithm is that it will not always return the same original string, even if the lenght will be always the same."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87135a72",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Do not forget:</b> a PNG file with a Graph is annexed to the work</div>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}