C에서 정수 길이 찾기

C에서 정수 길이 찾기

C의 정수 길이를 구하는 방법을 알고 싶습니다.

예:

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

기타 등등.

이거 C에서 어떻게 해요?

C:

이 숫자의 절대값의 Base-10 로그를 가져와서 반올림한 후 1을 더하면 어떨까요?이는 0이 아닌 양수 및 음수에 대해 작동하며 문자열 변환 함수를 사용할 필요가 없습니다.

log10,abs , , , , 입니다.floor은 기은에에 functions functions functions functions functions functions functions functions functions functions에 의해 제공됩니다.math.h §:

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

은 반드시 .the_integer != 0부터, sysloglog10(0)-HUGE_VAL에에에 man 3 log.

또한 입력이 음수인 경우 음수 부호를 포함한 숫자의 길이를 알고 싶다면 최종 결과에 1을 추가할 수 있습니다.

자바:

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

---

N.B. 이 방법에 포함된 계산의 부동 소수점 특성으로 인해 보다 직접적인 접근보다 속도가 느려질 수 있습니다.효율성에 대한 자세한 내용은 Kangkan의 답변을 참조하십시오.

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

빠르고 매우 간단한 솔루션에 관심이 있는 경우 다음 방법이 가장 빠를 수 있습니다(이는 해당 숫자의 확률 분포에 따라 다름).

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 이하의 수치에서는 smart-log가 더 빠릅니다.

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.09초입니다).

★★snprintf★★★★

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

이 문제에서, 나는 약간의 산술적 해법을 사용했다.감사합니다:)

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

길이 n:

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

간단한 프로그램의 경우...

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

번째 변수를 유지하려면 합니다.numdiscloss.discloss 。

int digits=1;

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

String에 정수를 던져 다음과 같은 길이를 얻는 것은 어떨까요?

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

이것은 부정적인 인티저와 긍정적인 인티저 모두에 해당된다.

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

0이 될 때까지 계속 10으로 나눈 다음 분할 수를 출력합니다.

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

다음과 같은 함수를 쓸 수 있습니다.

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

''' 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의 정수 정수)를.-xx < 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;
}

이 (아마도 시기상조) 최적화는 넷북에서 2000만 콜에 0.65초 걸립니다.zed_0xff와 같은 반복 분할은 1.6초, Kangkan과 같은 반복 분할은 1.8초, 부동소수점 함수(Jordan Lewis의 코드)를 사용하는 것은 6.6초입니다.snprintf 를 사용하면 11.5 초가 걸리지만, 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(s, "%d", n);
length_of_int = strlen(s);

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

(data_type) log10(syslog_name)+1

예:

len = (int)log10(번호)+1;

정수의 길이를 찾는 가장 효율적인 방법을 찾은 것 같습니다. 매우 단순하고 우아한 방법입니다.

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(표준){부호 없는 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;

}

네, 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++;
}

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

답변은 한 줄 코드로 되어 있습니다.

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

그것은 간단하고 똑똑하다!마음에 드시면 투표하세요!

꽤 심플하다

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 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 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 //1 문자도 카운트됩니다.- 마이너스 카운트를 하지 않는 경우는, 5 행째부터 카운터++ 를 삭제합니다.

• 56666 -> 6

• 0 - > 1

• 505 -> 3

솔루션

정수 길이가 변경되는 한도를 사용합니다.십진수의 경우 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)

음, 아마도 이렇게...?

#define _LEN(x) (sizeof(#x)/sizeof(char)-1)

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