Ejercicio Laravel

Crear un controlador ‘Aritmetica’ con las funciones:

suma($a,$b)

multiplica($a,$b)

resta($a,$b)

divide($a,$b)

Implementa las rutas para acceder a estas acciones y comprueba que funcionan.

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.

Ejemplos getters y llamadas internas


<?php

class EjemploInterno {

private $nombre;
private $apellidos;

function getNombre() {
return $this->nombre . " " . $this->apellidos;
}

function setNombre($nombre) {
if (strlen($nombre) < 4) {
throw new Exception("Nombre muy corto");
}
$n = explode(" ", $nombre);
$this->nombre = $n[0];
$this->apellidos = $n[1];
}

function __construct($nombre) {
$this->setNombre($nombre);
}

function __toString() {
return $this->getNombre();
}

}

$a = new EjemploInterno("Ana Pi");
$a->setNombre("Juan Fuentes");
echo $a->getNombre();

echo $a;

class EjemploInternoMagico {

private $nombre;
private $apellidos;

function __get($name) {
if ($name == "nombre") {
return $this->nombre . " " . $this->apellidos;
}
}

function __set($name, $value) {
if ($name == "nombre") {
if (strlen($value) < 4) {
throw new Exception("Nombre muy corto");
}
$n = explode(" ", $value);
$this->nombre = $n[0];
$this->apellidos = $n[1];
}
}

function __construct($nombre) {
$this->__set("nombre",$nombre);
}

function __toString() {
return $this->__get("nombre");
}

}

$a = new EjemploInternoMagico("Ana Pi");
$a->nombre="Juan Fuentes";
echo $a->nombre;

echo $a;

Ejercicio Herencia

Vamos a hacer unas clases para los productos de Ikea.

Primero tenemos una clase Producto genérico con la propiedad ‘nombre’ y ‘familia’ que se ponen en el constructor. Pongamos que son protected. Tendremos getter y setter mágicos.

De ahí vamos a derivar la clase ‘Asientos’ que incorpora la propiedad (protected) número de ‘patas’. Se pide en el constructor (junto con el nombre y la familia) y se llama al constructor padre.

De asientos derivamos la clase ‘Sillas’ y ‘Sillones’, sin nada especial.


class Producto {

protected $nombre;
protected $familia;

function __construct(String $nombre, String $familia) {
$this->nombre = $nombre;
$this->familia = $familia;
}

function __get($name) {
if (!property_exists($this, $name)) {
throw new Exception("La propiedad $name no existe");
}
return $this->$name;
}

function __set($name, $value) {
if (!property_exists($this, $name)) {
throw new Exception("La propiedad $name no existe");
}
$this->$name = $value;
}

}
class Asiento extends Producto{
protected $patas;
function __construct(String $nombre, String $familia, int $patas) {
parent::__construct($nombre, $familia);
$this->patas=$patas;
}
}
class Silla extends Asiento{

}
class Sillon extends Asiento{

}

Ejercicio Tienda

Vamos a crear una clase para rellenar elementos de la tienda, se llamará testTienda

En la clase tendremos un constructor que se conectará a la base de datos automáticamente (igual a como lo hemos estado haciendo).

Tendrá un método addCategorias(numero) que nos añadirá el número de categorías que le pongamos (por defecto 5). Con los nombres ‘Categoria1’, ‘Categoria2’,…

Tendrá un método addProductos(idCategoria,numero) que nos añadirá el número de productos que le pongamos (por defecto 5). Con los nombres ‘Producto1’, ‘Producto2’… el precio a cero y la categoría que le pasemos.

Tendrá un método addCatProd(categoria, producto) que pasándole el nombre de una categoría y el nombre de un producto nos añada a la base de datos esa categoría y ese producto haciendo que pertenezca a esa categoría.


