一组数字由1-49的任意7个数组成，答案是1-49的其中4个数，已知一组数字和答案，求正确矩阵公式。

一个公式里最多出现三个《+》号和一个《－》号。简单一点的就只有一个符号，公式里只有加和减。答案的四个数字也就是代表某种东西，它包括了这四个数字
。所以得到的任意一个数都是对的，主要就是公式配得起。
按四条重点算，第一组数字得出的答案必须是第二组的最后一个数字，(属性包括的其他三个数字也可) ，然后第二组用同一个公式得到第三组的最后一个数字，
第三组的数算第四组的最后一个数字，这就是我要算的。

要求算法《重点》：
(1)可以按排序算，（默认）除七数以外还可以加减1-10的数，结果等于四个答案的任意一个。例(1)

(2)可以按大小序算，（前六个数从小到大的排序）除七数以外还可以加减1-10的数，结果等于四个答案的任意一个，和（1）差不多。例(2).(3)

(3)可以按合数算，就是把一个数字拆开来相加，比如：0+3     3+1   这样算      这个应用在（1）.（2）都可能用上。例(4)

(4）可以按一个数算，有些题它的答案就是用一个数加1-10就得出结果。

例子：           排序《二数字尾+1》           
33 09 08 49 13 17 30 　      9+1=10           
34 29 02 25 16 07 10 　      9+1=10
37 33 23 04 47 15 22 　      3+1=04   

                 大小《三数字头+7》
02 06 21 45 46 49  28 　       2+7=09
06 14 26 27 30 43  21 　       2+7=09
04 11 15 16 35 42  09 　       1+7=08

                 大小《三数字-1》
02 12 20 25 31 47  29 　       20-1=19
01 02 09 20 24 49  43 　       09-1=08
06 23 24 38 39 40  32 　       24-1=23

                 大小《三数字合+5》
01 15 30 39 49 45  37 　      3+0+5=08
09 14 16 17 21 26  20 　      1+6+5=12
01 06 14 25 29 35  48 　      1+4+5=10

下面说说答案4个数字的属性；
等于01也就可以等于：01 13 25 37 49      
等于02也就可以等于：02 14 26 38
        03                            03 15 27 39
        04                            04 16 28 40
        05                            05 17 29 41
         ↓                           06 18 30 42
                                         07 19 31 43
                                         08 20 32 44
                                         09 21 33 45
                                         10 22 34 46
                                         11 23 35 47  
等于12也就可以等于：12 24 36 48  

首先我们知道前三组数字。算第四组的最后一个数字。
41  33  31  24  08  12  20 　        ←  这组数字用4种方法算出等于03 15 27 39

24  45  18  34  38  26  15　               这组算出等于01 13 25 37 49

17  16  10  42  43  38  13 　              ?????

以下()里是一组数字中出现的数字，()外面的是1-10的数字，从左至右算，不可以拿后面的数加减前面的数。

按排序算，除七数以外还可以加减1-10的数，结果等于四个答案的任意一个。
41  33  31  24  08  12  20  
4-1=03
(4+8)+3=15
(3+3+4)+5=15
(2+0)+1=03     ···········································N多种算法。
   

按大小序算，（前六个数从小到大的排序）除七数以外还可以加减1-10的数，结果等于四个答案的任意一个。
08  12  24  31  33  41  20
(0+8)+7=15
1+2=03
8+4+3=15    ············································N多种算法

 
按合数算，就是把一个数字拆开来相加，上面两种算法都有写出来。
41  33  31  24  08  12  20
跟排序大小算法相同，这个合数算法就是融合在大小排序的里面的。N多种算法。
   

按一个数算，有些题它的答案就是用一个数加1-10就得出结果。
41  33  31  24  08  12  20        这个也可以融合在大小排序的算法里面。
41-2=39
33+6=39
24+3=27
12+3=15       这个也可以融合在大小排序的算法里面，也是N多种算法。

第一组数字算出的公式保存下来，应用在第二组数字。相同的筛选出来，继续用在第三组数字上。

正确公式：
排序（三数字+七数字头）+6

41 33 31 24 08 12 20 　31+2+6=39   

24 45 18 34 38 26 15 　18+1+6=25  

17 16 10 42 43 38 13 　10+1+6=17

02 12 20 25 31 47  29

//.c文件
#include <stdio.h>
#include <malloc.h>

//待处理数据组
int question_set[3][7] ={0};
//答案集合数组
int answer_set[13][5] =
{
    {0},
    {1, 13, 25, 37, 49},
    {2, 14, 26, 38, 0},
    {3, 15, 27, 39, 0},
    {4, 16, 28, 40, 0},
    {5, 17, 29, 41, 0},
    {6, 18, 30, 42, 0},
    {7, 19, 31, 43, 0},
    {8, 20, 32, 44, 0},
    {9, 21, 33, 45, 0},
    {10, 22, 34, 46, 0},
    {11, 23, 35, 47, 0},
    {12, 24, 36, 48, 0}
};


//判断是否在某个数组集中
int isAnswer(int data)
{//是其中一员则返回序号 否则返回0
    int index = 0;
    int i = 0;

    for (index=1; index<13; ++index)
    {
        for (i=0; i<5; ++i)
        {
            if (answer_set[index][i] == data)
            {
                return index;
            }
        }
    }
    return 0;
}
//初始化待处理的数据组
void init_Q_Set()
{
    int index = 0;
    int dim = 0;

    for (dim=0; dim<3; ++dim)
    {
        printf("输入第%d组7个数据\n", dim+1);

        for (index=0; index<7; ++index)
        {
            scanf("%d", &question_set[dim][index]);
        }
    }
}
//把字符加入到字符串当中
char * itos(char *string, int index, char src)
{
    string[index] = src;

    return string;
}
//判断由公式得出是否第二组也满足此公式
int do_2_3(char *string)
{
    int index=0;
    int i=0;//
    int sum = 0;

    while(string[index] != 0)
    {
        i = question_set[1][string[index]-48];
        sum = question_set[2][string[index]-48];
        ++index;
        if (string[index] == '1')
        {
            ++index;
            if (string[index++] == '-')
            {
                i = i%10 - (string[index] - 48);
                sum = sum%10 - (string[index] - 48);
            }
            else
            {
                i = i%10 + (string[index] - 48);
                sum = sum%10 + (string[index] - 48);
            }
        }
        else if (string[index] == '2')
        {
            ++index;
            if (string[index++] == '-')
            {
                i = i/10 - (string[index] - 48);
                sum = sum/10 - (string[index] - 48);
            }
            else
            {
                i = i/10 + (string[index] - 48);
                sum = sum/10 + (string[index] - 48);
            }
        }
        else if (string[index] == '3')
        {
            ++index;
            if (string[index++] == '-')
            {
                i = i%10 + i/10 - (string[index] - 48);
                sum = sum%10 + sum/10 - (string[index] - 48);
            }
            else
            {
                i = i%10 + i/10 + (string[index] - 48);
                sum = sum%10 + sum/10 + (string[index] - 48);
            }
        }
        else if (string[index] == '4')
        {
            ++index;
            if (string[index++] == '-')
            {
                i = i - (string[index] - 48);
                sum = sum - (string[index] - 48);
            }
            else
            {
                i = i + (string[index] - 48);
                sum = sum + (string[index] - 48);
            }
        }
        ++index;

        if (i && (question_set[2][6]-1)%12+1 == isAnswer(i))
        {
            if ( sum>0 && sum <=49 )
            {
                printf("\n%s\n", string);
                i = 0;
                printf("第%c位数据", string[i]+1);
                ++i;
                switch (string[i])
                {
                case '1':
                    printf(" 只用其低位数据");
                    break;
                case '2':
                    printf(" 只用其高位数据");
                    break;
                case '3':
                    printf(" 用其高低数据相加");
                    break;
                case '4':
                    printf(" 用其数据");
                    break;
                }
                ++i;
                if (string[i] == '-')
                {
                    ++i;
                    printf("再减掉%c\n", string[i]);
                }
                else
                {
                    ++i;
                    printf("再加上%c\n", string[i]);
                }
               
                return 1;//表示符合
            }
        }
    }

    return 0;//表示不符合
}
//获取第一组满足要求的公式串
int do_1_2(int index_array, int index)
{
    int x = 0;
    int sum = 0;
    char *string = (char*) malloc (20*sizeof(char));
    int indexStr = 0;
    int flag = 0;

    //采用加上一个数(1~10)的格式
    for (x=1; x<=10; ++x)
    {
        flag = 0;
        indexStr = 0;
        string = itos(string, indexStr++, (char)(48+index_array));
        //方案1拆开数据用其数据值的低位 加上某个数
        sum = question_set[index-1][index_array]%10 + x;
        if (!flag && (question_set[index][6]-1)%12+1 == isAnswer(sum))
        {//
            string = itos(string, indexStr++, 48+1);
            flag = 1;
        }
        //方案2拆开数据用其数据值的高位 加上某个数据
        if (!flag)
        {
            sum = question_set[index-1][index_array]/10 + x;
        }
        if (!flag && (question_set[index][6]-1)%12+1 == isAnswer(sum))
        {//   
            string = itos(string, indexStr++, 48+2);
            flag = 1;
        }
        //方案3拆开数据 高位和低位都用上 加上某个数据
        if (!flag)
        {
            sum = question_set[index-1][index_array]/10 +
            question_set[index-1][index_array]%10 + x;
        }
        if (!flag && (question_set[index][6]-1)%12+1 == isAnswer(sum))
        {//
            string = itos(string, indexStr++, 48+3);
            flag = 1;
        }
        //方案4不拆开数据 直接用数据加上某个数据
        if (!flag)
        {
            sum = question_set[index-1][index_array] + x;
        }
        if (!flag && (question_set[index][6]-1)%12+1 == isAnswer(sum))
        {//
            string = itos(string, indexStr++, 48+4);
            flag = 1;
        }
        if (flag)
        {
            string = itos(string, indexStr++, '+');
            string = itos(string, indexStr++, (char)(48+x));
            string = itos(string, indexStr++, '\0');

            //return string;
            if (sum && do_2_3(string))
            {
                return 1;
            }
        }
        ///////////////////////////////////////////////////////////////////
        indexStr = 0;
        if (!flag)
        {
            string = itos(string, indexStr++, (char)(48+index_array));
        }
        //方案1拆开数据用其数据值的低位 加上某个数
        sum = question_set[index-1][index_array]%10 - x;
        if (!flag && (question_set[index][6]-1)%12+1 == isAnswer(sum))
        {//
            string = itos(string, indexStr++, 48+1);
            flag = 1;
        }
        //方案2拆开数据用其数据值的高位 加上某个数据
        if (!flag)
        {
            sum = question_set[index-1][index_array]/10 - x;
        }
        if (!flag && (question_set[index][6]-1)%12+1 == isAnswer(sum))
        {//   
            string = itos(string, indexStr++, 48+2);
            flag = 1;
        }
        //方案3拆开数据 高位和低位都用上 加上某个数据
        if (!flag)
        {
            sum = question_set[index-1][index_array]/10 +
            question_set[index-1][index_array]%10 - x;
        }
        if (!flag && (question_set[index][6]-1)%12+1 == isAnswer(sum))
        {//
            string = itos(string, indexStr++, 48+3);
            flag = 1;
        }
        //方案4不拆开数据 直接用数据加上某个数据
        if (!flag)
        {
            sum = question_set[index-1][index_array] - x;
        }
        if (!flag && (question_set[index][6]-1)%12+1 == isAnswer(sum))
        {//
            string = itos(string, indexStr++, 48+4);
            flag = 1;
        }
        if (flag)
        {
            string = itos(string, indexStr++, '-');
            string = itos(string, indexStr++, (char)(48+x));
            string = itos(string, indexStr++, '\0');
       
            if (sum && do_2_3(string))
            {
                return 1;
            }
            //return string;
        }
    }

    return 0;
}
//计算第一组
void cal_1_2()
{
    int index = 0;

    for (index=0; index<7; ++index)
    {
        if (do_1_2(index, 1))
        {
            return;
        }
    }

    return;
}

void deal()
{
    init_Q_Set();//

    cal_1_2();//
}

int main(void)
{
    deal();

    return 0;
}

程序计算的可能情况 只是全部的部分  符号（+, -）最多使用个数为2个

非常感谢！

感觉你也发了不少帖子了，大家普遍都反应看不太明白。
这个帖子里说的，和你给我看的没什么太大区别呀。看来还是人家 寒风 理解能力强。

这个题目怎么会这么古怪？是你自己发明的游戏规则吗？

是不是就是给一组数，和另一组数。然后让我们给出一个公式，描述它们之间的关系？

如果是的话，这觉得这么描述就好一点。为什么要管另一组数叫答案？这样容易混淆人的理解。

给出三组数，首先拿第一组按我说的四条来算，等于第二组的最后一个数，然后第二组算出第三组数的最后一个，第三组算第四组的最后一个，要用同一个公式。斑竹给出的那张图片参考。不过不是正确的公式。

斑竹说信息不足，是哪个方面，我提供的不足还是？

主要是感觉你的这个例子不对呀：
例子：           排序《二数字尾+1》         
33 09 08 49 13 17 30        9+1=10         
34 29 02 25 16 07 10        9+1=10
37 33 23 04 47 15 22        3+1=04   

你这里第一组算完了是 9＋1＝10
第二组最后一个数确实是 10.
但第二组算了是 10，怎么第三组就不是了？



[ 本帖最后由 pangding 于 2011-5-5 16:20 编辑 ]

终于有点看懂了。
唉，还是自己理解力不行。

看懂了之后，其实感觉楼主描述的还行。就是那个属性的问题，一开始一直没看明白。

我觉得没必要说属性这么玄乎的话。
就说只要 公式得到的数 和 下一组的最后一个数 除以12的余数相同就行了。或者用术语，说它们 关于模12同余 也行。


[ 本帖最后由 pangding 于 2011-5-5 16:21 编辑 ]

你的第二种算法，是只有当所有给出的组的前六个数都是已序的时候才能用？

另外是不是只有当算法取的数不为7的时候才能进行其它处理？
比如我如果假设采用《二数字尾＋1》这种算法，后来发现某组数中正好第二个数的尾数是7，是不是就表示不能应用这个公式，从而要推测其它公式？

第三种算法中，按合数算中生成的加号，是不是也要占三个加号名额中的一个？
比如你的例四中：3+0+5=08 是不是算有两个加号？


第一组的最后一个数是不是没用？
我只能用每组的前六个数进行公式推演，然后用下一组的最后一个数校验。是不是这个意思？


楼主说可以出现三个加号和一个减号。即是说，最复杂的公式可能是这样：
a()b()c()d()e
其中括号中可以填三个加号，和一个减号。
但是楼主的例子中，没有能给出这么多操作数的情况。是说可以从组中取很多次吗？
比如是
        第一个数的尾数 ＋ 第二个数的头数 + 第三个数合数 - 一个一至十的数
这样的公式是不是也行？


[ 本帖最后由 pangding 于 2011-5-5 16:26 编辑 ]