Я хотел бы знать, как я могу найти длину целого числа в C.
Например:
и так далее.
Как я могу сделать это в C?
Почему бы просто не взять десятичный логарифм абсолютного значения числа, округлить его в меньшую сторону и добавить единицу? Это работает для положительных и отрицательных чисел, отличных от 0, и позволяет избежать использования каких-либо функций преобразования строк.
Функции log10
, abs
и floor
предоставляются math.h
. Например:
int nDigits = floor(log10(abs(the_integer))) + 1;
Вы должны заключить это в предложение, гарантирующее, что the_integer! = 0
, поскольку log10 (0)
возвращает -HUGE_VAL
согласно ] man 3 log
.
Кроме того, вы можете добавить единицу к окончательному результату, если ввод отрицательный, если вас интересует длина числа, включая его отрицательный знак.
int nDigits = Math.floor(Math.log10(Math.abs(the_integer))) + 1;
N.B. Из-за того, что в этом методе используются вычисления с плавающей запятой, он может быть медленнее, чем при более прямом подходе. См. Комментарии к ответу Кангкана для обсуждения эффективности.
Наиболее эффективным способом могло бы быть использование подхода на основе быстрого логарифма, аналогичного тем, которые используются для определения самого высокого набора битов в целом числе.
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 секунды для 20 миллионов вызовов на моем нетбуке; итеративное деление, такое как zed_0xff, занимает 1,6 секунды, рекурсивное деление, такое как Kangkan, занимает 1,8 секунды, а использование функций с плавающей запятой (код Джордана Льюиса) занимает колоссальные 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;
}
Если вас интересуют быстрое и очень простое решение, наиболее быстрым может быть следующее (это зависит от распределения вероятностей рассматриваемых чисел):
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 я проверил это с помощью следующего цикла:
int res = 0;
for(int i = -2000000000; i < 2000000000; i += 200) res += printLen(i);
Это решение занимает 0,062 с, второе по скорости решение Пита Киркхэма, использующее подход интеллектуального логарифма, занимает 0,115 с - почти вдвое дольше. Однако для чисел около 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,09 с для подхода с умным журналом).
Да, с использованием 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++;
}
продолжайте делить на десять, пока не получите ноль, затем просто выведите количество делений.
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);
}
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 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;
}
Количество цифр целого числа 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 );
В первом решении нужно быть немного осторожным, чтобы вернуть 1
, если целое число равно 0
, и, возможно, вы также захотите обработать отрицательные целые числа (работа с -x
, если x < 0
).