C – Emite convertir un número generado por el usuario en palabras

Así que he estado trabajando en la Progtwigción en C de Kochan y he acertado en una de las preguntas que se lee a continuación:

“Escriba un progtwig que tome un entero ingresado desde el terminal y extraiga y muestre cada dígito del entero en inglés. Entonces, si el usuario escribe en 932, el progtwig debería mostrar lo siguiente: nueve tres dos (Recuerde mostrar cero si el tipos de usuario en sólo 0.) ”

Logré que el progtwig imprimiera los dígitos como palabras pero, desafortunadamente, en orden inverso. Desde allí pensé que podría ser una buena idea revertir el número, por así decirlo, pero ahora, cuando ejecuto ese valor a través de mi progtwig, solo se imprime “uno uno …” para el número de dígitos del número que ingrese en.

En otras palabras, originalmente logré mostrar 932 como “dos tres nueve”, pero cuando intenté invertir el número y ejecutar el 239 a través de mi progtwig, solo obtengo “one one one”.

Si alguien tiene algún indicio que pueda orientarme en la dirección correcta, sería muy apreciado. Mi código está abajo:

#include  int digitCount (int); int reverseNumber (int); int main(void) { //Chapter 6 Problem 6 int x, numberValue; printf("Enter the number you'd like converted to words\n"); scanf("%i", &x); numberValue = reverseNumber(x); printf("The reverse is %i\n", numberValue); do { numberValue = numberValue % 10; switch (numberValue) { case 0: printf("zero\t"); break; case 1: printf("one\t"); break; case 2: printf("two\t"); break; case 3: printf("three\t"); break; case 4: printf("four\t"); break; case 5: printf("five\t"); break; case 6: printf("six\t"); break; case 7: printf("seven\t"); break; case 8: printf("eight\t"); break; case 9: printf("nine\t"); break; default: break; } x = x / 10; } while (x != 0); return 0; } int digitCount (int u) { int cnt = 0; do { u = u / 10; cnt++; } while (u != 0); return cnt; } int reverseNumber (int y) { int cnt, Rev; cnt = digitCount(y); //returns number of digits while (cnt != 0) { Rev = Rev * 10 + y % 10; y = y / 10; cnt--; } return Rev; } 

En su función reverseNumber no ha inicializado Rev Hacer Rev=0

 int reverseNumber (int y) { int cnt, Rev=0; cnt = digitCount(y); //returns number of digits printf("Digit count %d\n", cnt); while (cnt != 0) { Rev = Rev * 10 + y % 10; y = y / 10; cnt--; } return Rev; } 

En main en el ciclo do while while use una variable temporal ya que está sobrescribiendo numberValue con numberValue % 10 . Pero la parte más irónica de tu progtwig ( donde complicaste todo por ti mismo ) es que no hay necesidad de invertir el número en absoluto. Ver el codigo aqui

  1. En la forma en que el usuario ingresó – http://ideone.com/pORaP2
  2. En orden inverso – http://ideone.com/5GS8al

Cuando encuentras módulo, obtienes el número en el orden inverso. Supongamos que ingresaste 234

  1. Primer paso 234%10 da 4 impresiones four . Y luego hace 234 a 23

  2. Segundo paso 23%10 da 3 impresiones three . Y luego hace 23 a 2

y luego finalmente imprime two .

Considere cuál es el problema principal con el que está lidiando; primero debe procesar el dígito más a la izquierda, luego el siguiente a la derecha y luego el siguiente. Pero la matemática de usar módulo y división va de derecha a izquierda. Entonces, lo que necesita es alguna forma de guardar el procesamiento matemático y revertir, o retrasar la salida. Hay dos opciones disponibles.

Para un enfoque iterativo, puede utilizar un enfoque de tipo de cola FIFO que contenga los resultados de cada dígito y luego imprima la cola. Podría ser tan simple como una matriz con indexación:

 int main(void) { int x, i; int result[32]; //arbitrary size int index = 0; printf("Enter the number you'd like converted to words\n"); scanf("%i", &x); do { results[index++] = x % 10; x = x / 10; } while( index < 32 && x != 0 ); //now print in reverse order for(i = index-1; i >= 0; i--) { switch (results[i]) { case 0: printf("zero\t"); break; case 1: printf("one\t"); break; case 2: printf("two\t"); break; case 3: printf("three\t"); break; case 4: printf("four\t"); break; case 5: printf("five\t"); break; case 6: printf("six\t"); break; case 7: printf("seven\t"); break; case 8: printf("eight\t"); break; case 9: printf("nine\t"); break; default: break; } } } 

Hay un segundo enfoque que funciona que es recursivo. Aquí demora la impresión de la salida hasta que alcanza el dígito más a la izquierda. La stack integrada se utiliza para las llamadas recursivas.

 void printNumbers(int x); int main(void) { int x; printf("Enter the number you'd like converted to words\n"); scanf("%i", &x); printNumbers(x); } void printNumbers(int v) { if( v > 9 ) { printNumbers( v / 10 ); } switch (v%10) { case 0: printf("zero\t"); break; case 1: printf("one\t"); break; case 2: printf("two\t"); break; case 3: printf("three\t"); break; case 4: printf("four\t"); break; case 5: printf("five\t"); break; case 6: printf("six\t"); break; case 7: printf("seven\t"); break; case 8: printf("eight\t"); break; case 9: printf("nine\t"); break; default: break; } } 

Ambos enfoques resolverán el problema, pero no si la entrada es un número negativo.

Mi respuesta simple:

 void printNum(int x) { static const char * const num[] = { "zero ", "one ", "two " , "three ", "four ", "five ", "six ", "seven ", "eight ", "nine " }; if (x < 10) { printf(num[x]); return; } printNum(x / 10); printNum(x % 10); }