Mes: octubre 2024

Crear una clase para trabajar con números complejos.

class Complejo

Tendrán una parte real y una imaginaria, ambas de tipo float. Deben inicializarse en el constructor (con parámetros). Crear un constructor vacío que ponga 0,0

Crearemos las siguientes funciones:

sumar(complejo) ->Suma al número el número complejo que le pasamos

multiplicar(complejo)->Multiplica por el complejo que le pasamos

igual(complejo) -> devuelve true si los números complejos son iguales

Todas estas funciones trabajan con el propio número.

Crearemos también una propiedad virtual de sólo lectura que nos devuelva el valor absoluto del número complejo. El valor absoluto viene definido por la raíz cuadrada de la suma del cuadrado de a y b

Además vamos a hacer:

Sobrecargar el ToString para que nos pinte una cadena con el número complejo. Si la parte real vale 5 y la imaginaria 3 nos escribe “5 + 3i”

Sobrecargar el equals para que si dos números complejos tienen la misma parte real y la misma parte imaginaria nos diga que son iguales

En la clase base

 public virtual String saludo()
        {
            return "Hola "+Nombre;
        }

Clases hijas:

 public class Empleado :Persona
    {
        public int Sueldo { get; set; }
        public Empleado(String nombre)
        {
            Nombre=nombre;
        }
        public override String  saludo()
        {
            return "¡Que pasa " + Nombre;
        }
    }

 internal class Alumno:Persona
    {
        public Alumno(String nombre)
        {
            Nombre = nombre;
        }
        public override String saludo()
        {
            return "Bienvenido " + Nombre;
        }
    }

  internal class Persona
    {
        public int Edad { get; set; }
        private static bool procesar= true; // Campo estático
        // Propiedad que tiene un campo privado asociado y que en el get o el set
        // Hacemos o comprobaciones o algo
        private string _nombre; // Campo privado para almacenar el valor de la propiedad
        public string Nombre
        {
            get => "Don/doña "+_nombre; // Descriptor de acceso get (lectura)
            set
            {
                // Descriptor de acceso set (escritura)
                if (!string.IsNullOrEmpty(value))
                {
                    this._nombre = value;
                }
            }
        }
        
        public Persona(): this("Anonimo")
        {
            
        }
        public Persona(String nombre):this(nombre,18)
        {
            
        }
        public Persona(String nombre, int edad)
        {
            Nombre = nombre;
            Edad = edad;
        }
        public void procesarOrden()
        {
            if (procesar) {
                procesar=false;
                Console.WriteLine("Procesando la orden");
            }
            else
            {
                Console.WriteLine("No puedo procesar cpu ocupada");
            }
        }
        public void acabarProceso()
        {
            procesar= true;
            Console.WriteLine("Proceso acabado");
        }
        public static String saludo()
        {
            return "Hola ";
        }
    }

En el programa

 Persona pepe = new Persona();
            Persona ana = new Persona();
            Persona juan = new Persona();

            pepe.procesarOrden();
            ana.procesarOrden();
            juan.procesarOrden();
            pepe.acabarProceso();
            ana.procesarOrden();
            juan.procesarOrden();

Vamos a crear una clase producto con las siguientes propiedades:
String Referencia
String Nombre
int Stock
Double Precio

Vamos a crear una propiedad virtual PVP que es el precio más el iva (21%) solo de lectura
En el stock vamos a comprobar en el setter que no ponemos valores negativos

Vamos a crear un constructor con todos los datos, uno con todos los datos menos el nombre (y le pondremos como nombre la referencia) y uno solo con la referencia y el precio (en nombre pondremos la referencia y en stock 0).
Probad a crear algún producto.

En program

  Persona pepe=new Persona();
            Persona pepe1 = new Persona("Pepe");
            Persona pepe2 = new Persona("pepe",30);
 

En la clase:

 public Persona(): this("Anonimo")
        {
            
        }
        public Persona(String nombre):this(nombre,18)
        {
            
        }
        public Persona(String nombre, int edad)
        {
            Nombre = nombre;
            Edad = edad;
        }

