是否可以通过使用纯位移、加法、减法和也许乘法来将无符号整数除以 10？使用资源非常有限且划分速度较慢的处理器。
【问题讨论】：
标签： math bit micro-optimization low-level integer-division
除法就是减法，所以是的。右移 1（除以 2）。现在从结果中减去 5，计算减法的次数，直到值小于 5。结果是减法的次数。哦，除法可能会更快。
如果除法器中的逻辑尚未为您执行此操作，则右移然后使用正常除法除以 5 的混合策略可能会提高性能。
【讨论】：
当然可以，如果您可以忍受一些精度损失。如果您知道输入值的值范围，则可以得出一个位移位和一个精确的乘法。 一些示例如何除以 10、60，... 就像在此博客中描述的一样，可以格式化 time the fastest way。
temp = (ms * 205) >> 11; // 205/2048 is nearly the same as /10
【讨论】：
(ms * 205) 可能会溢出。
编者注：这不是实际上编译器所做的，gives the wrong answer 用于以 9 结尾的大正整数，以 div10(1073741829) = 107374183 而不是 107374182 开头。不过，这对于较小的输入是准确的，这对于某些用途可能就足够了。
编译器（包括 MSVC）确实对常数除数使用定点乘法逆运算，但它们使用不同的魔法常数并对高半结果进行移位以获得所有可能输入的精确结果，与 C 抽象机的结果相匹配需要。算法见Granlund & Montgomery's paper。
请参阅Why does GCC use multiplication by a strange number in implementing integer division?，了解实际的 x86 asm gcc、clang、MSVC、ICC 和其他现代编译器的示例。
它甚至比编译器使用的乘法+右移精确除法还要快。
您可以使用乘法结果的高半部分除以小的整数常数。假设是32位机器（代码可以做相应调整）：
int32_t div10(int32_t dividend)
{
int64_t invDivisor = 0x1999999A;
return (int32_t) ((invDivisor * dividend) >> 32);
}
这里的情况是，我们乘以 1/10 * 2^32 的近似值，然后删除 2^32。这种方法可以适应不同的除数和不同的位宽。
这对 ia32 架构非常有效，因为它的 IMUL 指令会将 64 位乘积放入 edx:eax，而 edx 值将是想要的值。即（假设在 eax 中传递除数，在 eax 中返回商）
div10 proc
mov edx,1999999Ah ; load 1/10 * 2^32
imul eax ; edx:eax = dividend / 10 * 2 ^32
mov eax,edx ; eax = dividend / 10
ret
endp
即使在具有较慢乘法指令的机器上，这也会比软件甚至硬件除法更快。
【讨论】：
4294967219 / 10 = 429496721，但 4294967219 * div >> 32 = 429496722 对于更大的除数，签名版本也将不准确。
x/10 编译为 a fixed-point multiplicative inverse（并编写额外的代码来处理带符号除法的负输入），以便为所有可能的 32 位输入提供正确答案.对于无符号除以 10，MSVC（和其他编译器）（godbolt.org/g/aAq7jx）将乘以 0xcccccccd，并将高半部分右移 3。
虽然到目前为止给出的答案与实际问题相符，但与标题不符。所以这里有一个深受Hacker's Delight 启发的解决方案，它真正只使用位移位。
unsigned divu10(unsigned n) {
unsigned q, r;
q = (n >> 1) + (n >> 2);
q = q + (q >> 4);
q = q + (q >> 8);
q = q + (q >> 16);
q = q >> 3;
r = n - (((q << 2) + q) << 1);
return q + (r > 9);
}
我认为这是缺少乘法指令的架构的最佳解决方案。
【讨论】：
在一次只能移动一个位置的架构上，与 2 乘以 10 的递减幂进行一系列明确的比较可能比黑客喜欢的解决方案更有效。假设一个 16 位的红利：
uint16_t div10(uint16_t dividend) {
uint16_t quotient = 0;
#define div10_step(n) \
do { if (dividend >= (n*10)) { quotient += n; dividend -= n*10; } } while (0)
div10_step(0x1000);
div10_step(0x0800);
div10_step(0x0400);
div10_step(0x0200);
div10_step(0x0100);
div10_step(0x0080);
div10_step(0x0040);
div10_step(0x0020);
div10_step(0x0010);
div10_step(0x0008);
div10_step(0x0004);
div10_step(0x0002);
div10_step(0x0001);
#undef div10_step
if (dividend >= 5) ++quotient; // round the result (optional)
return quotient;
}
【讨论】：
n*10 仍然很便宜：(n<<3) + (n<<1)。这些小位移的答案可能对具有缓慢或不存在硬件乘法且仅位移 1 的机器有用。否则，定点逆对于编译时常数除数要好得多（就像现代编译器对 @987654324 所做的那样@)。
考虑到 Kuba Ober 的回应，还有一个与此相同的人。 它使用结果的迭代近似，但我不希望有任何令人惊讶的表现。
假设我们必须找到x，其中x = v / 10。
我们将使用逆运算v = x * 10，因为它有一个很好的属性，当x = a + b，然后x * 10 = a * 10 + b * 10。
让我们使用x 作为变量，保持迄今为止结果的最佳近似值。当搜索结束时，x 将保留结果。我们将设置x 的每一位b 从最重要到最不重要，一个接一个，最后将(x + b) * 10 与v 进行比较。如果它小于或等于v，则b 位在x 中设置。为了测试下一位，我们只需将 b 向右移动一个位置（除以二）。
我们可以通过在其他变量中保存x * 10 和b * 10 来避免乘以10。
这会产生以下算法，将v 除以 10。
uin16_t x = 0, x10 = 0, b = 0x1000, b10 = 0xA000;
while (b != 0) {
uint16_t t = x10 + b10;
if (t <= v) {
x10 = t;
x |= b;
}
b10 >>= 1;
b >>= 1;
}
// x = v / 10
编辑：为了得到 Kuba Ober 的算法，它避免了变量 x10 的需要，我们可以从 v 和 v10 中减去 b10。在这种情况下，x10 不再需要。算法变成了
uin16_t x = 0, b = 0x1000, b10 = 0xA000;
while (b != 0) {
if (b10 <= v) {
v -= b10;
x |= b;
}
b10 >>= 1;
b >>= 1;
}
// x = v / 10
循环可以展开，b 和b10 的不同值可以预先计算为常量。
【讨论】：
b10 <= v 的测试只是检查所说的倍数是否为1。无论如何，这就是我几年前为计算机系统架构课程教授长除法的方式。你在学校学了什么十进制长除法？
为了扩展 Alois 的答案，我们可以扩展建议的 y = (x * 205) >> 11 以获得更多倍数/班次：
y = (ms * 1) >> 3 // first error 8
y = (ms * 2) >> 4 // 8
y = (ms * 4) >> 5 // 8
y = (ms * 7) >> 6 // 19
y = (ms * 13) >> 7 // 69
y = (ms * 26) >> 8 // 69
y = (ms * 52) >> 9 // 69
y = (ms * 103) >> 10 // 179
y = (ms * 205) >> 11 // 1029
y = (ms * 410) >> 12 // 1029
y = (ms * 820) >> 13 // 1029
y = (ms * 1639) >> 14 // 2739
y = (ms * 3277) >> 15 // 16389
y = (ms * 6554) >> 16 // 16389
y = (ms * 13108) >> 17 // 16389
y = (ms * 26215) >> 18 // 43699
y = (ms * 52429) >> 19 // 262149
y = (ms * 104858) >> 20 // 262149
y = (ms * 209716) >> 21 // 262149
y = (ms * 419431) >> 22 // 699059
y = (ms * 838861) >> 23 // 4194309
y = (ms * 1677722) >> 24 // 4194309
y = (ms * 3355444) >> 25 // 4194309
y = (ms * 6710887) >> 26 // 11184819
y = (ms * 13421773) >> 27 // 67108869
每一行都是一个单独的、独立的计算，您将在注释中显示的值处看到您的第一个“错误”/不正确结果。对于给定的误差值，您通常最好采用最小的移位，因为这将最大限度地减少在计算中存储中间值所需的额外位，例如(x * 13) >> 7 比 (x * 52) >> 9 “更好”，因为它需要的开销少了两位，而两者都开始给出高于 68 的错误答案。
如果您想计算更多这些，可以使用以下 (Python) 代码：
def mul_from_shift(shift):
mid = 2**shift + 5.
return int(round(mid / 10.))
当这个近似值开始出错时，我做了很明显的计算：
def first_err(mul, shift):
i = 1
while True:
y = (i * mul) >> shift
if y != i // 10:
return i
i += 1
（请注意，// 用于“整数”除法，即它向零截断/舍入）
错误中出现“3/1”模式的原因（即 8 次重复 3 次后跟 9 次）似乎是由于碱基的变化，即 log2(10) 约为 3.32。如果我们绘制错误，我们会得到以下结果：
相对误差由以下公式给出：mul_from_shift(shift) / (1<<shift) - 0.1
【讨论】：
ms 是什么？
ms 的第一个值会给出不正确的答案，即参数适用于任何值
elemakil 的 cmets 代码可以在这里找到：https://doc.lagout.org/security/Hackers%20Delight.pdf 第 233 页。“无符号除以 10 [和 11。]”
【讨论】：
我在 AVR 汇编中设计了一种新方法，仅使用 lsr/ror 和 sub/sbc。它除以 8，然后减去除以 64 和 128 的数字，然后减去第 1,024 和第 2,048，依此类推。工作非常可靠（包括精确舍入）和快速（1 MHz 时为 370 微秒）。 16位数字的源代码在这里： http://www.avr-asm-tutorial.net/avr_en/beginner/DIV10/div10_16rd.asm 获取此源代码的页面在这里： http://www.avr-asm-tutorial.net/avr_en/beginner/DIV10/DIV10.html 我希望它有所帮助，即使这个问题已经存在十年了。 brgs, gsc
【讨论】：