class testTienda {

private $server = "localhost";
private $user = "root";
private $password = "";
private $db = "tienda_jp";
protected $conn;

function __construct() {
try {
$this->conn = new PDO("mysql:host=$this->server;dbname=$this->db;charset=UTF8", $this->user, $this->password);
$this->conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch (Exception $e) {
throw new Exception("Connection failed: " . $e->getMessage());
}
}

function addCategorias($numero = 5) {
try {
for ($i = 1; $i <= $numero; $i++) {
$sql = "insert into categorias (nombre) values ('Categoría$i')";
$this->conn->exec($sql);
}
} catch (Exception $ex) {
echo $ex->getMessage();
}
}

function addProducto($idCategoria, $numero = 5) {
try {

$sql = "insert into productos (nombre,idcategoria) values (:nombre,:idcategoria)";
$st = $this->conn->prepare($sql);
for ($i = 1; $i <= $numero; $i++) {
$st->execute(['nombre' => "Producto$i", "idcategoria" => $idCategoria]);
}
} catch (Exception $ex) {
echo $ex->getMessage();
}
}

function addCatProd($producto, $categoria) {
try {
$sql = "insert into categorias (nombre) values (:nombre)";
$st = $this->conn->prepare($sql);
$st->execute(['nombre' => $categoria]);
$id = $this->conn->lastInsertId();
$sql = "insert into productos (nombre,idcategoria) values (:nombre,:idcategoria)";
$st = $this->conn->prepare($sql);
$st->execute(['nombre' => $producto, "idcategoria" => $id]);
} catch (Exception $ex) {
echo $ex->getMessage();
}
}

}

Ejercicio Liga

Vamos a realizar varias clases para implementar una Liga de Fútbol.

En primer lugar crearemos la clase Equipo, que tendrá un nombre (pedido en el constructor) y puntos. Getters y setters mágicos.

Después la clase Partido, que tendrá un Equipo local y un Equipo visitante y unos goles del local y goles del visitante. En el constructor le pasamos el equipo local y el visitante. Los goles tendrán getter y setter mágicos.

Por último tenemos la clase Liga, que dispondrá de un array con diferentes equipos. Para añadirlos implementaremos la función Add(Equipo). Tendrá también un array de Partidos que incialmente estará vacío. Cuando llamemos a la función crearLiga() nos creará los partidos con los equipos que tengamos.

Un ejemplo:

$a=new Equipo(«Logroñés»);

$b=new Equipo(«ALbacete»);

$c=new Equipo(«Numancia»);

$liga=new Liga();

$liga->add($a);

$liga->add($b);

$liga->add($c);

$liga->crearLiga(); //Nos añadirá a partidos los siguientes partidos: Logroñés-Albacete, Logroñés-Numancia y Albacete-Numancia


class Equipo {

private $nombre;
private $puntos;

function __construct($nombre) {
$this->nombre = $nombre;
}

function __get($name) {
if (!property_exists($this, $name)) {
throw new Exception("La propiedad $name no existe");
}
return $this->$name;
}

function __set($name, $value) {
if (!property_exists($this, $name)) {
throw new Exception("La propiedad $name no existe");
}
$this->$name = $value;
}

}

class Partido {

private $local;
private $visitante;
private $gol_local;
private $gol_visitante;

function __construct(Equipo $local, Equipo $visitante) {
$this->local = $local;
$this->visitante = $visitante;
}

function __get($name) {
if ($name == "gol_local" || $name == "gol_visitante") {
return $this->$name;
} else {
throw new Exception("La propiedad $name no existe");
}
}

function __set($name, $value) {
if ($name == "gol_local" || $name == "gol_visitante") {
$this->$name = $value;
} else {
throw new Exception("La propiedad $name no existe");
}
}

}

class Liga {

private $equipos = [];
private $partidos = [];

function add(Equipo $equipo) {
$this->equipos[] = $equipo;
}

function crearLiga() {
$this->partidos = [];
for ($i = 0; $i < count($this->equipos) - 1; $i++) {
for ($j = $i + 1; $j < count($this->equipos); $j++) {
$this->partidos[] = new Partido($this->equipos[$i], $this->equipos[$j]);
}
}
}

function crearLigaIdayVuelta() {
$this->partidos = [];
foreach ($this->equipos as $local) {
foreach ($this->equipos as $visitante) {
if ($local != $visitante) {
$this->partidos[] = new Partido($local, $visitante);
}
}
}
}

}

Ejercicio: Clase complejo

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.

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. Veamos un ejemplo:

$c=new Complejo(2,3);

$d=new Complejo(1,4);

$c->suma($d);

Ahora $c vale (3,7), es decir, la suma de $c y $d. Todas las funciones se aplican al propio objeto.

Además las propiedades deben ser de tipo privado, accederemos a través de setter y getter mágicos.

Crearemos una función mágica tostring que nos pinte el número complejo en su forma acostumbrada (a+bi)

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


class Complejo {

private $real;
private $imaginaria;

function __construct(float $real, float $imaginaria) {
$this->real = $real;
$this->imaginaria = $imaginaria;
}

function sumar(Complejo $complejo) {
$this->real += $complejo->real;
$this->imaginaria += $complejo->imaginaria;
}

function multiplicar(Complejo $complejo) {
$real = $this->real * $complejo->real -
$this->imaginaria * $complejo->imaginaria;
$imaginaria = $this->real * $complejo->imaginaria +
$this->imaginaria * $complejo->real;
$this->real=$real;
$this->imaginaria=$imaginaria;
}

function igual(Complejo $complejo) {
return $this->real == $complejo->real && $this->imaginaria == $complejo->imaginaria;
}

function __get($name) {
if ($name=="absoluto"){
return sqrt($this->real**2+$this->imaginaria**2);
}
if (!property_exists($this, $name)) {
throw new Exception("La propiedad $name no existe");
}
return $this->$name;
}

function __set($name, $value) {
if (!property_exists($this, $name)) {
throw new Exception("La propiedad $name no existe");
}
$this->$name = $value;
}

function __toString() {
return $this->real . " + " . $this->imaginaria . "i";
}

}