Bash 如何计算字符串中n个长度的字符组合出现的次数

我使用下面的一行代码列出了

ATCG

组合的出现次数，形成长度为6的字符串。除了不打印0个匹配项外，它工作正常。是否有办法将正则表达式或其他部分更改为打印“0 ATTTAG”之类的内容

#/bin/bash
用于e_coli.fa中的文件
做
base=$（basename$file.fa）
cat$file | perl-nE’say for/（？因为
uniq-c
计算一行出现的次数，所以它不可能返回0。请求的更改需要完全重写

perl -e'
   while (<>) {
      ++$counts{$_} for /(?=([ATCG]{6}))/g;
   }

   for my $seq (glob("{A,C,G,T}" x 6)) {
      printf("%7d %s\n", $counts{$seq}, $seq);
   }
' "$file" >"${base}_hexhits_6mer.txt"

perl-e'
而（）{
++/（？=（[ATCG]{6}））/g的$counts{$}；
}
对于我的$seq（glob（“{A，C，G，T}”x 6））{
printf（“%7d%s\n”，$counts{$seq}，$seq）；
}
“$file”>“${base}\u hexhits\u 6mer.txt”
由于
uniq-c
统计一行出现的次数，因此它不可能返回0。请求的更改需要完全重写

perl -e'
   while (<>) {
      ++$counts{$_} for /(?=([ATCG]{6}))/g;
   }

   for my $seq (glob("{A,C,G,T}" x 6)) {
      printf("%7d %s\n", $counts{$seq}, $seq);
   }
' "$file" >"${base}_hexhits_6mer.txt"

perl-e'
而（）{
++/（？=（[ATCG]{6}））/g的$counts{$}；
}
对于我的$seq（glob（“{A，C，G，T}”x 6））{
printf（“%7d%s\n”，$counts{$seq}，$seq）；
}
“$file”>“${base}\u hexhits\u 6mer.txt”
你要求做的事情要复杂得多。要知道你没有看到的内容，你首先需要知道所有可能的字符组合，然后你可以根据这些组合进行筛选

在这里，我使用Perl中使用的滑动窗口方法在一个哈希中查找字符串
中的所有“seen”
ATCG
字符作为
、
Ts
、
Cs
和
Gs
（从
\uuuu数据
读取）。然后对这些字符进行排序，以便首先显示最常见的6-mer，然后打印出来

use strict;
use warnings;

my @bases = qw/ A G C T /;

my %data; 

for my $a1(@bases){
    for my $a2(@bases){
        for my $a3(@bases){ 
            for my $a4(@bases){
                for my $a5(@bases){
                    for my $a6(@bases){
                        $data{"$a1$a2$a3$a4$a5$a6"} = 0;
                    }
                }
            }
        }
    }
}

my $nucs = <DATA>; 

my $len = length($nucs);

for (my $i = 0; $i <= $len - 6; $i++) {
     my $kmer = substr($nucs, $i, 6);
     next if $kmer =~ tr/ACGT//c;
     $data{$kmer}++; # populate hash with "seen" 6-mers
}

# print out sorted hash
foreach my $seq (sort { $data{$b} <=> $data{$a} } keys %data ){
    print "$seq,$data{$seq}\n";
}

__DATA__
ATGCCCGTCGTAGTCATGCATGCATCGATCGATGCATGCTACGTGTTGT

使用严格；
使用警告；
my@base=qw/A G C T/；
我的%数据；
对于我的$a1（@bases）{
对于我的$a2（@bases）{
我的$a3（@bases）{
对于我的$a4（@bases）{
对于我的$a5（@bases）{
对于我的$a6（@bases）{
$data{“$a1$a2$a3$a4$a5$a6”}=0；
}
}
}
}
}
}
我的$nucs=；
my$len=长度（$nucs）；
因为（我的$i=0；$i你要求做的事情要复杂得多。要知道你没有看到的内容，你首先需要知道所有可能的字符组合，然后你可以根据这些组合进行筛选

