Нахождение длины целого числа в 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.
Кроме того, вы можете добавить один к окончательному результату, если вход отрицательный, если вы заинтересованы в длине номера, включая его отрицательный знак.
Джава:
int nDigits = Math.floor(Math.log10(Math.abs(the_integer))) + 1;
Принцип Природа с плавающей точкой расчетов, участвующих в этом методе, может привести к тому, что он медленнее, чем более прямой подход. Смотрите комментарии для ответа Кангкана на некоторое обсуждение эффективности.
Другие советы
Если вы заинтересованы в быстро а также очень простой Решение, следующее может быть быстрым (это зависит от распределения вероятностей рассматриваемых чисел):
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с, второго самого быстрого решения Pete Kirkham с использованием подхода Smart-logarithm занимает 0,115S - почти в два раза длиннее. Однако для номеров около 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, для небольших чисел - быстрее в обоих случаях, чем подход Smart-log. (GCC делает более быстрый код; 0,052 для этого решения и 0,09, для подхода Smart-log).
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));
}
Или вы можете запустить цикл, чтобы подсчитать цифры самостоятельно: сделать целое отделение на 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 человека на 20 миллионов звонков в моем нетбуке; Итеративное разделение, такое как ZED_0XFF, имеет 1,6 секунды, рекурсивное деление, такое как Kangkan занимает 1,8, а использование функций с плавающей точкой (Jordan Lewis 'Code) принимает колоссальный 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.
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 (номер) +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 // Считать - как один символ, а также, если вы не хотите считать минус, затем удалите счетчик ++ с 5-й строки.
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, размер = 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;
}
Это просто и умно! Upvote Если вам это нравится!
