这是500万长度的随机序列，由A、T、C、G四个字母组成。
    这是对应附件得到的结果模式，4的8次幂个八模体及其各自的出现次数。
8模体由8个碱基构成，（碱基即A、T、C、G）每个碱基有4种选择（或A、或T、或C、或G），这样就有4的8次幂种8模体（即65536种）。
附件1中的随机序列包含500万个字符，如果以1为间隔的话，应有 4999993个 8模体，因为每[i,i+7]位置区域上的8个碱基长的字符串都是一个8模体，i从0开始，直到4999992结束，i是i++逐渐增加的，附件2的结果就是在以1为间隔下得到的。   4999993个8模体由65536种8模体组成，附件2中的结果就是在4999993个8模体中每种8模体出现了多少次。
                                  如果以2为间隔的话，应有 2499996个 8模体，因为每[i,i+7]位置区域上的8个碱基长的字符串都是一个8模体，i从0开始，直到4999992结束，i是i+=2逐渐增加的。
                                  如果以k为间隔的话，应有 500万除k个 8模体，因为每[i,i+7]位置区域上的8个碱基长的字符串都是一个8模体，i从0开始，i是i+=k逐渐增加的，直到i+7>4999999结束。
                                  现在我能计算以1为间隔的，但以k为间隔的程序实在弄不出来。我是学物理的学生，计算机这块有些棘手，麻烦各位了。
谢谢。
这是统计以1为间隔的程序。
#include <stdio.h>

#define N_A 9
#define N_B (1u<<(2*N_A))

int main()
{
    static unsigned long octamer_count[N_B] = { 0 };    //当跑八模体以上时，因为数据量已经很大，要价个static,八模体以下不用它

    ////// 1 //////
    {
        FILE* file = fopen( "E:\\酵母\\光学与信息学\\碱基随机.txt", "rb" );
        if( !file )
        {
            puts( "cannot open the input file.");
            return 1;
        }
        {
            unsigned long octamer;
            unsigned long octamer_n = 0;
            char c;
            for( ; fread(&c,1,1,file)==1; )
            {
                switch( c )
                {
                    case 'A':
                        octamer = (octamer*4+0)%N_B; ++octamer_n; break;
                    case 'T':
                        octamer = (octamer*4+1)%N_B; ++octamer_n; break;
                    case 'C':
                        octamer = (octamer*4+2)%N_B; ++octamer_n; break;
                    case 'G':
                        octamer = (octamer*4+3)%N_B; ++octamer_n; break;
                    case '\r':
                    case '\n':
                        continue;
                    default:
                        puts( "Fuck" );
                    case 'N':
                        octamer_n = 0;
                        continue;
                }
                if( octamer_n < N_A )
                    continue;
                octamer_n = N_A;

                ++octamer_count[octamer];
            }
        }
        fclose( file );
    }

    ////// 2 //////
    {
        FILE* fileout = fopen( "E:\\酵母\\光学与信息学\\碱基随机9模体.txt", "wt" );
        if( !fileout )
        {
            puts( "cannot open the output file.");
            return 2;
        }
        {
            unsigned int i, j;
            for( i=0; i<sizeof(octamer_count)/sizeof(octamer_count[0]); ++i )
            {
                if( octamer_count[i] == 0 )
                    continue;
                for( j=N_B/4; j!=0; j/=4 )
                    fprintf( fileout, "%c", "ATCG"[i/j%4] );
                fprintf( fileout, "\t%u\n", octamer_count[i] );
            }
        }
        fclose( fileout );
    }

    return 0;
}

试试 fseek

求指教！！！
谢谢！！！

看不懂你说的东东
能不能具体举例一下

比如 ：
    你说的是不是从一个字符串中扫描所有可能存在的子字符串（是定长还是不定长）
    比如：ABCDEFGH   如果以3为间隔、定长为2的话  如何取  AB DE GH  ???

