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.

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);
}
}
}
}

}