Suma de n numeros

[jocris]

Alguen podria ayudarme en el siguiente ejercicio?
Necesito un programa para sumar N números al cuadrado. Por ejemplo: Si introduzco el número 3, el programa tiene que sumarme (1*1)+(2*2)+(3*3) y darme el resultado.
Si el número que entro es 5 tiene que hacer la suma de cuadrados hasta 5 y así sucesivamente.

Muchas gracias

[Mort20]

Debes usar un bucle (for por ejemplo, que te será más práctico para el caso). Durante el for vas viendo todos los números que debes sumar su cuadrado. A partir de ahí piensa en como vas guardando los resultados ;)

[cadetill]

Otra opción es hacer una función recursiva

Código:

int SumaCuadrados(int &valor)
{
  if (valor == 1) return 1;
  return SumaCuadrados(*valor--) + (valor * valor);
}

No lo he comprobado y como he dicho "por ahí" estoy empezando con c++ y mi sintaxis no es mi fuerte y seguro que hay algún error, pero la base sería esa :P

El tipo de dato devuelto limitará el valor pasado por parámetro (hay que controlarlo para que no se pase de rango y pete el programa).

Espero te sirva

Nos leemos

[jocris]

Gracias por tu respuesta, pero hace poco que me he aficionado a programar y te agradeceria que me pusieras algun ejemplo.
Muchas gracias.

[Mort20]

No es que sepa mucho, pero cómo decís que estáis empezando y eso, unos consejos (espero que no os parezca mal ;):

Bueno, cadetill tu código tiene un error:

Código:

int SumaCuadrados(int &valor)

Aquí valor lo pasas por referencia, sin embargo en el cuerpo de la función lo usas como puntero. Para hacerlo puntero debes poner int* valor; y entonces "valor" a secas, por decirlo de algún modo, contiene la dirección en memoria dónde está ubicado el entero. Y *valor accede al valor de dicho entero.

Así que en tu función - asumiendo que sigue como referencia - sólo debes cambiar el *valor-- por valor--.

Aunque yo pasaría el parámetro por valor de toda la vida y listo, ya que no veo la utilidad de hacer esto por referencia. Y a mi los profesores en 2º de carrera me tiraron de las orejas un montón de veces para que no pusiera returns y parámetros por referencia en la misma función a no ser que fueran casos excepcionales para hacerlo mas eficiente o porque era necesario XDDDD Ahoira me doy cuenta que tenían razón, pero los motivos no vienen al caso xD

Luego jocris, un ejemplo con tu programa comentado:

Código:

#include <iostream>
using namespace std;

int main ()
{
    int num;
      cin>>num;

    int aux = 0; //en esta variable iremos almacenando el valor de las sumas
     for(int c = 1; c<=num; ++c) //no nos interesa usar el 0, pero si usar num, así que empezamos des de 1.
     {
          aux += c*c; //0 + 1*1 en la 1a iteración, 1*1+2*2 en la 2a... y así sucesivamente
     }

   cout << aux << endl; //aquí tenemos nuestra suma

   //personalmente nunca pongo un return 0; al acabar el main salvo que use alguna cosa "especial", pero esto depende mucho del programador, y después de todo en el assembler no hay variación por lo general.
}

Se podría poner en una función y sería más apropiado porque podríamos usarlo para programas futuros.
Sobre si debe ser iterativo o recursivo, yo siempre me miro la eficiencia. La iteración es más rápida que la recursividad si es simple, pero si tenemos que hacer cosas complejas puede que si se puede hacer iterativo, sea más lento que uno recursivo, o directamente no se pueda hacer un modelo itertivo.

Por ejemplo, recorriendo un árbol binario, si lo hacemos recursivo podremos ver en la misma pasada el hijo izquierdo y el derecho. Sin embargo si es iterativo tendremos que usar un bucle para el izquierdo, y otro para el derecho. Y así en cada subárbol. Con lo que el iterativo sería un modelo significativamente más lento pese a que los bucles sean más rápidos. Y además, casi seguro que en el iterativo deberíamos hacer una llamada recursiva ya que no sabemos cuantos subárboles nos vamos a encontrar. Así que doblemente lento.

En este caso, hacerlo recursivo hace que sea más lento porque vamos llamando un número n de veces la misma función, y eso en código assembler se traduce en unas cuantas líneas más, que a su vez se traduce en más espacio ocupado en memoria. Si es iterativo, tienes el cuerpo del bucle en assembler una vez, y luego 2 instrucciones más - lo digo a boleo - una de comparación por si ya hemos acabado y otra de salto a otra vez el bucle, o al final del bucle. Con lo que en memoria tendremos el mismo espacio ocupado independientemente del número de iteraciones.

[jocris]

Mort20 Muchisimas gracias me ha sido de gran ayuda. Voy a mandar otro problema por si también pudieras ayudarme.

Mil gracias por el tiempo que me has dedicado!!!!