Сколько цифр в этой основе?

Вот решение в bash:

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


% digits 10000000000 42
7

Я думаю, что единственный способ устранить ошибку округления без возникновения других ошибок - это использовать или реализовать целочисленные логарифмы.

Проблемы с округлением с плавающей запятой.

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 (значение, основание) позволит избежать этих ошибки округления.

Похоже, формула мне подходит:

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

Так что это определенно просто ошибка округления.

Может быть полезно включить функцию округления (например, + 0,5) в ваш код где-нибудь: вполне вероятно, что деление дает (например) 2,99989787, к которому добавляется 1,0, что дает 3,99989787 и когда это преобразовывается в int , это дает 3.

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

Как отмечали другие, у вас есть ошибка округления, но предлагаемые решения просто перемещают опасную зону или делают ее меньше, они не устраняют ее. Если ваши числа являются целыми числами, вы можете проверить - с помощью целочисленной арифметики - что одна степень основания меньше или равна вашему числу, а следующая - над ним (первая степень - это число цифр). Но если вы используете арифметику с плавающей запятой где-либо в цепочке, вы будете уязвимы для ошибок (если ваша база не является степенью двойки, а может быть, даже тогда).

РЕДАКТИРОВАТЬ:
Вот грубое, но эффективное решение в целочисленных арифметика. Если ваши целочисленные классы могут содержать числа размером с основание * число, это даст правильный ответ.

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

Вам нужен потолок (= наименьшее целое число, не большее чем) log _b (n + 1), а не то, что вы вычисляете прямо сейчас, floor (1 + log _b (n)).

Вы можете попробовать:

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

Поскольку ваша формула верна (я только что попробовал), я думаю, что это ошибка округления в вашем делении, из-за которой число будет чуть меньше целого числа, которым оно должно быть. Поэтому, когда вы выполняете усечение до целого числа, вы теряете 1. Попробуйте добавить к окончательному значению дополнительные 0,5 (так что усечение будет фактически круглой операцией).

Количество цифр числа в заданной базе

Подойдет любой из следующих вариантов:

>>> 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 , которое является наименьшим числом с d цифрами в базе b. . То есть те числа, которые записываются 10 ... 0 в базе b . Обратите внимание, что ввод 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;
}

Используя вашу формулу,

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

проблема заключается в точности вычисления логарифма. Использование

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

должно решить эту проблему. Это не совсем то же самое, что

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

, потому что это дает ответ 3 для n = 8 b = 2, и не то же самое, что и

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

, потому что это дает ответ 4 для n = 7 b = 2 (при вычислении до полной точности).

На самом деле я получаю любопытные результаты реализации и компиляции первой формы с помощью 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 ).