Как получить цифры числа без преобразования его в массив строк/char?

Ответ 1

Далее печатаются цифры в порядке возрастания (т.е. единицы, затем десятки и т.д.):

do {
    int digit = n % 10;
    putchar('0' + digit);
    n /= 10;
} while (n > 0);

Ответ 2

Как насчет floor(log(number))+1?

С n цифрами и использованием базы b вы можете выразить любое число до pow(b,n)-1. Таким образом, чтобы получить число цифр числа x в базе b, вы можете использовать обратную функцию возведения в степень: логарифм base-b. Чтобы справиться с нецелочисленными результатами, вы можете использовать трюк floor()+1.

PS: Это работает для целых чисел, а не для чисел с десятичными знаками (в этом случае вы должны знать, какая точность используемого вами типа).

Ответ 3

Потому что все взводя, не зная вопроса.
Вот моя попытка бесполезности:

#include <iostream>

template<int D> int getDigit(int val)       {return getDigit<D-1>(val/10);}
template<>      int getDigit<1>(int val)    {return val % 10;}

int main()
{
    std::cout << getDigit<5>(1234567) << "\n";
}

Ответ 4

Я видел много ответов, но они all забыли использовать цикл do {...} while(), который на самом деле является каноническим способом решения этой проблемы и правильно обрабатывает 0.

Мое решение основано на этом на Naveen.

int n = 0;
std::cin>>n;

std::deque<int> digits;
n = abs(n);
do {
    digits.push_front( n % 10);
    n /= 10;
} while (n>0);

Ответ 5

Вы хотите что-то подобное?

 int n = 0;
    std::cin>>n;

    std::deque<int> digits;
    if(n == 0)
    {
        digits.push_front(0);
        return 0;
    }

    n = abs(n);
    while(n > 0)
    {
        digits.push_front( n % 10);
        n = n /10;
    }
    return 0;

Ответ 6

Что-то вроде этого:

int* GetDigits(int num, int * array, int len) {
  for (int i = 0; i < len && num != 0; i++) {
    array[i] = num % 10;
    num /= 10;
  }
}

Мод 10 даст вам цифры. Div 10s будет увеличивать число.

Ответ 7

Целочисленная версия тривиальна:

int fiGetDigit(const int n, const int k)
{//Get K-th Digit from a Number (zero-based index)
    switch(k)
    {
        case 0:return n%10;
        case 1:return n/10%10;
        case 2:return n/100%10;
        case 3:return n/1000%10;
        case 4:return n/10000%10;
        case 5:return n/100000%10;
        case 6:return n/1000000%10;
        case 7:return n/10000000%10;
        case 8:return n/100000000%10;
        case 9:return n/1000000000%10;
    }
    return 0;
}

Ответ 8

простая рекурсия:

#include <iostream>

// 0-based index pos
int getDigit (const long number, int pos) 
{
    return (pos == 0) ? number % 10 : getDigit (number/10, --pos);
}

int main (void) {
    std::cout << getDigit (1234567, 4) << "\n";    
}

Ответ 9

Эти решения являются рекурсивными или итеративными. Может ли более прямой подход быть немного более эффективным?

Слева-направо:

int getDigit(int from, int index)
{
   return (from / (int)pow(10, floor(log10(from)) - index)) % 10;
}

Справа налево:

int getDigit(int from, int index)
{
   return (from / pow(10, index)) % 10;
}

Ответ 10

Первая цифра (наименее значимая) = num% 10, вторая цифра = пол (num/10)% 10, 3-я цифра = пол (число/100)% 10. и т.д.

Ответ 11

Простым решением было бы использовать журнал 10 числа. Возвращает общее количество цифр - 1. Это можно исправить, используя преобразование числа в целое число.

int(log10(number)) + 1

Ответ 12

Используйте последовательность операций mod 10 и div 10 (независимо от синтаксиса на С++), чтобы назначить цифры по одному к другим переменным.

В псевдокоде

lsd = number mod 10
number = number div 10
next lsd = number mod 10
number = number div 10

и т.д...

болезненны!... но не строки или массивы символов.

Ответ 13

Не так круто, как ответ Мартина Йорк, но обращаясь только к произвольной проблеме:

Вы можете напечатать положительное целое число больше нуля, а просто с рекурсией:

#include <stdio.h>
void print(int x)
{
    if (x>0) {
        print(x/10);
        putchar(x%10 + '0');
    }
}

Это будет печатать последнюю младшую цифру.

Ответ 14

Несколько лет назад, в ответ на вышеуказанные вопросы, я бы написал следующий код:

int i2a_old(int n, char *s)
{
    char d,*e=s;//init begin pointer
    do{*e++='0'+n%10;}while(n/=10);//extract digits
    *e--=0;//set end of str_number
    int digits=e-s;//calc number of digits
    while(s<e)d=*s,*s++=*e,*e--=d;//reverse digits of the number
    return digits;//return number of digits
}

Я думаю, что функция printf (...) делает что-то подобное.

Теперь я напишу следующее:

int i2a_new(int n, char *s)
{
    int digits=n<100000?n<100?n<10?1:2:n<1000?3:n<10000?4:5:n<10000000?n<1000000?6:7:n<100000000?8:n<1000000000?9:10;
    char *e=&s[digits];//init end pointer
    *e=0;//set end of str_number
    do{*--e='0'+n%10;}while(n/=10);//extract digits
    return digits;//return number of digits
}

<сильные > Преимущества:таблица поиска отдельно; C, С++, Java, JavaScript, совместимый с PHP; получить число цифр, min comparisons: 3; получить число цифр, max comparisons: 4; быстрый код; сравнение очень простое и быстрое: cmp reg, immediate_data → 1 тактовая частота процессора.

Ответ 15

Получите все отдельные цифры во что-то вроде массива - два варианта:

int i2array_BigEndian(int n, char a[11])
{//storing the most significant digit first
    int digits=//obtain the number of digits with 3 or 4 comparisons
    n<100000?n<100?n<10?1:2:n<1000?3:n<10000?4:5:n<10000000?n<1000000?6:7:n<100000000?8:n<1000000000?9:10;
    a+=digits;//init end pointer
    do{*--a=n%10;}while(n/=10);//extract digits
    return digits;//return number of digits
}

int i2array_LittleEndian(int n, char a[11])
{//storing the least significant digit first
    char *p=&a[0];//init running pointer
    do{*p++=n%10;}while(n/=10);//extract digits
    return p-a;//return number of digits
}