在C中查找整数的长度

Question

我想知道如何在 C 中找到整数的长度。

例如：

• 1 => 1
• 25 => 2
• 12512 => 5
• 0 => 1

等等。

如何在 C 中做到这一点？

Answer 1

解决方案

使用整数长度变化的限制，在小数的情况下它是10的幂，因此每次验证指定的整数没有超过限制时使用一个计数器。

使用math.h 依赖：

#include <math.h>

int count_digits_of_integer(unsigned int integer) {
    int count = 1;

    while(1) {
        int limit = pow(10, count);
        if(integer < limit) break;
        count++;

    }

    return count;
}

无依赖：

int int_pow(int base, int exponent) {
    int potency = base;

    for(int i = 1; i < exponent; i++) potency *= base;

    return potency;

}

int count_digits_of_integer(unsigned int integer) {
    int count = 1;
    
    while(1) {
        int limit = int_pow(10, count);
        if(integer < limit) break;
        count++;

    }
    
    return count;
}

实施

#include <stdio.h>

// Copy and paste the solution code here

int main() {
    
    printf("%i -> (%i digits)\n", 0, count_digits_of_integer(0));
    printf("%i -> (%i digits)\n", 12, count_digits_of_integer(12));
    printf("%i -> (%i digits)\n", 34569, count_digits_of_integer(34569));
    printf("%i -> (%i digits)\n", 1234, count_digits_of_integer(1234));
    printf("%i -> (%i digits)\n", 3980000, count_digits_of_integer(3980000));
    printf("%i -> (%i digits)\n", 100, count_digits_of_integer(100));
    printf("%i -> (%i digits)\n", 9, count_digits_of_integer(9));
    printf("%i -> (%i digits)\n", 385784, count_digits_of_integer(385784));
    
    return 0;
}

输出：

0 -> (1 digits)
12 -> (2 digits)
34569 -> (5 digits)
1234 -> (4 digits)
3980000 -> (7 digits)
100 -> (3 digits)
9 -> (1 digits)
385784 -> (6 digits)

Answer 2

对于简单的程序...

int num = 456, length=0 // or read value from the user to num
while(num>0){
    num=num/10;
    length++;
}

使用另一个变量来保留初始num 值。

Answer 3

// Variables 

long c = 2222882;
long b = c;
float x = 10;
int length = 0;

//Loop to know the length

    for(int i = 0; b != 0; i++)
    {
        b = (float) c / x;
        x = x*10;
        length++;
    }
//Print this one
    printf("%i", length);

Answer 4

你为什么不把你的整数转换成 String 并得到这样的长度：

int data = 123;
int data_len = String(data).length();

Answer 5

在这个问题中，我使用了一些算术解决方案。谢谢:)

int main(void)
{
    int n, x = 10, i = 1;
    scanf("%d", &n);
    while(n / x > 0)
    {
        x*=10;
        i++;
    }
    printf("the number contains %d digits\n", i);

    return 0;
}

Answer 6

请在一行代码中找到我的答案：

#include <stdio.h> int main(void){ int c = 12388884; printf("length of integer is: %d",printf("%d",c)); return 0; }

这是简单而聪明的！ 喜欢的话点个赞吧！

Answer 7

int returnIntLength(int value){
    int counter = 0;
    if(value < 0)
    {
        counter++;
        value = -value;
    }
    else if(value == 0)
        return 1;

    while(value > 0){
        value /= 10;
        counter++;
    }

    return counter;
}

我认为这种方法非常适合这项任务：

价值和答案：

• -50 -> 3 //它会计算 - 如果你不想计算，也可以作为一个字符 减去然后从第 5 行删除 counter++。

• 566666 -> 6

• 0 -> 1

• 505 -> 3

Answer 8

这适用于消极和积极的intigers

    int get_len(int n)
    {
        if(n == 0)
        return 1;

        if(n < 0)    
        {
           n = n * (-1); // if negative
        }

        return  log10(n) + 1;
    }

同样的逻辑也适用于循环

  int get_len(int n)
  {
       if(n == 0)
       return 1;

       int len = 0;
       if(n < 0)
       n = n * (-1);

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

       return len;
  }

Answer 9

