convertir un número entero en una matriz

5 minutos de lectura

avatar de usuario
drosman

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]

donde

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

Cualquier sugerencia recibida con gratitud.

avatar de usuario
vava

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

  • ¿Por qué esta función es un puntero de caracteres? ¿Y qué significa nuevo personaje?[length] ¿hacer? Parece un puntero al primer índice de la matriz, pero a mi compilador no parece gustarle el ‘nuevo carácter’

    – drosman

    5 de febrero de 2009 a las 15:36

  • ‘nuevo char’ es lenguaje C++. La forma correcta de hacerlo en C es el segundo bit de código.

    – Chris Lutz

    5 de febrero de 2009 a las 15:46

  • Además, es importante que, al final de su programa, llame free() en cualquier matriz que obtuviste de esta función. De lo contrario, pierdes memoria.

    – Chris Lutz

    5 de febrero de 2009 a las 15:53

  • ¿No debería esto devolver int *?

    – Nick Presta

    5 de febrero de 2009 a las 15:53

  • Podría, pero no hay razón para usar 4 bytes int para almacenar dígitos de 4 bits. Char es una forma más compacta de hacerlo, aunque podría sustituirse fácilmente por ints.

    -vava

    6 de febrero de 2009 a las 0:25

avatar de usuario
Zach Scrivena

Sugerencia: eche un vistazo a esta pregunta anterior “Suma de dígitos en C#”. Explica cómo extraer los dígitos del 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++;
}

  • ¡Puro y simple!

    – RaGa__M

    14 de julio de 2018 a las 11:52

Podría calcular la cantidad de dígitos en un número entero con logaritmo en lugar de un bucle. Por lo tanto,

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

avatar de usuario
Dylan R Coss

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

Si necesita tener en cuenta los números negativos, es posible que necesite algo de lógica adicional. De hecho, cuando juegas con arreglos que no conoces por adelantado, es posible que desees realizar 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 );

}

  • no se requieren números negativos, afortunadamente. Es un contador de horas de conteo progresivo. Sin embargo, es posible que este número sea bastante grande.

    – drosman

    5 de febrero de 2009 a las 13:50

avatar de usuario
Praveen Manupati

#include <stdio.h>
#include <string.h>

int main(void)
{
  int i, inputNumber;
  char* charArray;

  printf("\nEnter number: ");
  scanf("%d", &inputNumber);

  /* converts int to print buffer which is char array */
  sprintf(charArray, "%d", inputNumber); 
  int size = strlen(charArray);

  int intArray[size];

  for (i = 0; i < size; i++)
  {
    intArray[i] = charArray[i] - '0';
  }

  return 0;
}

  • no se requieren números negativos, afortunadamente. Es un contador de horas de conteo ascendente. Sin embargo, es posible que este número sea bastante grande.

    – drosman

    5 de febrero de 2009 a las 13:50

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á cuántos dígitos convirtió tomando 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);
}

Prefiero las matrices automáticas a la asignación de memoria dinámica en este caso, ya que es más fácil hacerlo bien y no tener fugas accidentales.

  • “¿Un poco más de 3 bits?” Creo que acabas de ganar algún tipo de premio de fraseo.

    – relajarse

    5 de febrero de 2009 a las 12:34

  • sí, me imagino que suena extraño oO déjame cambiarlo

    – Johannes Schaub – litb

    5 de febrero de 2009 a las 12:35

  • Impresionante cómo diferentes rutas lógicas producen los mismos resultados 🙂 32 / 3 + 1 es casi lo mismo que log10 (2 ** 32) + 1 == log2 (2 ** 32) / log2 (10) + 1 == 32 / log2(10) + 1 < 32 / 3 + 1

    -vava

    5 de febrero de 2009 a las 13:06

  • ¿Puedes explicar MIN_DIGITS_IN_INT ((sizeof (int) * CHAR_BIT) / 3 + 1)?

    – yesraaj

    5 de febrero de 2009 a las 15:42

  • rajKumar, debe ser una constante de tiempo de compilación. así que no usé log10. necesita 3.32193 bits para almacenar un lugar decimal (ld(10)) – diez decisiones binarias. eso significa que no puede almacenar más de (tamaño de (int) * CHAR_BIT)/3.32193 lugares en un int, que es 9.63296

    – Johannes Schaub – litb

    5 de febrero de 2009 a las 19:09

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad