preguntas - tag de las canciones instagram

Obtener cada dígito individual de un entero entero

Question

Digamos que tengo un entero llamado ''score'', que se ve así:

int score = 1529587;

Ahora lo que quiero hacer es obtener cada dígito 1, 5, 2, 9, 5, 8, 7 del puntaje utilizando operadores bitwise (vea la nota de edición a continuación).

Estoy bastante seguro de que esto se puede hacer, ya que una vez usé un método similar para extraer los valores verde y azul rojos de un valor de color hexadecimal.

¿Cómo haría esto?

Editar
No necesariamente tiene que ser operadores bit a bit, solo pensé que sería más simple de esa manera.

Answer 1

De acuerdo con las respuestas anteriores.

Una pequeña corrección: hay una mejor manera de imprimir los dígitos decimales de izquierda a derecha, sin asignar un búfer adicional. Además, es posible que desee mostrar un carácter cero si la score es 0 (el bucle sugerido en las respuestas anteriores no se imprimirá nada).

Esto exige un pase adicional:

int div;
for (div = 1; div <= score; div *= 10)
    ;

do
{
    div /= 10;
    printf("%d/n", score / div);
    score %= div;
} while (score);

Answer 2

Esta solución proporciona resultados correctos en todo el rango [0, UINT_MAX] sin requerir que los dígitos se almacenen en búfer.

También funciona para tipos más amplios o tipos con signo (con valores positivos) con cambios de tipo apropiados.

Este tipo de enfoque es particularmente útil en entornos pequeños (p. Ej., El cargador de arranque Arduino) porque no termina tirando de la gran cantidad de printf () (cuando printf () no se usa para la salida de demostración) y usa muy poca RAM. Puede ver el valor con solo parpadear un solo led :)

#include <limits.h>
#include <stdio.h>

int
main (void)
{
  unsigned int score = 42;   // Works for score in [0, UINT_MAX]

  printf ("score via printf:     %u/n", score);   // For validation

  printf ("score digit by digit: ");
  unsigned int div = 1;
  unsigned int digit_count = 1;
  while ( div <= score / 10 ) {
    digit_count++;
    div *= 10;
  }
  while ( digit_count > 0 ) {
    printf ("%d", score / div);
    score %= div;
    div /= 10;
    digit_count--;
  }
  printf ("/n");

  return 0;
}

Answer 3

Generalmente, este problema se resuelve con el uso del módulo de un número en un bucle o convertir un número en una cadena. Para convertir un número en una cadena, puede usar la función itoa , considerando la variante con el módulo de un número en un bucle.

Contenido de un archivo get_digits.c

$ cat get_digits.c 

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


// return a length of integer
unsigned long int get_number_count_digits(long int number);

// get digits from an integer number into an array
int number_get_digits(long int number, int **digits, unsigned int *len);

// for demo features
void demo_number_get_digits(long int number);


int
main()
{
    demo_number_get_digits(-9999999999999);
    demo_number_get_digits(-10000000000);
    demo_number_get_digits(-1000);
    demo_number_get_digits(-9);
    demo_number_get_digits(0);
    demo_number_get_digits(9);
    demo_number_get_digits(1000);
    demo_number_get_digits(10000000000);
    demo_number_get_digits(9999999999999);
    return EXIT_SUCCESS;
}


unsigned long int
get_number_count_digits(long int number)
{
    if (number < 0)
        number = llabs(number);
    else if (number == 0)
        return 1;

    if (number < 999999999999997)
        return floor(log10(number)) + 1;

    unsigned long int count = 0;
    while (number > 0) {
        ++count;
        number /= 10;
    }
    return count;
}


int
number_get_digits(long int number, int **digits, unsigned int *len)
{
    number = labs(number);

    // termination count digits and size of a array as well as
    *len = get_number_count_digits(number);

    *digits = realloc(*digits, *len * sizeof(int));

    // fill up the array
    unsigned int index = 0;
    while (number > 0) {
        (*digits)[index] = (int)(number % 10);
        number /= 10;
        ++index;
    }

    // reverse the array
    unsigned long int i = 0, half_len = (*len / 2);
    int swap;
    while (i < half_len) {
        swap = (*digits)[i];
        (*digits)[i] = (*digits)[*len - i - 1];
        (*digits)[*len - i - 1] = swap;
         ++i;
    }

    return 0;
}


