Dividir un entero en sus dígitos c ++

Estoy tratando de aprender c ++ por mi cuenta y me he topado con un poco de locking. El problema es que necesito tomar un número entero, dividirlo en sus dígitos y obtener la sum de los dígitos y mostrarlos.

Ejemplo:

número de entrada: 123456
dígitos en el entero: 1 2 3 4 5 6
sum: 21

Lo hice todo, pero cuando copié el entero, en dígitos no puedo mostrarlo correctamente. Se muestra en orden inverso.

Así que en el progtwig de abajo, entro en 1234 y se escupe 4 3 2 1 . Sé por qué, simplemente no sé cómo arreglarlo.

Aquí está mi código hasta ahora:

 #include "stdafx.h" #include  #include  #include  int countDigitsInInteger(int n) { int count =0; while(n>0) { count++; n=n/10; } return count; } using namespace std; int main(int argc, char *argv[]) { int intLength =0; int number; int digit; int sum = 0; string s; cout <>number; cout << "Orginal Number = "<<number <<endl; //make the number positive if (number0) { digit = number % 10; number = number / 10; cout <<digit << " "; sum = sum+digit; } cout <<endl <<"Sum of the digits is: "<<sum<<endl; system("PAUSE"); return EXIT_SUCCESS; } 

Aquí está mi solución

no puedo ver 🙂

Su problema proviene del hecho de que está leyendo los dígitos al revés, por lo que necesita imprimirlos al revés. Una stack te ayudará tremendamente.

 #include "stdafx.h" #include  #include  #include  #include  int countDigitsInInteger(int n) { int count =0; while(n>0) { count++; n=n/10; } return count; } using namespace std; int main(int argc, char *argv[]) { int intLength =0; int number; int digit; int sum = 0; string s; cout << "Please enter an integer "; cin >>number; cout << "Orginal Number = "< digitstack; while(number>0) { digit = number % 10; number = number / 10; digitstack.push(digit); sum = sum+digit; } while(digitstack.size() > 0) { cout << digitstack.top() << " "; digitstack.pop(); } cout < 

Ah, y por cierto, mantén tu sangría limpia. Es importante.

EDITAR: En respuesta a Steve Townsend, este método no es necesariamente una exageración, es simplemente diferente al tuyo. El código puede reducirse para que parezca menos una exageración:

 #include  #include  #include  using namespace std; int getInput(string prompt) { int val; cout << prompt; cin >> val; return val < 0 ? -val : val; } int main(int argc, char** argv) { int num = getInput("Enter a number: "); cout << "Original Number: " << num << endl; stack digits; int sum = 0; while(num > 0) { digits.push(num % 10); sum += digits.top(); num = num / 10; } while(digits.size() > 0) { cout << digits.top() << " "; digits.pop(); } cout << endl << "Sum of digits is " << sum << endl; return 0; } 

La stack y la recursión son excesivas para este problema. Simplemente almacene cada dígito en una cadena y luego inviértalo antes de la salida. Debe trabajar en cómo llamar a la reverse con los miembros de la string para que esto funcione. for_each se puede utilizar para generar cada elemento de la cadena.

Para obtener crédito adicional (en virtud de la concisión y expresividad), inserte el número directamente en una stream de ostring y utilícelo como base para su string reversible.

Mi versión de stringstream de este código es de 5 líneas. La lógica es:

  • declarar cadena de caracteres
  • declarar int con valor
  • salida int a stringstream
  • crear cadena desde stringstream
  • for_each el dígito resultado por dígito usando for_each .

Puede sumr los dígitos utilizando la acumulación en la cadena, proporcione el hecho de que int('1') != 1 . Son dos líneas adicionales, para sumr los dígitos y generar el resultado.

El punto no es que hacer esto a través de la stack o la recursión sea MALO, es solo que una vez que te familiarices más con el STL, normalmente hay formas más elegantes de hacer un trabajo que las obvias. La implementación de este uso de stack, recursión y cualquier otra forma que se pueda imaginar convierte a una tarea simple en una gran experiencia de aprendizaje del mundo real.

Aquí está el código accumulate para sumr los miembros de una string consta de dígitos decimales, por ejemplo:

 #include  #include  std::string intString("654321"); int sum = accumulate(intString.begin(), intString.end(), 0) - (intString.size() * int('0')); 

EDITAR: aquí está el código completo, con fines comparativos:

 ostringstream intStream; int value(123456); intStream << value; string intString(intStream.str()); for_each(intString.begin(), intString.end(), [] (char c) { cout << c << endl; }); int sum = accumulate(intString.begin(), intString.end(), 0) - (intString.size() * int('0')); cout << "Sum is " << sum << endl; 

No olvidemos el enfoque de cadena , que también me parece elegante.

 #include  #include  int main() { int num = 123456789; std::cout << "Number: " << num << std::endl; std::stringstream tmp_stream; tmp_stream << num; std::cout << "As string: " << tmp_stream.str() << std::endl; std::cout << "Total digits: " << tmp_stream.str().size() << std::endl; int i; for (i = 0; i < tmp_stream.str().size(); i++) { std::cout << "Digit [" << i << "] is: " << tmp_stream.str().at(i) << std::endl; } return 0; } 

