自用笔记60——算24点浮点数比较

你有 4 张写有 1 到 9 数字的牌。你需要判断是否能通过 *，/，+，-，(，) 的运算得到 24。

示例 1:

输入: [4, 1, 8, 7]
输出: True
解释: (8-4) * (7-1) = 24
示例 2:

输入: [1, 2, 1, 2]
输出: False
注意:

除法运算符 / 表示实数除法，而不是整数除法。例如 4 / (1 - 2/3) = 12 。
每个运算符对两个数进行运算。特别是我们不能用 - 作为一元运算符。例如，[1, 1, 1, 1] 作为输入时，表达式 -1 - 1 - 1 - 1 是不允许的。
你不能将数字连接在一起。例如，输入为 [1, 2, 1, 2] 时，不能写成 12 + 12 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/24-game
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

int calculate(double a,double b,double c,double d)
{
    if(a+b+c+d == 24)
        return 1;
    else if(a+b+c-d == 24)
        return 1;
    else if(a+b-c-d == 24)
        return 1;
    else if(a-b-c-d == 24)
        return 1;
    else if(a*b*c*d == 24)
        return 1;
    else if(a*b*c/d == 24)
        return 1;
    else if(a*b/c/d == 24)
        return 1;
    else if(a/b/c/d == 24)
        return 1;
    else if(a*b*c+d == 24)
        return 1;
    else if(a*b*c-d == 24)
        return 1;
    else if(a*b/c+d == 24)
        return 1;
    else if(a*b/c-d == 24)
        return 1;
    else if(a/b/c+d == 24)
        return 1;
    else if(a/b/c-d == 24)
        return 1;
    else if(a*b+c+d == 24)
        return 1;
    else if(a*b+c-d == 24)
        return 1;
    else if(a*b-c-d == 24)
        return 1;
    else if(a/b+c+d == 24)
        return 1;
    else if(a/b+c-d == 24)
        return 1;
    else if(a/b-c-d == 24)
        return 1;
    else if((a+b)*c*d == 24)
        return 1;
    else if((a+b)*c/d == 24)
        return 1;
    else if((a+b)/c/d == 24)
        return 1;
    else if((a-b)*c*d == 24)
        return 1;
    else if((a-b)*c/d == 24)
        return 1;
    else if((a-b)/c/d == 24)
        return 1;
    else if((a+b)*c+d == 24)
        return 1;
    else if((a+b)*c-d == 24)
        return 1;
    else if((a+b)/c+d == 24)
        return 1;
    else if((a+b)/c-d == 24)
        return 1;
     else if((a-b)*c+d == 24)
        return 1;
    else if((a-b)*c-d == 24)
        return 1;
    else if((a-b)/c+d == 24)
        return 1;
    else if((a-b)/c-d == 24)
        return 1;
    else if((a+b+c)*d == 24)
        return 1;
    else if((a+b-c)*d == 24)
        return 1;
    else if((a-b-c)*d == 24)
        return 1;
    else if((a+b+c)/d == 24)
        return 1;
    else if((a+b-c)/d == 24)
        return 1;
    else if((a-b-c)/d == 24)
        return 1;
    else if((a*b+c)*d == 24)
        return 1;
    else if((a*b-c)*d == 24)
        return 1;
    else if((a/b+c)*d == 24)
        return 1;
    else if((a/b-c)*d == 24)
        return 1;
    else if((a*b+c)/d == 24)
        return 1;
    else if((a*b-c)/d == 24)
        return 1;
    else if((a/b+c)/d == 24)
        return 1;
    else if((a/b-c)/d == 24)
        return 1;
    else if((a+b)*(c+d) == 24)
        return 1;
    else if((a+b)*(c-d) == 24)
        return 1;
    else if((a-b)*(c-d) == 24)
        return 1;
    else if(a/(b+c/d) == 24)
        return 1;
    else if(fabs(a/(b-c/d)-24) < 0.001)
        return 1;
    else if(a*(b+c/d) == 24)
        return 1;
    else if(a*(b-c/d) == 24)
        return 1;
    else if(a*b/(c+d) == 24)
        return 1;
    else if(a*b/(c-d) == 24)
        return 1;
    else
        return 0;
}

