在C中找到整数的长度
https://stackoverflow.com/questions/3068397
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian题
我想知道如何在C中找到整数的长度。
例如：
- 1 => 1
- 25 => 2
- 12512 => 5
- 0 => 1
等等。
我该如何在C中这样做？
解决方案
C：
为什么不只是将数字的绝对值的基本10日志，将其围成并添加一个呢？这适用于不是0的正数和负数，并且避免了必须使用任何字符串转换功能。
这 log10, abs, ， 和 floor 功能由 math.h. 。例如：
int nDigits = floor(log10(abs(the_integer))) + 1;
您应该将其包裹在一个条款中，以确保 the_integer != 0, ， 自从 log10(0) 返回 -HUGE_VAL 根据 man 3 log.
此外，如果输入为负，则可能需要将一个添加到最终结果中，如果您对数字的长度（包括其负符号）感兴趣。
Java：
int nDigits = Math.floor(Math.log10(Math.abs(the_integer))) + 1;
NB 该方法所涉及的计算的浮点性质可能会使它比更直接的方法慢。有关效率的讨论，请参见Kangkan的回答评论。
其他提示
如果您对一个感兴趣 快速地 和 非常简单 解决方案，以下可能是最快的（这取决于所讨论数字的概率分布）：
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);
}
虽然它可能不会为最巧妙的解决方案赢得奖品，但要理解和执行也很琐碎 - 很快。
在Q6600上，使用MSC I对此进行了以下循环测试：
int res = 0;
for(int i = -2000000000; i < 2000000000; i += 200) res += printLen(i);
该解决方案需要0.062s，这是Pete Kirkham使用Smart-Logarithm方法的第二快的解决方案，其时间为0.115s，几乎是两倍。但是，对于大约10000及以下的数字，智能木材速度更快。
以牺牲一些清晰度为代价，您可以更可靠地击败Smart-Log（至少在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的智能模型方法）。
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;
}
您可以写这样的函数：
unsigned numDigits(const unsigned n) {
if (n < 10) return 1;
return 1 + numDigits(n / 10);
}
n的长度：
length = ( i==0 ) ? 1 : (int)log10(n)+1;
整数的数字数 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));
}
或者，您可以运行一个循环来计算数字：DO Integer Division Die 10直到数字为0：
int numDigits = 0;
do
{
++numDigits;
x = x / 10;
} while ( x );
你必须小心返回 1 如果整数是 0 在第一个解决方案中，您可能还想对待负整数（与 -x 如果 x < 0).
最有效的方法可能是使用基于快速对数的方法，类似于确定整数中最高位的方法。
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;
}
这个（可能过早的）优化需要0.65秒，用于我的上网本上的2000万个电话；像ZED_0XFF这样的迭代划分需要1.6秒，像Kangkan这样的递归划分为1.8s，并且使用浮点功能（Jordan Lewis的代码）需要6.6秒。使用SNPRINTF需要11.5s，但会为您提供SNPRINTF所需的任何格式所需的大小，而不仅仅是整数。乔丹报告说，时间安排的顺序不保留在他的处理器上，这确实比我的浮点更快。
最简单的是向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;
}
是的，使用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++;
}
正确 snprintf 执行：
int count = snprintf(NULL, 0, "%i", x);
int digits=1;
while (x>=10){
x/=10;
digits++;
}
return digits;
sprintf(s, "%d", n);
length_of_int = strlen(s);
您可以使用此 -
（data_type）log10（variable_name）+1
前任：
len =（int）log10（number）+1;
非常简单
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;
}
继续除以十，直到您获得零，然后只输出划分数。
int intLen(int x)
{
if(!x) return 1;
int i;
for(i=0; x!=0; ++i)
{
x /= 10;
}
return i;
}
我认为最短，最简单的解决方案是：
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);
我的方式：
只要数字不再可以除以10：
u8 NumberOfDigits(u32 number)
{
u8 i = 1;
while (number /= 10) i++;
return i;
}
我不知道与其他命题相比，它的速度有多快。
int intlen(int integer){
int a;
for(a = 1; integer /= 10; a++);
return a;
}
一种更详细的方法是使用此功能。
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;
}
这是对负面和积极的污染物的
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;
}
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 //它将计数 - 如果您不想计算负数，然后从第五行删除计数器++。
566666 -> 6
0 -> 1
505 -> 3
我认为我有最有效的方法来找到整数的长度，这是一种非常简单，优雅的方式：
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".
}
int main（void）{unsigned int n，size = 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;
}
请找到我的答案，这是在一行代码中：
#include <stdio.h>
int main(void){
int c = 12388884;
printf("length of integer is: %d",printf("%d",c));
return 0;
}
那简单明智！如果您喜欢这样，请举重！
