Question

问题是导出一个公式，用于确定给定十进制数在给定基数中可能具有的位数。

例如：十进制数100006可分别由基数2,3,4,5,6,7,8中的17,11,9,8,7,6,8位数表示。

到目前为止我得出的公式是这样的：（log10（num）/ log10（base））+ 1。

在C / C ++中，我用这个公式来计算上面给出的结果。

long long int size = ((double)log10(num) / (double)log10(base)) + 1.0;

但遗憾的是，在某些情况下，公式并没有给出正确答案，例如：

Number 8 in  base 2 : 1,0,0,0
Number of digits: 4
Formula returned: 3

Number 64 in  base 2 : 1,0,0,0,0,0,0
Number of digits: 7
Formula returned: 6

Number 64 in  base 4 : 1,0,0,0
Number of digits: 4
Formula returned: 3

Number 125 in  base 5 : 1,0,0,0
Number of digits: 4
Formula returned: 3

Number 128 in  base 2 : 1,0,0,0,0,0,0,0
Number of digits: 8
Formula returned: 7

Number 216 in  base 6 : 1,0,0,0
Number of digits: 4
Formula returned: 3

Number 243 in  base 3 : 1,0,0,0,0,0
Number of digits: 6
Formula returned: 5

Number 343 in  base 7 : 1,0,0,0
Number of digits: 4
Formula returned: 3

所以错误是1位数。我只是希望有人帮我纠正公式，以便它适用于所有可能的情况。

编辑：根据输入规范，我必须处理像10000000000这样的情况，即10 ^ 10，我不认为C / C ++中的log10（）可以处理这种情况吗？因此，高度赞赏这个问题的任何其他程序/公式。

Answer 1

编译器设置中存在快速浮动操作。您需要精确的浮动操作。问题是log10（8）/ log10（2）在数学中总是3。但可能是你的结果是2.99999，用于示例。这是坏的。您必须添加小添加剂，但不能添加0.5。它应该是大约.00001或类似的东西。

几乎是真正的公式：

int size = static_cast<int>((log10((double)num) / log10((double)base)) + 1.00000001);

真正的解决方案

您应该检查公式的结果。 Compexity为O(log log n)或O(log result)！

int fast_power(int base, int s)
{
    int res = 1;
    while (s) {
        if (s%2) {
            res*=base;
            s--;
        } else {
            s/=2;
            base*=base;
        }
    }
    return res;
}

int digits_size(int n, int base)
{
    int s = int(log10(1.0*n)/log10(1.0*base)) + 1;
    return fast_power(base, s) > n ? s : s+1;
}

此检查优于使用base次乘法的强力测试。

Answer 2

以下任何一种都可以使用：

>>> from math import *
>>> def digits(n, b=10):
...     return int(1 + floor(log(n, b))) if n else 1
...
>>> def digits(n, b=10):
...     return int(ceil(log(n + 1, b))) if n else 1
...

第一个版本在mathpath.org解释。在第二个版本中，+ 1是产生 n 的正确答案所必需的， n 是 d 位于 b 中的最小数字 / em>的。也就是说，那些在 b 中写入 10 ... 0 的数字。请注意，必须将输入0视为特殊情况。

十进制示例：

>>> digits(1) 1 >>> digits(9) 1 >>> digits(10) 2 >>> digits(99) 2 >>> digits(100) 3

二进制：

>>> digits(1, 2) 1 >>> digits(2, 2) 2 >>> digits(3, 2) 2 >>> digits(4, 2) 3 >>> digits(1027, 2) 11

编辑：OP声明log解决方案可能不适用于大型输入。我不知道这一点，但如果是这样，下面的代码不应该分解，因为它只使用整数运算（这次是在C中）：

unsigned int digits(unsigned long long n, unsigned long long b) { unsigned int d = 0; while (d++, n /= b); return d; }

此代码可能效率较低。并且是，它是为最大的默默无闻点而写的。它只是使用观察结果，即每个数字至少有一个数字，并且b的每个除数不产生0意味着存在一个额外的数字。更具可读性的版本如下：