bool judgePoint24(int* nums, int numsSize){
    int arr[24];
    memset(arr,0,sizeof(arr));
    int i=0;
    /*double a=nums[0],b=nums[1],c=nums[2],d=nums[3];*/
    arr[0] = calculate((double)nums[0],(double)nums[1],(double)nums[2],(double)nums[3]);
    arr[1] = calculate((double)nums[0],(double)nums[1],(double)nums[3],(double)nums[2]);
    arr[2] = calculate((double)nums[0],(double)nums[2],(double)nums[1],(double)nums[3]);
    arr[3] = calculate((double)nums[0],(double)nums[2],(double)nums[3],(double)nums[1]);
    arr[4] = calculate((double)nums[0],(double)nums[3],(double)nums[1],(double)nums[2]);
    arr[5] = calculate((double)nums[0],(double)nums[3],(double)nums[2],(double)nums[1]);
    arr[6] = calculate((double)nums[1],(double)nums[0],(double)nums[2],(double)nums[3]);
    arr[7] = calculate((double)nums[1],(double)nums[0],(double)nums[3],(double)nums[2]);
    arr[8] = calculate((double)nums[1],(double)nums[2],(double)nums[0],(double)nums[3]);
    arr[9] = calculate((double)nums[1],(double)nums[2],(double)nums[3],(double)nums[0]);
    arr[10] = calculate((double)nums[1],(double)nums[3],(double)nums[0],(double)nums[2]);
    arr[11] = calculate((double)nums[1],(double)nums[3],(double)nums[2],(double)nums[0]);
    arr[12] = calculate((double)nums[2],(double)nums[0],(double)nums[1],(double)nums[3]);
    arr[13] = calculate((double)nums[2],(double)nums[0],(double)nums[3],(double)nums[1]);
    arr[14] = calculate((double)nums[2],(double)nums[1],(double)nums[0],(double)nums[3]);
    arr[15] = calculate((double)nums[2],(double)nums[1],(double)nums[3],(double)nums[0]);
    arr[16] = calculate((double)nums[2],(double)nums[3],(double)nums[0],(double)nums[1]);
    arr[17] = calculate((double)nums[2],(double)nums[3],(double)nums[1],(double)nums[0]);
    arr[18] = calculate((double)nums[3],(double)nums[0],(double)nums[1],(double)nums[2]);
    arr[19] = calculate((double)nums[3],(double)nums[0],(double)nums[2],(double)nums[1]);
    arr[20] = calculate((double)nums[3],(double)nums[1],(double)nums[0],(double)nums[2]);
    arr[21] = calculate((double)nums[3],(double)nums[1],(double)nums[2],(double)nums[0]);
    arr[22] = calculate((double)nums[3],(double)nums[2],(double)nums[0],(double)nums[1]);
    arr[23] = calculate((double)nums[3],(double)nums[2],(double)nums[1],(double)nums[0]);
    /*arr[0]= calculate(a,b,c,d);
    arr[1]= calculate(a,b,d,c);
    arr[2]= calculate(a,c,b,d);
    arr[3]= calculate(a,c,d,b);
    arr[4]= calculate(a,d,b,c);
    arr[5]= calculate(a,d,c,b);
    arr[6]= calculate(b,a,c,d);
    arr[7]= calculate(b,a,d,c);
    arr[8]= calculate(b,c,a,d);
    arr[9]= calculate(b,c,d,a);
    arr[10]= calculate(b,d,a,c);
    arr[11]= calculate(b,d,c,a);
    arr[12]= calculate(c,a,b,d);
    arr[13]= calculate(c,a,d,b);
    arr[14]= calculate(c,b,a,d);
    arr[15]= calculate(c,b,d,a);
    arr[16]= calculate(c,d,a,b);
    arr[17]= calculate(c,d,b,a);
    arr[18]= calculate(d,a,b,c);
    arr[19]= calculate(d,a,c,b);
    arr[20]= calculate(d,b,a,c);
    arr[21]= calculate(d,b,c,a);
    arr[22]= calculate(d,c,a,b);
    arr[23]= calculate(d,c,b,a);*/
    for(i=0;i<24;i++)
    {
        if(arr[i] == 1)
            return true;
    }
    return false;
}

分情况无脑讨论计算所有的数字组合顺序和符号情况，然后判断是否是24即可：
1没括号的（形如abcd）；
（1）a,b,c,d是同一优先级运算
（2）a,b是优先级运算，c,d是次一级运算
（3）a,b,c是优先级运算，d是次一级运算
（4）b,c是优先级运算，a,d是次一级运算，且a是-，必不会是24
（5）c,d是优先级运算，同上
（6）b,c,d是优先级运算，a是次一级运算，且a是-，必不会是24
2有括号的（形如(a * b) * c * d）；
（1）a,b是次一级运算，c,d是优先级运算
（2）a,b是次一级运算，c是优先级运算，d是次一级运算
3有括号的（形如(a * b * c) * d）；
（1）a,b,c是次一级运算，d是优先级运算
（2）a,b是优先级运算，c是次一级运算，d是优先级运算
4有括号的（形如a * (b * c) * d）；
（1）b,c是次一级运算，a,d是优先级运算，包含在2（1）
（2）b,c是次一级运算，a是优先级运算，d是次一级运算，包含在2（2）
（3）b,c是次一级运算，a,d是次一级运算
5有括号的（形如(a * b) * (c * d)）；
（1）括号内是次一级运算，括号外是优先级运算
6有括号的（形如((a * b) * c) * d）；
包含在上
7有括号的（形如(a * (b * c)) * d）。

其实我分析的也有点懵，因为加括号的时候还需要考虑是不是通过改变顺序已经存在上述情况了，而且有很多情况仔细分析并无法得到24，所以实际剩下的可能性没那么多。大致默认a,b,c,d四个数是从左往右按照运算法则算的，然后一步步加括号。

但是需要注意的是，对于整数计算情况上述判断完全够用，如果计算过程有小数，只用int会导致计算结果偏差，所以要将给定的四个数转换为float或者double型计算。

另外对于浮点数计算之后的结果比较，如果计算过程是无限小数，那么就无法只通过“==”来判断结果是否符合要求，这个时候需要给定一个误差，判断计算结果和24的偏差是否小于这个误差，如果是可以认为计算的结果就是24

else if(fabs(a/(b-c/d)-24) < 0.001)
        return 1;

这里给定的误差是0.001，合适就行