void
demo_number_get_digits(long int number)
{
    int *digits;
    unsigned int len;

    digits = malloc(sizeof(int));

    number_get_digits(number, &digits, &len);

    printf("%ld --> [", number);
    for (unsigned int i = 0; i < len; ++i) {
        if (i == len - 1)
            printf("%d", digits[i]);
        else
            printf("%d, ", digits[i]);
    }
    printf("]/n");

    free(digits);
}

Demo con el GNU GCC

$~/Downloads/temp$ cc -Wall -Wextra -std=c11 -o run get_digits.c -lm
$~/Downloads/temp$ ./run
-9999999999999 --> [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9]
-10000000000 --> [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-1000 --> [1, 0, 0, 0]
-9 --> [9]
0 --> [0]
9 --> [9]
1000 --> [1, 0, 0, 0]
10000000000 --> [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
9999999999999 --> [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9]

Demo con el LLVM / Clang

$~/Downloads/temp$ rm run
$~/Downloads/temp$ clang -std=c11 -Wall -Wextra get_digits.c -o run -lm
setivolkylany$~/Downloads/temp$ ./run
-9999999999999 --> [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9]
-10000000000 --> [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-1000 --> [1, 0, 0, 0]
-9 --> [9]
0 --> [0]
9 --> [9]
1000 --> [1, 0, 0, 0]
10000000000 --> [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
9999999999999 --> [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9]

Entorno de prueba

$~/Downloads/temp$ cc --version | head -n 1
cc (Debian 4.9.2-10) 4.9.2
$~/Downloads/temp$ clang --version
Debian clang version 3.5.0-10 (tags/RELEASE_350/final) (based on LLVM 3.5.0)
Target: x86_64-pc-linux-gnu
Thread model: posix

Answer 4

Los valores RGB caen bien en los límites de bits; los dígitos decimales no. No creo que haya una manera fácil de hacer esto usando operadores bitwise en absoluto. Necesitaría usar operadores decimales como módulo 10 (% 10).

Answer 5

No reinventes la rueda. C tiene sprintf por una razón. Como su variable se llama puntuación, supongo que esto es para un juego en el que planea usar los dígitos individuales de la puntuación para mostrar los glifos numéricos como imágenes. En este caso, sprintf tiene convenientes modificadores de formato que le permitirán usar la almohadilla de cero, la almohadilla de espacio, etc., la puntuación a un ancho fijo, que tal vez quiera usar.

Answer 6

Usted utiliza el operador de módulo:

while(score)
{
    printf("%d/n", score % 10);
    score /= 10;
}

Tenga en cuenta que esto le dará los dígitos en orden inverso (es decir, primero el dígito menos significativo). Si desea primero el dígito más significativo, deberá almacenar los dígitos en una matriz y luego leerlos en orden inverso.

Answer 7

#include<stdio.h>

int main() {
int num; //given integer
int reminder;
int rev=0; //To reverse the given integer
int count=1;

printf("Enter the integer:");
scanf("%i",&num);

/*First while loop will reverse the number*/
while(num!=0)
{
    reminder=num%10;
    rev=rev*10+reminder;
    num/=10;
}
/*Second while loop will give the number from left to right*/
while(rev!=0)
{
    reminder=rev%10;
    printf("The %d digit is %d/n",count, reminder);
    rev/=10;
    count++; //to give the number from left to right 
}
return (EXIT_SUCCESS);}

Answer 8

//this can be easily understandable for beginners     
int score=12344534;
int div;
for (div = 1; div <= score; div *= 10)
{

}
/*for (div = 1; div <= score; div *= 10); for loop with semicolon or empty body is same*/
while(score>0)
{
    div /= 10;
    printf("%d/n`enter code here`", score / div);
    score %= div;
}