laowan001先生也不来试一试，在我的印象里，他还是有办法解决的。
另外，吹水佬版主更不在话下，不知道为什么，就是不出手，一展其锋芒。

问题是这样的：x+y+z+u+v+m=N，如果未知数不加限制，则用排列组合中的挡板法可以直接求出，现在的问题是限制未知数取某数的倍数，这个某数是大于等于2即可，我们也可以先研究个具体的，比如不能取5的倍数。
     我们把未知数x（y，z，u，v，m）=Pt+r的形式，与数论中的剩余类（剩余系）有点相似，0<r≤P-1，
这样每个未知数就是两部分组成的，而且t与r各自独立，根据乘法原理x=Pt+r是分步关系，如果t有i种方法，r有j种方法，则对于一个x来说，共有ij种方法。
      x+y+z+u+v+m=N→(x+y)+(z+u+v+m)=N→（(x+y）+[(z+u)+(v+m)]=N
我们先打分，充分利用对称原理，把(x+y)分成一个区块，(z+u+v+m)分成一个区块,假说x+y=N1，z+u+v+m=N2，N1+N2=N的情况下，得到N1有j1种方法，得到N2有j2种方法，则共有j1j2种方法，在整个运算过程中，始终是把未知数分区，2个变量和+（2个变量和+2个变量和）=2个变量和+4个变量和=N，（最开始一步是1个变量+1个变量=N2），然后，用2+2=4（数字都是代表的变量个数），2+4=6（同前注解），第一步是1+1=2.
数据区域用“+”，统计区域用“*”，第一步例外，直接统计各种和值的个数，第二步在第一步的基础上进行，把“和值”用在数据区域，首列，顶行都是用它，形成二维数据结构；把统计2的值照样处理，排列成首行，首列二维数据（它的二元运算用“*”，前边的数据区域用“+”），然后统计数据区域和值一样的有多少，即找到统计对应位置上的数求和。
     实际上，这些叙述不一定起多大作用，需要看一下整个帖子实例，每步干什么，最后得到什么数值。

可以先研究周期矩阵，它们不受限制，先不管单位矩阵，计算10个周期的即可，周期一定从0开始，因为单位矩阵的缘故，也就是X+Y+Z+V+U+M=N中，未知数可以取0-9的数字，看一看它们的分布，肯定之和是0--54，有10^6=100万种方法，落到0--54上，数据分布是对称的。
     当研究整个问题时，只需要把0--54乘限制条件即可（实际上，乘的是周期值，比方不能取5的倍数，那就是0---54*5了）。
      实际上，你研究完周期矩阵，下来研究单位矩阵时，也就好办了，比如不能取5的倍数，那么，未知数取值就是1--4之间，最小值是6，最大值是4*6=24，也就是说，4^6个值一定落到1至24上。
      最后，耦合一步，也简单，用周期倍数值+单位矩阵的和值，作为结果，合成方法数=周期倍数值的统计个数*单位和值的统计个数，说白了，周期矩阵，单位矩阵原来是各自独立，后来它们混合了一下。

解6元一次不定方程的解组数，条件变量不能取5的倍数，给出1至100之间的解组数（即N=1到100）

只要算出6周的数据，就可以用待定系数法求出多项式公式表达式。一般这类单条件的线性不定方程的解组数公式是一个比未知数个数少一次的多项式形式。它是六元的，所以，解组数表达式是一个最高5次的多项式，它有6个系数要求，所以，最少需要6个周期的数据。

最终还是没有人，一试身手。

这些表与它的关系，第一步，相当于x+y=N
                  第二步，相当于(x+y)+(z+u)=N
                  第三步，相当于[(x+y)+(z+u)]+(v+m)=N
     这三步，周期矩阵，与单位矩阵，操作步骤一样，只是起点，与参与的元素不同。
     
     单位矩阵，用1到P-1之间的几个元素，不能用0，也不能用P（限制条件值，比如，未知数，或者说变量，不能取7的倍数，则P=7，所用值就是1,2,3,4,5,6了）

      但是周期矩阵是从0开始，到某一个值即可，如果，想获得10个周期的数据，则此时，是从0到9，即0代表第一个周期，9实际上是第10个周期的。
      如N=36时，可以写成7*5+1的形式，7是限制条件（不能取它的倍数），5是周期值，5个周期，实际求出来的是第六个周期上的数据，在周期矩阵与单位矩阵耦合时，周期矩阵的值（周期数），需要乘7（周期值，或不能取得某数的倍数中，某数，这里不能取7的倍数，某数即7了）；但是，单位矩阵的合成值不变，直接参与运算，统计值，是得到这个合成值的方法数，即得到对应N的不定方程的解组数。
       第一步，统计用的是Excel中的COUNTIF(B$2:G$7,I2)计数函数
       以后各步，统计用的是Excel中的SUMIF(B$16:L$26,AA16,O$16:Y$26)计数函数

你的建议让我不知所措（让我先学代数，后学编程？无所适从）

好的编程都是建立在对问题的熟练程度上，对问题的来龙去脉不清楚，你就不可能有好的算法。

单位矩阵9        1        2        3        4        5        6        7        8
1        2        3        4        5        6        7        8        9
2        3        4        5        6        7        8        9        10
3        4        5        6        7        8        9        10        11
4        5        6        7        8        9        10        11        12
5        6        7        8        9        10        11        12        13
6        7        8        9        10        11        12        13        14
7        8        9        10        11        12        13        14        15
8        9        10        11        12        13        14        15        16

模9        统计2
2        1
3        2
4        3
5        4
6        5
7        6
8        7
9        8
10        7
11        6
12        5
13        4
14        3
15        2
16        1
合计        64
单位矩阵，第一步计算。

模9        1        2        3        4        5        6        7        8
2        3        4        5        6        7        8        9        10
3        4        5        6        7        8        9        10        11
4        5        6        7        8        9        10        11        12
5        6        7        8        9        10        11        12        13
6        7        8        9        10        11        12        13        14
7        8        9        10        11        12        13        14        15
8        9        10        11        12        13        14        15        16
9        10        11        12        13        14        15        16        17
10        11        12        13        14        15        16        17        18
11        12        13        14        15        16        17        18        19
12        13        14        15        16        17        18        19        20
13        14        15        16        17        18        19        20        21
14        15        16        17        18        19        20        21        22
15        16        17        18        19        20        21        22        23
16        17        18        19        20        21        22        23        24

统计2/1        1        1        1        1        1        1        1        1
1        1        1        1        1        1        1        1        1
2        2        2        2        2        2        2        2        2
3        3        3        3        3        3        3        3        3
4        4        4        4        4        4        4        4        4
5        5        5        5        5        5        5        5        5
6        6        6        6        6        6        6        6        6
7        7        7        7        7        7        7        7        7
8        8        8        8        8        8        8        8        8
7        7        7        7        7        7        7        7        7
6        6        6        6        6        6        6        6        6
5        5        5        5        5        5        5        5        5
4        4        4        4        4        4        4        4        4
3        3        3        3        3        3        3        3        3
2        2        2        2        2        2        2        2        2
1        1        1        1        1        1        1        1        1

模9        统计3
3        1
4        3
5        6
6        10
7        15
8        21
9        28
10        36
11        42
12        46
13        48
14        48
15        46
16        42
17        36
18        28
19        21
20        15
21        10
22        6
23        3
24        1
合计        512
单位矩阵，第二步计算2+1（2是列数据，1是行数据，交叉点是实际：数据区域，有行*列或得）