unsigned int digits(unsigned long long n, unsigned long long b) { unsigned int d = 1; while (n /= b) { d++; } return d; }

Answer 3

Number of digits of a numeral in a given base

Answer 4

由于你的公式是正确的（我只是尝试过），我认为它是你的除法中的舍入误差，导致数字略小于它应该的整数值。因此，当您截断为整数时，您将失去1.尝试在最终值中添加额外的0.5（以便截断实际上是一个循环操作）。

Answer 5

你想要的是天花板（=不大于的最小整数）log _b（n + 1），而不是你现在正在计算的楼层（1 + log _{b （N））。}

您可以尝试：

int digits = (int) ceil( log((double)(n+1)) / log((double)base) );

Answer 6

使用您的公式，

log(8)/log(2) + 1 = 4

问题在于对数计算的精度。使用

ceil(log(n+1)/log(b))

应该解决这个问题。这与

不完全相同

ceil(log(n)/log(b))

因为这给出了n = 8 b = 2的答案3，也没有与

相同

log(n+1)/log(b) + 1

因为这给出了n = 7 b = 2的答案4（当计算为全精度时）。

我实际上得到了一些好奇的结果，用g ++编译第一个表单：

double n = double(atoi(argv[1]));
double b = double(atoi(argv[2]));
int i = int(std::log(n)/std::log(b) + 1.0);

失败（IE给出答案3），而

double v = std::log(n)/std::log(b) + 1.0;
int i = int(v);

成功（给出答案4）。再看一下我认为是第三种形式

ceil(log(n+0.5)/log(b))

会更稳定，因为它避免了“关键”情况，当n（或第二种形式的n + 1）是b的整数幂时（对于n的整数值）。

Answer 7

正如其他人所指出的那样，你有舍入误差，但建议的解决方案只是移动危险区域或使其变小，它们不会消除它。如果你的数字是整数，那么你可以验证 - 使用整数算术 - 基数的一个幂小于或等于你的数字，而下一个数字高于它（第一个权力是位数）。但是如果你在链中的任何地方使用浮点运算那么你就容易出错（除非你的基数是2的幂，甚至可能是那么）。

修改：
这是整数算术中粗略但有效的解决方案。如果你的整数类可以保存与base * number一样大的数字，那么这将给出正确的答案。

  size = 0, k = 1;
  while(k<=num)
    {
      k *= base;
      size += 1;
    }

Answer 8

将舍入函数（例如+ 0.5）包装到代码中的某个地方可能是有益的：很可能该分区正在生成（例如）2.99989787，其中添加了1.0，给出了3.99989787以及何时将其转换为int ，它给出了3。

Answer 9

看起来这个公式对我来说是正确的：

Number 8 in  base 2 : 1,0,0,0
Number of digits: 4
Formula returned: 3

log10(8) = 0.903089
log10(2) = 0.301029

Division => 3

+1 => 4

所以这肯定只是一个舍入错误。

Answer 10

浮点舍入问题。

log10(216) / log10(6) =  2.9999999999999996

但是你不能按建议添加0.5，因为它不适用于以下

log10(1295) = log10(6) = 3.9995691928566091   //    5, 5, 5, 5
log10(1296) = log10(6) = 4.0                  // 1, 0, 0, 0, 0

使用log（value，base）函数可能会避免这些舍入错误。

Answer 11

我认为在不产生其他错误的情况下消除舍入错误的唯一方法是使用或实现整数对数。

Answer 12

以下是bash的解决方案：

% digits() { echo $1 $2  opq | dc | sed 's/ .//g;s/.//' | wc -c; }


% digits 10000000000 42
7

Answer 13

static int numInBase(int num, int theBase)
{
   if(num == 0) return 0;
   if (num == theBase) return 1;
   return 1 + numInBase(num/theBase,theBase);
}

这个基地有多少位数？

13 个答案: