Home | About | Journals | Submit | Contact Us | Français |

**|**Algorithms Mol Biol**|**v.12; 2017**|**PMC5348888

Formats

Article sections

Authors

Related links

Algorithms Mol Biol. 2017; 12: 5.

Published online 2017 March 14. doi: 10.1186/s13015-017-0094-z

PMCID: PMC5348888

Yannis Almirantis,^{1} Panagiotis Charalampopoulos,^{2} Jia Gao,^{2} Costas S. Iliopoulos,^{2} Manal Mohamed,^{2} Solon P. Pissis,^{}^{2} and Dimitris Polychronopoulos^{3}

Yannis Almirantis, Email: rg.sotirkomed.oib@rimlay.

Received 2016 November 14; Accepted 2017 March 2.

Copyright © The Author(s) 2017

The deviation of the observed frequency of a word *w* from its expected frequency in a given sequence *x* is used to determine whether or not the word is *avoided*. This concept is particularly useful in DNA linguistic analysis. The value of the deviation of *w*, denoted by *dev*(*w*), effectively characterises the extent of a word by its edge contrast in the context in which it occurs. A word *w* of length *k* > 2 is a *ρ*-avoided word in *x* if *dev*(*w*) ≤ *ρ*, for a given threshold *ρ* < 0. Notice that such a word may be completely *absent* from *x*. Hence, computing all such words naïvely can be a very time-consuming procedure, in particular for large *k*.

In this article, we propose an 𝒪(*n*)-time and 𝒪(*n*)-space algorithm to compute all *ρ*-avoided words of length *k* in a given sequence of length *n* over a fixed-sized alphabet. We also present a time-optimal 𝒪(*σ**n*)-time algorithm to compute all *ρ*-avoided words (of any length) in a sequence of length *n* over an integer alphabet of size *σ*. In addition, we provide a tight asymptotic upper bound for the number of *ρ*-avoided words over an integer alphabet and the expected length of the longest one. We make available an implementation of our algorithm. Experimental results, using both real and synthetic data, show the efficiency and applicability of our implementation in biological sequence analysis.

The systematic search for avoided words is particularly useful for biological sequence analysis. We present a linear-time and linear-space algorithm for the computation of avoided words of length *k* in a given sequence *x*. We suggest a modification to this algorithm so that it computes all avoided words of *x*, irrespective of their length, within the same time complexity. We also present combinatorial results with regards to avoided words and absent words.

The one-to-one mapping of a DNA molecule to a sequence of letters suggests that DNA analysis can be modelled within the framework of formal language theory [1]. For example, a region within a DNA sequence can be considered as a “word” on a fixed-sized alphabet in which some of its natural aspects can be described by means of certain types of automata or grammars. However, a linguistic analysis of the DNA needs to take into account many distinctive physical and biological characteristics of such sequences: The genome consists of coding regions that encode for polypeptide chains associated with biological functions as well as a plethora of regulatory and potentially functional non-coding regions, identified through multiple alignment of genomes of several organisms, and termed conserved non-coding elements (CNEs). In addition, it contains large non-coding regions most of which are not linked to any particular function. All these genomic components appear to have many statistical features in common with natural languages [2].

A computational tool oriented towards the systematic search for avoided words is particularly useful for *in silico* genomic research analyses. The search for *absent words* is already undertaken in the recent past and several results exist on the application and computation of such words [3–6]. However, words which may be present in a genome or in genomic sequences of a specific role (e.g., protein coding segments, regulatory elements, conserved non-coding elements etc.) but they are strongly underrepresented—as we can estimate on the basis of the frequency of occurrence of their longest proper factors—may be of particular importance. They can be words of nucleotides which are hardly tolerated because they negatively influence the stability of the chromatin or, more generally, the functional genomic conformation; they can represent targets of restriction endonucleases which may be found in bacterial and viral genomes; or, more generally, they may be short genomic regions whose presence in wide parts of the genome are not tolerated for less known reasons. The understanding of such avoidances is becoming an interesting line of research (for recent studies, see [7, 8]).

On the other hand, short words of nucleotides may be systematically avoided in large genomic regions or whole genomes for entirely different reasons, i.e. just because they play important signaling roles which confine their appearance only in specific positions: consensus sequences for the initiation of gene transcription and of DNA replication are well-known such oligonucleotides. Other such cases may be insulators, sequences anchoring the chromatin on the nuclear envelope like lamina-associated domains, short sequences like dinucleotide repeat motifs with enhancer activity, and several other cases. Again, we cannot exclude that this area of research could lead to the identification of short sequences of regulatory activities still unknown.

Brendel et al. in [9] initiated research into the linguistics of nucleotide sequences that focuses on the concept of words in continuous languages—languages devoid of blanks—and introduced an operational definition of words. The authors suggested a method to measure, for each possible word *w* of length *k*, the deviation of its observed frequency from the expected frequency in a given sequence. The values of the deviation, denoted by *dev*(*w*), were then used to identify words that are avoided among all possible words of length *k*. The typical length of avoided (or of overabundant) words of the nucleotide language was found to range from 3 to 5 (tri- to pentamers). The statistical significance of the avoided words was shown to reflect their biological importance. This work, however, was based on the very limited sequence data available at the time: only DNA sequences from two viral and one bacterial genomes were considered. Also note that *k* might change when considering eukaryotic genomes, the complex dynamics and function of which might impose a more demanding analysis. The authors in [10–12] have studied the concept of unusual words—based on different definitions than the ones Brendel et al. use for expectation and variance—focusing on the factors of a string, whereas based on Brendel et al. definitions, we consider here *any* word over the alphabet.

The computational problem can be described as follows. Given a sequence *x* of length *n*, an integer *k*, and a real number *ρ* < 0, compute the set of *ρ*-avoided words of length *k*, i.e. all words *w* of length *k* for which *dev*(*w*) ≤ *ρ*. We call this set the *ρ*-avoided words of length *k* in *x*. Brendel et al. did not provide an efficient solution for this computation [9]. Notice that such a word may be completely absent from *x*. Hence the set of *ρ*-avoided words can be naïvely computed by considering all possible *σ*^{k} words, where *σ* is the size of the alphabet.

Here we present an 𝒪(*n*)-time and 𝒪(*n*)-space algorithm for computing all *ρ*-avoided words of length *k* in a sequence of length *n* over a fixed-sized alphabet. For words over an integer alphabet of size *σ*, the algorithm requires time 𝒪(*σ**n*), which is optimal for sufficiently large *σ*. We also present a time-optimal 𝒪(*σ**n*)-time algorithm to compute all *ρ*-avoided words (of any length) in a sequence of length *n* over an integer alphabet of size *σ*. We provide a tight asymptotic upper bound for the number of *ρ*-avoided words over an integer alphabet and the expected length of the longest one. We also prove that the same asymptotic upper bound is tight for the number of *ρ*-avoided words of fixed length when the alphabet is sufficiently large.

As shown subsequently, the set of absent *ρ*-avoided words is a subset of the set of minimal absent words of a word. Hence the tight asymptotic bounds for *ρ*-avoided words are based on the proof we provide for the tightness of the known asymptotic bound on minimal absent words and the tightness of this bound for minimal absent words of fixed length over sufficiently large alphabets.