GGATATGTGAATTATGGTTATCTTGGTAATAGCAGAGCCCGGAGTGCGCGTAACGTGACACTGGGCCGAAGATGTACCTCGTTATATACCTGAAAGCGTG
上面是一个序列样本，100个字母长（字母只有A、T、C、G），计算2模体（2模体由两个字母组成，每个字母有4种选择，所以共16个2模体，这16个2模体包括AA、AT、AC、AG、TA、TC、TT、TG、CA、CC、CT、CG、GC、GT、GA、GG）。当以1为间隔统时100字母长的序列中2模体出现了99次，我现在要统计在2模体出现的这99次中上述16种2模体分别各出现了多少次。
                      当以2为间隔统时100字母长的序列中2模体出现了50次，我现在要统计在2模体出现的这50次中上述16种2模体分别各出现了多少次。
                      当以3为间隔统时100字母长的序列中2模体出现了33次，我现在要统计在2模体出现的这33次中上述16种2模体分别各出现了多少次。
                      以此类推。
      当然还要依此统计3模体、4模体、5模体等与上述同样的出现情况。
麻烦您了！！！

你看一下代码和演示案例  是否是你要的结果

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

int main()
{
    char* m="GGATATGTGAATTATGGTTATCTTGGTAATAGCAGAGCCCGGAGTGCGCGTAACGTGACACTGGGCCGAAGATGTACCTCGTTATATACCTGAAAGCGTG";
    char* substr[16]={"AA","AT","AC","AG","TA","TT","TC","TG","CA","CT","CC","CG","GA","GT","GC","GG"};
    int subcount[16];
    char buffer[3]={'\0'};
    int sp=3;
    int count=0;
    int i;
    for(i=0;i<16;i++) subcount[i]=0;
    while(*m!='\0')
    {
        strncpy(buffer,m,2);
         for(i=0;i<16;i++)
         {
             if(strcmp(buffer,substr[i])==0)
             {
                 subcount[i]++;
                 count++;
                 printf("%4s",buffer);
                 if(count % 8==0) printf("\n");
             }
         }
         m+=sp;
    }
    printf("\n共有%d个子模体被扫描到.\n",count);
    for(i=0;i<16;i++)
    {
        if(subcount[i]>0)
        {
            printf("%s--->出现了%d次\n",substr[i],subcount[i]);
        }
    }
    return 0;
}
/*
   GG  TA  GT  AA  TA  GG  TA  CT
  GG  AA  AG  AG  GC  CG  AG  GC
  CG  AA  GT  AC  CT  GG  CG  AG
  TG  AC  TC  TT  TA  AC  TG  AA
  CG
共有33个子模体被扫描到.
AA--->出现了4次
AC--->出现了3次
AG--->出现了4次
TA--->出现了4次
TT--->出现了1次
TC--->出现了1次
TG--->出现了2次
CT--->出现了2次
CG--->出现了4次
GT--->出现了2次
GC--->出现了2次
GG--->出现了4次
*/

[ 本帖最后由 wp231957 于 2014-4-21 10:55 编辑 ]

您好，非常感谢您。
我要的结果是扫描到的33个模体中每种2模体出现的次数，需要单独输出一个文件。
另外，序列100长只是一个简便的举例，实际长度是能有一亿多长度的。而且在计算8模体时，8模体的种类也是有65536个的（2模体有16种，即AA、AT、AC、AG等），
所以序列有一些实际操作的难度呀。

1、这个8模体的生成 需要电脑生成  不能像我代码那样硬编码
2、单独输出一个文件 这个不是问题
3、源文件太大的话  估计运行时间是个问题 而这个问题咋弄都是遍历  是需要大量时间的

1、是的，因为我要算k模体，k可能会是10，这样依照2模体有16种模体的理论，他就有4的10次幂个，即65536乘16个。
2、另外，就像我刚才举的例子，100长度，以1为间隔能读到99个二模体，以2为间隔能读到50个2模体，所以还要麻烦一下设置为能随意间隔读取。
3、对，源文件很大，所以比较麻烦。
谢谢！！！！！

第一个问题你有代码没   我对全排列不咋熟悉  你有现成代码最好
第二个问题不是问题
第三个问题没有办法