Как я могу подсчитать цифры в целых числах без строкового перевода?

Question

Я боюсь, что есть простой и очевидный ответ на этот вопрос. Мне нужно определить, сколько цифр имеет количество элементов, так что я могу заполнить каждый номер позиции с помощью минимума количество ведущих нулей, необходимых для поддержания выравнивания. Например, я не хочу, чтобы начальные нули, если общее число равно < 10, 1, если оно находится между 10 и 99 и т. Д.

Одним из решений было бы присвоить количество элементов строке и затем подсчитать символы. Тьфу! Есть ли способ лучше?

Редактировать: Я бы не подумал использовать common logarithm (я не знал, что такая вещь существует). Итак, не очевидно - мне - но определенно просто.

Answer 1

Это следует сделать это:

int length = (number ==0) ? 1 : (int)Math.log10(number) + 1; 

Answer 2

Одно из решений обеспечивается базой 10 логарифм, немного излишним.

Answer 3

Вы можете использовать время цикл, который, вероятно, будет быстрее, чем логарифм, потому что это использует только целочисленную арифметику:

int len = 0; 
while (n > 0) { 
    len++; 
    n /= 10; 
} 

Я оставляю это в качестве упражнения для читателя, чтобы настроить этот алгоритм для обработки нуля и отрицательные числа.

Answer 4

Вы можете прокручивать и удалять на 10, подсчитывать количество циклов;

int num = 423; 
int minimum = 1; 
while (num > 10) { 
    num = num/10; 
    minimum++; 
} 

Answer 5

int length = (int)Math.Log10(Math.Abs(number)) + 1; 

Вам может понадобиться для учета отрицательного знака ..

Answer 6

Если вы собираетесь раздуть число в .Net, то

num.ToString().PadLeft(10, '0') 

может делать то, что вы хотите ,

Answer 7

Поскольку число не содержит нулей, вы все равно конвертируете их. Я не уверен, почему вы так стараетесь избежать этого, чтобы найти длину, когда конечный результат должен быть строкой в ​​любом случае.

Answer 8

Хорошо, я не могу устоять: использовать /=:

#include <stdio.h> 

int 
main(){ 
     int num = 423; 
     int count = 1; 
     while(num /= 10) 
       count ++; 
     printf("Count: %d\n", count); 
     return 0; 
} 
534 $ gcc count.c && ./a.out 
Count: 3 
535 $ 

Answer 9

Более эффективное решение, чем повторного деления будет повторяться, если заявления с размножается ... например (Где п число, в которых количество цифр требуется)

unsigned int test = 1; 
unsigned int digits = 0; 
while (n >= test) 
{ 
    ++digits; 
    test *= 10; 
} 

Если есть какое-то разумное ограничение сверху на количество элементов (например, в 32-битном диапазоне беззнаковое число), то еще лучше путь к сравнить с элементами некоторого статического массива, например

// this covers the whole range of 32-bit unsigned values 
const unsigned int test[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 }; 

unsigned int digits = 10; 
while(n < test[digits]) --digits; 

Answer 10

Я бы разместил комментарий, но мой репутационный балл не предоставит мне это различие.

Все, что я хотел указать, было то, что хотя Log (10) очень изящный (читай: очень немного строк кода) решение, это, вероятно, самый больший процент для процессора.

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

Особенно, если вы собираетесь делать это для многих чисел ..