C에서 정수 길이 찾기

C에서 정수 길이 찾기

---

C에서 정수의 길이를 어떻게 찾을 수 있는지 알고 싶습니다.

예를 들면 :

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

등등.

C에서 어떻게 할 수 있습니까?

---

씨:

숫자의 절대 값에 대한 밑 수가 10 인 로그를 가져 와서 반올림 한 다음 1을 더하지 않는 이유는 무엇입니까? 이것은 0이 아닌 양수와 음수에 대해 작동하며 문자열 변환 함수를 사용할 필요가 없습니다.

log10, abs및 floor기능에 의해 제공된다 math.h. 예를 들면 :

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

에 따라 반환 the_integer != 0되기 때문에이를 보장하는 절로 이것을 감싸 야 합니다 .log10(0)-HUGE_VALman 3 log

또한 음수 부호를 포함한 숫자의 길이에 관심이 있다면 입력이 음수이면 최종 결과에 하나를 추가 할 수 있습니다.

자바:

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);
}

가장 독창적 인 솔루션으로는 상을받지 못할 수도 있지만 이해하는 것도 사소하고 실행도 사소합니다. 그래서 빠릅니다.

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).

---

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));
}

또는 루프를 실행하여 숫자를 직접 계산할 수 있습니다. 숫자가 0이 될 때까지 정수를 10으로 나눕니다.

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

1정수가 0첫 번째 솔루션에 있으면 반환하는 데 약간주의 해야하며 음의 정수를 처리 할 수도 있습니다 ( -xif 와 함께 작동 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;
}

이 (아마도 조기) 최적화는 넷북에서 2 천만 번의 호출에 0.65 초가 걸립니다. zed_0xff와 같은 반복 분할은 1.6 초, Kangkan과 같은 재귀 분할은 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;
}

---

예, 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);

---

이것을 사용할 수 있습니다-

(데이터 _ 유형) log10 (변수 _ 이름) +1

전의:

len = (int) log10 (숫자) +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;
}

---

0이 될 때까지 10으로 계속 나눈 다음 나눗셈 수를 출력하십시오.

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 //it will count - as one character as well if you dont want to count minus then remove counter++ from 5th line.

• 566666 -> 6

• 0 -> 1

• 505 -> 3

---

I think I got the most efficient way to find the length of an integer its a very simple and elegant way here it is:

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;

}

---

Kindly find my answer it is in one line code:

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

that is simple and smart! Upvote if you like this!

ReferenceURL : https://stackoverflow.com/questions/3068397/finding-the-length-of-an-integer-in-c