convertir un nombre entier dans un tableau

Question

Je suis en train de convertir un nombre entier en C dans un tableau contenant chacun que les chiffres du nombre

à savoir si j'ai

int number = 5400 

comment puis-je à

int numberArray[4] 

où

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

Toute suggestion reçue avec gratitude.

Answer 1

Cela fonctionnerait pour les nombres> = 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; 
} 

EDIT: Juste un peu plus de style C mais plus cryptique.

#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

Indice: Jetez un oeil à cette question précédente "Sum of digits in C#". Il explique comment extraire les chiffres du numéro à l'aide de plusieurs méthodes, certaines pertinentes en C.

De 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

Déterminer le nombre de chiffres est délicate, mais en supposant qu'il est toujours 4 chiffres, vous pouvez ne:

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

Answer 4

Code 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); 

Vous verrez comment vous avez converti en prenant la différence

digitsp - digits 

de chiffres Si vous voulez le mettre en fonction:

#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); 
} 

Je préfère automatique arr Ays à l'allocation de mémoire dynamique dans ce cas, car il est plus facile de le faire correctement et ne pas fuir accidentellement.

Answer 5

Si vous devez prendre en compte des nombres négatifs, vous aurez peut-être besoin d'une logique supplémentaire. En fait, lorsque vous jouez avec des tableaux, vous ne connaissez pas la taille d'upfront, vous pouvez vouloir faire plus de vérification de sécurité, et ajouter une API pour gérer la structure des données est très pratique aussi.

// 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

Vous pouvez calculer le nombre de chiffres d'un nombre entier avec un logarithme plutôt qu'une boucle. Ainsi,

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

en utilisant le code de vadim, je suis venu avec ce programme de test:

#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; 
} 

mais la sortie est une ânerie. Quelqu'un peut-il conseiller si j'ai fait quelque chose de stupide ici?

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

--dave

Answer 8

Essayez ceci,

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