int main(void){ 无符号整数 n，大小=0；

printf("get the int:");
scanf("%u",&n);

/*the magic*/
for(int i = 1; n >= i; i*=10){
    size++;
}

printf("the value is: %u \n", n);
printf("the size is: %u \n", size);

return 0;

}

Answer 10

更详细的方法是使用此函数。

int length(int n)
{
    bool stop;
    int nDigits = 0;
    int dividend = 1;
    do
    {
        stop = false;
        if (n > dividend)
        {
            nDigits = nDigits + 1;
            dividend = dividend * 10;
        }
        else {
            stop = true;
        }


    }
    while (stop == false);
    return nDigits;
}

Answer 11

如果您对快速且非常简单的解决方案感兴趣，以下可能是最快的（这取决于相关数字的概率分布）：

int lenHelper(unsigned x) {
    if (x >= 1000000000) return 10;
    if (x >= 100000000)  return 9;
    if (x >= 10000000)   return 8;
    if (x >= 1000000)    return 7;
    if (x >= 100000)     return 6;
    if (x >= 10000)      return 5;
    if (x >= 1000)       return 4;
    if (x >= 100)        return 3;
    if (x >= 10)         return 2;
    return 1;
}

int printLen(int x) {
    return x < 0 ? lenHelper(-x) + 1 : lenHelper(x);
}

虽然它可能不会因为最巧妙的解决方案而获奖，但理解起来很简单，执行起来也很简单 - 所以速度很快。

在使用 MSC 的 Q6600 上，我使用以下循环对此进行了基准测试：

int res = 0;
for(int i = -2000000000; i < 2000000000; i += 200) res += printLen(i);

此解决方案耗时 0.062 秒，Pete Kirkham 使用智能对数方法的第二快解决方案耗时 0.115 秒 - 几乎是两倍。但是，对于 10000 及以下的数字，智能日志更快。

以牺牲一些清晰度为代价，您可以更可靠地击败智能日志（至少在 Q6600 上）：

int lenHelper(unsigned x) { 
    // this is either a fun exercise in optimization 
    // or it's extremely premature optimization.
    if(x >= 100000) {
        if(x >= 10000000) {
            if(x >= 1000000000) return 10;
            if(x >= 100000000) return 9;
            return 8;
        }
        if(x >= 1000000) return 7;
        return 6;
    } else {
        if(x >= 1000) {
            if(x >= 10000) return 5;
            return 4;
        } else {
            if(x >= 100) return 3;
            if(x >= 10) return 2;
            return 1;
        }
    }
}

这个解决方案在大数字上仍然是 0.062 秒，而对于较小的数字会降到 0.09 秒左右 - 在这两种情况下都比智能日志方法更快。 （gcc 使代码更快；此解决方案为 0.052，智能日志方法为 0.09s）。

Answer 12

你可以用这个-

(data_type)log10(variable_name)+1

例如：

len = (int)log10(number)+1;

Answer 13

C:

为什么不直接取数字绝对值的以 10 为底的对数，四舍五入再加一？这适用于非 0 的正数和负数，并且避免使用任何字符串转换函数。

log10、abs 和 floor 函数由 math.h 提供。例如：

int nDigits = floor(log10(abs(the_integer))) + 1;

您应该将其包装在一个子句中，确保the_integer != 0，因为log10(0) 根据man 3 log 返回-HUGE_VAL。

此外，如果输入为负数，如果您对数字的长度（包括其负号）感兴趣，您可能希望在最终结果中加一。

Java：

int nDigits = Math.floor(Math.log10(Math.abs(the_integer))) + 1;

---

注意此方法中涉及的计算的浮点性质可能会导致它比更直接的方法慢。有关效率的一些讨论，请参阅康坎答案的 cmets。

Answer 14

int digits=1;

while (x>=10){
    x/=10;
    digits++;
}
return digits;

Answer 15

n 的长度：

length =  ( i==0 ) ? 1 : (int)log10(n)+1;

Answer 16

int intlen(int integer){
    int a;
    for(a = 1; integer /= 10; a++);
    return a;
}

Answer 17

我的方式：

只要数字不能被 10 整除，就除以：

u8 NumberOfDigits(u32 number)
{
    u8 i = 1;
    while (number /= 10) i++;

    return i;
}

不知道跟其他命题比起来有多快..

Answer 18

在我看来，最短和最简单的解决方案是：

int length , n;

printf("Enter a number: ");

