Преобразование int в int [] в 'C'

Question

Я в основном хочу преобразовать заданное число int и сохранить отдельные цифры в массиве для дальнейшей обработки. Я знаю, что могу использовать%, получить каждую цифру и сохранить ее. Но дело в том, что я не знаю количество цифр int до времени выполнения и, следовательно, я не могу выделить размер массива. Так что я не могу работать в обратном направлении (с места юнитов). Я также не хочу сначала хранить количество обратных слов в массиве, а затем снова обратить массив. Есть ли другой способ сделать это?

Например: int num = 12345; ВЫХОД: ar [0] = 1, ar [1] = 2 и т. Д., Где ar [] - массив типа int.

Answer 1

Преобразование, вероятно, не то слово.Вы можете взять int, динамически выделить новый int [], а затем сохранить цифры int в int [].Я использую базу 10 журналов для подсчета количества цифр в num.Включите math.h, чтобы использовать его.Следующий код не проверен, но даст вам представление о том, что делать.

int num = 12345;
int size = (int)(log10(num)+1);

// allocate array
int *digits = (int*)malloc(sizeof(int) * size);

// get digits
for(int i=size-1; i>=0; --i) {
  digits[i] = num%10;
  num=num/10; // integer division
}

Answer 2

Следующая полная программа показывает один из способов сделать это.Он использует целые числа без знака, чтобы не беспокоиться о преобразовании - вы не указали, что должно произойти для отрицательных чисел, поэтому, как и любой хороший консультант, я сделал так, чтобы проблема исчезла для собственного удобства: -)

Он в основном определяет необходимый размер массива и выделяет его.Сам массив имеет в начале один элемент, определяющий, сколько элементов в массиве (длина int).

Каждый последующий элемент представляет собой последовательность цифр.Приведенный ниже код main показывает, как его обрабатывать.

Если он не может создать массив, он просто вернет вам NULL - вы также должны помнить, чтобы освободить память, переданную обратно, как только выс этим покончено.

#include <stdio.h>
#include <stdlib.h>

int *convert (unsigned int num) {
    unsigned int *ptr;
    unsigned int digits = 0;
    unsigned int temp = num;

    // Figure out how many digits in the number.
    if (temp == 0) {
        digits = 1;
    } else {
        while (temp > 0) {
            temp /= 10;
            digits++;
        }
    }

    // Allocate enough memory for length and digits.
    ptr = malloc ((digits + 1) * sizeof (unsigned int));

    // Populate array if we got one.
    if (ptr != NULL) {
        ptr[0] = digits;
        for (temp = 0; temp < digits; temp++) {
            ptr[digits - temp] = num % 10;
            num /= 10;
        }
    }
    return ptr;
}

Эта convert функция выше - это "мясо" - она ​​выделяет целочисленный массив для размещения длины (индекс 0) и цифр (индексы с 1 по N, где N - числоцифр).Следующей была тестовая программа, которую я использовал.

int main (void) {
    int i;
    unsigned int num = 12345;
    unsigned int *arr = convert (num);

    if (arr == NULL) {
        printf ("No memory\n");
    } else {
        // Length is index 0, rest are digits.

        for (i = 1; i <= arr[0]; i++)
            printf ("arr[%d] = %u\n", i, arr[i]);
        free (arr);
    }

    return 0;
}

Вывод:

arr[1] = 1
arr[2] = 2
arr[3] = 3
arr[4] = 4
arr[5] = 5

Answer 3

Если у вас 32-битный целочисленный тип, максимальное значение будет состоять максимум из 10 цифр (исключая знак для отрицательных чисел). Это может быть ваш верхний предел.

Если вам необходимо динамически определить минимально достаточный размер, вы можете определить это с помощью обычных сравнений (поскольку вызов логарифмической функции, вероятно, более дорогой, но возможный):

size = 10;
if (myint < 1000000000) size--;
if (myint < 100000000) size--;
/* ... */

Объявление массива динамического размера зависит от используемого вами стандарта языка Си. В C89 динамический размер массива (на основе значений, рассчитанных во время выполнения) невозможен. Возможно, вам потребуется использовать динамически распределенную память.

НТН,

Юхан

Answer 4

Самый простой способ - это вычислить количество цифр, чтобы узнать размер нужного вам массива

int input = <input number>; // >= 0
int d, numdigits = 1;
int *arr;

d = input;
while (d /= 10)
   numdigits++;

arr = malloc(sizeof(int) * numdigits);

Есть еще более простой способ: возможно, вы передаете число вашей программе в качестве аргумента из командной строки. В этом случае вы получаете его в виде строки в argp [N], поэтому вы можете просто вызвать strlen (argp [N]), чтобы определить количество цифр в вашем номере.

Answer 5

Что вы в основном хотите сделать, это преобразовать ваше целое число в массив его десятичных позиций. Семейство функций printf прекрасно знает, как это сделать, не нужно изобретать велосипед. Я немного меняю назначение, так как вы ничего не сказали о знаках, и это просто имеет больше смысла для значений без знака.

unsigned* res = 0;
size_t len = 0;
{
  /* temporary array, large enough to hold the representation of any unsigned */
  char positions[20] = { 0 };
  sprintf(position, "%u", number);
  len = strlen(position);
  res = malloc(sizeof(unsigned[len]));
  for (size_t i = 0; i < len; ++i)
    res[i] = position[i] - '0';
}

Answer 6

Количество цифр можно узнать, взяв логарифм base-10 и добавив один. Для этого вы можете использовать функции log10 или log10f из стандартной математической библиотеки. Это может быть немного медленнее, но, вероятно, наиболее точным, если double имеет достаточно битов для точного представления вашего числа:

int numdigits = 1 + log10(num);

В качестве альтернативы, вы можете многократно делить на десять, пока результат не станет равным нулю, и посчитать цифры таким образом.

Еще один вариант - просто выделить достаточно места для максимального количества цифр, которое может иметь тип. Для 32-разрядного целого числа это было бы 10; для 64-битной 20 должно быть достаточно. Вы можете просто обнулить лишние цифры. Поскольку это не слишком много потерянного пространства даже в худшем случае, это может быть самый простой и быстрый вариант. Вы должны знать, сколько битов в int в вашей настройке.

Вы также можете оценить достаточно хорошо, выделив 3 цифры для каждых 10 используемых бит плюс один. Это должно быть достаточно цифр, если только число битов не является смехотворно большим (намного выше количества цифр, которое может иметь любой из обычных типов int).

int numdigits = 1
unsigned int n = num;
for (n = num; n & 0x03ff; n >>= 10) 
  numdigits += 3;
/* numdigits is at least the needed number of digits, maybe up to 3 more */

Последний не будет работать (напрямую), если число отрицательное.