Trifulcas

Mini ejercicio CodeFirst

Una empresa nos pide que creemos una BD para controlar su inventario. Tienen un almacen con una serie de productos de los que les interesa saber el nombre y la cantidad que tienen (p. ej. tuercas, 20).
Los productos se los compran a unos proveedores y quieren saber el nombre y el telefono de los mismos para que cuando necesiten renovar stock les puedan llamar.

El modelo E/R para esta base de datos es el siguiente:

Cread la BD, el contexto necesario, y las dos entidades. De momento no implementamos la relación. Lo haremos mañana.

Práctica migraciones

Añadimos un campo ‘Raza’ de tipo String a Pajaro
Añadimos la Entidad ‘Jaula’ con Id, Nombre, Ancho,Alto,Largo de tipo int y Precio de tipo Decimal

Añadimos la migracion ‘raza’ cuando añadimos el campo raza
Y la migración Jaula cuando añadimos la entidad jaula

Después actualizamos la base de datos.

Código DAO

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Data.SqlClient;

namespace DAOAcademia
{

    internal class DAOAlumno:IDAO<Alumno>
    {
        SqlConnection conn;
        public DAOAlumno() {
            conn=Conexion.getConn();
        }

        public int Delete(int id)
        {
            try
            {
                conn.Open();
                String sql = "delete alumno where id=@id";
                SqlCommand comando = new SqlCommand(sql, conn);
                comando.Parameters.AddWithValue("@id", id);

                int res = comando.ExecuteNonQuery();

                conn.Close();
                return res;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return 0;
            }
        }

        public List<Alumno> GetAll()
        {
            try
            {
                conn.Open();
                String sql = "select * from alumno";
                SqlCommand lectura = new SqlCommand(sql, conn);
                SqlDataReader sqlDataReader = lectura.ExecuteReader();
                List<Alumno> alumnos= new List<Alumno>();
                while (sqlDataReader.Read())
                {
                    Alumno alumno = new Alumno(sqlDataReader.GetInt32(0),
                        sqlDataReader.GetString(1) ?? "",
                        sqlDataReader.GetString(2)??"",
                        sqlDataReader.GetString(3)??""
                        );
                    alumnos.Add( alumno );
                }
                conn.Close();
                return alumnos;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return null;
            }
        }

        public Alumno GetById(int id)
        {
            Alumno alumno = null;
            try
            {
                conn.Open();
                String sql = "select *from alumno where id=@id";
                SqlCommand lectura = new SqlCommand(sql, conn);
                lectura.Parameters.AddWithValue("@id", id);
                SqlDataReader sqlDataReader = lectura.ExecuteReader();
                
                if (sqlDataReader.Read())
                {
                    alumno = new Alumno(sqlDataReader.GetInt32(0),
                        sqlDataReader[1] as string ??"",
                        sqlDataReader.GetString(2) ?? "",
                        sqlDataReader.GetString(3) ?? ""
                        );
                    
                }
                conn.Close();
                return alumno;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return alumno;
            }
        }

        public int Insert(Alumno alumno)
        {
            
            try
            {
                conn.Open();
                String sql = "insert into alumno (nombre,dni,email) values (@nombre,@dni,@email)";
                SqlCommand comando = new SqlCommand(sql, conn);
                comando.Parameters.AddWithValue("@nombre", alumno.Nombre);
                comando.Parameters.AddWithValue("@dni", alumno.DNI);
                comando.Parameters.AddWithValue("@email", alumno.Email);
                
                int res = comando.ExecuteNonQuery();

                conn.Close();
                return res;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return 0;
            }
        }

        public int Save(Alumno alumno)
        {
            if (alumno.Id == 0)
            {
                return Insert(alumno);
            }
            else
            {
                return Update(alumno);
            }
        }

