C - Intentando convertir una cantidad no especificada de dígitos ingresados ​​en sus respectivas palabras individuales

Question

Sé que esto es algo similar al programa que convierte dígitos en palabras usando cosas como "miles", "cien", etc. Sin embargo, estoy buscando tomar un entero de cualquier tamaño (como 543210) y crear una salida de "Cinco cuatro tres dos dos un cero". Estoy usando una declaración Switch que creo que entiendo completamente y tengo trabajo. Estoy atrapado en usar algún tipo de bucle para soltar cada dígito del entero e imprimir su palabra, luego repita para el siguiente dígito y el siguiente. Soy bastante nuevo en todo esto, ¡así que cualquier ayuda sería apreciada! Gracias.

Esto es lo que tengo hasta ahora (no mucho, pero estoy atrapado en dónde ir con un bucle):

#include <stdio.h>

int main(void)
{
        int num;

        printf("Please enter an integer: \n");
        scanf("%d", & num);

        while (num==0)
        {
        switch (num)
        {
                case (0):
                        printf("Zero ");
                        break;
                case (1):
                        printf("One ");
                        break;
                case (2):
                        printf("Two ");
                        break;
                case (3):
                        printf("Three ");
                        break;
                case (4):
                        printf("Four ");
                        break;
                case (5):
                        printf("Five ");
                        break;
                case (6):
                        printf("Six ");
                        break;
                case (7):
                        printf("Seven ");
                        break;
                case (8):
                        printf("Eight ");
                case (8):
                        printf("Eight ");
                        break;
                case (9):
                        printf("Nine ");
                        break;
                case (10):
                        printf("Ten ");
                        break;

        }
        }
        return 0;

}

Answer 1

La forma más fácil de hacer esto es consumir los dígitos del lado derecho usando la división entera "/" y "%".

Aquí hay algún código parcial:

int digit;
//start a loop
//if num > 10
digit = num % 10;
num = num / 10;
//else
digit = num;
//break the loop

Eso imprimirá los números de derecha a izquierda. Si desea izquierda a la derecha, puede hacer una función recursiva que si Num> 10 se llama a sí mismo con el parámetro de Num / 10, y luego imprime el valor del dígito.

Editar: aquí hay un ejemplo de su función recursiva:

void convertToWords (int num){
    if (num > 10){
        convertToWords(num / 10);
    int digit = num % 10;
    //your switch statement to print the words goes here
}

Answer 2

Por lo tanto, puede intentar leer una cadena con FGETS y bucle hasta el final de la cadena (o como en mi código de ejemplo, hasta el final de los dígitos) e imprima los nombres de los dígitos.

#include <stdio.h>

char *names[10] = {"Zero", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", };
int main()
{
    char buffer[500] = {0};
    int i = 0;
    fgets(buffer, sizeof(buffer), stdin);
    while (isdigit(buffer[i]))
        printf("%s ", names[buffer[i++] - '0']);

    return 0;
}

http://ideone.com/ba7rs3

Answer 3

La forma más comprensible de la OMI (si no la más eficiente) usa poderes de diez. Si comenzamos con el número 543210, entonces el número de dígitos está dado por log10(543210) + 1 = 6. Entonces

// start with a number
int num = 543210;
// how many digits?
int digits = log10(num) + 1; // 6
// now loop through each digit
for (int i = digits - 1; i > 0; --i) {
  int p = (int)pow(10, i);
  int digit = (num / p) % 10; // we want integer division
  switch (digit) { ... }
}

(Recuerda #include <math.h>.)

Answer 4

Un enfoque posible:

#include <stdio.h>

char *digits[10] = {
  "Zero", "One", "Two", "Three", "Four",
  "Five", "Six", "Seven", "Eight", "Nine"
};

int main() {
  int num, digit; 
  long long tenth = 1;
  printf("Please enter an integer: \n");
  scanf("%d", &num);

  while (tenth < num) {
    tenth *= 10;
  }

  while (tenth > 1) {
    tenth /= 10;
    digit = num / tenth;
    num %= tenth;
    printf("%s ", digits[digit]);
  }
  return 0;
}

Manifestación. Ahora para explicaciones:

En primer lugar, tiene poco sentido usar switch Aquí: los dígitos son bastante lineales por su naturaleza, por lo tanto, sus nombres pueden (y deben) almacenarse en una variedad de cuerdas (en su lugar (char *digits[10] en este código). Entonces podrá obtener una etiqueta para un dígito en particular simplemente accediendo a esta matriz usando este dígito como índice.

En segundo lugar, el problema clave de este programa es extraer cada dígito de la entrada por separado. Es más fácil de hacer de derecha a izquierda (tome el resultado de number % 10, asignar number / 10 a number, repita), pero aquí se deben hacer las cosas de otra manera, de izquierda a derecha. Entonces esto es lo que hacemos:

• calcular tenth - El primer poder de 10 que es más grande que el número dado (por ejemplo, si trabajamos con 546, eso será 1000)
• En cada iteración posterior:

-- dividir tenth por 10

- procesar el resultado de la división entera de number por tenth

- Asignar de nuevo a number el resto de number dividido por tenth

En la primera iteración tenth Se convierte en 100 (1000/10), 546/100 le da 5 (un entero dividido por entero es entero, los decimales se truncan), 546 % 100 le da 46, que se almacena como un número para la segunda iteración.

En la segunda iteración tenth se convierte en 10 (100/10), 46/10 le da 4, 46 % 10 le da 6. Siguiente ciclo: 10/10 => 1, 6/1 => 6, 6 % 1 => 0. Entonces tenth se ha vuelto igual a 1, y el bucle se detiene, ya que todos los dígitos se procesan.

Answer 5

Una solución sin límite inspirada en @hayri uğur koltuk

#include <ctype.h>
#include <stdio.h>
int main() {
  int ch;
  while (((ch = getc(stdin)) != EOF) && (isdigit(ch))) {
    static const char *Digit[10] = { "Zero", "One", "Two", "Three", "Four",
        "Five", "Six", "Seven", "Eight", "Nine" };
    printf("%s ", Digit[ch - '0']);
  }
  puts("\n");
  return 0;
}

Una solución recursiva simple

static void PrintDigit(unsigned n) {
  static const char *Digits[10] = {
    "Zero", "One", "Two", "Three", "Four",
    "Five", "Six", "Seven", "Eight", "Nine" };
  if (n > 9) {
    PrintDigit(n/10);
  }
  printf("%s ", Digits[n%10]);
}

void PrintDigits(unsigned n) {
  PrintDigit(n);
  printf("\n");
}