Question

我正在寻找一种算法来解决ab-cd类型的差异，其中a，b，c和d是类型容量边缘的整数，即ab溢出或丢失数字，具体取决于实际表示在机器上。我不能使用任意精度数学;其中一个平台将是一个SQL数据库。

我认为将产品分解为（a'+ a''）b-（c'+ c''）d然后以某种方式迭代下来。但可能有一种更有效的方法或至少一个聪明的想法如何进行分解。不幸的是，在大多数情况下a，b;光盘; A，C; b，d是互质的，所以减少至少并不简单。

有什么想法吗？

Answer 1

警告

此方法仅部分起作用。有些情况无法解决。

取自你的文字：

我正在寻找一种算法来解决ab-cd类型的差异，其中a，b，c和d是类型容量边缘的整数，

据我了解，您希望计算(a * b) - (c * d)以避免数字溢出。你想用算法解决这个问题。

我们需要认识到的第一件事是(a * b) - (c * d)的结果可能不适合数据类型。我不会试图解决这些问题。

所以，我会搜索不同的方法来计算“ab-cd”。我发现的是：

(a * b) - (c * d) = ((a - c) * b) - (c * (d - b))

您可以对变量进行重新排序以获得不同的产品，从而增加查找案例的机会，从而可以在没有可怕数字溢出的情况下计算操作：

((a - d) * b) - (d * (c - b))
((b - c) * a) - (c * (d - a))
((a - c) * b) - (c * (d - b))
((b - d) * c) - (b * (c - a))
((a - d) * c) - (a * (c - b))
((b - c) * d) - (b * (d - a))
((a - c) * d) - (a * (d - b))

另请注意，这仍然是产品的差异，这意味着您可以递归地应用它们，直到找到有效的方式。例如：

    Starting with:
        (a * b) - (c * d)
    =>
    Using the transformation:
        ((a - d) * b) - (d * (c - b))
    =>
    By substitution:
        (e * b) - (d * f)
    =>
    Rinse an repeat:
        ((e - f) * b) - (f * (d - b))

当然，我们需要确保通过执行此操作不会遇到数字溢出。值得庆幸的是，还可以使用以下方法测试特定产品是否会导致数字溢出（实际上没有产品）：

        var max = MaxValue;
        var min = MinValue;
        if (a == 0 || b == 0)
        {
            return false;
        }
        else
        {
            var lim = a < 0 != b < 0 ? min : max;
            if ((a < 0 == b < 0) == a < 0)
            {
                return lim / a > b;
            }
            else
            {
                return lim / a < b;
            }
        }

此外，还可以使用以下方法测试特定差异是否会导致数字溢出（实际上没有差异）：

        var max = MaxValue;
        var min = MinValue;
        if (a < 0 == b < 0)
        {
            return true;
        }
        else
        {
            if (a < 0)
            {
                if (b > 0)
                {
                    return min + b < a;
                }
                else
                {
                    return min - b < a;
                }
            }
            else
            {
                if (b > 0)
                {
                    return max - b > a;
                }
                else
                {
                    return max + b > a;
                }
            }
        }

通过它可以从上面的八个中选择一个表达式，这样你就可以在没有数字溢出的情况下进行计算。

但是......有时这些都不起作用。并且似乎有些情况甚至连他们的组合都不起作用（即冲洗和重复不起作用）*。也许还有其他身份可以完成图片。

*：我确实尝试使用一些启发式方法来探索组合，并尝试随机探索，有可能我没有选择好的启发式方法而且我没有随机的“运气”。这就是我无法确定的原因。

我想我已经取得了一些进展......但就最初的问题而言，我最终都失败了。当我有更多时间时，我可能会回到这个问题......或者我可能只是玩电子游戏。

Answer 2

如果您的产品接近Int32的限制，您可以使用Int64。

Answer 3

我所知道的解决这类问题的标准方法是做人类用超过一位数的数字做的事情，这是我们用手指自然计数的极限。我们向carry号前进。

例如，假设数字计算器中数字的限制为256（2 ^ 8）。为了得到（243 * 244） - （242 * 245）的差异，我们需要将数字分解为

Label | Part 1 (shifted 2 right) | Part 2 (remainder)
a       2                           43
b       2                           44
c       2                           42
d       2                           45

您需要一个数组来存储结果的各个数字或字符串。我认为数组更快，但字符串更方便可见（用于调试）。

   (a*b)-(c*d)
=>   a1*b1 shift4 + a1*b2 shift2 + a2*b1 shift2 + a2*b2
   - c1*d1 shift4 + c1*d2 shift2 + c2*d1 shift2 + c2*d2
=> 987654321 (right-aligned string positioning)
  +    4xxxx
  +     88xx
  +     86xx
  +     1892
  -    4xxxx
  -     90xx
  -     84xx
  -     1890
  ==========
           2

一个天真的实现将独立地完成每个步骤，将每个数字推到位并在必要时将其向前推进。关于优化这些算法的文献可能很多，例如将其分解为每个2位数的数组插槽（因为您的数字限制256的寄存器可以轻松处理2个2位数字的添加）。

Answer 4

您可以使用BC Math Functions处理32位和32位上的大数字。 64位系统

大数字的例子

$a = "4543534543543534543543543543545";
$b = "9354354546546756765756765767676";
$c = "5654656565656556565654656565656";
$d = "4556565656546546546546546356435" ;


var_dump(calculate($a, $b, $c, $d));

输出

string '257010385579862137851193415136408786476450997824338960635377204776397393100227657735978132009487561885957134796870587800' (length=120)

使用的功能

function calculate($a, $b, $c, $d) 
{
    return bcmul(bcmul(bcmul(bcsub($a, $c),bcsub($a, $d)),bcsub($b, $c)),bcsub($b, $d));
}

Answer 5

在玩了一点之后，我发现了一个更简单的算法，遵循我原来的想法。它可能比组合乘法稍慢，因为它需要真正的乘法和除法而不仅仅是移位和加法，但到目前为止我还没有对抽象语言中的性能进行基准测试。

这个想法是以下重写ab-cd =（a'+ q * d）b-cd = a'b-（c-qb）d = a'b-c'd

如果您将ab-cd命名为＆gt; b和c＆gt; d，算法似乎转换速度最快，即减少最大数量并最大化q。

q=(int)floor((a>c)? a/d : c/b);
a -= q*d;
c -= q*b;

现在重新排序并重新开始。只要所有数字足够小以便安全乘法，任何数字都小于2甚至是负数，你就可以完成，或者你找到两边任何数字的相同值。

大整数乘积差分算法

5 个答案:

警告