We make available an open-source implementation of our algorithm. Experimental results, using both real and synthetic data, show its efficiency and applicability. Specifically, using our method we confirm that restriction endonucleases which target self-complementary sites are not found in eukaryotic sequences [8]. In addition, we apply our algorithm in the case of CNEs, which are classes of sequences whose functions in our genomes remain largely enigmatic [13, 14]. We observe interesting patterns of occurring avoided words within CNEs compared to CNE-like sequences (surrogates) that are in accordance with their distinct sequence characteristics which classify them from other non-functional sequences [15, 16].

A preliminary version of this article has appeared in [17].

We begin with basic definitions and notation generally following [18]. Let *x* = *x*[0]*x*[1] ⋯ *x*[*n* - 1] be a *word* of *length*
*n* = |*x*| over a finite ordered *alphabet*
Σ of fixed size *σ*, i.e. *σ* = |Σ| = 𝒪(1). We also consider the case of an *integer alphabet*; in this case each letter is replaced by its rank such that the resulting string consists of integers in the range {1, …, *n*}. For two positions *i* and *j* on *x*, we denote by *x*[*i*…*j*] = *x*[*i*] ⋯ *x*[*j*] the *factor* (sometimes called *subword*) of *x* that starts at position *i* and ends at position *j* (it is empty if *j* < *i*), and by *ε* the *empty word*, word of length 0. We recall that a prefix of *x* is a factor that starts at position 0 (*x*[0…*j*]) and a suffix is a factor that ends at position *n* - 1 (*x*[*i*…*n* - 1]), and that a factor of *x* is a *proper* factor if it is not *x* itself. A factor of *x* that is neither a prefix nor a suffix of *x* is called an *infix* of *x*. We say that *x* is *a power* of a word *y* if there exists a positive integer *k*, *k* > 1, such that *x* is expressed as *k* consecutive concatenations of *y*; we denote that by *x* = *y*^{k}.

Let *w* = *w*[0]*w*[1] ⋯ *w*[*m* - 1] be a word, 0 < *m* ≤ *n*. We say that there exists an *occurrence* of *w* in *x*, or, more simply, that *w*
*occurs in*
*x*, when *w* is a factor of *x*. Every occurrence of *w* can be characterised by a starting position in *x*. Thus we say that *w* occurs at the *starting position*
*i* in *x* when *w* = *x*[*i*…*i* + *m* - 1]. Further let *f*(*w*) denote the *observed frequency*, that is, the number of occurrences of a non-empty word *w* in word *x*. Note that overlapping occurrences are considered as distinct ones; e.g. *f*(TT) = 2 in TTT. If *f*(*w*) = 0 for some word *w*, then *w* is called *absent*, otherwise, *w* is called *occurring*.

By *f*(*w*_{p}), *f*(*w*_{s}), and *f*(*w*_{i}) we denote the observed frequency of the longest proper prefix *w*_{p}, suffix *w*_{s}, and infix *w*_{i} of *w* in *x*, respectively. We can now define the *expected frequency* of word *w*, |*w*| > 2, in *x* as in Brendel et al. [9]:

$$\begin{array}{c}\hfill E(w)=\frac{f({w}_{p})\times f({w}_{s})}{f({w}_{i})},\phantom{\rule{1em}{0ex}}\phantom{\rule{0.333333em}{0ex}}\text{if}\phantom{\rule{0.333333em}{0ex}}\phantom{\rule{0.333333em}{0ex}}f({w}_{i})>0\u037e\phantom{\rule{0.333333em}{0ex}}\text{else}\phantom{\rule{0.333333em}{0ex}}E(w)=0.\end{array}$$

1

The above definition can be explained intuitively as follows. Suppose we are given *f*(*w*_{p}), *f*(*w*_{s}), and *f*(*w*_{i}). Given an occurrence of *w*_{i} in *x*, the probability of it being preceded by *w*[0] is $\frac{f({w}_{p})}{f({w}_{i})}$ as *w*[0] precedes exactly *f*(*w*_{p}) of the *f*(*w*_{i}) occurrences of *w*_{i}. Similarly, this occurrence of *w*_{i} is also an occurrence of *w*_{s} with probability $\frac{f({w}_{s})}{f({w}_{i})}$. Although these two events are not always independent, the product $\frac{f({w}_{p})}{f({w}_{i})}\times \frac{f({w}_{s})}{f({w}_{i})}$ gives a good approximation of the probability that an occurrence of *w*_{i} at position *j* implies an occurrence of *w* at position *j* - 1. It can be seen then that by multiplying this product by the number of occurrences of *w*_{i} we get the above formula for the expected frequency of *w*.

Moreover, to measure the deviation of the observed frequency of a word *w* from its expected frequency in *x*, we define the *deviation* (*χ*^{2} test) of *w* as:

$$\begin{array}{c}\hfill \mathit{dev}(w)=\frac{f(w)-E(w)}{max\{\sqrt{E(w)},1\}}.\end{array}$$

2

For more details on the *biological* justification of these definitions see [9].

Using the above definitions and a given threshold, we are in a position to classify a word *w* as either *avoided* or *common* in *x*. In particular, for a given threshold *ρ* < 0, a word *w* is called *ρ*-*avoided* if *dev*(*w*) ≤ *ρ*. In this article, we consider the following computational problems.

In our algorithms, suffix trees are used extensively as computational tools. For a general introduction to suffix trees, see [18].

The *suffix tree*
𝒯(*x*) of a non-empty word *x* of length *n* is a compact trie representing all suffixes of *x*. The nodes of the trie which become nodes of the suffix tree are called *explicit* nodes, while the other nodes are called *implicit*. Each edge of the suffix tree can be viewed as an upward maximal path of implicit nodes starting with an explicit node. Moreover, each node belongs to a unique path of that kind. Then, each node of the trie can be represented in the suffix tree by the edge it belongs to and an index within the corresponding path.

We use ℒ(*v*) to denote the *path-label* of a node *v*, i.e., the concatenation of the edge labels along the path from the root to *v*. We say that *v* is path-labelled ℒ(*v*). Additionally, 𝒟(*v*) = |ℒ(*v*)| is used to denote the *word-depth* of node *v*. Node *v* is a *terminal* node, if and only if, ℒ(*v*) = *x*[*i*…*n* - 1], 0 ≤ *i* < *n*; here *v* is also labelled with index *i*. It should be clear that each occurring word *w* in *x* is uniquely represented by either an explicit or an implicit node of 𝒯(*x*). The *suffix-link* of a node *v* with path-label ℒ(*v*) = *α**y* is a pointer to the node path-labelled *y*, where *α* ∈ Σ is a single letter and *y* is a word. The suffix-link of *v* exists if *v* is a non-root internal node of 𝒯(*x*). We denote by Child
(*v*, *α*) the explicit node that is obtained from *v* by traversing the outgoing edge whose label starts with *α* ∈ Σ.

