Representa números triangulares - C++

Se pide realizar un programa que compruebe si el número introducido por el usuario es triangular y si es así, que lo represente como un triángulo rectángulo. Se propone el siguiente código:

 1 #include <iostream>
 2  using namespace std;
 3  
 4  void imprime_linea(int);
 5  bool esTriangular(int N);
 6  
 7  int main()
 8  {
 9      int suma=0, i=1, n;
10      cout << "Intro numero: ";    cin >> n;
11  
12  if(esTriangular(n))
13      {
14          cout << "Es triangular" << endl;
15          suma=0;
16          for(int i=1; suma<n; i++)
17          {
18              suma+=i;
19              imprime_linea(i);
20          }
21      }
22      else
23          cout << "No es triangular" << endl;
24  }
25  
26  void imprime_linea(int i)
27  {
28      for(int j=0; j<i; j++)
29          cout << "*";
30  
31      cout << endl;
32  }
33  
34  bool esTriangular(int N)
35  {
36      int suma=0;
37      for(int i=1; suma<N; i++)
38          suma+=i;
39      if (suma==N)
40          return true;
41      else
42          return false;
43  }

Serie de Tribonacci - C++

Se quiere realizar un programa que muestre la serie de Tribonacci de tal forma que el usuario introduzca por teclado el número de términos que quiere que se muestren. En la solución se han utilizado dos funciones, una para el cálculo de la serie y otra para recorrer y mostrar el vector.

 1 #include <iostream>
 2  #include <vector>
 3  using namespace std;
 4  
 5  //FUNCIONES
 6  vector<int> serie_tribonacci(int);
 7  void muestra_vector(const vector<int>&);
 8  
 9  int main()
10  {
11      int terminos;
12  
13      //Numero de terminos introducidos por teclado
14      cout << "Intro numero de terminos: ";
15      cin >> terminos;
16  
17      //Para mayor optimizacion declaramos el vector con el numero de terminos
18      vector<int> v(terminos);
19  
20      //Llamada a funcion serie_tribonacci
21      v=serie_tribonacci(terminos);
22      muestra_vector(v);
23  
24      return 0;
25  }
26  
27  vector<int> serie_tribonacci(int n)
28  {
29      vector<int> v(n); //Vector de tamaño de elementos
30  
31      //Condiciones inciales
32      v.at(0)=1;
33      v.at(1)=1;
34      v.at(2)=2;
35  
36      //Recorrido del vector desde la posicion 3
37      for(size_t i=3; i<n; i++)
38          v.at(i)=v.at(i-1)+v.at(i-2)+v.at(i-3);
39  
40      return v;
41  }
42  
43  void muestra_vector(const vector<int>& v)
44  {
45      for(auto x:v)
46          cout << x << " ";
47  }

Producto de escalar por vector - Sobrecarga de operadores - C++

Se quiere realizar un programa que multiplique un escalar por un vector. Ambos datos serán introducidos por el usuario. Además se pide sobrecargar el operador de entrada, de salida y de producto. El código es el siguiente:

 1 #include <iostream>
 2  using namespace std;
 3  
 4  class miVector
 5  {
 6      int x,y;
 7  public:
 8      miVector(int cx=0, int cy=0)
 9      {
10          x=cx;
11          y=cy;
12      }
13      friend istream& operator>>(istream &in, miVector &v);
14      friend ostream& operator<<(ostream &out, miVector v);
15      friend  miVector operator*(const int &escalar, const miVector &v);
16  };
17  
18  istream& operator>>(istream &in, miVector &v)
19  {
20      in>>v.x>>v.y;
21      return in;
22  }
23  
24  ostream& operator<<(ostream &out, miVector v)
25  {
26      out << "(" << v.x << "," << v.y << ")";
27      return out;
28  }
29   miVector operator*(const int &escalar, const miVector &v)
30   {
31       miVector vm(escalar*v.x, escalar*v.y);
32       return vm;
33   }
34  int main()
35  {
36      miVector v, vmulti;
37      int escalar;
38  
39      cout << "Intro coordenadas de vector: ";
40      cin >>v;
41  
42      cout << "Intro escalar que multiplica al vector: ";
43      cin >> escalar;
44  
45      cout << endl << v << " * " << escalar << " = " << escalar*v << endl ;
46      return 0;
47  }

Producto escalar de dos vectores - Sobrecarga de operadores - C++