Salidas:

 Number: 123456789 As string: 123456789 Total digits: 9 Digit [0] is: 1 Digit [1] is: 2 Digit [2] is: 3 Digit [3] is: 4 Digit [4] is: 5 Digit [5] is: 6 Digit [6] is: 7 Digit [7] is: 8 Digit [8] is: 9 

Empuje los dígitos en una stack.

Después de que hayas obtenido todos los dígitos,

  sum = 0 ; while( stack not empty ) { pop the stack to get a digit sum += digit display digit } display sum 

Necesitas una stack, dices? Use la stack de STL: std::stack

 digit = number % 10; 

Esta operación devolverá el número más correcto.

por lo tanto, cuando intente acceder a su aplicación con una entrada “1357”, en la primera ejecución a través del ciclo while, devolverá 7. Luego, devolverá 5, y así sucesivamente.

Si todo lo que desea es la sum de los dígitos individuales, entonces el orden en que los obtenga (y los imprima) no afectará la respuesta final. Si aún desea que se impriman en el orden correcto, puede almacenar los dígitos en una matriz (o Vector o Pila, como han mencionado otros), invertir el contenido y luego recorrer la estructura para imprimir su contenido.

Use std :: stack para almacenar dígitos separados, luego imprima el contenido de la stack.

Aquí hay un buen artículo: http://en.wikipedia.org/wiki/Stack_(data_structure )

aquí es cómo usar stacks en C ++: http://www.sgi.com/tech/stl/stack.html

Tendrá que almacenarlos e imprimirlos en orden inverso, o bien hacer una recursión e imprimir después de la llamada recursiva.

 int printdigits(int number) { if (number == 0) return 0; int digit = number % 10; int sum = printdigits(number / 10); cout < 

Tu sangría es horrible. Dicho esto, la razón por la que sus dígitos están saliendo en orden inverso es bastante simple: está obteniendo los dígitos en orden inverso. Piénselo: está tomando un rest del número dividido por diez y luego imprimiendo el rest. Luego divides el número por 10 … y así sucesivamente. Debe almacenar los dígitos en una matriz, luego imprimir la matriz en orden inverso.

Y aprender a sangrar.

Ser una sum realmente no importa el orden, pero la lógica que está utilizando lo divide del dígito menos significativo al más significativo (y es la forma más fácil).

Pondré un ejemplo de buena fe de que no lo reproducirá, si se trata de una tarea, utilícela como una oportunidad para aprender …

 // reference: www.cplusplus.com #include  #include  #include  #include  #include  using namespace std; // What does this do? template  struct gen { gen(T start) : _num(start) {} // Do we need these? But why have I commented them out? //gen(gen const& copy) : _num(copy._num) {} //gen& operator=(gen const& copy) { _num = copy._num; } //~gen() {} // Why do we do this? T operator()() { T digit = _num % 10; _num /= 10; return digit; } T _num; }; // How is this different to the above? template  bool check_non_zero (T i) { return i != 0; } // And this? what's going on here with the parameter v? template  T sum_of_digits(T value, std::vector& v) { // Why would we do this? if (value == 0) { v.push_back(0); return 0; } // What is the purpose of this? v.resize(_size); // What is this called? gen gen_v(value); // generate_n? What is this beast? what does v.begin() return? where did _size come from? generate_n(v.begin(), _size, gen_v); // reverse? what does this do? reverse(v.begin(), v.end()); // erase? find_if? what do they do? what the heck is check_non_zero? v.erase(v.begin(), find_if(v.begin(), v.end(), check_non_zero)); // what the heck is accumulate? return accumulate(v.begin(), v.end(), 0); } int main() { // What does this do? vector v; // What is this peculiar syntax? NOTE: 10 here is because the largest possible number of int has 10 digits int sum = sum_of_digits(123, v); cout << "digits: "; // what does copy do? and what the heck is ostream_iterator? copy(v.begin(), v.end(), ostream_iterator(cout, " ")); cout << endl; cout << "sum: " << sum << endl; // other things to consider, what happens if the number is negative? return 0; } 

Utilicé esto para la entrada de 5 números

int main () {

using namespace std;

int number ; `

 cout << "Enter your digit: "; cin >> number; if (number == 0) return 0; int a = number % 10; int second = (number / 10); int b = second % 10; int third = (second / 10); int c = third % 10; int fourth = (third / 10); int d = fourth % 10; int fifth = (fourth / 10); int e = fifth % 10; cout << e << " " << d << " " << c << " " << b << " " << a << endl; return 0; 

}

Una solución simple:

 int n = 12345; vector digits; while (n != 0) { digits.insert(digits.begin(), n%10); n /= 10; } for(auto & i : digits) cout << i << " "; 

salida: 1 2 3 4 5