In any standard implementation of the suffix tree, we assume that each node of the suffix tree is able to access its parent. Note that once 𝒯(*x*) is constructed, it can be traversed in a depth-first manner to compute the word-depth 𝒟(*v*) for each node *v*. Let *u* be the parent of *v*. Then the word-depth 𝒟(*v*) is computed by adding 𝒟(*u*) to the length of the label of edge (*u*, *v*). If *v* is the root then 𝒟(*v*) = 0. Additionally, a depth-first traversal of 𝒯(*x*) allows us to count, for each node *v*, the number of terminal nodes in the subtree rooted at *v*, denoted by 𝒞(*v*), as follows. When internal node *v* is visited, 𝒞(*v*) is computed by adding up 𝒞(*u*) of all the nodes *u*, such that *u* is a child of *v*, and then 𝒞(*v*) is incremented by 1 if *v* itself is a terminal node. If a node *v* is a leaf then 𝒞(*v*) = 1.

Consider the word *x* = AGCGCGACGTCTGTGT. Fig. 1 represents the suffix tree 𝒯(*x*). Note that word GCG is represented by the explicit internal node *v*; whereas word TCT is represented by the implicit node along the edge connecting the node labelled 15 and the node labelled 9. Consider node *v* in 𝒯(*x*); we have that ℒ(*v*) = GCG, 𝒟(*v*) = 3, and 𝒞(*v*) = 2.

[4] An absent word *w* of *x* is *minimal* if and only if all proper factors of *w* occur in *x*.

We first show that the known asymptotic upper bound on the number of minimal absent words of a word is tight.

[19]* The upper bound*
𝒪(*σ**n*)
* on the number of minimal absent words of a word of length*
*n*
* over an alphabet of size*
*σ*
* is tight if*
2 ≤ *σ* ≤ *n*.

To prove that the bound is tight it suffices to construct a word with these many minimal absent words asymptotically.

Let Σ = {*a*_{1}, *a*_{2}}, i.e. *σ* = 2, and consider the word $x={a}_{2}{a}_{1}^{n-2}{a}_{2}$ of length *n*. All words of the form ${a}_{2}{a}_{1}^{k}{a}_{2}$ for 0 ≤ *k* ≤ *n* - 3 are minimal absent words in *x*. Hence *x* has at least *n* - 2 = Ω(*n*) minimal absent words.

Let Σ = {*a*_{1}, *a*_{2}, *a*_{3}, …, *a*_{σ}} with 3 ≤ *σ* ≤ *n* and consider the word $x={a}_{2}{a}_{1}^{k}{a}_{3}{a}_{1}^{k}{a}_{4}{a}_{1}^{k}\cdots {a}_{i}{a}_{1}^{k}{a}_{i+1}\cdots {a}_{\mathit{\sigma}}{a}_{1}^{k}{a}_{1}^{m}$, where $k=\lfloor \frac{n}{\mathit{\sigma}-1}\rfloor -1$ and *m* = *n* - (*σ* - 1)(*k* + 1). Note that *x* is of length *n*. Further note that ${a}_{i}{a}_{1}^{j}$ is a factor of *x*, for all 2 ≤ *i* ≤ *σ* and 0 ≤ *j* ≤ *k*. Similarly, ${a}_{1}^{j}{a}_{l}$ is a factor of *x*, for all 3 ≤ *l* ≤ *σ* and 0 ≤ *j* ≤ *k*. Thus all proper factors of all the words in the set $S=\{{a}_{i}{a}_{1}^{j}{a}_{l}\phantom{\rule{0.166667em}{0ex}}|\phantom{\rule{0.166667em}{0ex}}0\le j\le k,\phantom{\rule{0.166667em}{0ex}}2\le i\le \mathit{\sigma},\phantom{\rule{0.166667em}{0ex}}3\le l\le \mathit{\sigma}\}$ occur in *x*. However, the only words in *S* that occur in *x* are the ones of the form ${a}_{i}{a}_{1}^{k}{a}_{i+1}$, for 2 ≤ *i* < *σ*. Hence *x* has at least $(\mathit{\sigma}-1)(\mathit{\sigma}-2)(k+1)-(\mathit{\sigma}-2)=(\mathit{\sigma}-1)(\mathit{\sigma}-2)\lfloor \frac{n}{\mathit{\sigma}-1}\rfloor -(\mathit{\sigma}-2)=\mathrm{\Omega}(\mathit{\sigma}n)$ minimal absent words. □

In the following lemma we show that, for sufficiently large alphabets, 𝒪(*σ**n*) is a tight asymptotic bound for the number of minimal absent words of fixed length.

*The upper bound*
𝒪(*σ**n*)
* on the number of minimal absent words of fixed length of a word of length*
*n*
* over an alphabet of size*
*σ*
* is tight if*
$\sqrt{n}+1\le \mathit{\sigma}\le n$.

Let Σ = {*a*_{1}, *a*_{2}, *a*_{3}, …, *a*_{σ}} be an alphabet of size *σ*. We will show that we can construct words of any length *n*, with *σ* ≤ *n* ≤ *σ*(*σ* - 1), that have Ω(*σ**n*) minimal absent words of length 3.

We first construct the strings (blocks) *B*_{i} = *a*_{i+1}*a*_{i}*a*_{i+2}*a*_{i} ⋯ *a*_{i+j}*a*_{i} ⋯ *a*_{σ}*a*_{i}, for 1 ≤ *i* ≤ *σ* - 1. Note that |*B*_{i}| = 2(*σ* - *i*) and that a letter *a*_{i} occurs in *B*_{j} if and only if *j* ≤ *i*. We then consider the word *x* = *B*_{1}*B*_{2} ⋯ *B*_{i} ⋯ *B*_{σ-1} which has length $|x|={\sum}_{i=1}^{\mathit{\sigma}-1}2(\mathit{\sigma}-i)=\mathit{\sigma}(\mathit{\sigma}-1)$.

Now consider any prefix *y* of *x* with |*y*| > 2(*σ* - 1). Then $y={B}_{1}{B}_{2}\cdots {B}_{j-1}\overline{{B}_{j}}$, where $\overline{{B}_{j}}$ is a prefix of *B*_{j} for some *j* > 1. For any *i* < *j* the words of length 3 with *a*_{i} as the mid-letter that occur in *y* are the ones in the set *U*_{i} = {*a*_{ℓ}*a*_{i}*a*_{ℓ}∣1 ≤ *ℓ* ≤ *i* - 2} ∪ {*a*_{k}*a*_{i}*a*_{k+1}∣*i* + 1 ≤ *k* ≤ *σ* - 1} ∪ {*a*_{i-2}*a*_{i}*a*_{i-1}} ∪ {*a*_{σ}*a*_{i}*a*_{i+2}}, with the last singleton not included if *i* = *j* - 1 and $\overline{{B}_{j}}=\mathit{\epsilon}$. We thus have |*U*_{i}| ≤ *σ*.