scanf("%d", &n);

length = 0;

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

printf("Length of the number: %d", length);

Answer 19

我认为我找到了找到整数长度的最有效方法 这是一种非常简单优雅的方式 在这里：

int PEMath::LengthOfNum(int Num)
{
int count = 1;  //count starts at one because its the minumum amount of digits posible
if (Num < 0)
{
    Num *= (-1);
}

for(int i = 10; i <= Num; i*=10)
{
     count++;
}      
return count;
                // this loop will loop until the number "i" is bigger then "Num"
                // if "i" is less then "Num" multiply "i" by 10 and increase count
                // when the loop ends the number of count is the length of "Num".
}

Answer 20

sprintf(s, "%d", n);
length_of_int = strlen(s);

Answer 21

正确的snprintf 实现：

int count = snprintf(NULL, 0, "%i", x);

Answer 22

最有效的方法可能是使用基于快速对数的方法，类似于用于确定整数中最高位集的方法。

size_t printed_length ( int32_t x )
{
    size_t count = x < 0 ? 2 : 1;

    if ( x < 0 ) x = -x;

    if ( x >= 100000000 ) {
        count += 8;
        x /= 100000000;
    }

    if ( x >= 10000 ) {
        count += 4;
        x /= 10000;
    }

    if ( x >= 100 ) {
        count += 2;
        x /= 100;
    }

    if ( x >= 10 )
        ++count;

    return count;
}

我的上网本上的 2000 万次调用需要 0.65 秒（可能为时过早）；像 zed_0xff 这样的迭代除法需要 1.6 秒，像康坎这样的递归除法需要 1.8 秒，使用浮点函数（Jordan Lewis 的代码）需要高达 6.6 秒。使用 snprintf 需要 11.5 秒，但会给您 snprintf 任何格式所需的大小，而不仅仅是整数。 Jordan 报告说，他的处理器没有维护时序的顺序，它的浮点运算速度比我的快。

最简单的可能是向 snprintf 询问打印的长度：

#include <stdio.h>

size_t printed_length ( int x )
{
    return snprintf ( NULL, 0, "%d", x );
}

int main ()
{
    int x[] = { 1, 25, 12512, 0, -15 };

    for ( int i = 0; i < sizeof ( x ) / sizeof ( x[0] ); ++i )
        printf ( "%d -> %d\n", x[i], printed_length ( x[i] ) );

    return 0;
}

Answer 23

继续除以十直到得到零，然后输出除数。

int intLen(int x)
{
  if(!x) return 1;
  int i;
  for(i=0; x!=0; ++i)
  {
    x /= 10;
  }
  return i;
}

Answer 24

int get_int_len (int value){
  int l=1;
  while(value>9){ l++; value/=10; }
  return l;
}

第二个也适用于负数：

int get_int_len_with_negative_too (int value){
  int l=!value;
  while(value){ l++; value/=10; }
  return l;
}

Answer 25

整数x 的位数等于1 + log10(x)。所以你可以这样做：

#include <math.h>
#include <stdio.h>

int main()
{
    int x;
    scanf("%d", &x);
    printf("x has %d digits\n", 1 + (int)log10(x));
}

或者您可以运行一个循环来自己计算数字：将整数除以 10，直到数字为 0：

int numDigits = 0;
do
{
    ++numDigits;
    x = x / 10;
} while ( x );

如果整数是0 在第一个解决方案中返回1，您必须小心一点，并且您可能还想处理负整数（如果x < 0 使用-x）。

Answer 26

很简单

int main() {
    int num = 123;
    char buf[50];

    // convert 123 to string [buf]
    itoa(num, buf, 10);

    // print our string
    printf("%s\n", strlen (buf));

    return 0;
}

Answer 27

你可以这样写一个函数：

unsigned numDigits(const unsigned n) {
    if (n < 10) return 1;
    return 1 + numDigits(n / 10);
}

Answer 28

是的，使用 sprintf。

int num;
scanf("%d",&num);
char testing[100];
sprintf(testing,"%d",num);
int length = strlen(testing);

或者，您可以使用log10 函数以数学方式执行此操作。

int num;
scanf("%d",&num);
int length;
if (num == 0) {
  length = 1;
} else {    
  length = log10(fabs(num)) + 1;
  if (num < 0) length++;
}