Se pide realizar un programa que realice el producto escalar de dos vectores introducidos por el usuario. Para una mayor legibilidad en el main, se pide utilizar los operadores de salida, entrada, y producto. A continuación se muestra la solución:

 1 #include <iostream>
 2  using namespace std;
 3  
 4  class miVector
 5  {
 6      int x,y;
 7  
 8  public:
 9      miVector(int cx=0,int cy=0)
10      {
11          x=cx;
12          y=cy;
13      }
14      friend istream& operator>>(istream &in, miVector &v);
15      friend ostream& operator<<(ostream &out, miVector &v);
16      friend int operator*(const miVector &v, const miVector &v2);
17  };
18  
19  istream& operator>>(istream &in, miVector &v)
20  {
21      in>> v.x >> v.y;
22      return in;
23  }
24  
25  ostream& operator<<(ostream &out, miVector &v)
26  {
27      out << "(" << v.x << "," << v.y << ")";
28      return out;
29  }
30  
31  int operator*(const miVector &v, const miVector &v2)
32  {
33      int prod=v.x*v2.x+v.y*v2.y;
34      return prod;
35  }
36  int main()
37  {
38      miVector v1,v2;
39  
40      cout << "Intro coordenadas del primer vector: ";cin >> v1;
41      cout << "Intro coordenadas del segundo vector: "; cin >> v2;
42      cout << v1 << " * " << v2 << " = " << v1*v2;
43  
44      return 0;
45  }

Norma de un vector - Sobrecarga de operadores - C++

Se pide realizar un programa que calcule la norma de un vector introducido por teclado. Se deberá sobrecargar la entrada y la salida. La solución se muestra a continuación:

 1 #include <iostream>
 2  #include <cmath>
 3  using namespace std;
 4  
 5  class miVector
 6  {
 7      int x,y;
 8  
 9  public:
10      miVector(int cx=0, int cy=0)
11      {
12          x=cx;
13          y=cy;
14      }
15  
16      friend istream& operator>>(istream &in, miVector &v);
17      friend ostream& operator<<(ostream &out, miVector v);
18      friend float Norma(const miVector &v);
19  };
20  
21  istream& operator>>(istream &in, miVector &v)
22  {
23      in >> v.x >> v.y;
24      return in;
25  }
26  
27  ostream& operator<<(ostream &out, miVector v)
28  {
29      out << "(" << v.x << "," << v.y << ")";
30      return out;
31  }
32  
33  float Norma(const miVector &v)
34  {
35      float norma=sqrt(pow(v.x,2)+pow(v.y,2));
36      return norma;
37  }
38  
39  
40  int main()
41  {
42      miVector v;
43      float norma;
44  
45      cout << "Intro coordenadas del primer vector: "; cin>>v;
46  
47      norma=Norma(v);
48      cout << endl << "La norma del vector " << v << " es: " << norma;
49  }

Multiplicación de fracciones Parte 4 - Sobrecarga de operadores (operator>>) - C++

Después de haber realizado la sobrecarga de operadores en la Parte 3 procedemos a realizar la sobrecarga del operador de entrada, operator>>. Este operador se declara como istream& operator>> (istream &in, variables de entrada); Esta sobrecarga nos permite guardar el numerador y el denominador de la fracción en una misma variable f1, como se representa en la linea 78, esto da una mayor simplicidad al código del main. Te preguntarás como puede ser esto posible, pues bien, si vamos a la linea 51, se establece que el primer dato introducido por teclado será el numerador y el segundo el denominador. Finalmente, al igual que hacíamos con el operador de salida, hay que devolver el in, es decir, return in.