We notice that the strings of the form *a*_{k}*a*_{i} for all *k* ∈ *P*_{i} = {1, 2, …, *σ*}\{*i* - 1, *i*} occur in *y* and similarly the strings of the form *a*_{i}*a*_{ℓ} for all *ℓ* ∈ *S*_{i} = {1, 2, …, *σ*}\{*i*, *i* + 1} occur in *y*. Hence, all proper factors of all strings in *V*_{i} = {*a*_{k}*a*_{i}*a*_{ℓ}∣*k* ∈ *P*_{i}, *ℓ* ∈ *S*_{i}} occur in *y* and |*V*_{i}| = (*σ*-2)^{2}. Then all the words in *M*_{i} = *V*_{i}\*U*_{i} are minimal absent words of *y* of length 3 with mid-letter *a*_{i} and they are at least (*σ*-2)^{2} - *σ*. Now, since |*B*_{i}| < 2*σ* for all *i*, we have that $j>\frac{|y|}{2\mathit{\sigma}}$. Hence ${\sum}_{i=1}^{j-1}|{M}_{i}|\ge ({(\mathit{\sigma}-2)}^{2}-\mathit{\sigma})\times \frac{|y|}{2\mathit{\sigma}}$. Since the sets *M*_{i} are pairwise disjoint it then follows that *y* has Ω(*σ*|*y*|) minimal absent words of length 3.

Hence, given an alphabet of size *σ* we can construct words of any length *n*, such that 2*σ* < *n* ≤ *σ*(*σ* - 1), that have Ω(*σ**n*) minimal absent words of length 3.

Note that when *σ* ≤ *n* ≤ 2*σ* the example of *y* = *a*_{1}*a*_{2}*a*_{3} ⋯ *a*_{σ} (possibly padded with *a*_{σ}’s) gives the desired result as at most *σ* out of the *σ*^{2} possible combinations *a*_{i}*a*_{j} (of length 2) occur in *y*, while all proper factors of all such combinations occur in *y*.□

In this section, we provide some useful insights of combinatorial nature which were not considered by Brendel et al. [9]. By the definition of *ρ*-avoided words it follows that a word *w* may be *ρ*-avoided even if it is absent from *x*. In other words, *dev*(*w*) ≤ *ρ* may hold for either *f*(*w*) > 0 (occurring) or *f*(*w*) = 0 (absent).

Consider again the word *x* = AGCGCGACGTCTGTGT, *k* = 3, and *ρ* = - 0.4.

- Word
*w*_{1}= CGT, at position 7 of*x*, is an*occurring**ρ*-avoided word:$$\begin{array}{c}\hfill E({w}_{1})=3\times 3/6=1.5,\phantom{\rule{0.333333em}{0ex}}\mathit{dev}({w}_{1})=(1-1.5)/\sqrt{1.5}=-0.408248.\end{array}$$ - Word
*w*_{2}= AGT is an*absent**ρ*-avoided word:*E*(*w*_{2}) = 1 × 3/6 = 0.5,*dev*(*w*_{2}) = (0 - 0.5)/1 = - 0.5.

This means that a naïve computation should consider *all* possible *σ*^{k} words. Then for each possible word *w*, the value of *dev*(*w*) can be computed via pattern matching on the suffix tree of *x*. In particular, we can search for the occurrences of *w*, *w*_{p}, *w*_{s}, and *w*_{i} in *x* in time 𝒪(*k*) [18]. In order to avoid this inefficient computation, we exploit the following crucial lemmas.

*Any absent*
*ρ*-*avoided word*
*w*
* in*
*x*
* is a minimal absent word of*
*x*.

For *w* to be a *ρ*-avoided word it must hold that

$$\begin{array}{c}\hfill \mathit{dev}(w)=\frac{f(w)-E(w)}{max\{\sqrt{E(w)},1\}}\le \mathit{\rho}<0.\end{array}$$

This implies that *f*(*w*) - *E*(*w*) < 0, which in turn implies that *E*(*w*) > 0 since *f*(*w*) = 0. From $E(w)=\frac{f({w}_{p})\times f({w}_{s})}{f({w}_{i})}>0$, we conclude that *f*(*w*_{p}) > 0 and *f*(*w*_{s}) > 0 must hold. Since *f*(*w*) = 0, *f*(*w*_{p}) > 0, and *f*(*w*_{s}) > 0, *w* is a minimal absent word of *x*: all proper factors of *w* occur in *x*. □

*Let*
*w*
* be a word occurring in*
*x*
* and*
𝒯(*x*)
* be the suffix tree of*
*x*.* Then, if*
*w*_{p}
* is a path-label of an implicit node of*
𝒯(*x*), *dev*(*w*) ≥ 0.

For any *w* that occurs in *x* it holds that *f*(*w*_{i}) ≥ *f*(*w*_{s}), which implies that $f({w}_{p})\ge \frac{f({w}_{p})\times f({w}_{s})}{f({w}_{i})}=E(w)$. Furthermore, by the definition of the suffix tree, if *w* occurs in *x* and *w*_{p} is a path-label of an implicit node then *f*(*w*_{p}) = *f*(*w*). It thus follows that *f*(*w*) - *E*(*w*) = *f*(*w*_{p}) - *E*(*w*) ≥ 0, and since $max\{1,\sqrt{E(w)}\}>0$, the claim holds. □

*The number of*
*ρ*-*avoided words of length*
*k* > 2
* in a word of length*
*n*
* over an alphabet of size*
*σ*
* is*
𝒪(*σ**n*);* in particular, this number is no more than*
(*σ* + 1)*n* - *k* + 1.* The upper bound*
𝒪(*σ**n*)
* is tight if*
$\sqrt{n}+1\le \mathit{\sigma}\le n$.

By Lemma 3, every *ρ*-avoided word is either occurring or a minimal absent word. It is known that the number of minimal absent words in a word of length *n* is smaller than or equal to *σ**n* [20]. Clearly, the occurring *ρ*-avoided words in a word of length *n* are at most *n* - *k* + 1. Therefore the number of *ρ*-avoided words of length *k* are no more than (*σ* + 1)*n* - *k* + 1. This implies that 𝒪(*σ**n*) is an asymptotic upper bound. In the case of an alphabet of size $\sqrt{n}+1\le \mathit{\sigma}\le n$, it follows from Lemma 2 that there exist words with Ω(*σ**n*) minimal absent words of a fixed length *k* > 2. Consider such a word *x*, the respective *k*, and some $\mathit{\rho}\ge -\frac{1}{n}$. Let *w* be any minimal absent word of *x*. We have that *f*(*w*_{p}) ≥ 1, *f*(*w*_{s}) ≥ 1, and *f*(*w*_{i}) ≤ *n*; and hence $E(w)\ge \frac{1}{n}$. Since *f*(*w*) = 0, it follows that $\mathit{dev}(w)\le -\frac{1}{n}\le \mathit{\rho}$. Thus, every minimal absent word of *x* is *ρ*-avoided, and since there are Ω(*σ**n*) of them of length *k*, we conclude that 𝒪(*σ**n*) is a tight asymptotic bound in this case. □

