---
# System prepended metadata

title: pro-UT2-A9. Supuesto agencia de alquiler de vehículos
tags: [ut2, prueba, pro, práctica, oop, simulacro]

---

# pro-UT2-A9. Supuesto agencia de alquiler de vehículos

---
* **Richard Francisco Vaca Garcia, 1ro CFGS DAW**
---

## Actividad

Realizar la siguiente actividad utilizando la metodología de [pair programming](https://blog.soyhenry.com/que-es-el-pair-programming/)

Los dos miembros del grupo entregarán el mismo producto. El nombre de los dos componentes del grupo debe aparecer en la entrega.

## Supuesto. Versión 1.0. (6p)

### Enunciado

La agencia de coches de alquiler **NOCAR** desea elaborar una apliación para gestionar el alquiler de los vehículos.

De cara al alquiler del vehículo la información relevante de cada vehículo es su **matrícula**, su **categoría** y la **capacidad** del tanque de combustible en litros.

Las categorías de los vehículos son A, B y C.

La capacidad del tanque de combustible es de:

* 50l para los vehículos de categoría **A**
* 45l para los vehículos de categoría **B**
* 40l para los vehículos de categoría **C**

Cuando se crea un objeto de la clase vehículo se le pasa la matricula y la categoría. La capacidad del tanque se deduce de la categoría del vehículo.

Cuando se realiza un alquiler se guarda el DNI del cliente, la matrícula del vehículo y la duración en días del alquiler. Al cliente se le entrega el vehículo con el depósito lleno.

El precio por día del alquiler es de:

* 30€ para los vehículos de categoría **A**
* 20€ para los vehículos de categoría **B**
* 10€ para los vehículos de categoría **C**

Además, cuando se realiza un alquiler el cliente deja una fianza de 100€.

Cuando el cliente devuelve el vehículo se mira cuantos litros de combustible le quedan al vehículo y se le descuentan al cliente de la fianza a 2€ por litro.

La agencia de vehículos tiene una **lista con todos sus vehículos** y una lista de **alquileres** con la matrícula, el DNI del cliente y la duración del alquiler. Además guarda el **saldo** de ingresos y el **saldo total de las fianzas** depositadas

El día a día en la recepción de la agencia de alquiler es el siguiente:

* Añadir vehículos - Se crea un objeto de la clase Vehiculo y se añade a lista de vehículos de la agencia
* Mostrar vehículos - Se muestra la ficha de todos los vehículos de la agencia.
* Mostrar vehículos libres - se muestra la ficha de todos los vehículos que no están alquilados
* Alquiler:
    * Se añade a la lista de alquileres el DNI del cliente. la matrícula del vehículo y el número de días del alquiler (un objeto de la clase alquiler)
    * Se aumenta el saldo de la agencia multiplicando el número de días del alquiler por el precio por día del vehículo en función de su categoría.
    * Se aumenta el saldo de las fianzas depositadas en 100€
    * Se muestra por pantalla un resumen de la operación.
* Devolución:
    * Se usan como datos de entrada la matrícula del vehículo y el número de litros que le faltan al depósito.
    * Se le devuelve al cliente la fianza menos el coste del combustible que le falta al depósito (se actualiza el saldo de fianzas).
    * Se elimina el objeto con la información del alquiler de la lista de alquileres de la Agencia
    * Se muestra por pantalla un resumen de la operación.
* Mostrar duración media - muestra el promedio del número de dias de todos los vehículos alquilados.

### El producto-

Se debe entregar un archivo **nocar.1.0.zip** con todos los archivos de la aplicación.

Cada clase debería estar definida en un archivo por separado y deberá haber un archivo para el programa principal.

El programa principal `main.py` consistirá en un menú en el que se mostrarán las opciones de la operativa de la agencia.

### Las clases

Se deben crear **clases abstractas** con la definición de la interfaz de todas las clases que se vayan a utilizar. 

A partir de la interfaz se implementará por herencia las clases abstractas.

Se recomienda usar una clase para `Vehiculo` otra para `Alquiler` y otra para `AgenciaNocar`

```python=
# import system.os

from os import system
system("clear")
from abc import ABC, abstractmethod

class VehicleInterface(ABC):
    capacity_A = 50
    capacity_B = 45
    capacity_C = 40

    @abstractmethod
    def _get_capacity():
        pass

    @abstractmethod
    def _get_category():
        pass

class Vehicle(VehicleInterface):
    def __init__(self, license, category):
        self._license = license
        self._category = category
    
    def __str__(self):
        return f"\nLa matrícula del vehículo es {self._license} y su categoría es {self._category} y su capacidad es {self._get_capacity()}"

    def _get_capacity(self):
        if self._category == "A":
            return self.capacity_A
        elif self._category == "B":
            return self.capacity_B
        else:
            return self.capacity_C

    def _get_category(self):
        return self._category

# v1 = Vehicle("9999BBA", "B")
# print(v1)




class RentInterface(ABC):
    deposit = 100
    length_A = 30
    length_B = 20
    length_C = 10


class Rent(RentInterface):
    def __init__(self, nid, license, rent_length):
        self._nid = nid
        self._license = license
        self._rent_length = rent_length
    
    def __str__(self):
        return f"El DNI del cliente es {self._nid} la matricula es {self._license} y la duración es de {self._rent_length} días"
        

    

#alq= Rent("12345678X","237964G", 3)
#print(alq)


class AgenciaNocarInterface(ABC):
    @abstractmethod
    def vehicle_add():
        pass

    @abstractmethod
    def show_vehicle_list():
        pass

    @abstractmethod
    def show_free_vehicle():
        pass

    @abstractmethod
    def vehicle_out():
        pass

    @abstractmethod
    def show_avg_length():
        pass

class AgenciaNocar(AgenciaNocarInterface):
    def __init__(self, license):
        self._vehicles_list = ["12345689G", "A"]
        self._rents_list = ["12345689G", "445666A"]
        self._license = license

    def vehicle_add(self, license, category):
        vcle = Vehicle(license, category)
        self._vehicles_list.append(vcle)

    def show_vehicle_list(self):
        for vehicle in self._vehicles_list:
            print(vehicle,end=" ")
        return self._vehicles_list

    def vehicle_out(self, license):
        for vehicle in range(len(self._rents_list)):
            if vehicle == license:
                self._rents_list.remove(vehicle)
        return self._rents_list

    def show_free_vehicle(self,vcle):
        free_vehicle = []
        self.vcle = vcle
        if not self.vcle in self._rents_list:
            free_vehicle.append(self.vcle)
            return free_vehicle
    def show_avg_length():
        pass

vehicle = AgenciaNocar("12345689G")
vehicle.show_vehicle_list()
vehicle.vehicle_out("445666A")
vehicle.show_free_vehicle()
```



# Version 1.0:

***Clase vehículo:***
```python=

from abc import ABC, abstractmethod

class VehicleInterface(ABC):
    _capacities = {"A" : 50, "B" : 45, "C" : 40}
    def __init__(self, registration, category):
        self._registration = registration
        self._category = category
        
    @abstractmethod
    def __str__():
        pass
        
    @abstractmethod
    def get_capacity(self):
        pass

class Vehicle(VehicleInterface):
    def __init__(self, registration, category):
        self._registration  = registration
        self._category = category
        
    def __str__(self):
        return f"La matrícula del vehículo es {self._registration}, la categoría es {self._category} y la capacidad es de {self.get_capacity()}l "

    def get_capacity(self):
            if self._category == "A":
                return (self._capacities.get('A'))
            if self._category == "B":
                return (self._capacities.get('B'))
            if self._category == "C":
                return (self._capacities.get('C'))



v = Vehicle("124567G", "B")
# print(v)
       
```

***Clase alquiler:***
```python=
from abc import ABC, abstractmethod
from vehiculos import Vehicle
class RentInterface(ABC):
    _prices_per_day = {"A" : 30, "B" : 20, "C" : 10}
        
    def __init__(self, dni, registration, duration):
        self._dni = dni
        self._registration = registration 
        self._duration = duration
        
    @abstractmethod
    def __str__():
        pass
        
    @abstractmethod
    def get_price_per_day():
        pass

class Rent(RentInterface):
    def __init__(self, dni, registration, duration):
        self._dni = dni
        self._registration = registration 
        self._duration = duration
        
    def __str__(self):
        return f"El DNI del cliente es {self._dni} la matrícula del vehículo es {self._registration} el precio por día es de {self.get_price_per_day()}€"
    def get_price_per_day(self):
        v = Vehicle("124567G","A")
        if v._category == "A":
             precio = self._prices_per_day.get('A') 
             return precio              
        if v._category == "B":
            precio = self._prices_per_day.get('B') 
            return precio
        if v._category == "C":
            precio = self._prices_per_day.get('B') 
            return precio

r = Rent("42379434X", "124567G", 3) 
print(r)
```
***Clase Nocar:***

```python=
from os import system
system("clear")

from abc import ABC, abstractmethod
from vehiculos import Vehicle
from alquiler import Rent

class NocarAgencyInterface(ABC):
    _rental_deposit = 100   # fianza
    _liter_fuel_cost = 2    # coste del litro de gasolina
    
    def __init__(self):
        self._vehicles = []
        self._rentals = []
        self._income_balance = 0
        self._deposit_balance = 0
       
        
    @abstractmethod
    def add_vehicle(self):
        pass
    
    @abstractmethod
    def show_vehicles():
        pass

    @abstractmethod
    def show_not_rented():
        pass         # Mostrar no alquilados
    
    @abstractmethod
    def vehicle_rent():
        pass
    
    @abstractmethod
    def vehicle_return():
        pass
        
    @abstractmethod
    def show_average_duration():
        pass

    @abstractmethod
    def show_rented():
        pass
    

class Nocar(NocarAgencyInterface):
    _vehicles = []
    _rentals = []
    def __init__(self):
        self._vehicles = []
        self._rentals = []
        self._income_balance = 0
        self._deposit_balance = 0

    def add_vehicle(self, matricula, categoria):
        self._category = categoria
        self._vehicles.append(matricula)
        self._vehicles.append(categoria)
        return self._vehicles

    def show_vehicles(self):
        return self._vehicles

    def show_not_rented(self):
        libres = []
        for vehicle in range (len(self._vehicles)):
            if self._vehicles[vehicle]!= "A" and self._vehicles[vehicle] != "B" and self._vehicles[vehicle] != "C":
                if self._vehicles[vehicle] not in self._rentals:
                    libres.append(self._vehicles[vehicle])
        return libres
    def vehicle_rent(self, dni, registration, duration):
        self._dni = dni
        self._registration = registration
        self._duration = duration
        precio = 0
        if ag._category == "A":
             precio = duration * Rent._prices_per_day.get('A')     
        if ag._category == "B":
             precio = duration * Rent._prices_per_day.get('B')
        if ag._category == "C" :
            precio = duration * Rent._prices_per_day.get('C')
        if registration not in self._rentals:      
            self._rentals.append(dni)
            self._rentals.append(registration)
            self._rentals.append(duration)
            self._deposit_balance += self._rental_deposit 
            self._income_balance += precio
            return f"El vehículo que acabas de alquilar tiene la matrícula {registration}, la duración del alquiler es de {duration} días y el precio a pagar es de {precio}€"
         else:
            return f"El vehículo ya está alquilado"
        

    def vehicle_return(self, matricula, litros):
        devolver = self._rental_deposit - (litros * self._liter_fuel_cost)
        self._deposit_balance -= devolver

        l = len(self._rentals)
        for i in range ((l)-1,-1,-1): 
            if self._rentals[i] == matricula:
                del self._rentals[i-1:i+2]
                self._rentals.append('') 
        del self._rentals[-1]
        return f"Se le devuelven al cliente {devolver}€"


    def show_average_duration(self):
        diastotales = 0 
        contador = 0 
        for i in self._rentals:
            if type(i)!= str:
                contador+=1
                diastotales += i
        media = diastotales/contador
        return media
    def show_rented (self):
        return self._rentals



ag = Nocar()
v = Vehicle("564597GC","A")
v2 = Vehicle("262626TF","B")
v3 =  Vehicle("646646GC","C")

alq = Rent("74747482B",v._registration, 6)
alq2 = Rent("87276333N",v2._registration, 8)
alq3 = Rent("913459X", v3._registration, 10)
ag.add_vehicle(v._registration, v._category)
ag.add_vehicle(v2._registration, v2._category)
ag.add_vehicle(v3._registration, v3._category)
print(ag.show_vehicles())
print(ag.show_not_rented())
print(ag.vehicle_rent(alq._dni,alq._registration,alq._duration))
print(ag.vehicle_rent(alq2._dni,alq2._registration,alq2._duration))
print(ag.vehicle_rent(alq3._dni,alq3._registration,alq3._duration))
print(ag.vehicle_return(v._registration,20))
print(ag.show_average_duration())
print(ag.show_not_rented())
```

***Programa principal:***
```python=
from os import system
system("clear")
from agencianocar import *

agencia = Nocar()

opcion = 1

while opcion != 0:
    system("clear")
    print("1. Añadir vehículo")
    print("2. Mostrar vehículos")
    print("3. Mostrar vehículos no alquilados")
    print("4. Alquilar vehículo")
    print("5. Terminar alquiler de un vehículo")
    print("6. Promedio del número de dias de los vehículos alquilados. ")
    print("7. Mostrar vehiculos alquilados y por quienes están alquilados")
    opcion = int(input("Introduce una opcion: "))
    if opcion == 1:
        matricula = input("Introduce la matrícula del vehículo: ")
        categoria = input("Introduce la categoría del vehículo: ")
        agencia.add_vehicle(matricula, categoria)
    
    elif opcion == 2:
        print(agencia.show_vehicles())
    
    elif opcion == 3:
        print(agencia.show_not_rented())
    
    elif opcion == 4:
        dni = input("DNI: ")
        matricula = input("Matrícula: ")
        dias = int(input("Número de días: "))
        agencia.vehicle_rent(dni, matricula, dias)
    
    elif opcion == 5:
        matricula = input("Matrícula: ")
        litros = int(input("Litros que le faltan al combustible: "))
        agencia.vehicle_return(matricula, litros)
    
    elif opcion == 6:
        print(agencia.show_average_duration())
    
    elif opcion == 7:
        print(agencia.show_rented())

    else:
        print("Opción incorrecta")
    
    input("Pulsa Enter para continuar ")

```


## Supuesto. Versión 2.0. (2p)

### Enunciado

La agencia realiza un mantenimiento a los vehículos después de que son **devueltos**. El mantenimiento incluye una limpieza del vehículo y llenarles el depósito. La limpieza tiene el siguiente coste:

* 10€ para los vehículos de categoría **A**
* 8€ para los vehículos de categoría **B**
* 5€ para los vehículos de categoría **C**

El coste de la limpieza se decrementa del **saldo** de la agencia.

LLenar el depósito cuesta 1€ por cada litro de gasolina que le falta al vehículo. Decrementar el costo del **saldo de fianzas** de la agencia.

# Version 2.0:

***Clase vehículo:***
```python=
import os
os.system("cls")

from abc import ABC, abstractmethod

class VehicleInterface(ABC):
    _capacities = {"A" : 50, "B" : 45, "C" : 40}
    def __init__(self, registration, category):
        self._registration = registration
        self._category = category
        
    @abstractmethod
    def __str__():
        pass
        
    @abstractmethod
    def get_capacity(self):
        pass

class Vehicle(VehicleInterface):
    def __init__(self, registration, category):
        self._registration  = registration
        self._category = category
        
    def __str__(self):
        return f"La matrícula del vehículo es {self._registration}, la categoría es {self._category} y la capacidad es de {self.get_capacity()}l "

    def get_capacity(self):
            if self._category == "A":
                return (self._capacities.get('A'))
            if self._category == "B":
                return (self._capacities.get('B'))
            if self._category == "C":
                return (self._capacities.get('C'))



v = Vehicle("124567G", "B")
# print(v)
```

***Clase alquiler:***
```python=
import os
os.system("cls")

from abc import ABC, abstractmethod
from vehiculos import Vehicle
class RentInterface(ABC):
    _prices_per_day = {"A" : 30, "B" : 20, "C" : 10}
        
    def __init__(self, dni, registration, duration):
        self._dni = dni
        self._registration = registration 
        self._duration = duration
        
    @abstractmethod
    def __str__():
        pass
        
    @abstractmethod
    def get_price_per_day():
        pass

class Rent(RentInterface):
    def __init__(self, dni, registration, duration):
        self._dni = dni
        self._registration = registration 
        self._duration = duration
        
    def __str__(self):
        return f"El DNI del cliente es {self._dni} la matrícula del vehículo es {self._registration} el precio por día es de {self.get_price_per_day()}€"
    def get_price_per_day(self):
        v = Vehicle("124567G","A")
        if v._category == "A":
             precio = self._prices_per_day.get('A') 
             return precio              
        if v._category == "B":
            precio = self._prices_per_day.get('B') 
            return precio
        if v._category == "C":
            precio = self._prices_per_day.get('B') 
            return precio

r = Rent("42379434X", "124567G", 3) 
print(r)
```
***Clase Nocar:***

```python=
from os import system
system("cls")

from abc import ABC, abstractmethod
from vehiculos import Vehicle
from alquiler import Rent

class NocarAgencyInterface(ABC):
    _rental_deposit = 100   # fianza
    _liter_fuel_cost = 2    # coste del litro de gasolina
    _maintenance = {"A" : 10, "B" : 8, "C" : 5}
    _capacities = {"A" : 50, "B" : 45, "C" : 40}
    
    def __init__(self):
        self._vehicles = []
        self._rentals = []
        self._income_balance = 0
        self._deposit_balance = 0
        self._maintenance_cost = 0
       
        
    @abstractmethod
    def add_vehicle(self):
        pass
    
    @abstractmethod
    def show_vehicles():
        pass

    @abstractmethod
    def show_not_rented():
        pass         # Mostrar no alquilados
    
    @abstractmethod
    def vehicle_rent():
        pass
    
    @abstractmethod
    def vehicle_return():
        pass
        
    @abstractmethod
    def show_average_duration():
        pass

    @abstractmethod
    def show_rented():
        pass
    

class Nocar(NocarAgencyInterface):
    _vehicles = []
    _rentals = []
    def __init__(self):
        self._vehicles = []
        self._rentals = []
        self._income_balance = 0
        self._deposit_balance = 0

    def add_vehicle(self, matricula, categoria):
        self._category = categoria
        self._vehicles.append(matricula)
        self._vehicles.append(categoria)
        return self._vehicles

    def show_vehicles(self):
        return self._vehicles

    def show_not_rented(self):
        libres = []
        for vehicle in range (len(self._vehicles)):
            if self._vehicles[vehicle]!= "A" and self._vehicles[vehicle] != "B" and self._vehicles[vehicle] != "C":
                if self._vehicles[vehicle] not in self._rentals:
                    libres.append(self._vehicles[vehicle])
        return libres
    def vehicle_rent(self, dni, registration, duration):
        self._dni = dni
        self._registration = registration
        self._duration = duration
        precio = 0
        
        if ag._category == "A":
             precio = duration * Rent._prices_per_day.get('A')     
        if ag._category == "B":
             precio = duration * Rent._prices_per_day.get('B')
        if ag._category == "C" :
            precio = duration * Rent._prices_per_day.get('C')
            
        if registration not in self._rentals:
            self._rentals.append(dni)
            self._rentals.append(registration)
            self._rentals.append(duration)
            self._deposit_balance += self._rental_deposit 
            self._income_balance += precio
            return f"El vehículo que acabas de alquilar tiene la matrícula {registration}, la duración del alquiler es de {duration} días y el precio a pagar es de {precio}€"
        else:
            return f"El vehículo ya está alquilado"

    def vehicle_return(self, matricula, litros):
        l = len(self._rentals)
        for i in range ((l)-1,-1,-1): 
            if self._rentals[i] == matricula:
                del self._rentals[i-1:i+2]
                self._rentals.append('') 
        del self._rentals[-1]

        if ag._category == "A":
             costelimpieza = self._maintenance.get('A')
        if ag._category == "B":
             costelimpieza =  self._maintenance.get('B')
        if ag._category == "C" :
            costelimpieza = self._maintenance.get('C')


        if ag._category == "A":
            costegas = self._capacities.get('A')
        if ag._category == "B":
            costegas =  self._capacities.get('B')
        if ag._category == "C" :
            costegas = self._capacities.get('C')

        devolver = self._rental_deposit - (litros * self._liter_fuel_cost)
        # costellenardeposito = self._maintenance_cost * litros
        costellenardeposito = costegas * litros
        costemantenimiento = costelimpieza + costellenardeposito
        self._deposit_balance -= devolver + costemantenimiento
        return f"Se le devuelven al cliente {devolver}€"

    def show_average_duration(self):
        diastotales = 0 
        contador = 0 
        for i in self._rentals:
            if type(i)!= str:
                contador+=1
                diastotales += i
        media = diastotales/contador
        return media
    def show_rented (self):
        return self._rentals



ag = Nocar()
v = Vehicle("564597GC","A")
v2 = Vehicle("262626TF","B")
v3 =  Vehicle("646646GC","C")

alq = Rent("74747482B",v._registration, 6)
alq2 = Rent("87276333N",v2._registration, 8)
alq3 = Rent("913459X", v3._registration, 10)
ag.add_vehicle(v._registration, v._category)
ag.add_vehicle(v2._registration, v2._category)
ag.add_vehicle(v3._registration, v3._category)
print(ag.show_vehicles())
print(ag.show_not_rented())
print(ag.vehicle_rent(alq._dni,alq._registration,alq._duration))
print(ag.vehicle_rent(alq2._dni,alq2._registration,alq2._duration))
print(ag.vehicle_rent(alq3._dni,alq3._registration,alq3._duration))
print(ag.vehicle_return(v._registration,20))
print(ag.show_average_duration())
print(ag.show_not_rented())
```

***Programa principal:***
```python=
from os import system
system("cls")
from agenciaNocar import *

agencia = Nocar()

opcion = 1

while opcion != 0:
    system("cls")
    print("1. Añadir vehículo")
    print("2. Mostrar vehículos")
    print("3. Mostrar vehículos no alquilados")
    print("4. Alquilar vehículo")
    print("5. Terminar alquiler de un vehículo")
    print("6. Promedio del número de dias de los vehículos alquilados")
    print("7. Mostrar vehiculos alquilados y por quienes están alquilados")
    opcion = int(input("Introduce una opcion: "))
    if opcion == 1:
        matricula = input("Introduce la matrícula del vehículo: ")
        categoria = input("Introduce la categoría del vehículo: ")
        agencia.add_vehicle(matricula, categoria)
    
    elif opcion == 2:
        print(agencia.show_vehicles())
    
    elif opcion == 3:
        print(agencia.show_not_rented())
    
    elif opcion == 4:
        dni = input("DNI: ")
        matricula = input("Matrícula: ")
        dias = int(input("Número de días: "))
        agencia.vehicle_rent(dni, matricula, dias)
    
    elif opcion == 5:
        matricula = input("Matrícula: ")
        litros = int(input("Litros que le faltan al combustible: "))
        agencia.vehicle_return(matricula, litros)
    
    elif opcion == 6:
        print(agencia.show_average_duration())
    
    elif opcion == 7:
        print(agencia.show_rented())

    else:
        print("Opción incorrecta")
    
    input("Pulsa Enter para continuar: ")
```


### El producto-

Haz una copia de `nocar.1.0` en otra carpeta.

Modifica los archivos con los requisitos de la nueva versión.

Si has llegado hasta aquí se deben entregar todos los archivos comprimidos en un archivo **nocar.2.0.zip**

## Supuesto. Versión 3.0. (2p)

### Enunciado

El jefe del proyecto ha descubierto que localizar elementos en un **diccionario** es instantaneo, mientras que hacerlo en una lista tiene el coste de que se ha de recorrer la lista elemento a elemento para localizar el que se está buscando.

En base a la nueva información propone sustituir la **lista de alquileres** por un **diccionario anidaddo** (un diccionario de diccionarios) en el que las **claves** son las **matrículas** de los vehículos alquilados y el valor de cada uno un diccionario con el DNI del cliente y el número de días del alquiler.

Ejemplo:

```python
d_alquileres = {
    '1234ABC' : {'dni' : '12343123A', num_dias : 5},
    '2222BBB' : {'dni' : '22222222B', num_dias : 2}, 
    '3333CCC' : {'dni' : '12343123A', num_dias : 8},
}
```
Más información sobre diccionarios en [los apuntes de clase](https://www3.gobiernodecanarias.org/medusa/eforma/campus/pluginfile.php/6656923/mod_resource/content/7/pro-ut2-6-Diccionarios%20en%20Python.pdf).

Al usar esta estructura de datos ya no necesitaremos objetos de la clase `Alquiler` tendremos que eliminarla y reescribir algunas partes de la aplicación para que usen la nueva estructura de datos.

### El producto

Haz una copia de `nocar.2.0` en otra carpeta.

Modifica los archivos con los requisitos de la nueva versión.

Si has llegado hasta aquí se deben entregar todos los archivos comprimidos en un archivo **nocar.3.0.zip**

###### tags: `pro` `ut2` `oop` `prueba` `práctica` `simulacro`