流行测验：解决数学难题？

Question

我在网上找到一篇关于越南三年级数学的文章。我想看看我们如何解决这个问题会很有趣。以数学或编程方式。

我为此编写了一个测试函数，您可以随意将其调整为您喜欢的任何编程语言：

var answer = [1,1,1,1,1,1,1,1,1,1];
var isCorrect = function (answer) {
    return ((((((((((((a[0]+13)*a[1])/a[2])+a[3])+12)*a[4])-a[5])-11)+a[6])*a[7])/a[8])-10) === 66;
};

规则是数组中不应有可重复的数字。 接受的数字是 1-9。

Answer 1

from constraint import *

def formula(a, b, c, d, e, f, g, h, i):
    return abs(a + (13 * (b / c)) + d + (12 * e) - f -
               11 + ((g * h) / i) - 10 - 66) < 0.001

if __name__ == '__main__':
    all_vals = [float(i) for i in xrange(1, 10)]
    p = Problem()
    [p.addVariable(l, all_vals) for l in 'abcdefghi']

    p.addConstraint(AllDifferentConstraint())
    p.addConstraint(FunctionConstraint(formula), 'abcdefghi')
    result = p.getSolution()
    print [s for s in sorted(result.items(), key=lambda (k,v): k)]

答案是：

[('a', 9.0), ('b', 8.0), ('c', 6.0), 
 ('d', 2.0), ('e', 4.0), ('f', 1.0), 
 ('g', 5.0), ('h', 7.0), ('i', 3.0)]

Answer 2

Maraca，您的 MATLAB 代码运行良好，除了应更改 S 行以获得正确的算术结果。新代码是：

p = perms(1:9);
S = p(:,1)+(13.*p(:,2)./p(:,3))+p(:,4)+(12.*p(:,5))-p(:,6)-11+(p(:,7).*p(:,8)./p(:,9))-10 == 66;
sum(S)
p(S,:)

例如，一个测试解决方案是 (a b c d e f g h i) = (3 2 1 5 4 7 9 8 6)

使用代码中的这种更改，有 128 个独特的解决方案。

请参阅link。

Answer 3

我想可能有一种更有效的方法来解决这个问题，但是，因为只有 9 个变量和 9 个可能的值，而且我们有电脑，蛮力的。

这个想法是为每个排列尝试 check() 函数，即可以将数字 1 到 9 放入数组 a[] 的方法。这意味着9！迭代次数 = 362880，我的笔记本电脑可以在几秒钟内处理完。

我构建了递归 permutate()： 对于它所在的每个级别，permutate 函数循环数字 1 到 9，将它们中的每一个放在数组的 level- 位置（但前提是该数字尚未位于先前的位置），然后调用自身以获得下一个级别. 9级时，数组已满，可以调用check函数。

这是java中的代码：

public class Test {
    static float[] a = { 0, 0, 0, 0, 0, 0, 0, 0, 0};
private static int countSolutions = 0;
public static void main(String[] args){
    permutate(0);
    System.out.println(countSolutions);
}

public static boolean permutate( int level){
    boolean isCorrect = false;
    if(level == 9){
        isCorrect = check();
        if(!isCorrect){
        }
    }
    else 
        for(int i = 1; i <= 9; i++){
            int j = 0;
            for(; j < level && a[j]!=i; j++);
            if( j == level){
                a[level] = i;
                isCorrect = permutate( level + 1);
            }
        }
    return isCorrect;
}

private static boolean check() {
    float result = ((((((((((((a[0]+13)*a[1])/a[2])+a[3])+12)*a[4])-a[5])-11)+a[6])*a[7])/a[8])-10);
    if ( result == 66){
        countSolutions ++;
        for (int i = 0; i < 9; i++) {
            System.out.print(a[i]+",");
        }
        System.out.println();
        return true;
    }else{
        return false;
    }
}

}

结果 (144)：

1.0 2.0 4.0 7.0 5.0 8.0 3.0 6.0 9.0

1.0 2.0 7.0 5.0 3.0 4.0 9.0 8.0 6.0

....

....

Answer 4

Matlab / Octave（蛮力）：

p = perms(1:9) ;
S = (((((((((((p(:,1)+13).*p(:,2))./p(:,3)+p(:,4))+12).*p(:,5))-p(:,6))-11)+p(:,7)).*p(:,8))./p(:,9))-10) == 66 ;
sum(S)
p(S,:)

我在 octave 上在线执行了它，它表明有 144 种解决方案，计算只需几分之一秒。 (http://octave-online.net 最初的弹窗看起来很吓人，但它只是想提供帮助，点击它离开并将整个程序代码复制到底部的控制台行并点击 [return] 以查看所有 144 个解决方案，有时你会得到错误“有效负载太大”，但它只是显示，数学在后台运行良好。）

说明

对于数学问题，显然设计用于解决这些问题的编程语言是一个不错的选择，并且可以减轻您的大量工作，因此尽管我是 Java 程序员，但我使用了 Octave，这就是程序的内容确实：

1. 1:9 给出了一个带有数字的向量 1 到 9 (1 x 9)
2. perms() 计算该向量的所有排列并将其作为矩阵 (9!x 9) 返回
3. ; 抑制输出
4. p = 置换矩阵存储在p
5. p(:,n) 访问p 的nth 列，因此所有解决方案都是一次计算的
6. .* 和 ./ 确保单元格乘法而不是标准矩阵乘法
7. 结果向量与66 的比较会返回一个逻辑向量，该向量存储在S 中，类似于一个向量，当等式为真时为1，否则为0 (9! x 1 )
8. sum(S) 输出解数
9. p(S,:) 返回之前等式为真的所有行，即解 (144 x 9)