In this section, we present Algorithm AvoidedWords for computing all *ρ*-avoided words of length *k* in a given word *x*. The algorithm builds the suffix tree 𝒯(*x*) for word *x*, and then prepares 𝒯(*x*) to allow constant-time observed frequency queries. This is mainly achieved by counting the terminal nodes in the subtree rooted at node *v* for every node *v* of 𝒯(*x*). Additionally during this pre-processing, the algorithm computes the word-depth of *v* for every node *v* of 𝒯(*x*). By Lemma 3, *ρ*-avoided words are classified as either occurring or (minimal) absent, therefore Algorithm AvoidedWords calls Routines AbsentAvoidedWords and OccurringAvoidedWords to compute both classes of *ρ*-avoided words in *x*. The outline of Algorithm AvoidedWords is as follows.

In Lemma 3, we showed that each absent *ρ*-avoided word is a minimal absent word. Thus, Routine AbsentAvoidedWords starts by computing all minimal absent words in *x*; this can be done in time and space 𝒪(*n*) for a fixed-sized alphabet or in time 𝒪(*σ**n*) for integer alphabets [4, 5]. Let < (*i*, *j*), *α* > be a tuple representing a minimal absent word in *x*, where for some minimal absent word *w* of length |*w*| > 2, *w* = *x*[*i*…*j*]*α*, *α* ∈ Σ; this representation is clearly unique.

Intuitively, the idea is to check the length of every minimal absent word. If a tuple < (*i*, *j*), *α* > represents a minimal absent word *w* of length *k* = *j* - *i* + 2, then the value of *dev*(*w*) is computed to determine whether *w* is an absent *ρ*-avoided word. Note that, if *w* = *x*[*i*…*j*]*α* is a minimal absent word, then *w*_{p} = *x*[*i*…*j*], *w*_{i} = *x*[*i* + 1…*j*], and *w*_{s} = *x*[*i* + 1…*j*]*α* occur in *x* by Definition 1. Thus, there are three (implicit or explicit) nodes in 𝒯(*x*) path-labelled *w*_{p}, *w*_{i}, and *w*_{s}, respectively.

The observed frequencies of *w*_{p}, *w*_{i}, and *w*_{s} are already computed during the pre-processing of 𝒯(*x*). For an explicit node *v* of 𝒯(*x*), path-labelled *w*^{′} = *x*[*i*^{′}…*j*^{′}], the value 𝒞(*v*), which is the number of terminal nodes in the subtree rooted at *v*, is equal to the number of occurrences (observed frequency) of *w*^{′} in *x*. For an implicit node along the edge (*u*, *v*) path-labelled *w*^{′′}, the number of occurrences of *w*^{′′} is equal to 𝒞(*v*) (and not 𝒞(*u*)). The implementation of this procedure is given in Routine AbsentAvoidedWords.

Lemma 4 suggests that for each occurring *ρ*-avoided word *w*, *w*_{p} is a path-label of an explicit node *v* of 𝒯(*x*). Thus, for each internal node *v* such that 𝒟(*v*) = *k* - 1 and ℒ(*v*) = *w*_{p}, Routine OccurringAvoidedWords computes *dev*(*w*), where *w* = *w*_{p}*α*, *α* ∈ Σ, is a path-label of a child (explicit or implicit) node of *v*. Note that if *w*_{p} is a path-label of an explicit node *v* then *w*_{i} is a path-label of an explicit node *u* of 𝒯(*x*); node *u* is well-defined and it is the node pointed at by the suffix-link of *v*. The implementation of this procedure is given in Routine OccurringAvoidedWords.

*Given a word*
*x*,* an integer*
*k* > 2,* and a real number*
*ρ* < 0,* Algorithm*
AvoidedWords
* computes all*
*ρ*-*avoided words of length*
*k* in *x*.

By definition, a *ρ*-avoided word *w* is either an absent *ρ*-avoided word or an occurring one. Hence, the proof of correctness relies on Lemmas 3 and 4. First, Lemma 3 indicates that an absent *ρ*-avoided word in *x* is necessarily a minimal absent word. Routine AbsentAvoidedWords considers each minimal absent word *w* and verifies if *w* is a *ρ*-avoided word of length *k*.

Second, Lemma 4 indicates that for each occurring *ρ*-avoided word *w*, *w*_{p} is a path-label of an explicit node *v* of 𝒯(*x*). Routine OccurringAvoidedWords considers every child of each such node of word-depth *k*, and verifies if its path-label is a *ρ*-avoided word. □

*Given a word*
*x*
* of length*
*n*
* over a fixed-sized alphabet, an integer*
*k* > 2,* and a real number*
*ρ* < 0,* Algorithm*
AvoidedWords
* requires time and space*
𝒪(*n*);* for integer alphabets, it requires time*
𝒪(*σ**n*).

Constructing the suffix tree 𝒯(*x*) of the input word *x* takes time and space 𝒪(*n*) for a word over a fixed-sized alphabet [18]. Once the suffix tree is constructed, computing arrays 𝒟 and 𝒞 by traversing 𝒯(*x*) requires time and space 𝒪(*n*). Note that the path-labels of the nodes of 𝒯(*x*) can by implemented in time and space 𝒪(*n*) as follows: traverse the suffix tree to compute for each node *v* the smallest index *i* of the terminal nodes of the subtree rooted at *v*. Then ℒ(*v*) = *x*[*i*…*i* + 𝒟(*v*) - 1].

Next, Routine AbsentAvoidedWords requires time 𝒪(*n*). It starts by computing all minimal absent words of *x*, which can be achieved in time and space 𝒪(*n*) over a fixed-sized alphabet [4, 5]. The rest of the procedure deals with checking each of the 𝒪(*n*) minimal absent words of length *k*. Checking each minimal absent word *w* to determine whether it is a *ρ*-avoided word or not requires time 𝒪(1). In particular, an 𝒪(*n*)-time pre-processing of 𝒯(*x*) allows the retrieval of the (implicit or explicit) node in 𝒯(*x*) corresponding to the longest proper prefix of *w* in time 𝒪(1) [21]. Finally, Routine OccurringAvoidedWords requires time 𝒪(*n*). It traverses the suffix tree 𝒯(*x*) to consider all explicit nodes of word-depth *k* - 1. Then for each such node, the procedure checks every (explicit or implicit) child of word-depth *k*. The total number of these children is at most *n* - *k* + 1. For every child node, the procedure checks whether its path-label is a *ρ*-avoided word in time 𝒪(1) via the use of suffix-links.

For integer alphabets, the suffix tree can be constructed in time 𝒪(*n*) [22] and all minimal absent words can be computed in time 𝒪(*σ**n*) [4, 5]. The efficiency of Algorithm AvoidedWords is then limited by the total number of words to be considered, which, by Lemma 5, is 𝒪(*σ**n*). Note that for integers alphabets, a batch of *q*
Child
(*v*, *α*) queries can be answered off-line in time 𝒪(*n* + *q*) with the aid of radix sort (in Routine AbsentAvoidedWords) or on-line in time 𝒪(*q*log*σ*) (in Routine OccurringAvoidedWords).□