Además en este código se ha introducido una función simplifica que como su nombre indica, simplificará el resultado de la multiplicación de fracciones hasta obtener la irreducible.

 1 //Visualizacion y entrada con sobrecarga de operador
 2  #include <iostream>
 3  #include <cmath>
 4  using namespace std;
 5  
 6  class Fraccion
 7  {
 8      int n,d;
 9  
10  public:
11      Fraccion(int num=0, int den=1)
12      {
13          n=num;
14          d=den;
15      }
16      //Set para introducir los datos de las fracciones
17      //No se necesita el set, lo hara el istream
18      //Para diferenciar el num y den de cualquier fracion y sacarlo por pantalla
19      //No se necesita el Get, lo hace el ostream
20      //Friend para que la funcion pueda acceder a la clase
21      friend Fraccion operator* (Fraccion f1, Fraccion f2);
22      friend ostream& operator<< (ostream &out, Fraccion f);
23      friend istream& operator>> (istream &in, Fraccion &f);
24      friend Fraccion simplifica(Fraccion f);
25  };
26  
27  Fraccion operator* (Fraccion f1, Fraccion f2)
28  {
29      Fraccion fm(f1.n*f2.n, f1.d*f2.d);
30      return fm;
31  }
32  
33  ostream& operator<< (ostream &out, Fraccion f)
34  {
35      if(f.n<0&&f.d<0 || f.d<0)
36      {
37          f.n=f.n*(-1);
38          f.d=f.d*(-1);
39          out << f.n << "/" << f.d;
40      }
41      else if(f.n==f.d)
42          out <<  " 1 " ;
43      else
44          out << f.n << "/" << f.d ;
45  
46      return out;
47  }
48  
49  istream& operator>> (istream &in, Fraccion &f)
50  {
51      in >> f.n >> f.d;
52      return in;
53  }
54  
55  Fraccion simplifica(Fraccion f)
56  {
57      int fmin=min(abs(f.n),abs(f.d));
58  
59      for(int i=fmin; i>1; i--)
60      {
61          if(f.n%i==0 && f.d%i==0)
62          {
63              f.n=f.n/i;
64              f.d=f.d/i;
65              i=min(abs(f.n),abs(f.d));
66          }
67      }
68      return f;
69  }
70  
71  
72  int main()
73  {
74      Fraccion f1, f2, fMulti; //Hay que inicializar siempre las fracciones?
75  
76      cout << "Intro numerador y denominador de la primera fraccion: ";
77      cin >> f1;
78      cout << endl << "Intro numerador y denominador de la segunda fraccion: ";
79      cin >> f2;
80  
81      fMulti=simplifica(f1*f2);
82  
83      cout<<endl<<"La multiplicacion de "<<f1<<" * "<<f2<<" = "<<fMulti<<endl;
84  }

Multiplicación de fracciones Parte 3 - Sobrecarga de operadores (operator<<) - C++

Una vez visto la sobrecarga del operador * en la parte 2, procedemos a hacer la sobrecarga del operador de salida,  operator<<. Este operador se declara siempre como ostream& operator<< (ostream &out, parámetros de entrada). Al realizar esta sobrecarga, podremos establecer como queremos que se muestre la fracción, por ejemplo, en la linea 37 establecemos que si el numerador y el denominador es negativo o si solo el denominador es negativo, multiplique a toda la fracción por menos uno para su mejor visualización. Una vez que hemos puesto todas las premisas que queramos en dicho operador siempre deberá devolver out, es decir, return out;. Como se puede apreciar en la linea 68 ahora podremos visualizar de una forma muy cómoda en el main las fracciones poniendo simplemente su nombre. 

 1 //Visualizacion con sobrecarga de operador
 2  #include <iostream>
 3  using namespace std;
 4  
 5  class Fraccion
 6  {
 7      int n,d;
 8  
 9  public:
10      Fraccion(int num=0, int den=1)
11      {
12          n=num;
13          d=den;
14      }
15      //Set para introducir los datos de las fracciones
16      void SetN(int num)
17      {
18          n=num;
19      }
20      void SetD(int den)
21      {
22          d=den;
23      }
24      //Friend para que la funcion pueda acceder a la clase
25      friend Fraccion operator* (Fraccion f1, Fraccion f2);
26      friend ostream& operator<< (ostream &out, Fraccion f);
27  };
28  
29  Fraccion operator* (Fraccion f1, Fraccion f2)
30  {
31      Fraccion fm(f1.n*f2.n , f1.d*f2.d);
32      return fm;
33  }
34  
35  ostream& operator<< (ostream &out, Fraccion f)
36  {
37      if((f.n<0&&f.d<0) || f.d<0)
38      {
39          f.n=f.n*(-1);
40          f.d=f.d*(-1);
41          out << f.n << "/" << f.d;
42      }
43  
44      else if(f.n==f.d)
45          out << "1";
46      else
47          out << f.n << "/" << f.d ;
48  
49      return out;
50  }
51  int main()
52  {
53      Fraccion f1, f2, fMulti;
54      int n1,n2,d1,d2;
55  
56      cout << "Intro primer numerador: "; cin >>n1;
57      cout << "Intro primer denominador: "; cin >>d1;
58      cout << endl << "Intro segundo numerador: "; cin >>n2;
59      cout << "Intro segundo denominador: "; cin >>d2;
60  
61      f1.SetN(n1);
62      f1.SetD(d1);
63      f2.SetN(n2);
64      f2.SetD(d2);
65  
66      fMulti=f1*f2;
67  
68      cout<<endl<<"La multiplicacion de "<<f1<<" * "<<f2<<" = "<<fMulti<<endl;
69  }