przekonwertować liczbę całkowitą do tablicy

Question

próbuję przekonwertować liczbę całkowitą w C do tablicy zawierającej każdy z tej liczby na cyfry

znaczy, jeśli mam

int number = 5400 

jak mogę dostać się do

int numberArray[4] 

gdzie

numberArray[0] = 0; 
numberArray[1] = 0; 
numberArray[2] = 4; 
numberArray[3] = 5; 

Wszelkie sugestie otrzymane z wdzięcznością.

Answer 1

To działa dla liczb> = 0

#include <math.h> 

char * convertNumberIntoArray(unsigned int number) { 
    int length = (int)floor(log10((float)number)) + 1; 
    char * arr = new char[length]; 
    int i = 0; 
    do { 
     arr[i] = number % 10; 
     number /= 10; 
     i++; 
    } while (number != 0); 
    return arr; 
} 

EDYCJA: Tylko trochę bardziej styl C, ale bardziej tajemniczy.

#include <math.h> 

char * convertNumberIntoArray(unsigned int number) { 
    unsigned int length = (int)(log10((float)number)) + 1; 
    char * arr = (char *) malloc(length * sizeof(char)), * curr = arr; 
    do { 
     *curr++ = number % 10; 
     number /= 10; 
    } while (number != 0); 
    return arr; 
} 

Answer 2

Wskazówka: Spójrz na to wcześniejsze pytanie "Sum of digits in C#". Wyjaśnia, w jaki sposób wyodrębnić cyfr numeru przy użyciu kilku metod, niektóre istotne w C.

Od Greg Hewgill's answer:

/* count number of digits */ 
int c = 0; /* digit position */ 
int n = number; 

while (n != 0) 
{ 
    n /= 10; 
    c++; 
} 

int numberArray[c]; 

c = 0;  
n = number; 

/* extract each digit */ 
while (n != 0) 
{ 
    numberArray[c] = n % 10; 
    n /= 10; 
    c++; 
} 

Answer 3

Zastanawianie się liczba cyfr jest trudne, ale zakładając, że zawsze 4 cyfry można temat:

for (i = 0; i < 4; i++) { 
    numberArray[i] = number%10; 
    number = number div 10; 
} 

Answer 4

kod C:

/* one decimal digit takes a few more than 3 bits. (2^3=8, 2^4=16) */ 
int digits[(sizeof (int) * CHAR_BIT)/3 + 1], 
    *digitsp = digits; 
do { 
    *digitsp++ = number % 10; 
    number /= 10; 
} while(number > 0); 

Zobaczysz ile cyfr ty przekształcone poprzez różnicę

digitsp - digits 

Jeśli chcesz umieścić go na funkcję:

#define MIN_DIGITS_IN_INT ((sizeof (int) * CHAR_BIT)/3 + 1) 

int to_array(int number, int *digits) { 
    int *digitsp = digits; 
    do { 
     *digitsp++ = number % 10; 
     number /= 10; 
    } while(number > 0); 
    return digitsp - digits; 
} 

int main() { 
    int number = rand(); 
    int digits[MIN_DIGITS_IN_INT]; 
    int n = to_array(number, digits); 

    /* test whether we're right */ 
    while(n-- > 0) 
     printf("%d", digits[n]); 
    } 
    printf(" = %d\n", number); 
} 

Preferuję automatyczny arr ays do dynamicznego przydzielania pamięci w tym przypadku, ponieważ łatwiej jest zrobić to dobrze i nie przeciekać przypadkowo.

Answer 5

Jeśli musisz uwzględnić liczby ujemne, możesz potrzebować dodatkowej logiki. W rzeczywistości, gdy grasz z tablicami, nie wiesz, ile to jest z góry, możesz chcieć zrobić jeszcze więcej kontroli bezpieczeństwa, a dodanie API do obsługi struktury danych jest bardzo wygodne.

// returns the number of digits converted 
// stores the digits in reverse order (smalles digit first) 
// precondition: outputdigits is big enough to store all digits. 
// 
int convert(int number, int* outputdigits, int* signdigit) { 

    int* workingdigits = outputdigits; 

    int sign = 1; 
    if(number < 0) { *signdigit = -1; number *= -1; } 
    ++workingdigits; 

    for (; number > 0; ++ workingdigits) { 
    *workingdigits = number % 10; 
    number = number/10; 
    } 

    return workingdigits - outputdigits; 
} 

void printdigits(int* digits, int size, int signdigit) { 
    if(signdigit < 0) printf("-"); 

    for(int* digit = digits+size-1; digit >= digits; --digit){ 
    printf("%d", *digit); 
    } 
} 

int main() { 
    int digits[10]; 
    int signdigit; 
    printdigits(digits, convert(10, digits, &signdigit), signdigit); 
    printdigits(digits, convert(-10, digits, &signdigit), signdigit); 
    printdigits(digits, convert(1005, digits, &signdigit), signdigit); 

} 

Answer 6

Można obliczyć liczbę cyfr w liczbie całkowitej za pomocą logarytmu zamiast pętli. Zatem

int * toArray(int number) 
{ 
    int n = log10(number) + 1; 
    int i; 
    int *numberArray = calloc(n, sizeof(int)); 
    for (i = 0; i < n; ++i, number /= 10) 
    { 
     numberArray[i] = number % 10; 
    } 
    return numberArray; 
} 

Answer 7

użyciu kodu Vadima, wymyśliłem tego programu testowego:

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

char * convertNumberIntoArray(unsigned int number) { 
    unsigned int length = (int)(log10((float)number)) + 1; 
    char * arr = (char *) malloc(length * sizeof(char)), * curr = arr; 
    do { 
     *curr++ = number % 10; 
     number /= 10; 
    } while (number != 0); 
    return arr; 
} 



int main(void) 
{ 
    int InputNumber; 
    int arr[5]; 

    printf("enter number: \n"); 
    scanf("%d", &InputNumber); 

    convertNumberIntoArray(InputNumber); 

    printf("The number components are: %d %d %d\n", arr[0],arr[1],arr[2]); 

    system("PAUSE");  
    return 0; 
} 

ale wyjście jest śmieci. Czy ktoś może doradzić, czy zrobiłem coś głupiego tutaj?

/***** output *****/ 
enter number: 
501 
The number components are: 2009291924 2009145456 -1 
Press any key to continue . . . 

--dave

Answer 8

Spróbuj tego,

void initialise_array(int *a, int size, int num) { 
    for (int i = 0; i < size; ++i, num /= 10) 
     a[(size - 1) - i] = num % 10; 
}