blocks|key|480418|text|您可以使用“分而治之”的方式，使用标准库(通常在该工作中非常有效)将部分转换为字符串。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|480419|因此，与其在每次迭代中除以10，您还可以将代码块除以10**15，并让库将这些块转换为15位数字字符串。最多三步之后，你就完蛋了。|480420|当然，您必须对零填充做一些字符串操作。但是也许您的库在这里也可以帮助您，如果您对所有较低的部分使用%25015d零填充格式，对于最高的非零部分使用非填充%25d格式。|offset|length|style|CODE|480421|entityMap^0|0|0|1D|5|22|2|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@$F|O|G|P|H|I]|$F|Q|G|R|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

You can use divide-and-conquer in such a way that the parts can be converted to string using your standard library (which will typically be quite efficient at that job).

So instead of dividing by 10 in every iteration, you can e.g. divide by 10**15, and have your library convert the chunks to 15-digit strings. After at most three steps, you're finished.

Of course you have to do some string manipulation regarding the zero-padding. But maybe your library can help you here as well, if you use something like a <code>%015d</code> zero-padding format for all the lower parts, and for the highest non-zero part use a non-padding <code>%d</code> format.

blocks|key|2131191|text|您可以尝试您的运气与一个人为的方法，如下所示。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2131192|数字可以用二进制编码的十进制表示来表示.在这种表示法中，每个十进制数字都存储在4位上，当执行加法时，如果两位数之和超过9，则添加6并向左进位。|2131193|如果您预先存储了所有2的幂的BCD表示，那么它最多需要128个加法来执行转换。您可以节省一点，因为对于低功耗，您不需要全长度加法(39位数)。|2131194|但这听起来像是很多行动。您可以通过将几个BCD数字打包成一个整数来“并行”它们:+32位上的整数加法相当于同时添加8位BCD数字。但我们的运货有问题。为了解决这一问题，我们可以将数字存储在5位而不是4位上，而携带将出现在第5位中。然后，我们可以通过掩蔽获得携带，将它们添加到下一个数字(移位左5)，并调整数字和(乘以10并减去)。|2131195|++2+3+4+5+6
%2B+7+6+9+2+1
=+9+913+7+7|code-block|syntax|javascript|2131196|携带：|2131197|+0-0-1-0-0|2131198|调整：|2131199|++9+913+7+7
-0000010000
=+9+9+3+7+7|2131200|实际上，你必须处理可能的级联携带，所以和将涉及两个加数，并进行，并生成一个和并执行。|2131201|32位操作允许您一次处理6位数字(3+9位位7轮)，64位操作12位数(4轮39位数)。|2131202|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|16|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|18|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

You may try your luck with a contrived method, as follows.

Numbers can be represented using the Binary-Coded Decimal representation. In this representation, every decimal digit is stored on 4 bits, and when performing an addition, if the sum of two digits exceeds 9, you add 6 and carry to the left.

If you have pre-stored the BCD representation of all powers of 2, then it takes at most 128 additions to perform the conversion. You can spare a little by the fact that for low powers, you don't need full length addition (39 digits).

But this sounds as a lot of operations. You can "parallelize" them by packing several BCD digits in an single integer: an integer addition on 32 bits is equivalent to 8 simultaneaous BCD digit additions. But we have a problem with the carries. To work around, we can store the digits on 5 bits instead of 4, and the carries will appear in the fifth bit. Then we can obtain the carries by masking, add them to the next digits (shift left 5), and adjust the digit sums (multiply by 10 and subtract).

<pre><code> 2 3 4 5 6
+ 7 6 9 2 1
= 9 913 7 7
</code></pre>

Carries:

<pre><code> 0-0-1-0-0
</code></pre>

Adjustments:

<pre><code> 9 913 7 7
-0000010000
= 9 9 3 7 7
</code></pre>

Actually, you have to handle possible cascaded carries, so the sum will involve the two addends and carries in, and generate a sum and carries out.

32 bits operations allow you to process 6 digits at a time (7 rounds for 39 digits), and 64 bits operations, 12 digits (4 rounds for 39 digits).

