Перейти к содержанию
Определить количество разрядов числа
Просмотров 13к. Обновлено 15 октября 2021
Написать функцию, которая определяет количество разрядов введенного целого числа.
Чтобы программно посчитать количество разрядов числа, необходимо последовательно его делить нацело на 10, пока это число не станет равным нулю. При этом считать количество делений. Например, дано число 345. После первого деления останется 34, после второго — 3, после третьего — 0. Таким образом, мы видим, что количество делений равно количеству разрядов числа.
Для реализации данного алгоритма следует использовать цикл «пока» (while). Условием его выполнения является неравенство числа нулю. Хотя, если вводятся только положительные числа или перед этим отрицательное число превращают в положительное, в условии может быть «больше нуля».
Перед циклом вводится переменная-счетчик (например, i), которой присваивается значение 0 и которая при каждом делении заданного числа внутри цикла увеличивается на единицу. После завершения деления именно ее значением будет определяться количество разрядов числа.
Поскольку надо написать функцию, то скорее всего эта функция должна принимать заданное число, а возвращать количество разрядов.
Pascal
var num: longint;function digits (n:longint): byte;
var i: byte;
begin
i := 0;
while n > 0 do begin
n := n div 10;
i := i + 1
end;
digits := i
end;begin
write ('Введите число: ');
readln (num);
if num<0 then num:=abs(num);
writeln ('Количество разрядов = ', digits(num));
end.
Введите число: -98
Количество разрядов = 2
Язык Си
#include < stdio.h>
int digits (int);main() {
int num;
scanf("%d",&num);
printf("%dn", digits(num));
}int digits(int n) {
int i;
if (n < 0) n = -n;
while (n > 0) {
n = n/10;
i += 1;
}
return i;
}
3543
4
Python
количество разрядов в числе Python
def digits(n):
i = 0
while n > 0:
n = n//10
i += 1
return inum = abs(int(input('Введите число: ')))
print('Количество разрядов:', digits(num))
Введите число: 65098234
Количество разрядов: 8
КуМир
алг колич_разрядов
нач
цел num
ввод num
вывод разряды(num)
коналг цел разряды(цел n)
нач
цел i, m
m := n
i := 0
если m < 0 то m := -m всё
нц пока m > 0
m := div(m,10)
i := i+1
кц
знач := i
кон
-562
3
Basic-256
input num
gosub digits
enddigits:
if num < 0 then num = abs(num)
i = 0
while num > 0
num = num 10
i = i + 1
endwhile
print i
return
-7823342
7
На чтение 3 мин Просмотров 757 Опубликовано 02.03.2023
Содержание
- Введение
- Длинный способ с циклом while
- Короткий способ циклом for
- Самый быстрый способ
- Заключение
Введение
В ходе статьи рассмотрим три вариации кода для определения количества разрядов в ведённом пользователем числе на языке программирования Python.
Длинный способ с циклом while
Дадим пользователю возможность ввести число:
n = int(input('Введите число: '))Если было введено отрицательное число, нужно его сделать положительным. Для этого добавим его в модуль методом abs():
n = int(input('Введите число: '))
n = abs(n)Добавим переменную count равную нулю:
n = int(input('Введите число: '))
n = abs(n)
count = 0Создадим цикл while, который не закончится, пока n > 0. В цикле будем убирать последнюю цифру в переменной n, а к count прибавлять единицу:
n = int(input('Введите число: '))
n = abs(n)
count = 0
while n > 0:
n //= 10
count += 1Осталось вывести результат:
n = int(input('Введите число: '))
n = abs(n)
count = 0
while n > 0:
n //= 10
count += 1
print(count)
# Введите число: 164832
# 6Короткий способ циклом for
Обычно подобным не занимаются при помощи цикла for, но почему бы и нет. Как и в предыдущем способе даём пользователю возможность ввода числа, и добавляем его в модуль. Также создаём переменную count равную нулю:
n = abs(int(input('Введите число: ')))
count = 0Создадим цикл for, в котором пройдёмся по количеству символов в переменной n. Внутри цикла прибавляем к count единицу:
n = abs(int(input('Введите число: ')))
count = 0
for i in range(len(str(n))):
count += 1Выведем результат в консоль:
n = abs(int(input('Введите число: ')))
count = 0
for i in range(len(str(n))):
count += 1
print(count)
# Введите число: 111
# 3Самый быстрый способ
Как и в предыдущих способах даём пользователю возможность ввода числа, и добавляем его в модуль:
n = abs(int(input('Введите число: ')))Теперь в переменную count сохраним длину значения преобразованного в строковый тип данных в переменной n:
n = abs(int(input('Введите число: ')))
count = len(str(n))Выведем результат:
n = abs(int(input('Введите число: ')))
count = len(str(n))
print(f'В числе {n} находится {count} разрядов.')
# Введите число: 17424312
# В числе 17424312 находится 8 разрядов.Заключение
В ходе статьи мы с Вами разобрали целых 3 способа определить количество разрядов в числе в Python. Надеюсь Вам понравилась статья, желаю удачи и успехов! 🙂
Разряды и классы чисел
- Классы чисел
- Разряды чисел
Классы чисел
Цифры в записи многозначных чисел разбивают справа налево на группы по три цифры в каждой. Эти группы называют классами. В каждом классе цифры справа налево обозначают единицы, десятки и сотни этого класса:
Названия классов многозначных чисел справа налево:
- первый — класс единиц,
- второй — класс тысяч,
- третий — класс миллионов,
- четвёртый — класс миллиардов,
- пятый — класс триллионов,
- шестой — класс квадриллионов,
- седьмой — класс квинтиллионов,
- восьмой — класс секстиллионов.
Для удобства чтения записи многозначного числа, между классами оставляется небольшой пробел. Например, чтобы прочитать число 148951784296, выделим в нём классы:
148 951 784 296
и прочитаем число единиц каждого класса слева направо:
148 миллиардов 951 миллион 784 тысячи 296.
При чтении класса единиц в конце обычно не добавляют слово единиц
.
Разряды чисел
Каждая цифра в записи многозначного числа занимает определённое место — позицию. Место (позицию) в записи числа, на котором стоит цифра, называют разрядом.
Разряд числа — это позиция (место) цифры в записи числа.
Счёт разрядов идёт справа налево. То есть, первая цифра справа в записи числа называется цифрой первого разряда, вторая цифра справа — цифрой второго разряда и т. д. Например, в первом классе числа 148 951 784 296, цифра 6 является цифрой первого разряда, 9 — цифра второго разряда, 2 — цифра третьего разряда:
Единицы, десятки, сотни, тысячи и т. д. иначе ещё называют разрядными единицами:
- Единицы называют единицами первого разряда (или простыми единицами) и пишутся на первом месте справа.
- Десятки — единицами второго разряда и пишутся в числе на втором месте справа.
- Сотни — единицами третьего разряда и пишутся на третьем месте справа.
- Единицы тысяч — единицами четвёртого разряда и пишутся на четвёртом месте справа.
- Десятки тысяч — единицами пятого разряда и пишутся на пятом месте справа.
- Сотни тысяч — единицами шестого разряда и пишутся в числе на шестом месте справа и так далее.
Каждые три разряда, следующие друг за другом, составляют класс. Первые три разряда: единицы десятки и сотни — образуют класс единиц (первый класс). Следующие три разряда: единицы тысяч, десятки тысяч и сотни тысяч — образуют класс тысяч (второй класс). Третий класс будут составлять единицы, десятки и тысячи миллионов и так далее.
Пример. Запишите цифрами число, которое содержит:
1) 37 единиц второго класса и 565 единиц первого класса;
2) 450 единиц второго класса и 9 единиц первого класса;
3) 8 единиц второго класса и 50 единиц первого класса.
Решение:
1) 37 565;
2) 450 009;
3) 8 050.
Все разрядные единицы, кроме простых единиц, называются составными единицами. Так, десяток, сотня, тысяча и т. д. — составные единицы. Каждые 10 единиц любого разряда составляют одну единицу следующего (более высокого) разряда:
| 10 единиц | = | 1 десяток; |
| 10 десятков | = | 1 сотня; |
| 10 сотен | = | 1 тысяча; |
| 10 тысяч | = | 1 десяток тысяч; |
| 10 десятков тысяч | = | 1 сотня тысяч; |
| 10 сотен тысяч | = | 1 тысяча тысяч (1 миллион); |
и так далее.
Любая составная единица по сравнению с другой единицей, меньшей её называется единицей высшего разряда, а по сравнению с единицей, большей её, называется единицей низшего разряда. Например, сотня является единицей высшего разряда относительно десятка и единицей низшего разряда относительно тысячи.
Чтобы узнать, сколько в числе заключается всех единиц какого-либо разряда, надо отбросить все цифры, означающие единицы низших разрядов и прочитать число, выражаемое оставшимися цифрами.
Например, требуется узнать, сколько всего сотен содержится в числе 6284, т. е. сколько сотен заключается в тысячах и в сотнях данного числа вместе.
В числе 6284 на третьем месте в классе единиц стоит цифра 2, значит в числе есть две простые сотни. Следующая влево цифра — 6, означает тысячи. Так как в каждой тысяче содержится 10 сотен то, в 6 тысячах их заключается 60. Всего, таким образом, в данном числе содержится 62 сотни.
Цифра 0 в каком-нибудь разряде означает отсутствие единиц в данном разряде.
Например, цифра 0 в разряде десятков означает отсутствие десятков, в разряде сотен — отсутствие сотен и т. д. В том разряде, где стоит 0, при чтении числа ничего не произносится:
24 527 — двадцать четыре тысячи пятьсот двадцать семь.
20 507 — двадцать тысяч пятьсот семь.
Constant-cost version that uses x86 assembly and a lookup table:
int count_bsr(int i) {
struct {
int max;
int count;
} static digits[32] = {
{ 9, 1 }, { 9, 1 }, { 9, 1 }, { 9, 1 },
{ 99, 2 }, { 99, 2 }, { 99, 2 },
{ 999, 3 }, { 999, 3 }, { 999, 3 },
{ 9999, 4 }, { 9999, 4 }, { 9999, 4 }, { 9999, 4 },
{ 99999, 5 }, { 99999, 5 }, { 99999, 5 },
{ 999999, 6 }, { 999999, 6 }, { 999999, 6 },
{ 9999999, 7 }, { 9999999, 7 }, { 9999999, 7 }, { 9999999, 7 },
{ 99999999, 8 }, { 99999999, 8 }, { 99999999, 8 },
{ 999999999, 9 }, { 999999999, 9 }, { 999999999, 9 },
{ INT_MAX, 10 }, { INT_MAX, 10 }
};
register const int z = 0;
register unsigned log2;
if (i < 0) i = -i;
__asm__ __volatile__ (
"bsr %1, %0;"
"cmovz %2, %0;"
: "=r" (log2)
: "rm" (i), "r"(z));
return digits[log2].count + ( i > digits[log2].max );
}
Another one, with a smaller lookup table and a log10 approximation taken from here.
int count_bsr2( int i ) {
static const unsigned limits[] =
{0, 10, 100, 1000, 10000, 100000,
1000000, 10000000, 100000000, 1000000000};
register const int z = 0;
register int l, log2;
if (i < 0) i = -i;
__asm__ __volatile__ (
"bsr %1, %0;"
"cmovz %2, %0;"
: "=r" (log2)
: "rm" (i), "r"(z));
l = (log2 + 1) * 1233 >> 12;
return (l + ((unsigned)i >= limits[l]));
}
Both of these take advantage of the fact that on x86 -INT_MIN is equal to INT_MIN.
Update:
As per suggestion here are the timings for the count_bsr and a slightly faster 64-bit only count_bsr_mod routines compared to the binary search and binary chop algos using very nice paxdiablo’s test program modified to generate sets with a random sign distribution. Tests were built with gcc 4.9.2 using «-O3 -falign-functions=16 -falign-jumps=16 -march=corei7-avx» options and executed on an otherwise quiescent Sandy Bridge system with turbo and sleep states off.
Time for bsr mod: 270000 Time for bsr: 340000 Time for binary chop: 800000 Time for binary search: 770000 Time for binary search mod: 470000
Source for the test,
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <limits.h>
#include <time.h>
#define numof(a) (sizeof(a) / sizeof(a[0]))
/* Random numbers and accuracy checks. */
static int rndnum[10000];
static int rt[numof(rndnum)];
/* All digit counting functions here. */
static int count_bchop (int n) {
int r = 1;
if (n < 0) n = (n == INT_MIN) ? INT_MAX : -n;
if (n >= 100000000) {
r += 8;
n /= 100000000;
}
if (n >= 10000) {
r += 4;
n /= 10000;
}
if (n >= 100) {
r += 2;
n /= 100;
}
if (n >= 10)
r++;
return r;
}
static int count_bsearch(int i)
{
if (i < 0)
{
if (i == INT_MIN)
return 11; // special case for -2^31 because 2^31 can't fit in a two's complement 32-bit integer
i = -i;
}
if (i < 100000) {
if (i < 1000) {
if (i < 10) return 1;
else if (i < 100) return 2;
else return 3;
} else {
if (i < 10000) return 4;
else return 5;
}
} else {
if (i < 10000000) {
if (i < 1000000) return 6;
else return 7;
} else {
if (i < 100000000) return 8;
else if (i < 1000000000) return 9;
else return 10;
}
}
}
// Integer log base 10, modified binary search.
static int count_bsearch_mod(int i) {
unsigned x = (i >= 0) ? i : -i;
if (x > 99)
if (x > 999999)
if (x > 99999999)
return 9 + (x > 999999999);
else
return 7 + (x > 9999999);
else
if (x > 9999)
return 5 + (x > 99999);
else
return 3 + (x > 999);
else
return 1 + (x > 9);
}
static int count_bsr_mod(int i) {
struct {
int m_count;
int m_threshold;
} static digits[32] =
{
{ 1, 9 }, { 1, 9 }, { 1, 9 }, { 1, 9 },
{ 2, 99 }, { 2, 99 }, { 2, 99 },
{ 3, 999 }, { 3, 999 }, { 3, 999 },
{ 4, 9999 }, { 4, 9999 }, { 4, 9999 }, { 4, 9999 },
{ 5, 99999 }, { 5, 99999 }, { 5, 99999 },
{ 6, 999999 }, { 6, 999999 }, { 6, 999999 },
{ 7, 9999999 }, { 7, 9999999 }, { 7, 9999999 }, { 7, 9999999 },
{ 8, 99999999 }, { 8, 99999999 }, { 8, 99999999 },
{ 9, 999999999 }, { 9, 999999999 }, { 9, 999999999 },
{ 10, INT_MAX }, { 10, INT_MAX }
};
__asm__ __volatile__ (
"cdq nt"
"xorl %%edx, %0 nt"
"subl %%edx, %0 nt"
"movl %0, %%edx nt"
"bsrl %0, %0 nt"
"shlq $32, %%rdx nt"
"movq %P1(,%q0,8), %q0 nt"
"cmpq %q0, %%rdx nt"
"setg %%dl nt"
"addl %%edx, %0 nt"
: "+a"(i)
: "i"(digits)
: "rdx", "cc"
);
return i;
}
static int count_bsr(int i) {
struct {
int max;
int count;
} static digits[32] = {
{ 9, 1 }, { 9, 1 }, { 9, 1 }, { 9, 1 },
{ 99, 2 }, { 99, 2 }, { 99, 2 },
{ 999, 3 }, { 999, 3 }, { 999, 3 },
{ 9999, 4 }, { 9999, 4 }, { 9999, 4 }, { 9999, 4 },
{ 99999, 5 }, { 99999, 5 }, { 99999, 5 },
{ 999999, 6 }, { 999999, 6 }, { 999999, 6 },
{ 9999999, 7 }, { 9999999, 7 }, { 9999999, 7 }, { 9999999, 7 },
{ 99999999, 8 }, { 99999999, 8 }, { 99999999, 8 },
{ 999999999, 9 }, { 999999999, 9 }, { 999999999, 9 },
{ INT_MAX, 10 }, { INT_MAX, 10 }
};
register const int z = 0;
register unsigned log2;
if (i < 0) i = -i;
__asm__ __volatile__ (
"bsr %1, %0;"
"cmovz %2, %0;"
: "=r" (log2)
: "rm" (i), "r"(z));
return digits[log2].count + ( i > digits[log2].max );
}
/* Structure to control calling of functions. */
typedef struct {
int (*fnptr)(int);
const char *desc;
} tFn;
static tFn fn[] = {
{ NULL, NULL },
{ count_bsr_mod, " bsr mod" },
{ count_bsr, " bsr" },
{ count_bchop, " binary chop" },
{ count_bsearch, " binary search" },
{ count_bsearch_mod," binary search mod"}
};
static clock_t clk[numof (fn)];
int main (int c, char *v[]) {
int i, j, k, r;
int s = 1;
/* Test code:
printf ("%11d %dn", INT_MIN, count_bsearch(INT_MIN));
//for (i = -1000000000; i != 0; i /= 10)
for (i = -999999999; i != 0; i /= 10)
printf ("%11d %dn", i, count_bsearch(i));
printf ("%11d %dn", 0, count_bsearch(0));
for (i = 1; i != 1000000000; i *= 10)
printf ("%11d %dn", i, count_bsearch(i));
printf ("%11d %dn", 1000000000, count_bsearch(1000000000));
printf ("%11d %dn", INT_MAX, count_bsearch(INT_MAX));
return 0;
/* */
/* Randomize and create random pool of numbers. */
int p, n;
p = n = 0;
srand (time (NULL));
for (j = 0; j < numof (rndnum); j++) {
rndnum[j] = ((rand() & 2) - 1) * rand();
}
rndnum[0] = INT_MAX;
rndnum[1] = INT_MIN;
/* For testing. */
for (k = 0; k < numof (rndnum); k++) {
rt[k] = (fn[1].fnptr)(rndnum[k]);
}
/* Test each of the functions in turn. */
clk[0] = clock();
for (i = 1; i < numof (fn); i++) {
for (j = 0; j < 10000; j++) {
for (k = 0; k < numof (rndnum); k++) {
r = (fn[i].fnptr)(rndnum[k]);
/* Test code:
if (r != rt[k]) {
printf ("Mismatch error [%s] %d %d %d %dn",
fn[i].desc, k, rndnum[k], rt[k], r);
return 1;
}
/* */
}
}
clk[i] = clock();
}
/* Print out results. */
for (i = 1; i < numof (fn); i++) {
printf ("Time for %s: %10dn", fn[i].desc, (int)(clk[i] - clk[i-1]));
}
return 0;
}
Перейти к содержанию
На чтение 1 мин Просмотров 1.1к. Опубликовано 3 июля, 2022 Обновлено 3 июля, 2022
Напишите цикл, который считает количество разрядов введенного с клавиатуры числа
В данном случае следует использовать математический способ решения задачи – путем
последовательного избавления от разрядов числа делением нацело на 10 в цикле.
Первое деление выносится за цикл потому, что если число равно нулю, то цикл while его не
обработает и счетчик цифр count останется равным нулю.
n = int(input())
n = abs(n)
count = 1
n //= 10
while n > 0:
n //= 10
count += 1
print(count)Пример выполнения:
-123
3Однако случай введения числа 0 можно обработать и через if:
if n == 0:
count = 1Обратим внимание, что если число оканчивается на 0, например 150, программа работает
правильно, так как от разрядов числа избавляются с конца, а не с начала. Первое деление нацело
учтет цифру 0 в счетчике count.
Если же перед числом поставить 0, например 015, программа насчитает 2 разряда, так как
проверка n > 0 вернет ложь, когда от числа останется одна первая цифра.
( 1 оценка, среднее 4 из 5 )