Javascript 数学计算

我有一个数字列表如下：

1,2,3,4,5,6,7,8

如何使用javascript在不重复数字两次的情况下搜索以下等式的答案

() - () = 1  
() + () = 9  
() - () = 2  
() + () = 7  

---

谢谢你

你可以尝试用蛮力方法解决这个问题

用4个项目组成一个数组

每一项都是其中一个方程的所有解

方程的解是满足方程的数对的数组

第一个方程有7个解，第二个方程有4个解，第三个方程有6个解，第四个方程有3个解

所有可能的组合都是

7*4*6*3=504

检查第一个方程的每个解以及第二个方程的所有解，依此类推。。。有四个嵌套的

for

循环。确认没有两次使用数字

问题没有解决方案

这是一把小提琴

这是密码

solve();

function solve()
{
    // solutions

    var s =
        [    
            [
                [2,1],[3,2],[4,3],[5,4],[6,5],[7,6],[8,7]
            ],
            [
                [8,1],[7,2],[6,3],[5,4]
            ],
            [
                [3,1],[4,2],[5,3],[6,4],[7,5],[8,6]
            ],
            [
                [6,1],[5,2],[4,3]
            ]
        ];

    // counters

    var i0,i1,i2,i3;

    var n0 = s[0].length,
        n1 = s[1].length,    
        n2 = s[2].length,    
        n3 = s[3].length;    

    // configuration check

    var a,
        found,
        j,
        foundn;

    // check every combination of valid solutions

    foundn = 0;

    for( i0=0; i0<n0; i0++ )
    {
        for( i1=0; i1<n1; i1++ )
        {
            for( i2=0; i2<n2; i2++ )
            {
                for( i3=0; i3<n3; i3++ )
                {
                    // the array a is used to check how many times
                    // each number is used. Item nr. 0 is unused.

                    a = [0,0,0,0,0,0,0,0,0];
                    a[s[0][i0][0]]++;
                    a[s[0][i0][1]]++;
                    a[s[1][i1][0]]++;
                    a[s[1][i1][1]]++;
                    a[s[2][i2][0]]++;
                    a[s[2][i2][1]]++;
                    a[s[3][i3][0]]++;
                    a[s[3][i3][1]]++;
                    found = true;
                    for( j=1; j<=8; j++ )
                    {
                        if( a[j] > 1 )
                        {
                            found = false;
                            break;
                        }
                    }
                    if( found )
                    {
                        console.log( s[0][i0][0] + ' ' +
                                     s[0][i0][1] + ' ' + 
                                     s[1][i1][0] + ' ' + 
                                     s[1][i1][1] + ' ' + 
                                     s[2][i2][0] + ' ' + 
                                     s[2][i2][1] + ' ' + 
                                     s[3][i3][0] + ' ' + 
                                     s[3][i3][1] );
                        foundn++;
                    }
                }    
            }   
        }    
    }

    console.log( 'found ' + foundn + ' configurations' );
}

solve（）；
函数solve（）
{
//解决方案
var s=
[    
[
[2,1],[3,2],[4,3],[5,4],[6,5],[7,6],[8,7]
],
[
[8,1],[7,2],[6,3],[5,4]
],
[
[3,1],[4,2],[5,3],[6,4],[7,5],[8,6]
],
[
[6,1],[5,2],[4,3]
]
];
//计数器
var i0、i1、i2、i3；
变量n0=s[0]。长度，
n1=s[1]。长度，
n2=s[2]。长度，
n3=s[3]。长度；
//配置检查
var a，
建立
J
foundn；
//检查每个有效解决方案的组合
foundn=0；
对于（i0=0；i0）您尝试过什么吗？这是硬件吗？要么提出一个算法，要么使用暴力。但两者都不是特定于javascript的。算法是解决问题的方法，找到"“最佳”算法是您的挑战找到满足每一行的每一个组合，按最短可能数对行进行排序，为第一个条目选择一个可能，删除这些数字，然后在剩余的时间重复lines@Alundrathedreamwalker我认为我们可以帮助他概念化算法的运行方式，并让代码编写完成向他告别。