studio - superponer graficas en r

convertir un número entero en una matriz

Question

Estoy tratando de convertir un número entero en C en una matriz que contiene cada uno de los dígitos de ese número

es decir, si tengo

int number = 5400

como puedo llegar a

int numberArray[4]

dónde

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

Cualquier sugerencia recibida con gratitud

Answer 1

Averiguar el número de dígitos es complicado, pero suponiendo que siempre son 4 dígitos, puede hacer:

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

Answer 2

Código 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);

Verás cuántos dígitos convertiste al tomar la diferencia

digitsp - digits

Si quieres ponerlo en una función:

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

En este caso, prefiero los arreglos automáticos a la asignación de memoria dinámica, ya que es más fácil hacerlo bien y no filtrar accidentalmente.

Answer 3

Esto funcionaría para números> = 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;
}

EDITAR: Solo un poco más estilo C pero más críptico.

#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 4

Podría calcular la cantidad de dígitos en un entero con logaritmo en lugar de un bucle. Así,

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 5

Si necesita tener en cuenta los números negativos, es posible que necesite alguna lógica adicional. De hecho, cuando juegas con las matrices, no conoces el tamaño inicial, es posible que desees hacer más comprobaciones de seguridad, y agregar una API para manejar la estructura de los datos también es muy útil.

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

usando el código de vadim, se me ocurrió este programa de prueba:

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

pero el resultado es basura. ¿Alguien puede avisar si he hecho algo estúpido aquí?

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

--dave

Answer 7

Prueba esto,

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

Answer 8

Sugerencia: Eche un vistazo a esta pregunta anterior " Suma de dígitos en C # ". Explica cómo extraer los dígitos en el número usando varios métodos, algunos relevantes en C.

De la respuesta de Greg Hewgill :

/* 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++;
}