在这里，我使用Perl中使用的滑动窗口方法在一个哈希中查找字符串
中的所有“seen”
ATCG
字符作为
、
Ts
、
Cs
和
Gs
（从
\uuuu数据
读取）。然后对这些字符进行排序，以便首先显示最常见的6-mer，然后打印出来

use strict;
use warnings;

my @bases = qw/ A G C T /;

my %data; 

for my $a1(@bases){
    for my $a2(@bases){
        for my $a3(@bases){ 
            for my $a4(@bases){
                for my $a5(@bases){
                    for my $a6(@bases){
                        $data{"$a1$a2$a3$a4$a5$a6"} = 0;
                    }
                }
            }
        }
    }
}

my $nucs = <DATA>; 

my $len = length($nucs);

for (my $i = 0; $i <= $len - 6; $i++) {
     my $kmer = substr($nucs, $i, 6);
     next if $kmer =~ tr/ACGT//c;
     $data{$kmer}++; # populate hash with "seen" 6-mers
}

# print out sorted hash
foreach my $seq (sort { $data{$b} <=> $data{$a} } keys %data ){
    print "$seq,$data{$seq}\n";
}

__DATA__
ATGCCCGTCGTAGTCATGCATGCATCGATCGATGCATGCTACGTGTTGT

使用严格；
使用警告；
my@base=qw/A G C T/；
我的%数据；
对于我的$a1（@bases）{
对于我的$a2（@bases）{
我的$a3（@bases）{
对于我的$a4（@bases）{
对于我的$a5（@bases）{
对于我的$a6（@bases）{
$data{“$a1$a2$a3$a4$a5$a6”}=0；
}
}
}
}
}
}
我的$nucs=；
my$len=长度（$nucs）；
对于（my$i=0；$i），最简单的方法是为每个模式构建一个出现计数的散列，然后打印所有可能模式的计数

该程序使用
glob
技巧生成由a、T、C和G组成的所有可能的六个字符串的列表

use strict;
use warnings 'all';

my @files = qw/ e_coli.fa /;

my %counts;

for my $file ( @files ) {

    open my $fh, '<', $file or die qq{Unable to open "$file" for input: $!};

    while ( <$fh> ) {
        ++$counts{$1} while /(?= ( [ATCG]{6} ) ) /gx;
    }
}

for my $pattern ( glob '{A,T,C,G}' x 6 ) {
    printf "%4d %s\n", $counts{$pattern} // 0, $pattern;
}