blocks|key|480453|text|如果只想将数字编码为字符串，则为。
使用快速的十六进制数字，因为您可以通过位操作来转换所有数字.此外，使用Base64，编码也是可行的，只需通过位操作%2B转换表即可完成。Booth表示只能在O(n)中用小整数表示，其中n是打印数字的计数。|type|ordered-list-item|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|480454|如果你需要base10
然后打印一个十六进制字符串，并将其转换为十进制字符串，如下所示：|480455|-+[str\_hex2dec](https://stackoverflow.com/a/18231860/2521214)|code-block|syntax|javascript|480456|这比#1慢得多，但在小整数算法上仍然可行.您也可以使用dec2hex进行反向操作(从字符串输入数字).|unstyled|480457|对于bigint库，还有另一种简化字符串/整数转换的方法：|480458|BCD
二进制编码十进制..。打印为十六进制的数字是十进制数字。所以每个数字都有4位。这浪费了一些内存，但许多CPU都支持BCD，并且可以对这些整数进行本机操作。|480459|10%5En+碱
有时使用基本10%5En而不是2%5Em，而
10%5En+<=+2%5Em
m是原子整数的位宽，n+i是适合它内部的十位数。
例如，如果您的原子无符号整数是16位，那么它可以在基本的65536中保持2值。如果您使用基本的10000，您可以打印每个原子，从左开始使用零值作为十进数，然后将所有这样的打印叠加在一起。
这也浪费了一些内存，但通常不会浪费太多(如果位宽被合理选择)，您可以对整数使用标准指令。只有传送带才会有一点变化。
例如，对于32位单词：
2%5E32+=+4294967296+>=+1000000000
所以我们每32位浪费log2(4.2949...)+=+~2.1比特。这比BCD+log2(16/10)*(32/4)=+~5.42比特要好得多，而且通常更好地使用更高的比特宽度。|480460|entityMap^0|D|3|N|4|1H|7|2M|4|30|1|0|0|B|I|4|0|0|2|2|R|7|0|2|6|0|0|3|0|0|4|5|1|0|4|D|4|K|3|12|1|1C|1|2J|5|2R|1|32|5|7H|M|8C|P|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|D]|$9|17|A|18|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|E|@]|F|$]]|$1|I|3|J|5|K|7|1E|8|@]|E|@]|F|$L|M]]|$1|N|3|O|5|P|7|1F|8|@$9|1G|A|1H|B|C]|$9|1I|A|1J|B|D]]|E|@]|F|$]]|$1|Q|3|R|5|P|7|1K|8|@$9|1L|A|1M|B|C]]|E|@]|F|$]]|$1|S|3|T|5|6|7|1N|8|@$9|1O|A|1P|B|C]]|E|@]|F|$]]|$1|U|3|V|5|6|7|1Q|8|@$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]|$9|1V|A|1W|B|D]|$9|1X|A|1Y|B|D]|$9|1Z|A|20|B|D]|$9|21|A|22|B|D]|$9|23|A|24|B|D]|$9|25|A|26|B|D]|$9|27|A|28|B|D]|$9|29|A|2A|B|D]|$9|2B|A|2C|B|D]|$9|2D|A|2E|B|D]]|E|@]|F|$]]|$1|W|3|-4|5|P|7|2F|8|@]|E|@]|F|$]]]|X|$]]

<ol>
<li>if you want to just encode your numbers as string

use hex numbers that is fast as you can cast all the digits just by bit operations ... also using Base64 encoding is doable just by bit operations + the translation table. Booth representations can be done on small int arithmetics only in <code>O(n)</code> where <code>n</code> is the count of printed digits. </li>
<li>If you need base10

then print a hex string and convert it to decimal on strings like this:

<ul>
<li><a href="https://stackoverflow.com/a/18231860/2521214">str_hex2dec</a></li>
</ul>

this is much slower than #1 but still doable on small int arithmetics ... You can do this also in reverse (input number from string) by using <code>dec2hex</code> ...</li>
</ol>

For bigint libs there are also another ways of easing up the string/integer conversions:

<ol>
<li>BCD

binary coded decimal ... the number printed as hex is the decadic number. So each digit has 4 bits. This waste some memory but many CPU's has BCD support and can do operations on such integers natively.</li>
<li>Base <code>10^n</code>

sometimes is used base <code>10^n</code> instead of <code>2^m</code> while 

<pre><code>10^n &lt;= 2^m
</code></pre>

The <code>m</code> is bitwidth of your atomic integer and <code>n</code> i snumber of decadic digits that fits inside it.

for example if your atomic unsigned integer is 16 bit it can hold up to <code>65536</code> values in base <code>2</code>. If you use base <code>10000</code> instead you can print each atom asa decadic number with zeropad from left and simply stack all such prints together.

This also waste some memory but usually not too much (if the bitwidth is reasonably selected) and you can use standard instructions on the integers. Only the Carry propagation will change a bit...

for example for 32bit words:

<pre><code>2^32 = 4294967296 &gt;= 1000000000
</code></pre>

so we wasted <code>log2(4.2949...) = ~2.1</code> bits per each 32 bits. This is much better than BCD <code>log2(16/10)*(32/4)= ~5.42</code> bits And usually even better with higher bit widths</li>
</ol>

I have looked for a while to find an algorithm which converts integers to string. My requirement is to do this manually as I am using my own large number type. I have <code>+ - * /(with remainder)</code> defined, but need to find a way to print a single number from a double int (high and low, if int is 64bits, 128bits total). 

I have seen some answers such as

<a href="https://stackoverflow.com/questions/3982320/convert-integer-to-string-without-access-to-libraries">Convert integer to string without access to libraries</a>

<a href="https://stackoverflow.com/questions/37632165/converting-a-big-integer-to-decimal-string">Converting a big integer to decimal string</a>

but was wondering if a faster algorithm was possible. I am open to working with bits directly(e.g. base2 to base10-string - I could not find such an algorithm however), but I was just hoping to avoid repeated division by 10 for numbers possibly as large as 2^128.

Algorithm for Converting large integer to string without modulo base

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我已经找了一段时间来寻找一个将整数转换为字符串的算法。我的要求是手动这样做，因为我正在使用我自己的大数字类型。我已经定义了+ - * /(with remainder)，但是需要找到一种方法从一个双int (高和低，如果int是64位，128位总计)打印一个数字。我看到了一些答案，例如但他想知道一个更快的算法是否有可能...

问不带模基的大整数转换为字符串的算法
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问不带模基的大整数转换为字符串的算法EN