class Persona
    {
        // A la manera de java, creo getter y setter
        private int sueldo;
        public int getSueldo()
        {
            return sueldo;
        }
        public void setSueldo(int sueldo)
        {
            this.sueldo = sueldo;
        }

        // Propiedad sin ninguna modificación. El get y el set se hacen tal cual
        public int Edad { get; set; }

        // Propiedad que tiene un campo privado asociado y que en el get o el set
        // Hacemos o comprobaciones o algo
        private string _nombre; // Campo privado para almacenar el valor de la propiedad
        public string Nombre
        {
            get => "Don/doña "+_nombre; // Descriptor de acceso get (lectura)
            set
            {
                // Descriptor de acceso set (escritura)
                if (!string.IsNullOrEmpty(value))
                {
                    _nombre = value;
                }
            }
        }
        protected int id;
    }

  var tuple = (1, "hello");
            Console.WriteLine(tuple);
            Console.WriteLine(tuple.Item1);
            Console.WriteLine(tuple.Item2);
            var namedTuple = (Number: 1, Message: "hello");
            Console.WriteLine(namedTuple.Number);
            Console.WriteLine(namedTuple.Message);
            int[] valores = { 1, 2, 3, 4, 5, 6, 77 };
            var res=GetMinMax(valores);
            Console.WriteLine(res.Item1 );
            Console.WriteLine(res.Item2);
            var (a, b) = res;
            Console.WriteLine(a);
            Console.WriteLine(b);
            var(min,max) = GetMinMax(valores);
            Console.WriteLine(min);
            Console.WriteLine(max);

            (max, min) = (min, max);
            Console.WriteLine(min);

            // Modificar la función pivote a la que le pasabamos una lista de números
            // y nos devuelve en formato de tupla dos listas. Una con los números
            // más pequeños que el pivote y otra con las mayores
            // pivote([1,2,3,4,5,6,7],3)=>([1,2],[4,5,6,7]
            // pivote([1,2,3,4,5,6,7],1)=>([],[2,3,4,5,6,7]
            // pivote([1,2,3,4,5,6,7],7)=>([1,2,3,4,5,6],[])
            // pivote([1,2,3,4,5,6,7],8)=>([1,2,3,4,5,6,7,8],[])

 public static (List<int>,List<int>) pivote(List<int> lista, int elemento)
{
List<int> izq=new List<int>();
List<int> der = new List<int>();
foreach(int numero in lista)
{
if (numero < elemento)
{
izq.Add(numero);
}
if (numero > elemento)
{
der.Add(numero);
}
}
return (izq, der);
}

 HashSet<int> numeros = new HashSet<int>();

            // Agregar elementos al HashSet
            numeros.Add(1);
            numeros.Add(2);
            numeros.Add(3);
            numeros.Add(1);
            // Iterar a través del HashSet con foreach
            foreach (int numero in numeros)
            {
                Console.WriteLine(numero);
            }
            HashSet<int> masnumeros = new HashSet<int>() { 3, 4, 5, 6 };
            numeros.SymmetricExceptWith(masnumeros);
            foreach (int numero in numeros)
            {
                Console.WriteLine(numero);
            }

            // Cread dos hashset con nombres de dos clases (clase1 y clase2)
            // Y mostrad:
            // Los nombres que estén en las dos clases
            // Los nombres de la primera clase que no están en la segunda

Dictionary<string, int> edades = new Dictionary<string, int>();

// Agregar elementos al diccionario
edades.Add("Juan", 25);
edades.Add("Ana", 30);
edades.Add("Pedro", 22);

// Acceder a elementos por clave
int edadDeJuan = edades["Juan"];
Console.WriteLine($"Edad de Juan: {edadDeJuan}");
edades["Juan"] = 90;
edadDeJuan = edades["Juan"];
Console.WriteLine($"Edad de Juan: {edadDeJuan}");
// Iterar a través del diccionario con foreach
foreach (var kvp in edades)
{
Console.WriteLine($"{kvp.Key}: {kvp.Value} años");
}
foreach(var claves in edades.Keys)
{
Console.WriteLine(claves+"-"+ edades[claves]);
}
foreach (var valores in edades.Values)
{
Console.WriteLine(valores);
}
edades.Remove("Juan");
edades.Remove("Pepe");
foreach (var kvp in edades)
{
Console.WriteLine($"{kvp.Key}: {kvp.Value} años");
}
if (!edades.ContainsKey("Ana"))
{
edades.Add("Ana", 40);
}
if (edades.ContainsValue(30))
{
Console.WriteLine("Hay un alumno con 30 años");
}
if (edades.TryAdd("Pep", 30))
{
Console.WriteLine("Añadida Ana");
}
else
{
Console.WriteLine("No he podido añadir a Ana");
}
int edad;
if (edades.TryGetValue("Ana",out edad))
{
Console.WriteLine("Hemos obtenido el valor");
}
else
{
Console.WriteLine("No existe el valor");
}
if (edades.TryGetValue("Pablo", out edad))
{
Console.WriteLine("Hemos obtenido el valor");
}
else
{
Console.WriteLine("No existe el valor");
}

Probad a crear un diccionaro ‘traduccion’ de cadenas como clave y cadenas como valor e introducid algunas traducciones del español al inglés (ej ‘agua’, ‘water’).
Después probad a buscar esos valores.