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

Ejercicio herencia

Arreglar la siguiente jerarquía de herencias para que incorpore constructores en las clases derivadas y funcione el área:

abstract class Figuras {
    abstract function area();  
}
abstract class Bidimensional extends Figuras{
    
}
class Circulo extends Bidimensional{
    private $radio;
}
class Triangulo extends Bidimensional{
  private $base;
  private $altura;
}
abstract class Tridimensional extends Figuras{
    
}
class Cubo extends Tridimensional{
   private $lado;
}
class Esfera extends Tridimensional{
   private $radio
}

Propiedades estáticas


class Estaticas {
   static public $iva;
   public $nombre;
}

$a=new Estaticas();
$b=new Estaticas();
$c=new Estaticas();
Estaticas::$iva=.21;
$a->nombre="Ana";
$b->nombre="Eva";
$c->nombre="Rosa";

var_dump($a::$iva);
var_dump($b::$iva);
var_dump($c::$iva);

class Producto{
    static private $iva=.21;
    public $nombre;
    public $precio;
    function __construct($nombre,$precio) {
        $this->nombre=$nombre;
        $this->precio=$precio;
    }
    function PVP(){
        return $this->precio*(1+$this::$iva);
    }
}
$manzana=new Producto("Manzana",2);
echo $manzana->PVP();
$uvas=new Producto("Uvas",3.5);
echo $uvas->PVP();

Clases abstractas y polimorfismo

<?php

abstract class Figuras {
    abstract function dibujar();
    function saludo(){
        echo "Hola";
    }
}

abstract class Bidimensional extends Figuras{
    
}
class Circulo extends Bidimensional{
    function dibujar(){
        echo "Estoy dibujando un círculo";
    }
}
class Hexagono extends Bidimensional{
    function dibujar(){
        echo "Dibujando hexágono";
    }
}
abstract class Tridimensional extends Figuras{
    
}
class Cubo extends Tridimensional{
    function dibujar(){
        echo "Esto es un cubo";
    }
}
class Piramide extends Tridimensional{
    function dibujar(){
        echo "Porámide";
    }
}

$figuras=[new Circulo(),new Piramide(), new Cubo(),new Hexagono(),new Circulo()];

foreach ($figuras as $figura){
    $figura->dibujar();
}