        public int Update(Alumno alumno)
        {
            try
            {
                conn.Open();
                String sql = "update alumno set nombre=@nombre,dni=@dni,email=@email where id=@id";
                SqlCommand comando = new SqlCommand(sql, conn);
                comando.Parameters.AddWithValue("@nombre", alumno.Nombre);
                comando.Parameters.AddWithValue("@dni", alumno.DNI);
                comando.Parameters.AddWithValue("@email", alumno.Email);
                comando.Parameters.AddWithValue("@id", alumno.Id);

                int res = comando.ExecuteNonQuery();

                conn.Close();
                return res;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return 0;
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DAOAcademia
{
    internal interface IDAO<T>
    {
        List<T> GetAll();
        T GetById(int id);
        int Insert(T entity);
        int Update(T entity);
        int Save(T entity);
        int Delete(int id);
    }
}

using System;
using System.Collections.Generic;
using Microsoft.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DAOAcademia
{
internal class Conexion
{
public static SqlConnection getConn()
{
var connection = new SqlConnection();
connection.ConnectionString = “Data Source=.\\SQLEXPRESS;” +
“Initial Catalog=pasiona;Integrated Security=True;” +
“TrustServerCertificate=True”;
return connection;
}
}
}
]/c]

Primeros pasos DAO

 class Alumno
    {
        public int Id { get; set; }
        public string Nombre { get; set; }
        public string DNI { get; set; }
        public string Email { get; set; }

        public Alumno(int id, string nombre, string dni, string email)
        {
            Id = id;
            Nombre = nombre;
            DNI = dni;
            Email = email;
        }
        public override string ToString()
        {
            return Id+" - "+Nombre+" - "+DNI+" - "+Email;
        }
    }

 internal class DAOAlumno
    {
        public DAOAlumno() { }
        public List<Alumno> getAll()
        {
            var connection = new SqlConnection();
            connection.ConnectionString = "Data Source=.\\SQLEXPRESS;" +
                "Initial Catalog=pasiona;Integrated Security=True;" +
                "TrustServerCertificate=True";
            connection.Open();
            String sql = "select * from alumno";
            SqlCommand lectura = new SqlCommand(sql, connection);
            SqlDataReader sqlDataReader = lectura.ExecuteReader();
            List<Alumno> alumnos=new List<Alumno>();
            while (sqlDataReader.Read())
            {
                Alumno temp = new Alumno(sqlDataReader.GetInt32(0),
                    sqlDataReader.GetString(1),
                    sqlDataReader.GetString(2),
                    sqlDataReader.GetString(3));
                alumnos.Add(temp); 
            }

            sqlDataReader.Close();
            connection.Close();
            return alumnos;
        }
    }

  DAOAlumno dao=new DAOAlumno();
            List<Alumno> clase = dao.getAll();
            Console.WriteLine(String.Join(" | ",clase));

Organización DIlema prisionero

Matriz de pagos que nos dice cuanto se lleva cada jugador
(Lo puedo poner, de momento, en el campeonato, pero si yo quiero ser SOLIDO lo inyectaría)
IMatrizPagos: getPagos(int jug1, int jug2)
PrisioneroClasico

Jugador nombre y un dinero: IEstrategia
OPen/Close Jugador->Panfilo, Tuntun,…
JUgador: Inyecto Panfilo:Iestrategia
IEstrategia: return 0 o 1 getDecision()
Panfilo: IEstrategia
getDecision(){ return 0;}
Estrategias (cooperar siempre, desertar siempre o al azar)

Campeonato: Jugadores, 50 rondas y un resultado final

Al hacer el campeonato introduzco los jugadores que serán una Lista de 2 a X
Hacer las rondas y ordenar por dinero
Enfrentar (jug1,jug2)
HacerRondas(): Lista hacer todas las combinaciones de 2 en 2
A,B,C,D,E -> A yB, AyC, AyD, AyE, ByC,ByD,ByE,CyD,CyE,DyE
Los jugadores cada uno con su dinero

Resultados()->Mostrar la lista ordenada por el dinero descendente

Echemos un mus

Siempre ganan las cartas más altas (o más bajas en pequeña)

Una doble pareja es más que un trío, que es más que una pareja, que es más que no tener nada.

Si no tienen juego es el que más se acerca a 30

Si tienen juego el orden es: 31,32,40,39,38,37,36,35,34 y 33.

Machine learning

Kata: Dilema del prisionero

El Dilema del prisionero es un clásico de la teoría de juegos. El enunciado clásico es así:

<i>La policía arresta a dos sospechosos. No hay pruebas suficientes para condenarlos y, tras haberlos separado, los visita a cada uno y les ofrece el mismo trato. Si uno confiesa y su cómplice no, el cómplice será condenado a la pena total, diez años, y el primero será liberado. Si uno calla y el cómplice confiesa, el primero recibirá esa pena y será el cómplice quien salga libre. Si ambos confiesan, ambos serán condenados a seis años. Si ambos lo niegan, todo lo que podrán hacer será encerrarlos durante un año por un cargo menor.</i>

Lo curioso del caso es que la mejor estrategia conjunta es callarse, pero la mejor estrategia individual es confesar. El juego se ha transformado en una versión en la que los participantes ganan dinero dependiendo de lo que elijan. La matriz de pago suele ser la siguiente:

