Finding all substrings within a string and storing the results? - c++

Question

class ORF_Finder {
public:
void findORFs(string & strand, int sizeOfStrand);
vector<string> orf1Strands;
vector<string> orf2Strands;
vector<string> orf3Strands;
private:
string newStrand;
string newSub;
};
void ORF_Finder::findORFs(string & strand, int sizeOfStrand) {
int pos, pos1, index = 0;
for (int i = 0; i < strand.size(); i++) {
pos = strand.find("ATG");
pos1 = strand.find("TAA");
newSub = strand.substr(pos, pos1);
newStrand.insert(index, newSub);
strand.erase(pos, pos1);
index = index + 3;
if ((pos1 % 3 == 0) && (pos1 >= pos + 21)) {
orf1Strands.push_back(newStrand);
}
else if ((pos1 % 3 == 1) && (pos1 >= pos + 21)) {
orf2Strands.push_back(newStrand);
}
else if ((pos1 % 3 == 2) && (pos1 >= pos + 21)) {
orf3Strands.push_back(newStrand);
}
}
}
^ assume all strings are declared and I'm "using namespace std".
My goal is to ask the user for an imported DNA strand (ex: "TCAATGCGCGCTACCATGCGGAGCTCTGGGCCCAAATTTCATCCATAACTGGGGCCCTTTTAAGGGCCCGGGAAATTT") and find all instances where a substring starts with "ATG" and ends with "TAA", "TAG", or "TGA" (I omitted "TAG" and "TGA" for simplicity sake).
The substring will be as so: "ATG ... ... ... ... TAA" and then it will be stored into a vector to be utilized later. However, I would like to find multiple instances of each reading frame (ORF1 should start at the "T" of the imported strand, ORF2 should start at the "C" of the imported strand, and ORF3 should start at the "A" of the imported strand) and should work in triplets, hence the inclusion of mod 3 in the if statements. The purpose of "pos1 >= pos + 21" is so that every substring is at least seven codons long.
The above code is what I've done thus far but obviously, it's incorrect. I'm trying to tell pos to find "ATG" and pos1 to find "TAA". newSub is the substring that will be generated from "ATG" to "TAA" and newStrand will be generated to contain the substring. I would then erase the portion of the strand (to avoid repetition) and increment index.
Sorry for the long description but I've been stressing over this and I've tried everything in my willpower to solve this.

Answer 1

Knutt-Morris Pratt is the fastest solution. Aho-corasick algorithm its a generalized version from kmp algorithm. Basically its a trie with failure links computed from a breadth-first search. You can try my PHP implementation phpahocorasick # codeplex.com. Then you need to add a wildcard to find all substrings.

Answer 2

Here is a possible implementation.
Characteristics :
can process large strings since it only keep one single copy of the initial string
accept one arbitrary initial sequence (here "ATG")
accept many end sequences (here "TAA", "TAG", or "TGA")
accept only substring of at least 7 codons
substrings are only described by there index in initial string and length (to save memory)
per your requirement keep results in 3 different vectors according to the modulo 3 of their index
Code :
#include <iostream>
#include <string>
#include <stdexcept>
#include <vector>
class Strand {
const std::string* data;
size_t begin;
size_t len;
public:
Strand(const std::string& data, size_t begin, size_t end): begin(begin),
len(end - begin), data(&data) {
if (end <= begin) {
throw std::invalid_argument("end < begin");
}
}
std::string getString() const {
const char *beg = data->c_str();
beg += begin;
return std::string(beg, len);
}
};
class Parser {
const std::string& data;
const std::string& first;
const std::vector<std::string>& end;
size_t dataLen;
std::vector<Strand> orf1Strands;
std::vector<Strand> orf2Strands;
std::vector<Strand> orf3Strands;
public:
enum TypStrand {
one = 0, two, three
};
Parser(const std::string& data, const std::string& first,
const std::vector<std::string>& end): data(data),
first(first), end(end) {
dataLen = data.length();
}
void parse();
const std::vector<Strand>& getVector(int typ) const {
switch(typ) {
case 0 : return orf1Strands;
case 1 : return orf2Strands;
default : return orf3Strands;
}
}
const std::vector<Strand>& getVector(TypStrand typ) const {
return getVector((int) typ);
}
};
void Parser::parse() {
size_t pos=0;
size_t endSize = end.size();
std::string firstChars = "";
for(size_t i=0; i<endSize; i++) {
firstChars += end[i].at(0);
}
for(;;) {
pos = data.find(first, pos);
if (pos == std::string::npos) break;
size_t strandEnd = pos + 18;
for(;;) {
if (strandEnd + 3 >= dataLen) break;
strandEnd = data.find_first_of(firstChars, strandEnd);
if ((strandEnd - pos) % 3 != 0) {
strandEnd += 1;
continue;
}
if (strandEnd + 3 >= dataLen) break;
for (size_t i=0; i<endSize; i++) {
if (data.compare(strandEnd, end[i].length(), end[i]) == 0) {
std::cout << "Found sequence ended with " << end[i] << std::endl;
switch(pos %3) {
case 0 :
orf1Strands.push_back(Strand(data, pos,
strandEnd + 3));
break;
case 1 :
orf2Strands.push_back(Strand(data, pos,
strandEnd + 3));
break;
case 2 :
orf3Strands.push_back(Strand(data, pos,
strandEnd + 3));
break;
}
pos = strandEnd + end[i].length() - 1;
break;
}
}
if (pos > strandEnd) break;
strandEnd += 3;
}
if (strandEnd + 3 >= dataLen) break;
pos = pos + 1;
}
}
using namespace std;
int main() {
std::string first = "ATG";
vector<string> end;
std::string ends[] = { "TAA", "TAG", "TGA"};
for (int i=0; i< sizeof(ends)/sizeof(std::string); i++) {
end.push_back(ends[i]);
}
string data = "TCAATGCGCGCTACCATGCGGAGCTCTGGGCCCAAATTTC"
"ATCCATAACTGGGGCCCTTTTAAGGGCCCGGGAAATTT";
Parser parser(data, first, end);
parser.parse();
for (int i=0; i<3; i++) {
int typ = i;
const vector<Strand>& vect = parser.getVector(typ);
cout << "Order " << i << " : " << vect.size() << endl;
if (vect.size() > 0) {
for(size_t j=0; j<vect.size(); j++) {
cout << vect[i].getString() << endl;
}
}
}
return 0;
}
Todo :
add comments
fix the management of enum TypStrand : once the program is written, I think that it would be better to have an array of three vectors than three separate ones.
minimal number of codons should be configurable
test more intensively for corner cases
3 is a magic number and really should be expressed as a constant

Answer 3

Simple:
Scan the whole string for occurrances of the start or end sequences.
If you find an end sequence, extract the part from the previous start sequence.
You will have a few cornercases like e.g. the handling of multiple signal sequences that could be paired differently, but that's all just normal programming.
The problem with your approach is that you don't scan the string from start to end, but you repeatedly search for the start and end from the beginning. You need to continue after the last position instead. Check out the various find.. functions of the string class to get an idea how to do that.