Question

下午好，

如何将一个二进制字符串转换为十进制字符串，其字符数多于语言最大整数类型中的位数？换句话说，假设你有字符串

111001101001110100100(...)1001001111011100100

并且你不能先将它转换为整数，你将如何在基数10中写它？

非常感谢。

Answer 1

您可以使用以下算法：

// X is the input
while ( X != "0" )
  compute X' and R such that X = 10 * X' + R  (Euclidean division, see below)
  output R    // least significant decimal digit first
  X = X'

X的10的欧几里德除法计算如下：

R = 0  // remainder in 0..9
X' = ""
for (b in bits of X)  // msb to lsb
  R = 2*R + b
  if R >= 10
    X' += "1"
    R -= 10
  else
    X' += "0"

Remove leading "0" from X'
The remainder is R in 0..9

Answer 2

10不是2的幂，因此二进制表示的任何位置的数字可能影响十进制表示中的最低有效位。您必须存储整个十进制表示来转换位串。

如果找不到适合您语言的长十进制数据类/库，可以自行构建，这并不难。只需存储足够的小数位，例如作为一个列表，并做数学。您只需要为此任务添加，因此它更容易实现。

Answer 3

我使用任意精确数字（bignum）库，如GMP。

GMP有一个“gmp_scanf”功能，可以满足您的要求。

Answer 4

在基数10中编写自己的算术。只需要添加。 Python中的示例实现：

from math import log, ceil

def add(a, b):
    """Add b to a in decimal representation."""
    carry = 0
    for i in range(len(b)):
        carry, a[i] = divmod(a[i] + b[i] + carry, 10)
    while carry:
        i += 1
        carry, a[i] = divmod(a[i] + carry, 10)

# an example string
s = bin(3 ** 120)[2:]

# reserve enough decimal digits
res = [0] * int(ceil(len(s) * log(2) / log(10)))

# convert
for c in s:
    add(res, res)
    if c == "1":
        add(res, [1])

#print output
print str.join("", map(str, reversed(res)))

这使用整数列表来表示基数10中的数字。列表项对应于基数10的数字。索引0处的项目对应于1，索引1处的项目对应于数字，依此类推。

Answer 5

假设您没有任意精确的数学包，但您确实拥有一组基本的字符串操作例程，您可以执行以下操作：

构造2的幂列表，然后反向解构二进制字符串通过为字符串中的每个“1”位添加适当的2的幂来一次订购一个位。

你需要做的唯一的任意精度算术函数是加法，这是公平的使用长手算法易于实现。

假设您确实实现了一个名为的任意算术添加函数： ADD将包含十进制数的2个字符串作为输入并返回小数和作为一个字符串。类似的东西：

  SumString = ADD(DecimalString1, DecimalString2)

SumString是一个十进制数字字符串，表示DecimalString1和DecimalString2的总和。

步骤1：构建2个列表的权力，如下所示：

  BitString is string           /* String of '1' and '0' values... */
  BitString = '111001101001110100100(...)1001001111011100100' /* or whatever... */

  PowerOf2 is array of string  /* Array of strings containing powers of 2 */
  PowerOf2[1] = '1'            /* 2**0 to get things started... */
  /* Build as many powers of 2 as there are 'bits' in the input string */   
  for i from 2 to length(BitString) by +1  
    PowerOf2[i] = ADD(PowerOf2[i-1], PowerOf2[i-1])  
    end

注意：上面假设数组/字符串是基于1的（而不是基于零）。

步骤2：解构BitString，随时累积总和：

  DecimalValue is string        /* Decimal value of BitString */
  BitString is string           /* Your input set of bits as a string... */
  ReverseBitString is string    /* Reversed input */

  DecimalValue = ''             /* Result */  
  BitString = '111001101001110100100(...)1001001111011100100' /* or whatever... */  
  ReverseBitString = reverse(BitString) /* Reverse so we process lsb to msb */  

  for i from 1 to length(ReverseBitString) by +1  
     if substr(ReverseBitString, i, 1) == '1' then  /* Bit at position i */  
        DecimalValue = ADD(DecimalValue, PowerOf2[i])  
        end   
     end    

  if DecimalValue = '' then DecimalValue = '0' /* bit string was all zero */   
  Display DecimalValue /* This is the result */

如何构建任意精度ADD函数？它类似于：

  function ADD (DecVal1 is string, DecVal2 is string) return string  
     SumVal is string   
     Rev1 is string  
     Rev2 is string      
     DigitSum is integer
     CarryDigit is integer

     SumVal = ''               /* Result so far... */
     Rev1 = reverse(DecVal1)   /* Reverse digit order */
     Rev2 = reverse(DecVal2)   /* Reverse digit order */

     /* Pad shorter reversed sting with trailing zeros... */
     if length(Rev1) > length(Rev2) then
        Rev2 = concat(Rev2, copies(length(Rev1) - length(Rev2), '0')
        end
     else
        Rev1 = concat(Rev1, copies(length(Rev2) - length(Rev1), '0')
        end

     /* Sum by digit position, least to most significant */
     CarryDigit = 0    
     for i from 1 to length(Rev1) by + 1
        DigitSum = CtoI(substr(Rev1, i, 1)) + CtoI(substr(Rev2, i, 1)) + CarryDigit
        if DigitSum > 9 then
           DigitSum = DigitSum - 10
           CarryDigit = 1
           end
        else
           CarryDigit = 0
           end 

        SumVal = concat(ItoC(DigitSum), SumVal)
        end

      if CarryDigit > 0 then
        SumVal = concat(ItoC(CarryDigit), SumVal)
        end

      return SumVal

假设内置字符串函数：

reverse（String）：以相反的顺序返回字符串
length（String）：返回给定字符串的长度
concat（String，String）：返回两个字符串的连接
substr（String，start，length）：从长度字符开始返回字符串的子串（基于1）
CtoI（String）：返回给定字符的十进制整数值（例如'1'= 1，'2'= 2，...）
ItoC（整数）：返回整数的十进制字符表示（例如，1 ='1'，2 ='2'，...）
copies（count，string）：返回字符串

二进制字符串到十进制字符串

5 个答案: