Imprimir números comprendidos en un intervalo - Bucle For - Python

Se quiere realizar un programa que solicite al usuario los dos extremos de un intervalo y el programa imprima los números comprendidos en este. Para ello se fuerza a que los números introducidos por el usuario sean enteros. Cabe destacar que se ha tenido en cuenta la posibilidad de que el usuario introduzca un valor mayor en el extremo inferior del intervalo que en el extremo superior, intercambiando así sus valores.

def muestra_num(a,b):
    if a>b:
        aux=a
        a=b
        b=aux
    for i in range(1,b-a):
        print(a+i)
    
ext_inf=int(input('Extremo inferior del intervalo: '))
ext_sup=int(input('Extremo superior del intervalo: '))
muestra_num(ext_inf,ext_sup)

Calcular factorial - Python

Realizar un programa que pida al usuario un numero y que realice el factorial de este. Se ha implementado la función def factorial(a): para así poder reutilizar el código si fuera necesario.

Solución:

def factorial(a):
    result=1
    for i in range(1,a+1):
        result=result*i
    return(result)
      
n=int(input('Intro numero: '))
print(f'{n}! = {factorial(n)}')

Manejo de excepciones - Python

En el anterior post vimos como podían surgir posibles problemas si el usuario no introducía como extremos del intervalo números. Ahora trataremos de cubrir situaciones inesperadas para que el programa pueda responder con un mensaje de error, para ello utilizaremos las excepciones.

Las excepciones constan por lo menos de dos partes: 'try' y 'except TypeError'. Dentro de try introduciremos la sección critica del programa, es decir, donde pueden surgir errores. Si sucede una situación la cual el programa no ha contemplado previamente, saltará la excepción que será tratada dentro de 'except TypeError'. En nuestro caso el programa imprimirá un mensaje de error y devolverá al sistema -1 indicando así que algo ha ido mal.

De esta forma si el usuario introduce una cadena de caracteres como extremo del intervalo, la excepción saltará y el sistema sabrá manejar la situación.

A continuación se muestra una posible solución:

from random import *

def aleatorio(a,b):
    try:
        if a>b:
            aux=a
            a=b
            b=aux      
        return randint(a, b)
    except TypeError:
        print("Los limites deben ser numeros")
        return -1

for i in range(0,5):
    print(aleatorio(2,7))

Obtener números aleatorios comprendidos en un intervalo con Randint() - Python

Lo primero que debemos hacer es importar la biblioteca random que nos permitirá utilizar el comando randint() posteriormente. Lo haremos de la siguiente forma:

from random import *

Ahora definiremos una función que nos devuelva un numero aleatorio entre dos valores dados. Contemplaremos la posibilidad de que el usuario introduzca un valor del extremo inferior del intervalo mayor al del extremo superior (por ejemplo [7,2]). Para solucionar este posible fallo, se intercambiarán los valores de los extremos del intervalo (en nuestro ejemplo resultaría [2,7]). Finalmente utilizaremos randint(extremo inferior, extremo superior).

Por último, se ha realizado un bucle for para sacar por pantalla 5 valores aleatorios comprendidos en el intervalo indicado por el usuario.

Posible solución:

from random import *

def aleatorio(a,b):
    if a>b:
        aux=a a
        a=b b
        b=aux
    return randint(a, b)

for i in range(0,5):
    print(aleatorio(2,7))

Cabe destacar que si el usuario introduce una cadena de caracteres como extremo del intervalo, el programa no funcionará. En el siguiente post haremos unas pequeñas modificaciones para contemplar estas situaciones.

Funcion de paridad - Python

Definir una función que detecte la paridad de un número introducido por el usuario.

Solución:

def paridad(a):
    if a%2==0:
        print("es par")
    else:
        print("es imapr")
        
num=int(input('Intro numero: '))
paridad(num)

Funciones Lambda - Python

Las funciones Lambda son aquellas funciones en las que solamente se ejecuta una linea de código. En ellas, primeramente se definen los parámetros y posteriormente la instrucción que se realizará. A continuación se muestran algunos ejemplos:

x=lambda a,:a*5
print(x(3)) 

""" Salida: 15 """

y=lambda a,b: a + b
print(y(3,5))

""" Salida: 8 """z=lambda a,b,c: a+b*c
print(z(1,2,3))

""" Salida: 7 """

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  }

Multiplicación de fracciones. Introducción a sobrecarga de operadores - C++