*Algorithm*
AvoidedWords
* solves Problem*
AvoidedWordsComputation
* in time and space*
𝒪(*n*).* For integer alphabets, the algorithm solves the problem in time*
𝒪(*σ**n*);* this is time-optimal if*
$\sqrt{n}+1\le \mathit{\sigma}\le n$.

Although the biological motivation is yet to be shown for this, we present here how we can modify Algorithm AvoidedWords so that it computes *all*
*ρ*-avoided words (of all lengths) in a given word *x* of length *n* over an integer alphabet of size *σ* in time 𝒪(*σ**n*). We further show that this algorithm (AllAvoidedWords) is in fact time-optimal.

Based on Lemma 1 and similarly to the proof of Lemma 5 we obtain the following result.

*The number of*
*ρ*-*avoided words in a word of length*
*n*
* over an alphabet of size*
2 ≤ *σ* ≤ *n*
* is*
𝒪(*σ**n*)
* and this bound is tight*.

It is clear that if we just remove the condition on the length of each minimal absent word in Line 2 of AbsentAvoidedWords we then compute all absent *ρ*-avoided words in time 𝒪(*σ**n*). In order to compute all occurring *ρ*-avoided words in *x* it suffices by Lemma 4 to investigate the children of explicit nodes. We can thus traverse the suffix tree 𝒯(*x*) and for each explicit internal node, check for all of its children (explicit or implicit) whether their path-label is a *ρ*-avoided word. We can do this in 𝒪(1) time as described. The total number of these children is at most 2*n* - 1, as this is the bound on the number of edges of 𝒯(*x*) [18]. This modified algorithm is clearly time-optimal for fixed-sized alphabets as it then runs in time 𝒪(*n*). The time optimality for integer alphabets follows directly from Lemma 8. Hence we obtain the second result of this article.

*Algorithm*
AllAvoidedWords
* solves Problem*
AllAvoidedWordsComputation
* in time*
𝒪(*σ**n*).* This is time-optimal if*
2 ≤ *σ* ≤ *n*.

In [23], it is shown that all |𝒜| minimal absent words of a word *x* of length *n* over an integer alphabet can be computed in time 𝒪(*n* + |𝒜|) and space 𝒪(*n*). Computing minimal absent words and checking for each of them if it is an avoided word is the bottleneck for algorithms AvoidedWords and AllAvoidedWords. The result of [23] implies that for a word *x* of length *n* over an integer alphabet we can make both algorithms to require time 𝒪(*n* + |𝒜|) and space 𝒪(*n*). We can do that by checking for each minimal absent word output by the algorithm whether it is avoided, instead of storing a representation of them and then making the check.

As the complexity of algorithms AvoidedWords and AllAvoidedWords does not depend on the value of *ρ*, one can use a negative *ρ* close to 0, sort the output *ρ*-avoided words with respect to *dev*(*w*), and consider the extreme ones.

*The expected length of the longest*
*ρ*-*avoided word in a word*
*x*
* of length*
*n*
* over an alphabet*
Σ
* of size*
*σ* > 1
* is*
𝒪(log_{σ}*n*)
* when the letters are independent and identically distributed random variables uniformly distributed over*
Σ.

By Lemma 4 the length of the longest occurring word is bounded above by the word-depth of the deepest internal explicit node in 𝒯(*x*) incremented by 1. We note that the greatest word-depth of an internal node corresponds to the longest repeated factor in word *x*. Moreover, for a word *w* to be a minimal absent word, *w*_{i} must appear at least twice in *x* (in the occurrences of *w*_{p} and *w*_{s}). Hence the length of the longest *ρ*-avoided word is bounded by the length of the longest repeated factor in *x* incremented by 2. The expected length of the longest repeated factor in a word is known to be 𝒪(log_{σ}*n*) [24] and hence the lemma follows. □

Algorithm AvoidedWords was implemented as a program to compute the *ρ*-avoided words of length *k* in one or more input sequences; there is an option to run Algorithm AllAvoidedWords instead. The program was implemented in the C++ programming language and developed under GNU/Linux operating system. Our program makes use of the implementation of the compressed suffix tree available in the Succinct Data Structure Library [25]. The input parameters are a (Multi)FASTA file with the input sequence(s), an integer *k* > 2, and a real number *ρ* < 0. The output is a file with the set of *ρ*-avoided words of length *k* per input sequence. The implementation is distributed under the GNU General Public License, and it is available at http://github.com/solonas13/aw. The experiments were conducted on a Desktop PC using one core of Intel Core i5-4690 CPU at 3.50 GHz under GNU/Linux. The program was compiled with g++ version 4.8.4 at optimisation level 3 (−O3). We also implemented a brute-force approach for the computation of *ρ*-avoided words. We mainly used it to confirm the correctness of our implementation. Here we do not plot the results of the brute-force approach as it is easily understood that it is orders of magnitude slower than our approach.

To evaluate the time performance of our implementation, synthetic DNA (*σ* = 4) and protein (*σ* = 20) data were used. The input sequences were generated using a randomised script. In the first experiment, our task was to establish that the performance of the program does not essentially depend on *k* and *ρ*; i.e., the elapsed time of the program remains unchanged up to some constant with increasing values of *k* and decreasing values of *ρ*. As input datasets, for this experiment, we used a DNA and a protein sequence both of length 1M (1 Million letters). For each sequence we used different values of *k* and *ρ*. The results, for elapsed time are plotted in Fig. 2. It becomes evident from the results that the time performance of the program remains unchanged up to some constant. The longer time required for the protein sequences for some value of *k* is explained by the increased number of branching nodes in this depth in the corresponding suffix tree due to the size of the alphabet (*σ* = 20). To confirm this we counted the number of nodes considered by the algorithm to compute the *ρ*-avoided words for *k* = 4 and *ρ* = - 10 for both sequences. The number of considered nodes for the DNA sequence was 260 whereas for the protein sequence it was 1,585,510.

In the second experiment, our task was to establish the fact that the elapsed time and memory usage of the program grow linearly with *n*, the length of the input sequence. As input datasets, for this experiment, we used synthetic DNA and proteins sequences ranging from 1 to 128 M. For each sequence we used constant values for *k* and *ρ*: *k* = 8 and *ρ* = - 10. The results, for elapsed time and peak memory usage, are plotted in Fig. 3. It becomes evident from the results that the elapsed time and memory usage of the program grow linearly with *n*. The longer time required for the protein sequences compared to the DNA sequences for increasing *n* is explained by the increased number of branching nodes in this depth (*k* = 8) in the corresponding suffix tree due to the size of the alphabet (*σ* = 20). To confirm this we counted the number of nodes considered by the algorithm to compute the *ρ*-avoided words for *n* = 64M for both the DNA and the protein sequence. The number of nodes for the DNA sequence was 69,392 whereas for the protein sequence it was 43,423,082.

In the next experiment, our task was to evaluate the time and memory performance of our implementation with real data. As input datasets, for this experiment, we used all chromosomes of the human genome. Their lengths range from around 46M (chromosome 21) to around 249M (chromosome 1). For each sequence we used *k* = 8 and *ρ* = - 10. The results, for elapsed time and peak memory usage, are plotted in Fig. 4. The results with real data confirm that the elapsed time and memory usage of the program grow linearly with *n*.

In an experiment with a prokaryote, we computed the set of avoided words for *k* = 6 (hexamers) and *ρ* = - 10 in the complete genome of *Escherichia coli* and sorted the output in increasing order of their deviation. The most avoided words were extremely enriched in self-complementary (palindromic) hexamers. In particular, within the output of 28 avoided words, 23 were self-complementary; and the 17 most avoided ones were *all* self-complementary. For comparison, we computed the set of avoided words for *k* = 6 and *ρ* = - 10 from an eukaryotic sequence: a segment of the human chromosome 21 (its leftmost segment devoid of N’s) equal to the length of the *E. coli* genome. In the output of 10 avoided words, no self-complementary hexamer was found. Our results confirm that the restriction endonucleases which target self-complementary sites are not found in eukaryotic sequences [8].

Then, we proceeded to the examination of several collections of CNEs obtained through multiple sequence alignment between the human and other genomes. The detailed description of how those CNEs were identified could be found in [15]. For each CNE of these datasets, a sequence stretch (surrogate sequence) of non-coding DNA of equal length and equal GC content was taken at random from the repeat-masked human genome. The CNEs of each collection were concatenated into a single long sequence and the same procedure was followed for the corresponding surrogates. Seven CNEs concatenates and the corresponding surrogate datasets have been formed and used in this experiment. We have determined through the proposed algorithm the avoided words for *k* = 10 (decamers) and *ρ* = - 2 for these fourteen datasets and the results are presented in Table 1. In Table 2, we show likewise for *k* > 2 (all avoided words) and *ρ* = - 2.

The number of avoided words, for *k* = 10 and *ρ* = - 2, for each concatenate of surrogates (Row 1); the number of avoided words of the corresponding CNE dataset (Row 2); and their ratio (Row 3)

The number of avoided words, for *k* > 2 and *ρ* = - 2, for each concatenate of surrogates (Row 1); the number of avoided words of the corresponding CNE dataset (Row 2); and their ratio (Row 3)

The first five CNEs collections have been composed through multiple sequence alignment of the same set of genomes and they differ only in the thresholds of sequence similarity applied between the considered genomes: from 75 to 80 (the least conserved CNEs, which thus are expected to serve less demanding functional roles) to 95–100 which represent the extremely conserved non-coding elements (UCNEs or CNEs 95–100) [15]. The remaining two collections have been composed under different constraints and have been derived after alignment of genomes belonging to the *Mammalian* and *Amniotic* groups. In Tables 1 and 2, the last line shows the ratios formed by the numbers of avoided words of each concatenate of surrogates divided by the numbers of avoided words of the corresponding CNE dataset.

Two immediate results stem from inspection of Tables 1 and 2:

- In all cases, the number of avoided words from the non-functional (surrogate) concatenate of sequences far exceeds the corresponding number derived from the corresponding CNE dataset.
- In the case of datasets with increasing degree of similarity between aligned genomes (from 75–80 to 95–100) the ratios of the numbers of avoided words show a clear increasing trend.

Both these findings can be understood on the basis of the difference in functionality, and thus tolerance to mutations, between CNE and surrogate datasets. One particularly frequent source of mutations is the slippage error during DNA replication; see e.g. reference [26]. Within a genomic sequence, this phenomenon causes the generation and increase in length, during evolutionary time, of polypyrimidine and polypurine nucleotide tracts. The expansion of those tracts is impeded at a considerable degree in the case of sequences which serve a functional role (as CNEs do) due to several constraints. On the other hand, in non-functional regions (as our surrogates mostly are) this procedure ceases to be tolerated only when it reaches to the formation of a polypyrimidine/polypurine tract with length affecting the proper folding or other structural features of the chromatin. Then, selection eliminates it, while its longer proper factors are tolerated in sufficient numbers within the sequence, thus resulting to an avoided word. In support of this explanation is the observation that all lists of avoided words found by our algorithm in concatenates of surrogates exhibit a considerable enrichment in oligopurines and oligopyrimidines. Taking at random some examples, for *k* = 10, we notice: AAAAAAAAAT, AAAAAACCAC, ACAAAAAAAA, CTCCTCTTTT, etc.

Our second observation, i.e. the positive correlation between (1) the paucity of avoided decamers in CNEs collections and (2) the similarity thresholds used for their identification comes in accordance with the above argument. CNEs extracted under a stricter requirement of sequence similarity between evolutionary distant species are CNEs whose functionality is less tolerant to alterations due to random mutations in general. Hence, they also tolerate less the propagation within their sequence of parasite polypyrimidine/polypurine tracts too.

We presented an 𝒪(*n*)-time and 𝒪(*n*)-space algorithm to compute all *ρ*-avoided words of length *k* in a sequence of length *n* over a fixed-sized alphabet. For integer alphabets, our algorithm runs in time 𝒪(*σ**n*) and is optimal for a sufficiently large alphabet of size *σ*. We also presented a time-optimal 𝒪(*σ**n*)-time algorithm to compute all *ρ*-avoided words (of any length) in a sequence of length *n* over an integer alphabet. Moreover, we provided a tight asymptotic upper bound for the number of *ρ*-avoided words over an integer alphabet and the expected length of the longest one.

In the process, we showed that the known asymptotic upper bound on the number of minimal absent words of a sequence is tight for integer alphabets. We also showed that the same asymptotic bound is tight for the number of minimal absent words of a fixed length if the alphabet is sufficiently large.

Finally, we made available an implementation of our algorithm. Experimental results, using both real and synthetic data, show its efficiency and applicability in biological sequence analysis.

YA and SPP conceived the study. PC, JG, MM, CSI, and SPP devised the algorithms. PC showed the tight asymptotic bounds. JG and SPP implemented the algorithms. YA, JG, SPP, and DP conceived and conducted the experiments. All authors contributed equally in writing up the manuscript. All authors read and approved the final manuscript.

Open access for this article was funded by King's College London.

The authors declare that they have no competing interests.

This research was partially supported by the Leverhulme Trust. PC is supported by the Graduate Teaching Scholarship scheme of the Department of Informatics at King's College London. DP is supported by the UK Medical Research Council (MRC) postdoctoral scheme.

Yannis Almirantis, Email: rg.sotirkomed.oib@rimlay.

Panagiotis Charalampopoulos, Email: ku.ca.lck@soluopopmalarahc.sitoiganap.

Jia Gao, Email: ku.ca.lck@oag.aij.

Costas S. Iliopoulos, Email: ku.ca.lck@soluopoili.satsoc.

Manal Mohamed, Email: ku.ca.lck@demahom.lanam.

Solon P. Pissis, Email: ku.ca.lck@sissip.nolos.

Dimitris Polychronopoulos, Email: ku.ca.crm.csc@soluoponorhcylop.d.

1. Searls DB. The linguistics of DNA. Am Sci. 1992;80(6):579–591.

