C++ C++；-输出给定长度的所有可能的DNA Kmer

如果我想对了，问题实际上是将十进制整数转换为基数4，然后替换相应的基数。我想我可以使用itoa来实现这一点，但itoa不是C标准，我的编译器也不支持它。我欢迎任何聪明的想法。以下是我的示例代码：

#include <iostream>
#include <string>
#include <math.h>

#define K 3

using namespace std;

int main() {

  int num_kmers = pow(4,K);
  string* kmers = NULL;

  /* Allocate memory for kmers array */
  kmers = new string[num_kmers];

  /* Populate kmers array */
  for (int i=0; i< pow(4,K); i++) {

    // POPULATE THE kmers ARRAY HERE                                                                                                                                                         

  }

  /* Display all possible kmers */
  for (int i=0; i< pow(4,K); i++)
    cout << kmers[i] << "\n";

  delete [] kmers;
}

#包括
#包括
#包括
#定义k3
使用名称空间std；
int main（）{
int num_kmers=pow（4，K）；
字符串*kmers=NULL；
/*为kmers数组分配内存*/
kmers=新字符串[num_kmers]；
/*填充kmers数组*/
对于（inti=0；icout一旦用户输入的文本被接受，您就不需要将十进制转换为任何形式

创建字符串数组也可能是一个错误，它随
K
呈指数增长。只需打印输出即可

char bases[] = { 'A', 'C', 'T', 'G' };
std::vector< int > sequence( K ); // allow dynamic K
std::vector< char > output( K * ( 2 << K * 2 ) ); // flat sequence of sequences
std::vector< char >::iterator out_it = output.begin();

int i;
do {
    // print current sequence
    for ( i = 0; i < K; ++ i ) std::cout << bases[ sequence[ i ] ];
    std::cout << '\n';

    // store current sequence
    for ( i = 0; i < K; ++ i ) * out_it ++ = bases[ sequence[ i ] ];

    // advance to next sequence
    for ( i = K; i > 0; -- i ) {
        // increment the last base that we can
        if ( sequence[ i - 1 ] != sizeof bases - 1 ) {
            ++ sequence[ i - 1 ];
            break;
        }
        // reset bases that can't be incremented
        sequence[ i - 1 ] = 0;
    }
} while ( i > 0 ); // if i <= 0, failed to increment anything, we're done.

charbase[]={'A'，'C'，'T'，'G'}；
std:：vector序列（K）；//允许动态K
std:：vectoroutput（K*（2:：iterator out_it=output.begin（）；
int i；
做{
//打印当前序列
对于（i=0；i
干杯。
在我看来，这非常适合自定义迭代器。这样，您的主程序就可以很简单：

std::vector<std::string> v;
v.reserve(kmerIterator<4>::end() - kmerIterator<4>::begin());
std::copy(kmerIterator<4>::begin(), kmerIterator<4>::end(),
    std::back_inserter(v));

std:：vector v；
v、 保留（kmerIterator:：end（）-kmerIterator:：begin（））；
std:：copy（kmerierator:：begin（），kmerierator:：end（），
标准：背部插入器（v）；

但是，由于我们将kmer概念实现为一个迭代器，因此我们也可以使用所有其他通用算法。由于我们将kmer迭代器实现为一个随机访问迭代器，因此找到第i个kmer非常简单：

kmerIterator<4>::begin()[i]

kmerierator:：begin（）[i]

以下是我的完整程序：

#include <iostream>
#include <iterator>
#include <algorithm>
#include <vector>

template<unsigned int n>
class kmerIterator :
    public std::iterator<std::random_access_iterator_tag,
        std::string,
        unsigned int>
{
private:
    typedef kmerIterator k; // 'cause I'm lazy
    difference_type it;
    kmerIterator(difference_type i) : it(i) {}
public:
    kmerIterator() : it() {}
    static k begin() {
        return 0;
    }
    static k end() {
        return difference_type(1) << n*2;
    }
    k& operator++() { ++it; return *this; }
    k operator++(int) { return it++; }
    k& operator--() { --it; return *this; }
    k operator--(int) { return it--; }
    k operator+(difference_type delta) { return it + delta; }
    k operator-(difference_type delta) { return it - delta; }
    difference_type operator-(const k& rhs) { return it - rhs.it; }
    bool operator<(const k& rhs) const { return it < rhs.it; }
    bool operator>(const k& rhs) const { return it > rhs.it; }
    bool operator<=(const k& rhs) const { return it <= rhs.it; }
    bool operator>=(const k& rhs) const { return it >= rhs.it; }
    k operator+=(difference_type delta) { return it+=delta; }
    k operator-=(difference_type delta) { return it-=delta; }
    std::string operator[](difference_type delta) const { return *k(it+delta); }
    std::string operator*() const {
        std::string rz;
        int i = 2*n;
        do {
            i -= 2;
            rz += "ACGT"[(it>>i)&3];
        } while(i);
        return rz;
    }
};

int main() {
    std::copy(kmerIterator<2>::begin(),
        kmerIterator<2>::end(),
        std::ostream_iterator<std::string>(std::cout, "\n"));

    std::vector<std::string> v;
    v.reserve(kmerIterator<4>::end() - kmerIterator<4>::begin());
    std::copy(kmerIterator<4>::begin(),
        kmerIterator<4>::end(),
        std::back_inserter(v));
    std::cout << v[42] << "\n";
    std::cout << kmerIterator<4>::begin()[56] << "\n";
}

#包括
#包括
#包括
#包括
模板
kmerIterator类：
公共标准：迭代器
{
私人：
typedef kmeriator k；//因为我很懒
不同类型的it；
kmerIterator（difference_type i）：它（i）{
公众：
kmerIterator（）：它（）{}
静态k begin（）{
返回0；
}
静态k端（）{
返回差异_type（1）rhs.it；}
bool操作符=rhs.it；}
k运算符+=（差分类型delta）{返回它+=delta；}
k运算符-=（差分类型delta）{返回它-=delta；}
字符串运算符[]（差分类型delta）常量{return*k（it+delta）；}
std:：字符串运算符*（）常量{
std：：字符串rz；
int i=2*n；
做{
i-=2；
rz+=“ACGT”[（it>>i）和3]；
}而(i),；
返回rz；
}
};
int main（）{
std:：copy（kmerierator:：begin（），
kmerIterator:：end（），
std:：ostream_迭代器（std:：cout，“\n”）；
std：：向量v；
v、 保留（kmerIterator:：end（）-kmerIterator:：begin（））；
std:：copy（kmerierator:：begin（），
kmerIterator:：end（），
标准：背部插入器（v）；
std：：cout哇，这不应该这么难

std::string kmers(int i, int K) {
  static const char* DNA = "ACGT";
  if (K==0) return std::string();
  return DNA[i%4] + kmers(i / 4, K-1);
}

const int K = 2;
int main () {
  for (int i = 0; i != 1<<(2*K); ++i)
    std::cout << "kmers[" << i << "] = " << kmers(i,K) << std::endl;
}

std:：字符串kmer（inti，intk）{
静态常量char*DNA=“ACGT”；
if（K==0）返回std:：string（）；
返回DNA[i%4]+kmer（i/4，K-1）；
}
常数int K=2；
int main（）{
对于（int i=0；i！=1
#包括
#包括
#包括
#包括
类kmer
{
公众：
kmer（）；
kmer（std:：string&str，int&k）：k_k，str_k（str）
{
对于（int i=0；我坚持住，我发现了一个令人讨厌的（明显的）等等。你应该真的，真的，真的使用一个
向量
。哦，我完全同意。但是我想写一些适合他目前存在的代码的东西。显然，如果他不小心，这会溢出。向量化我，船长。谢谢你的回答。不幸的是，这是一个更大的生物信息学应用程序的一部分n这确实需要我将结果存储在一个数组中。我很清楚大型K的危险性。@ned：你可以用它来构建一个数组，而不是打印输出。但是如果你尽可能避免使用此类数组，应用程序可能会更具可伸缩性。当涉及到大量信息时，它变得很重要将宝贵的内存用于有意义的数据，而不是“蓬松”
#include <iostream>
#include <iterator>
#include <algorithm>
#include <vector>

template<unsigned int n>
class kmerIterator :
    public std::iterator<std::random_access_iterator_tag,
        std::string,
        unsigned int>
{
private:
    typedef kmerIterator k; // 'cause I'm lazy
    difference_type it;
    kmerIterator(difference_type i) : it(i) {}
public:
    kmerIterator() : it() {}
    static k begin() {
        return 0;
    }
    static k end() {
        return difference_type(1) << n*2;
    }
    k& operator++() { ++it; return *this; }
    k operator++(int) { return it++; }
    k& operator--() { --it; return *this; }
    k operator--(int) { return it--; }
    k operator+(difference_type delta) { return it + delta; }
    k operator-(difference_type delta) { return it - delta; }
    difference_type operator-(const k& rhs) { return it - rhs.it; }
    bool operator<(const k& rhs) const { return it < rhs.it; }
    bool operator>(const k& rhs) const { return it > rhs.it; }
    bool operator<=(const k& rhs) const { return it <= rhs.it; }
    bool operator>=(const k& rhs) const { return it >= rhs.it; }
    k operator+=(difference_type delta) { return it+=delta; }
    k operator-=(difference_type delta) { return it-=delta; }
    std::string operator[](difference_type delta) const { return *k(it+delta); }
    std::string operator*() const {
        std::string rz;
        int i = 2*n;
        do {
            i -= 2;
            rz += "ACGT"[(it>>i)&3];
        } while(i);
        return rz;
    }
};

int main() {
    std::copy(kmerIterator<2>::begin(),
        kmerIterator<2>::end(),
        std::ostream_iterator<std::string>(std::cout, "\n"));

    std::vector<std::string> v;
    v.reserve(kmerIterator<4>::end() - kmerIterator<4>::begin());
    std::copy(kmerIterator<4>::begin(),
        kmerIterator<4>::end(),
        std::back_inserter(v));
    std::cout << v[42] << "\n";
    std::cout << kmerIterator<4>::begin()[56] << "\n";
}

std::string kmers(int i, int K) {
  static const char* DNA = "ACGT";
  if (K==0) return std::string();
  return DNA[i%4] + kmers(i / 4, K-1);
}

const int K = 2;
int main () {
  for (int i = 0; i != 1<<(2*K); ++i)
    std::cout << "kmers[" << i << "] = " << kmers(i,K) << std::endl;
}

#include <iostream>
#include <string>
#include <string_view>
#include <vector>

class kmer
{
public:
    kmer();
    kmer(std::string &str, int &k) : k_(k), str_(str)
    {
        for(int i = 0; i <= str_.size() - k_; ++i)
            value_.push_back(str_.substr(i, k_));
    }
    auto value() { return value_; }
    auto size() { return value_.size(); }
private:
    std::vector<std::string_view> value_;
    std::string_view str_;
    int k_;
};

int main()
{
    std::string seq{"AGCTAGCT"};
    kmer k4_mer(seq, 4);
    
    std::cout << "Total " << k4_mer.size() << " mers\n";
    for(auto &i : k4_mer.value())
        std::cout << i << "\n";

    return 0;
}