Ejercicio Custom Generics

Con el interfaz Giros y las clases torretas y tanque vamos a crear una clase ‘Calibrar’ que utilice una variable privada ‘pieza’ de tipo genérico pero que implemente el interfaz giros. La tenemos que pasar en el constructor. Tendrá el método giros que nos coloca la pieza en posición cero a base de girar a la derecha y nos devuelve el número de giros que hemos tenido que hacer.

Ejercicio Agenda

Vamos a crear una agenda de teléfonos. Crearemos la clase Agenda y utilizaremos un SortedList<string,string).

Tendremos los siguientes métodos:

agregarContacto(nombre,telefono) Añade el nombre a la agenda, si ya está cambia el número

quitarContacto(nombre) Elimina el nombre y el número de la agenda

telefono(nombre) Nos devuelve el teléfono de ese contacto

nombre(telefono) Nos devuelve el nombre del contacto que tenga ese teléfono

repetidos() Nos devuelve una lista con los contactos que tengan el mismo teléfono (List de string con los nombres)

Sobreescribiremos el método toString para que nos muestre toda la agenda.

Ejercicio diccionario

Vamos a crear una clase Ventas para almacenar las ventas de los empleados. Para ello usaremos un diccionario <string,int> en el que la clave es el nombre del empleado y el valor las ventas.

Tendrá los siguientes métodos:

agregarVenta(string empleado, int ventas)

Nos añade las ventas al diccionario. Si el empleado existe se suman las ventas, no se sustituyen.

totalVentas()

Nos devuelve el total de ventas de todos los empleados

mediaVentas()

Nos devuelve la media de ventas por empleado

mejorVendedor()

Nos devuelve el nombre del mejor vendedor

despedir(string nombre)

Elimina al vendedor del diccionario

 

Ejercicio Queue

Crear la clase Tarea con las siguientes propiedades:

Nombre (string)

Encargado(string)

Horas(int)

Crear la clase Programa con la siguiente propiedad:

Queue<Tarea> Lista

Y los siguientes métodos:

add(Tarea t) -> añade la tarea a la lista

procesar() -> Devuelve el nombre, encargado y horas de la primera tarea y la quita de la lista

tiempo()-> Devuelve el número de horas necesario para procesar todas las tareas

optimizar()->Reordena las tareas para que las que ocupan menos horas se pongan la primera de la lista.

Nueva funcionalidad Dilema prisionero

1.- Incorporar nuevas estrategias:

Espejo: Si el jugador contrario ha cooperado más que desertado, nosotros también cooperamos. En caso contrario, desertamos. Si hay empate o es la primera vez, cooperamos.

Contrario: Hacemos lo contrario de la última jugada del adversario, si ha cooperado, desertamos y viceversa.

2.- Diferentes matrices de pago

Poder incorporar variantes de la matriz de pago. Por ejemplo el juego ‘Gallina’ tiene la siguiente matriz de pagos:

Cooperar Desertar
Cooperar 5, 5 1, 10
Desertar 10,1 -20, -20

En el juego AmigoEnemigo la matriz de pagos es la siguiente:

Cooperar Desertar
Cooperar 1, 1 0, 2
Desertar 2, 0 0, 0

Podemos probar como cambia la efectividad de las estrategias en diferentes condiciones.

3.- El Juego no tiene constructor y todas las propiedades se inicializan en la declaración o hay que añadirlas a mano. Crear un constructor (puede tener parámetros por defecto) que solucione esta carencia, y que nos permita pasar otra matriz de pago.

¿Un return o varios?

La cosa no está clara:

https://stackoverflow.com/questions/36707/should-a-function-have-only-one-return-statement

Artículo sobre el tema:

https://www.anthonysteele.co.uk/TheSingleReturnLaw

Una buena práctica:

Minimize the number of returns in each routine. It’s harder to understand a routine if, reading it at the bottom, you’re unaware of the possibility that it returned somewhere above.

Use a return when it enhances readability. In certain routines, once you know the answer, you want to return it to the calling routine immediately. If the routine is defined in such a way that it doesn’t require any cleanup, not returning immediately means that you have to write more code.

Escribir en fichero


string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
StreamWriter outputFile = new StreamWriter(Path.Combine(docPath, "salida.txt")));
outputFile.WriteLine("Esto es una línea");
outputFile.WriteLine("Esto es otra");
outputFile.Close();

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€)

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.

Inyección de dependencia

Las interfaces nos permiten desacoplar las funciones al no depender de una clase, sino de la implementación de un interfaz:

https://anexsoft.com/ejemplo-de-inyeccion-de-dependencias-con-c

Definición:

https://www.freecodecamp.org/news/a-quick-intro-to-dependency-injection-what-it-is-and-when-to-use-it-7578c84fa88f/

https://www.dotnettricks.com/learn/dependencyinjection/implementation-of-dependency-injection-pattern-in-csharp

Gente que está en contra (en ocasiones):

Las ventajas de NO usar inyección de dependencias