使用严格；
使用“全部”警告；
my@files=qw/e_coli.fa/；
我的百分比计算；
对于我的$file（@files）{
打开我的$fh，“最简单的方法是为每个模式构建一个出现计数的散列，然后打印所有可能模式的计数

该程序使用
glob
技巧生成由a、T、C和G组成的所有可能的六个字符串的列表

use strict;
use warnings 'all';

my @files = qw/ e_coli.fa /;

my %counts;

for my $file ( @files ) {

    open my $fh, '<', $file or die qq{Unable to open "$file" for input: $!};

    while ( <$fh> ) {
        ++$counts{$1} while /(?= ( [ATCG]{6} ) ) /gx;
    }
}

for my $pattern ( glob '{A,T,C,G}' x 6 ) {
    printf "%4d %s\n", $counts{$pattern} // 0, $pattern;
}

使用严格；
使用“全部”警告；
my@files=qw/e_coli.fa/；
我的百分比计算；
对于我的$file（@files）{
打开我的$fh，“如果您有大量数据，并且需要更快的速度，这里有一个C解决方案：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void reader(FILE* in, unsigned long hist[4096]) {
  for (unsigned long key=0, count=0;;) {
    switch(getc(in)) {
      case EOF:                      return;
      case 'A': key <<= 2;           break;
      case 'C': key <<= 2; key += 1; break;
      case 'G': key <<= 2; key += 2; break;
      case 'T': key <<= 2; key += 3; break;
      default:  count=0;             continue;
    }
    if (count == 5) ++hist[key & 0xFFF];
    else ++count;
  }
}

int putkey(FILE* out, unsigned long key) {
  char s[6];
  for (int j=6; j--; key >>= 2) s[j] = "ACGT"[key&3];
  return fprintf(out, "%.6s", s); 
}

void writer(FILE* out, unsigned long hist[4096]) {
  for (unsigned long key = 0; key < 4096; ++key) {
    fprintf(stdout, "%7lu ", hist[key]);
    putkey(out, key);
    putchar('\n');
  }
}

int main(int argc, char** argv) {
  FILE* in = stdin;
  if (argc > 1) in = fopen(argv[1], "r");
  if (!in) { perror(argv[1]); exit(1); }
  unsigned long hist[4096] = {0};
  reader(in, hist);
  writer(stdout, hist);
  return 0;
}

#包括
#包括
#包括
无效读取器（文件*in，未签名的长历史[4096]）{
for（无符号长键=0，计数=0；；）{
开关（getc（in））{
案例EOF：返回；
案例“A”：键如果您有大量数据，并且需要更快的速度，这里有一个C解决方案：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void reader(FILE* in, unsigned long hist[4096]) {
  for (unsigned long key=0, count=0;;) {
    switch(getc(in)) {
      case EOF:                      return;
      case 'A': key <<= 2;           break;
      case 'C': key <<= 2; key += 1; break;
      case 'G': key <<= 2; key += 2; break;
      case 'T': key <<= 2; key += 3; break;
      default:  count=0;             continue;
    }
    if (count == 5) ++hist[key & 0xFFF];
    else ++count;
  }
}

int putkey(FILE* out, unsigned long key) {
  char s[6];
  for (int j=6; j--; key >>= 2) s[j] = "ACGT"[key&3];
  return fprintf(out, "%.6s", s); 
}

void writer(FILE* out, unsigned long hist[4096]) {
  for (unsigned long key = 0; key < 4096; ++key) {
    fprintf(stdout, "%7lu ", hist[key]);
    putkey(out, key);
    putchar('\n');
  }
}

int main(int argc, char** argv) {
  FILE* in = stdin;
  if (argc > 1) in = fopen(argv[1], "r");
  if (!in) { perror(argv[1]); exit(1); }
  unsigned long hist[4096] = {0};
  reader(in, hist);
  writer(stdout, hist);
  return 0;
}

#包括
#包括
#包括
无效读取器（文件*in，未签名的长历史[4096]）{
for（无符号长键=0，计数=0；；）{
开关（getc（in））{
案例EOF：返回；
案例“A”：此键可能有帮助：正则表达式无法匹配不存在的内容。有超过4000个不同的四个字符的六字符组合。是否确实需要4000行输出，其中大多数为零？这可能有帮助：正则表达式无法匹配不存在的内容。有超过4000个不同的六字符组合四个字符的字符组合。您真的想要4000行输出，其中大多数是零吗？这比borodin和ikegami的解决方案快，至少在我的机器上是这样，但它匹配的子字符串包含字母表之外的字母（特别是换行符）@rici-很有趣。应该已经解决了匹配非ATCG字符
的问题，除非'A | G | C | T'
是不可操作的，因为
'A | G | C | T'
是一个简单的字符串，总是正确的。对不起，实现了什么？这比borodin和ikegami的解决方案要快，至少在我的机器上是这样，但它匹配的子字符串包括字母表之外的字母（特别是换行符）。@rici-很有趣。应该已经解决了匹配非ATCG字符的问题
下一步，除非'A | G | C | T'
是不可操作的，因为
'A | G | C | T'
是一个简单的字符串，总是正确的。对不起，实现了什么？{A，C，G，T}'x 6它真的很棒。