2. Mantegna RN, Buldyrev SV, Goldberger AL, Havlin S, Peng C-K, Simons M, Stanley HE. Linguistic features of noncoding DNA sequences. Phys Rev Lett. 1994;73(23):3169. doi: 10.1103/PhysRevLett.73.3169. [PubMed] [Cross Ref]

3. Acquisti C, Poste G, Curtiss D, Kumar S. Nullomers: really a matter of natural selection? PLoS ONE. 2007;2(10):1022. doi: 10.1371/journal.pone.0001022. [PMC free article] [PubMed] [Cross Ref]

4. Barton C, Heliou A, Mouchard L, Pissis SP. Linear-time computation of minimal absent words using suffix array. BMC Bioinform. 2014;15(1):1. doi: 10.1186/s12859-014-0388-9. [PMC free article] [PubMed] [Cross Ref]

5. Barton C, Heliou A, Mouchard L, Pissis SP. Parallelising the computation of minimal absent words. In: Wyrzykowski R, Deelman E, Dongarra J, Karczewski K, Kitowski J, Wiatr K, editors. Parallel processing and applied mathematics—11th international conference, PPAM 2015, Krakow, Poland, September 6–9, 2015. Revised selected papers, Part II. lecture notes in computer science. vol. 9574. Berlin: Springer; 2015. p. 243–53. doi:10.1007/978-3-319-32152-3%5f23.

6. Crochemore M, Fici G, Mercas R, Pissis SP. Linear-time sequence comparison using minimal absent words and applications. In: Kranakis E, Navarro G, Chávez E, editors. LATIN 2016: theoretical informatics: 12th Latin American symposium, Ensenada, April 11–15, 2016, Proceedings. Lecture notes in computer science. Berlin: Springer; 2016. p. 334–46. doi:10.1007/978-3-662-49529-2%5f25.

7. Belazzougui D, Cunial F. Space-efficient detection of unusual words. In: International symposium on string processing and information retrieval. Berlin: Springer; 2015. p. 222–33. doi:10.1007/978-3-319-23826-5%5f22.

8. Rusinov I, Ershova A, Karyagina A, Spirin S, Alexeevski A. Lifespan of restriction-modification systems critically affects avoidance of their recognition sites in host genomes. BMC Genom. 2015;16(1):1. doi: 10.1186/s12864-015-2288-4. [PMC free article] [PubMed] [Cross Ref]

9. Brendel V, Beckmann JS, Trifonov EN. Linguistics of nucleotide sequences: morphology and comparison of vocabularies. J Biomol Struct Dyn. 1986;4(1):11–21. doi: 10.1080/07391102.1986.10507643. [PubMed] [Cross Ref]

10. Apostolico A, Bock ME, Lonardi S, Xu X. Efficient detection of unusual words. J Comput Biol. 2000;7(1–2):71–94. doi: 10.1089/10665270050081397. [PubMed] [Cross Ref]

11. Apostolico A, Bock ME, Lonardi S. Monotony of surprise and large-scale quest for unusual words. J Comput Biol. 2003;10(3–4):283–311. doi: 10.1089/10665270360688020. [PubMed] [Cross Ref]

12. Apostolico A, Gong F-C, Lonardi S. Verbumculus and the discovery of unusual words. J Comput Sci Technol. 2004;19(1):22–41. doi: 10.1007/BF02944783. [Cross Ref]

13. Harmston N, Barešić A, Lenhard B. The mystery of extreme non-coding conservation. Philos Trans R Soc B. 2013;368(1632):20130021. doi: 10.1098/rstb.2013.0021. [PMC free article] [PubMed] [Cross Ref]

14. Polychronopoulos D, Sellis D, Almirantis Y. Conserved noncoding elements follow power-law-like distributions in several genomes as a result of genome dynamics. PloS ONE. 2014;9(5):95437. doi: 10.1371/journal.pone.0095437. [PMC free article] [PubMed] [Cross Ref]

15. Polychronopoulos D, Weitschek E, Dimitrieva S, Bucher P, Felici G, Almirantis Y. Classification of selectively constrained DNA elements using feature vectors and rule-based classifiers. Genomics. 2014;104(2):79–86. doi: 10.1016/j.ygeno.2014.07.004. [PubMed] [Cross Ref]

16. Polychronopoulos D, Krithara A, Nikolaou C, Paliouras G, Almirantis Y, Giannakopoulos G. In: Dediu AH, Martín-Vide C, Truthe B, editors. Analysis and classification of constrained DNA elements with *n*$n$-gram graphs and genomic signatures. Berlin: Springer; 2014. p. 220–34. doi:10.1007/978-3-319-07953-0%5f18

17. Almirantis Y, Charalampopoulos P, Gao J, Iliopoulos CS, Mohamed M, Pissis SP, Polychronopoulos D. Optimal computation of avoided words. In: Algorithms in bioinformatics: 16th international workshop (WABI 2016). Berlin: Springer International Publishing. p. 1–13. doi:10.1007/978-3-319-43681-4%5f1.

18. Crochemore M, Hancart C, Lecroq T. Algorithms on strings. Cambridge: Cambridge University Press; 2007.

19. Charalampopoulos P, Crochemore M, Fici G, Mercas R, Pissis SP. Alignment-free sequence comparison using absent words (Under Review)

20. Mignosi F, Restivo A, Sciortino M. Words and forbidden factors. Theor Comput Sci. 2002;273(1):99–117. doi: 10.1016/S0304-3975(00)00436-9. [Cross Ref]

21. Gawrychowski P, Lewenstein M, Nicholson PK. Weighted ancestors in suffix trees. Eur Symp Algorithms. 2014;1:455–466.

22. Farach M. Optimal suffix tree construction with large alphabets. In: Proceedings, 38th annual symposium on foundations of computer science. New York City: IEEE; 1997. p. 137–43. doi:10.1109/SFCS.1997.646102.

23. Fujishige Y, Tsujimaru Y, Inenaga S, Bannai H, Takeda M. Computing DAWGs and minimal absent words in linear time for integer alphabets. In: Faliszewski P, Muscholl A, Niedermeier R, editors. 41st International symposium on mathematical foundations of computer science (MFCS 2016). Leibniz international proceedings in informatics (LIPIcs), vol. 58: Schloss Dagstuhl–Leibniz-Zentrum fuer Informatik; 2016. p. 1–14. doi:10.4230/LIPIcs.MFCS.2016.38.

24. Manber U, Myers G. Suffix arrays: a new method for on-line string searches. Siam J Comput. 1993;22(5):935–948. doi: 10.1137/0222058. [Cross Ref]

25. Gog S, Beller T, Moffat A, Petri M. From theory to practice: plug and play with succinct data structures. In: International Symposium on experimental algorithms. Berlin: Springer; 2014. p. 326–37. doi:10.1007/978-3-319-07959-2%5f28.

Articles from Algorithms for Molecular Biology : AMB are provided here courtesy of **BioMed Central**

PubMed Central Canada is a service of the Canadian Institutes of Health Research (CIHR) working in partnership with the National Research Council's national science library in cooperation with the National Center for Biotechnology Information at the U.S. National Library of Medicine(NCBI/NLM). It includes content provided to the PubMed Central International archive by participating publishers. |