	Cooperar	Desertar
Cooperar	3, 3	-5, 5
Desertar	5, -5	-1, -1

Cada jugador elige de antemano lo que va a hacer. Si los dos han decidido cooperar gana cada uno 3€. Si los dos deciden desertar pierden cada uno 1€. Si uno deserta y el otro coopera el que deserta gana 5€ y el que coopera pierde 5€.

Como es imaginable hay muchas estrategias si tenemos que jugar varias veces este juego. Podemos cooperar siempre, desertar siempre, reaccionar a lo que haga el otro jugador, jugar al azar…

Para probar diferentes estrategias vamos a programar un juego que permita varios jugadores, cada uno con su estrategia, y los va a enfrentar uno a uno con la matriz de pagos puesta más arriba. Los enfrentamientos tienen 50 rondas cada uno. Al final de cada enfrentamiento los jugadores habrán ganado o perdido dinero. Se sumarán los importes y se mostrará una clasificación.

Por ejemplo, tenemos los jugadores Pánfilo, cuya estrategia es cooperar siempre, Maquiavelo, que siempre deserta y Tuntún, que elige al azar. Se enfrentarían siguiendo el esquema:

Maquiavelo-Pánfilo

Maquiavelo-Tuntún

Pánfilo-Tuntún

Cada enfrentamiento implica jugar 50 veces seguidas al dilema del prisionero. Por ejemplo, en Maquiavelo Pánfilo sería algo como esto:

Maquiavelo: Deserta | Pánfilo: Coopera (Maquiavelo gana 5€ y Pánfilo pierde 5€)

(Así 50 veces) El resultado final es que Maquiavelo habrá ganado 250 € y Pánfilo habrá perdido 250 €

Una vez realizados todos los enfrentamientos se mostrará el ranking por dinero obtenido.

Para la realización del ejercicio pensad primero en el enfoque: Qué clases vais a implementar, si conviene utilizar interfaces, etcétera.

Ejercicio LINQ sintaxis query

Con la sintaxis de query obtener el nombre y la nota de los alumnos ordenados por edad descendente y nota descendente

También los alumnos aprobados ordenados por edad (todo el objeto)

Ejercicios LINQ

Con la lista de los alumnos de ejemplo obtener:

Los alumnos cuyo nombre empieza por ‘o’
¿Cuántos alumnos hay aprobados?
Obtener una lista con el nombre de los aprobados
¿Hay algún alumno que haya sacado un 10?
Obtener la media de las notas de los alumnos que han aprobado
Lo mismo para los suspendidos
Mostrar el nombre y la edad de los tres alumnos con mejor nota

Estadística con Python

Git

Docker

React

Programación en C#

Bases de datos relacionales con MySql