Se procede a realizar un programa que realice la multiplicación de dos fracciones. En primer lugar se solicitarán las fracciones al usuario y para ello, se han creado dos funciones dentro de la clase Fraccion, SetN y SetD. Posteriormente se realiza la multiplicación de estas mediante una función friend declarada en la misma clase. Para realizar dicha operación se necesita acceder al numerador de cada fraccion de forma independiente al denominador, por lo que necesitaremos las funciones GetN y GetD. Finalmente, en el main se declara la variable fMulti como Fraccion y se llama a la función multiplicación. Se mostrará el resultado por pantalla.

En las siguiente entradas de este blog veremos como simplificar este programa utilizando la sobrecarga de operadores.

 1 #include <iostream>
 2  using namespace std;
 3  
 4  class Fraccion
 5  {
 6      int n,d;
 7  
 8  public:
 9      Fraccion(int num=0, int den=1)
10      {
11          n=num;
12          d=den;
13      }
14      //Set para introducir los datos de las fracciones
15      void SetN(int num)
16      {
17          n=num;
18      }
19      void SetD(int den)
20      {
21          d=den;
22      }
23      //Para diferenciar el num y den de cualquier fracion y sacarlo por pantalla
24      int GetN()
25      {
26          return n;
27      }
28  
29      int GetD()
30      {
31          return d;
32      }
33      //Friend para que la funcion pueda acceder a la clase
34      friend Fraccion multiplica(const Fraccion &f1, const Fraccion &f2);
35  };
36  
37  Fraccion multiplica(const Fraccion &f1, const Fraccion &f2)
38  {
39      Fraccion result;
40      result.n=f1.n*f2.n;
41      result.d=f1.d*f2.d;
42      return result;
43  }
44  int main()
45  {
46      Fraccion f1, f2, fMulti;
47      int n1,n2,d1,d2;
48  
49      cout << "Intro primer numerador: "; cin >>n1;
50      cout << "Intro primer denominador: "; cin >>d1;
51      cout << endl << "Intro segundo numerador: "; cin >>n2;
52      cout << "Intro segundo denominador: "; cin >>d2;
53  
54      f1.SetN(n1);
55      f1.SetD(d1);
56      f2.SetN(n2);
57      f2.SetD(d2);
58  
59      fMulti=multiplica(f1,f2);
60  
61      cout<<endl<<"La multiplicacion es: "<<fMulti.GetN()<<" / "<<fMulti.GetD()<<endl;
62  }

Histograma de un vector - C++

Se realizará un programa el cual lea un fichero realizado por el usuario con una serie de números como el que se muestra a continuación. Es importante que el archivo se encuentre guardado en la carpeta donde esté alojado el proyecto. Para trabajar con ficheros necesitaremos la librería #include <fstream>.

En primer lugar se leerá el fichero vector y se irán introduciendo todos los números en el vector v. Posteriormente se declara otro fichero como salida, ofstream histo("histograma.txt"); .En dicho fichero será almacenado el histograma final. Para obtenerlo, será necesario crear un vector histograma con el mismo tamaño al de v. Finalmente, mediante un bucle for y un contador se irán contabilizando las veces que aparece cada número.

Además se ha implementado una función que calculará la media de dicho vector y devolverá con el fin de sacar el resultado por pantalla.

 1 ///HISTOGRAMA DE UN VECTOR
 2  #include <iostream>
 3  #include <vector>
 4  #include <fstream>
 5  using namespace std;
 6  double calcula_media(vector<int>);
 7  
 8  int main()
 9  {
10      vector<int> v;
11      ifstream fich("vector.txt");
12      int dato;
13  
14      ///Intro datos de fichero a vector
15      while(fich >> dato)
16          v.push_back(dato);
17  
18      ofstream histo("histograma.txt");
19  
20      for(size_t j=0; j<v.size(); j++)
21          histo << j << "  ";
22      histo << endl;
23  
24      //Crear vector histograma con mismo tamaño al de v
25      vector<int> histograma(v.size());
26  
27      //Contabilizar
28      for(size_t i=0; i<v.size(); i++)
29          histograma.at(v.at(i))++;
30  
31      for(auto x:histograma)
32          histo << x << "  ";
33      histo << endl;
34  
35      double media=calcula_media(v);
36      histo << "Media: " << media;
37  }
38  
39  double calcula_media(vector<int> v)
40  {
41      double suma=0;
42      for(size_t j=0; j<v.size(); j++)
43          suma+=v.at(j); //suma=suma+v.at(j)
44      double media=suma/v.size();
45      return media;
46  }

El resultado final para el fichero mostrado anteriormente es: