From 8dcc2560cd99023deb29166066e0137057c0ce81 Mon Sep 17 00:00:00 2001 From: fragata-adrian Date: Tue, 27 Oct 2020 17:10:12 -0300 Subject: [PATCH 01/12] comence a trabajar --- tp-base.py | 124 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 124 insertions(+) create mode 100644 tp-base.py diff --git a/tp-base.py b/tp-base.py new file mode 100644 index 0000000..ca04747 --- /dev/null +++ b/tp-base.py @@ -0,0 +1,124 @@ +import random +import threading +import time +import logging + +logging.basicConfig(format='%(asctime)s.%(msecs)03d [%(threadName)s] - %(message)s', datefmt='%H:%M:%S', level=logging.INFO) + +botellasSobrantes = [] +latasSobrantes = [] +heladeras = [] +semaforoHeladeras = threading.Semaphore(0) + +cantidadHeladeras = 1 +cantidadProveedores = 1 + +class Heladera(): + def __init__(self, nombre): + self.botellas = [] + self.latas = [] + self.nombre = nombre + + def enchufar(self): + print("Enchufando heladera..") + time.sleep(2) + + def enfriamientoRapido(self): + print("Iniciando el enfriamiento rapido") + time.sleep(1) + + def hayEspacio(self): + if len(self.botellas) == 10 and len(self.latas) == 15: + return False + else: + return True + + def agregarBotella(self, cantidad): + aPoner = cantidad + print("Agregando " + str(cantidad) + " Botellas en heladera " + str(self.nombre)) + while len(self.botellas) < 10: + self.botellas.append(1) + aPoner -= 1 + time.sleep(1) + if aPoner > 0: + return aPoner + else: + return 0 + + def agregarLata(self, cantidad): + aPoner = cantidad + print("Agregando " + str(cantidad) + " Latas en heladera " + str(self.nombre)) + while len(self.latas) < 15: + self.latas.append(1) + aPoner -= 1 + time.sleep(1) + if aPoner > 0: + return aPoner + else: + return 0 + + +class Proveedor(threading.Thread): + def __init__(self, nombre): + super().__init__() + self.name = nombre + + def cantAPoner(self): + return random.randint(1,10) + + + def reponer(self, heladera): + global botellasSobrantes, latasSobrantes + + sobranteBotellas = heladera.agregarBotella(self.cantAPoner()) + sobranteLatas = heladera.agregarLata(self.cantAPoner()) + + while sobranteBotellas > 0: + botellasSobrantes.append(1) + sobranteBotellas -= 1 + while sobranteLatas > 0: + latasSobrantes.append(1) + latasSobrantes -= 1 + + def run(self): + while True: + + self.reponer(elegirHeladera) + time.sleep(5) + +def hayHeladerasDisponibles(): + i = 0 + resultado = False + while i < len(heladeras): + h = heladeras[i] + if h.hayEspacio: + resultado = True + else: + pass + return resultado + +def elegirHeladera(): + global heladeras + i = 0 + + if hayHeladerasDisponibles(): + heladeraConEspacio = None + try: + while i < len(heladeras): + heladeraActual = heladeras[i] + if heladeraActual.hayEspacio: + heladeraConEspacio = heladeraActual + raise Exception("Se encontro") + i += 1 + except: + return heladeraConEspacio + + +for i in range(cantidadHeladeras): + heladeras.append(Heladera(i)) + +for i in range(cantidadProveedores): + Proveedor(i).start() + + + From 0f12bd9315edba78008a92341f34ad7791850d7a Mon Sep 17 00:00:00 2001 From: fragata-adrian Date: Tue, 27 Oct 2020 20:58:16 -0300 Subject: [PATCH 02/12] El programa corre --- tp-base.py | 112 +++++++++++++++++++++++++++-------------------------- 1 file changed, 58 insertions(+), 54 deletions(-) diff --git a/tp-base.py b/tp-base.py index ca04747..58c5ca5 100644 --- a/tp-base.py +++ b/tp-base.py @@ -5,13 +5,39 @@ logging.basicConfig(format='%(asctime)s.%(msecs)03d [%(threadName)s] - %(message)s', datefmt='%H:%M:%S', level=logging.INFO) -botellasSobrantes = [] -latasSobrantes = [] +botellasSobrantes = 0 +latasSobrantes = 0 heladeras = [] -semaforoHeladeras = threading.Semaphore(0) +semaforoHeladeras = threading.Semaphore(1) -cantidadHeladeras = 1 -cantidadProveedores = 1 +cantidadHeladeras = 2 +cantidadProveedores = 2 + + +def hayHeladerasDisponibles(): + i = 0 + resultado = False + while i < len(heladeras): + h = heladeras[i] + if h.hayEspacio(): + resultado = True + i += 1 + return resultado + +def elegirHeladera(): + global heladeras + i = 0 + if hayHeladerasDisponibles(): + heladeraConEspacio = None + try: + while i < len(heladeras): + heladeraActual = heladeras[i] + while heladeraActual.hayEspacio(): + heladeraConEspacio = heladeraActual + raise Exception("Se encontro") + i += 1 + except: + return heladeraConEspacio class Heladera(): def __init__(self, nombre): @@ -19,14 +45,6 @@ def __init__(self, nombre): self.latas = [] self.nombre = nombre - def enchufar(self): - print("Enchufando heladera..") - time.sleep(2) - - def enfriamientoRapido(self): - print("Iniciando el enfriamiento rapido") - time.sleep(1) - def hayEspacio(self): if len(self.botellas) == 10 and len(self.latas) == 15: return False @@ -35,11 +53,12 @@ def hayEspacio(self): def agregarBotella(self, cantidad): aPoner = cantidad - print("Agregando " + str(cantidad) + " Botellas en heladera " + str(self.nombre)) + while len(self.botellas) < 10: self.botellas.append(1) aPoner -= 1 - time.sleep(1) + time.sleep(2) + if aPoner > 0: return aPoner else: @@ -47,11 +66,12 @@ def agregarBotella(self, cantidad): def agregarLata(self, cantidad): aPoner = cantidad - print("Agregando " + str(cantidad) + " Latas en heladera " + str(self.nombre)) + while len(self.latas) < 15: self.latas.append(1) aPoner -= 1 - time.sleep(1) + time.sleep(2) + if aPoner > 0: return aPoner else: @@ -69,56 +89,40 @@ def cantAPoner(self): def reponer(self, heladera): global botellasSobrantes, latasSobrantes + botellasAPoner = self.cantAPoner() + botellasSobrantes + latasAPoner = self.cantAPoner() + latasSobrantes + + logging.info("Agregando " + str(botellasAPoner) + " Botellas en heladera " + str(heladera.nombre)) + sobranteBotellas = heladera.agregarBotella(botellasAPoner) - sobranteBotellas = heladera.agregarBotella(self.cantAPoner()) - sobranteLatas = heladera.agregarLata(self.cantAPoner()) + logging.info("Agregando " + str(latasAPoner) + " Latas en heladera " + str(heladera.nombre)) + sobranteLatas = heladera.agregarLata(latasAPoner) - while sobranteBotellas > 0: - botellasSobrantes.append(1) - sobranteBotellas -= 1 - while sobranteLatas > 0: - latasSobrantes.append(1) - latasSobrantes -= 1 + logging.info("Sobraron " + str(sobranteBotellas) + " Botellas y " + str(sobranteLatas) + " latas.") + + botellasSobrantes += sobranteBotellas + latasSobrantes += sobranteLatas def run(self): - while True: - - self.reponer(elegirHeladera) - time.sleep(5) - -def hayHeladerasDisponibles(): - i = 0 - resultado = False - while i < len(heladeras): - h = heladeras[i] - if h.hayEspacio: - resultado = True + semaforoHeladeras.acquire() + + if hayHeladerasDisponibles(): + self.reponer(elegirHeladera()) else: - pass - return resultado + logging.info("Las heladeras estan llenas!") -def elegirHeladera(): - global heladeras - i = 0 + semaforoHeladeras.release() - if hayHeladerasDisponibles(): - heladeraConEspacio = None - try: - while i < len(heladeras): - heladeraActual = heladeras[i] - if heladeraActual.hayEspacio: - heladeraConEspacio = heladeraActual - raise Exception("Se encontro") - i += 1 - except: - return heladeraConEspacio + + for i in range(cantidadHeladeras): heladeras.append(Heladera(i)) for i in range(cantidadProveedores): - Proveedor(i).start() + nombre = 'Proveedor ' + str(i) + Proveedor(nombre).start() From 08a74d0066f87870aca36bd10b42ee225791cc64 Mon Sep 17 00:00:00 2001 From: fragata-adrian Date: Wed, 28 Oct 2020 17:32:28 -0300 Subject: [PATCH 03/12] base terminada --- tp-base.py | 72 ++++++++++++++++++++++++++++-------------------------- 1 file changed, 38 insertions(+), 34 deletions(-) diff --git a/tp-base.py b/tp-base.py index 58c5ca5..6ff2523 100644 --- a/tp-base.py +++ b/tp-base.py @@ -8,10 +8,11 @@ botellasSobrantes = 0 latasSobrantes = 0 heladeras = [] +heladeraConEspacio = 0 semaforoHeladeras = threading.Semaphore(1) -cantidadHeladeras = 2 -cantidadProveedores = 2 +cantidadHeladeras = 5 +cantidadProveedores = 20 def hayHeladerasDisponibles(): @@ -25,19 +26,11 @@ def hayHeladerasDisponibles(): return resultado def elegirHeladera(): - global heladeras - i = 0 - if hayHeladerasDisponibles(): - heladeraConEspacio = None - try: - while i < len(heladeras): - heladeraActual = heladeras[i] - while heladeraActual.hayEspacio(): - heladeraConEspacio = heladeraActual - raise Exception("Se encontro") - i += 1 - except: - return heladeraConEspacio + global heladeras, heladeraConEspacio + if not heladeras[heladeraConEspacio].hayEspacio(): + print("Iniciando enfriado rapido en heladera", heladeras[heladeraConEspacio].nombre) + heladeraConEspacio += 1 + print("Enchufando heladera", heladeras[heladeraConEspacio].nombre, "\n") class Heladera(): def __init__(self, nombre): @@ -53,11 +46,15 @@ def hayEspacio(self): def agregarBotella(self, cantidad): aPoner = cantidad - - while len(self.botellas) < 10: - self.botellas.append(1) - aPoner -= 1 - time.sleep(2) + try: + while aPoner > 0: + if len(self.botellas) == 10: + raise Exception("La heladera se lleno de botellas") + self.botellas.append(1) + aPoner -= 1 + except: + pass + time.sleep(random.randint(3, 10)) if aPoner > 0: return aPoner @@ -67,15 +64,23 @@ def agregarBotella(self, cantidad): def agregarLata(self, cantidad): aPoner = cantidad - while len(self.latas) < 15: - self.latas.append(1) - aPoner -= 1 - time.sleep(2) + try: + while aPoner > 0: + if len(self.latas) == 15: + raise Exception("La heladera se lleno de latas") + self.latas.append(1) + aPoner -= 1 + except: + pass + time.sleep(random.randint(3, 10)) if aPoner > 0: return aPoner else: return 0 + + def estadoActual(self): + return "La heladera "+ str(self.nombre) +" tiene " + str(len(self.botellas)) + " Botellas y "+ str(len(self.latas)) + " Latas" class Proveedor(threading.Thread): @@ -86,37 +91,36 @@ def __init__(self, nombre): def cantAPoner(self): return random.randint(1,10) - def reponer(self, heladera): global botellasSobrantes, latasSobrantes botellasAPoner = self.cantAPoner() + botellasSobrantes latasAPoner = self.cantAPoner() + latasSobrantes - logging.info("Agregando " + str(botellasAPoner) + " Botellas en heladera " + str(heladera.nombre)) + logging.info("Ingreso " + str(botellasAPoner) + " Botellas y " + str(latasAPoner) + " Latas") + sobranteBotellas = heladera.agregarBotella(botellasAPoner) - - logging.info("Agregando " + str(latasAPoner) + " Latas en heladera " + str(heladera.nombre)) sobranteLatas = heladera.agregarLata(latasAPoner) - logging.info("Sobraron " + str(sobranteBotellas) + " Botellas y " + str(sobranteLatas) + " latas.") + logging.info(heladera.estadoActual()) + logging.info("Sobraron " + str(sobranteBotellas) + " Botellas y " + str(sobranteLatas) + " latas.\n") botellasSobrantes += sobranteBotellas latasSobrantes += sobranteLatas def run(self): + global heladeraConEspacio semaforoHeladeras.acquire() if hayHeladerasDisponibles(): - self.reponer(elegirHeladera()) + elegirHeladera() + self.reponer(heladeras[heladeraConEspacio]) else: logging.info("Las heladeras estan llenas!") - + semaforoHeladeras.release() - - - + for i in range(cantidadHeladeras): heladeras.append(Heladera(i)) From 0793dd718903b15661bbc120d311d8bcde5da768 Mon Sep 17 00:00:00 2001 From: Fabiola Date: Wed, 28 Oct 2020 19:15:27 -0300 Subject: [PATCH 04/12] comenzamos el bonus 1 y algo corre --- bonus/bonus1.py | 195 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 195 insertions(+) create mode 100644 bonus/bonus1.py diff --git a/bonus/bonus1.py b/bonus/bonus1.py new file mode 100644 index 0000000..5411a33 --- /dev/null +++ b/bonus/bonus1.py @@ -0,0 +1,195 @@ +import random +import threading +import time +import logging + +logging.basicConfig(format='%(asctime)s.%(msecs)03d [%(threadName)s] - %(message)s', datefmt='%H:%M:%S', level=logging.INFO) + +botellasSobrantes = 0 +latasSobrantes = 0 +heladeras = [] +heladeraConEspacio = 0 +semaforoHeladeras = threading.Semaphore(1) +monitorBeode = threading.Condition() + +cantidadHeladeras = 5 +cantidadProveedores = 20 + + +def hayHeladerasDisponibles(): + i = 0 + resultado = False + while i < len(heladeras): + h = heladeras[i] + if h.hayEspacio(): + resultado = True + i += 1 + return resultado + +def elegirHeladera(): + global heladeras, heladeraConEspacio + if not heladeras[heladeraConEspacio].hayEspacio(): + print("Iniciando enfriado rapido en heladera", heladeras[heladeraConEspacio].nombre) + heladeraConEspacio += 1 + print("Enchufando heladera", heladeras[heladeraConEspacio].nombre, "\n") + +class Heladera(): + def __init__(self, nombre): + self.botellas = [] + self.latas = [] + self.nombre = nombre + + def hayEspacio(self): + if len(self.botellas) == 10 and len(self.latas) == 15: + return False + else: + return True + + def hayBotellas(self): + return len(self.botellas) > 0 + + def hayLatas(self): + return len(self.latas) > 0 + + def agregarBotella(self, cantidad): + aPoner = cantidad + try: + while aPoner > 0: + if len(self.botellas) == 10: + raise Exception("La heladera se lleno de botellas") + self.botellas.append(1) + aPoner -= 1 + except: + pass + time.sleep(random.randint(3, 10)) + + if aPoner > 0: + return aPoner + else: + return 0 + + def agregarLata(self, cantidad): + aPoner = cantidad + + try: + while aPoner > 0: + if len(self.latas) == 15: + raise Exception("La heladera se lleno de latas") + self.latas.append(1) + aPoner -= 1 + except: + pass + time.sleep(random.randint(3, 10)) + + if aPoner > 0: + return aPoner + else: + return 0 + + def estadoActual(self): + return "La heladera "+ str(self.nombre) +" tiene " + str(len(self.botellas)) + " Botellas y "+ str(len(self.latas)) + " Latas" + + +class Proveedor(threading.Thread): + def __init__(self, nombre): + super().__init__() + self.name = nombre + + def cantAPoner(self): + return random.randint(1,10) + + def reponer(self, heladera): + global botellasSobrantes, latasSobrantes + botellasAPoner = self.cantAPoner() + botellasSobrantes + latasAPoner = self.cantAPoner() + latasSobrantes + + logging.info("Ingreso " + str(botellasAPoner) + " Botellas y " + str(latasAPoner) + " Latas") + + sobranteBotellas = heladera.agregarBotella(botellasAPoner) + sobranteLatas = heladera.agregarLata(latasAPoner) + + logging.info(heladera.estadoActual()) + logging.info("Sobraron " + str(sobranteBotellas) + " Botellas y " + str(sobranteLatas) + " latas.\n") + + botellasSobrantes += sobranteBotellas + latasSobrantes += sobranteLatas + + def run(self): + global heladeraConEspacio + semaforoHeladeras.acquire() + + if hayHeladerasDisponibles(): + elegirHeladera() + with monitorBeode: + self.reponer(heladeras[heladeraConEspacio]) + monitorBeode.notify() + else: + logging.info("Las heladeras estan llenas!") + + semaforoHeladeras.release() + +class Beode(threading.Thread): + def __init__(self,monitor, nombre, limite,tipoDeConsumo): + super().__init__() + self.name = nombre + self.limite = limite + self.consumo = 0 + self.tipoDeConsumo = tipoDeConsumo + self.monitor = monitor + + def elegirHeladera(self): + h = random.randint(0,len(heladeras)-1) + return heladeras[h] + + def consumir(self,heladera): + if self.tipoDeConsumo.lower() == "botella": + if heladera.hayBotellas(): + heladera.botellas.pop(0) + self.consumo += 1 + else: + logging.info("No hay lo que quiero tomar") + self.monitor.wait() + elif self.tipoDeConsumo.lower() == "lata": + if heladera.hayLatas(): + heladera.latas.pop(0) + self.consumo += 1 + else: + logging.info("No hay lo que quiero tomar") + self.monitor.wait() + elif self.tipoDeConsumo.lower() == "ambos": + alAzar = random.choice([0,1]) + if heladera.hayLatas() or heladera.hayBotellas(): + if alAzar == 0: + heladera.botellas.pop(0) + if alAzar == 1: + heladera.latas.pop(0) + self.consumo += 1 + else: + logging.info("No hay lo que quiero tomar") + self.monitor.wait() + logging.info("Estoy bebiendo "+ self.tipoDeConsumo + " voy tomando "+ str(self.consumo)) + + + def run(self): + while self.consumo < self.limite: + with self.monitor: + self.consumir(self.elegirHeladera()) + + logging.info("Me canse de tomar me voy a dormir") + + + + +for i in range(cantidadHeladeras): + heladeras.append(Heladera(i)) +time.sleep(10) + +for i in range(cantidadProveedores): + nombre = 'Proveedor ' + str(i) + Proveedor(nombre).start() + +b = Beode(monitorBeode,"Pepe",5,"botella") +b.start() + + + From 1826451fdee7191090cf17acbf98442ea123eb39 Mon Sep 17 00:00:00 2001 From: fragata-adrian Date: Thu, 29 Oct 2020 15:36:10 -0300 Subject: [PATCH 05/12] listo el bonus 1 --- bonus/bonus1.py | 65 ++++++++++++++++++++++++++++--------------------- tp-base.py | 2 +- 2 files changed, 38 insertions(+), 29 deletions(-) diff --git a/bonus/bonus1.py b/bonus/bonus1.py index 5411a33..a4df2fe 100644 --- a/bonus/bonus1.py +++ b/bonus/bonus1.py @@ -31,7 +31,10 @@ def elegirHeladera(): if not heladeras[heladeraConEspacio].hayEspacio(): print("Iniciando enfriado rapido en heladera", heladeras[heladeraConEspacio].nombre) heladeraConEspacio += 1 - print("Enchufando heladera", heladeras[heladeraConEspacio].nombre, "\n") + if heladeraConEspacio == len(heladeras): + heladeraConEspacio = 0 + else: + print("Enchufando heladera", heladeras[heladeraConEspacio].nombre, "\n") class Heladera(): def __init__(self, nombre): @@ -141,40 +144,40 @@ def elegirHeladera(self): h = random.randint(0,len(heladeras)-1) return heladeras[h] + def consumirBotella(self, heladera): + if heladera.hayBotellas(): + heladera.botellas.pop(0) + self.consumo += 1 + logging.info("Estoy bebiendo "+ self.tipoDeConsumo + " de la heladera " + str(heladera.nombre) + " voy tomando "+ str(self.consumo) + "\n") + else: + logging.info("No hay lo que quiero tomar en la heladera " + str(heladera.nombre) + "\n") + self.monitor.wait() + + def consumirLata(self, heladera): + if heladera.hayLatas(): + heladera.latas.pop(0) + self.consumo += 1 + logging.info("Estoy bebiendo "+ self.tipoDeConsumo + " de la heladera " + str(heladera.nombre) + " voy tomando "+ str(self.consumo) + "\n") + else: + logging.info("No hay lo que quiero tomar en la heladera " + str(heladera.nombre) + "\n") + self.monitor.wait() + def consumir(self,heladera): if self.tipoDeConsumo.lower() == "botella": - if heladera.hayBotellas(): - heladera.botellas.pop(0) - self.consumo += 1 - else: - logging.info("No hay lo que quiero tomar") - self.monitor.wait() + self.consumirBotella(heladera) elif self.tipoDeConsumo.lower() == "lata": - if heladera.hayLatas(): - heladera.latas.pop(0) - self.consumo += 1 - else: - logging.info("No hay lo que quiero tomar") - self.monitor.wait() + self.consumirLata(heladera) elif self.tipoDeConsumo.lower() == "ambos": alAzar = random.choice([0,1]) - if heladera.hayLatas() or heladera.hayBotellas(): - if alAzar == 0: - heladera.botellas.pop(0) - if alAzar == 1: - heladera.latas.pop(0) - self.consumo += 1 - else: - logging.info("No hay lo que quiero tomar") - self.monitor.wait() - logging.info("Estoy bebiendo "+ self.tipoDeConsumo + " voy tomando "+ str(self.consumo)) - + if alAzar == 0: + self.consumirBotella(heladera) + if alAzar == 1: + self.consumirLata(heladera) def run(self): while self.consumo < self.limite: with self.monitor: self.consumir(self.elegirHeladera()) - logging.info("Me canse de tomar me voy a dormir") @@ -182,14 +185,20 @@ def run(self): for i in range(cantidadHeladeras): heladeras.append(Heladera(i)) -time.sleep(10) +time.sleep(5) for i in range(cantidadProveedores): nombre = 'Proveedor ' + str(i) Proveedor(nombre).start() -b = Beode(monitorBeode,"Pepe",5,"botella") -b.start() +bb = Beode(monitorBeode,"Pepe",5,"botella") +bb.start() + +bl= Beode(monitorBeode, "Eduardo", 2, "lata") +bl.start() + +ba= Beode(monitorBeode,"Barbi", 5, "ambos") +ba.start() diff --git a/tp-base.py b/tp-base.py index 6ff2523..cc30abe 100644 --- a/tp-base.py +++ b/tp-base.py @@ -120,7 +120,7 @@ def run(self): semaforoHeladeras.release() - + for i in range(cantidadHeladeras): heladeras.append(Heladera(i)) From cbcc824c03676a6b80b4e8553e3afe7038330195 Mon Sep 17 00:00:00 2001 From: Fabiola Date: Thu, 29 Oct 2020 16:43:15 -0300 Subject: [PATCH 06/12] arrancando bonus 2 --- bonus/bonus1.py | 24 +++-- bonus/bonus2.py | 226 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 242 insertions(+), 8 deletions(-) create mode 100644 bonus/bonus2.py diff --git a/bonus/bonus1.py b/bonus/bonus1.py index a4df2fe..138f81a 100644 --- a/bonus/bonus1.py +++ b/bonus/bonus1.py @@ -29,12 +29,12 @@ def hayHeladerasDisponibles(): def elegirHeladera(): global heladeras, heladeraConEspacio if not heladeras[heladeraConEspacio].hayEspacio(): - print("Iniciando enfriado rapido en heladera", heladeras[heladeraConEspacio].nombre) + logging.info("Iniciando enfriado rapido en heladera "+ str(heladeras[heladeraConEspacio].nombre)) heladeraConEspacio += 1 if heladeraConEspacio == len(heladeras): heladeraConEspacio = 0 else: - print("Enchufando heladera", heladeras[heladeraConEspacio].nombre, "\n") + logging.info("Enchufando heladera "+ str(heladeras[heladeraConEspacio].nombre) + "\n") class Heladera(): def __init__(self, nombre): @@ -145,21 +145,28 @@ def elegirHeladera(self): return heladeras[h] def consumirBotella(self, heladera): + semaforoHeladeras.acquire() if heladera.hayBotellas(): heladera.botellas.pop(0) self.consumo += 1 logging.info("Estoy bebiendo "+ self.tipoDeConsumo + " de la heladera " + str(heladera.nombre) + " voy tomando "+ str(self.consumo) + "\n") + semaforoHeladeras.release() else: logging.info("No hay lo que quiero tomar en la heladera " + str(heladera.nombre) + "\n") + semaforoHeladeras.release() self.monitor.wait() + def consumirLata(self, heladera): + semaforoHeladeras.acquire() if heladera.hayLatas(): heladera.latas.pop(0) self.consumo += 1 logging.info("Estoy bebiendo "+ self.tipoDeConsumo + " de la heladera " + str(heladera.nombre) + " voy tomando "+ str(self.consumo) + "\n") + semaforoHeladeras.release() else: logging.info("No hay lo que quiero tomar en la heladera " + str(heladera.nombre) + "\n") + semaforoHeladeras.release() self.monitor.wait() def consumir(self,heladera): @@ -173,6 +180,7 @@ def consumir(self,heladera): self.consumirBotella(heladera) if alAzar == 1: self.consumirLata(heladera) + time.sleep(3) def run(self): while self.consumo < self.limite: @@ -180,16 +188,11 @@ def run(self): self.consumir(self.elegirHeladera()) logging.info("Me canse de tomar me voy a dormir") - - + for i in range(cantidadHeladeras): heladeras.append(Heladera(i)) -time.sleep(5) -for i in range(cantidadProveedores): - nombre = 'Proveedor ' + str(i) - Proveedor(nombre).start() bb = Beode(monitorBeode,"Pepe",5,"botella") bb.start() @@ -200,5 +203,10 @@ def run(self): ba= Beode(monitorBeode,"Barbi", 5, "ambos") ba.start() +for i in range(cantidadProveedores): + nombre = 'Proveedor ' + str(i) + Proveedor(nombre).start() + + diff --git a/bonus/bonus2.py b/bonus/bonus2.py new file mode 100644 index 0000000..73d7105 --- /dev/null +++ b/bonus/bonus2.py @@ -0,0 +1,226 @@ +import random +import threading +import time +import logging + +logging.basicConfig(format='%(asctime)s.%(msecs)03d [%(threadName)s] - %(message)s', datefmt='%H:%M:%S', level=logging.INFO) + +botellasSobrantes = 0 +latasSobrantes = 0 +heladeras = [] +heladeraConEspacio = 0 +semaforoHeladeras = threading.Semaphore(1) +monitorBeode = threading.Condition() + +cantidadHeladeras = 5 +cantidadProveedores = 20 + + +def hayHeladerasDisponibles(): + i = 0 + resultado = False + while i < len(heladeras): + h = heladeras[i] + if h.hayEspacio(): + resultado = True + i += 1 + return resultado + +def elegirHeladera(): + global heladeras, heladeraConEspacio + if not heladeras[heladeraConEspacio].hayEspacio(): + logging.info("Iniciando enfriado rapido en heladera "+ str(heladeras[heladeraConEspacio].nombre)) + heladeraConEspacio += 1 + if heladeraConEspacio == len(heladeras): + heladeraConEspacio = 0 + else: + logging.info("Enchufando heladera "+ str(heladeras[heladeraConEspacio].nombre)+ "\n") + +def lataPinchada(): + global heladeras + indiceRandom = random.randint(0,len(heladeras)-1) + h = heladeras[indiceRandom] + caso = random.choice([0,1,2,3,4]) + if caso == 3: + h.latas.pop(0) + print("Se ha pinchado una lata \n") + + + + + +class Heladera(): + def __init__(self, nombre): + self.botellas = [] + self.latas = [] + self.nombre = nombre + + def hayEspacio(self): + if len(self.botellas) == 10 and len(self.latas) == 15: + return False + else: + return True + + def hayBotellas(self): + return len(self.botellas) > 0 + + def hayLatas(self): + return len(self.latas) > 0 + + def agregarBotella(self, cantidad): + aPoner = cantidad + try: + while aPoner > 0: + if len(self.botellas) == 10: + raise Exception("La heladera se lleno de botellas") + self.botellas.append(1) + aPoner -= 1 + except: + pass + time.sleep(random.randint(3, 10)) + + if aPoner > 0: + return aPoner + else: + return 0 + + def agregarLata(self, cantidad): + aPoner = cantidad + + try: + while aPoner > 0: + if len(self.latas) == 15: + raise Exception("La heladera se lleno de latas") + self.latas.append(1) + aPoner -= 1 + except: + pass + time.sleep(random.randint(3, 10)) + lataPinchada() + if aPoner > 0: + return aPoner + else: + return 0 + + def estadoActual(self): + return "La heladera "+ str(self.nombre) +" tiene " + str(len(self.botellas)) + " Botellas y "+ str(len(self.latas)) + " Latas" + + + +class Proveedor(threading.Thread): + def __init__(self, nombre): + super().__init__() + self.name = nombre + + def cantAPoner(self): + return random.randint(1,10) + + def reponer(self, heladera): + global botellasSobrantes, latasSobrantes + botellasAPoner = self.cantAPoner() + botellasSobrantes + latasAPoner = self.cantAPoner() + latasSobrantes + + logging.info("Ingreso " + str(botellasAPoner) + " Botellas y " + str(latasAPoner) + " Latas") + + sobranteBotellas = heladera.agregarBotella(botellasAPoner) + sobranteLatas = heladera.agregarLata(latasAPoner) + + logging.info(heladera.estadoActual()) + logging.info("Sobraron " + str(sobranteBotellas) + " Botellas y " + str(sobranteLatas) + " latas.\n") + + botellasSobrantes += sobranteBotellas + latasSobrantes += sobranteLatas + + def run(self): + global heladeraConEspacio + semaforoHeladeras.acquire() + + if hayHeladerasDisponibles(): + elegirHeladera() + with monitorBeode: + self.reponer(heladeras[heladeraConEspacio]) + monitorBeode.notify() + else: + logging.info("Las heladeras estan llenas!") + + semaforoHeladeras.release() + +class Beode(threading.Thread): + def __init__(self,monitor, nombre, limite,tipoDeConsumo): + super().__init__() + self.name = nombre + self.limite = limite + self.consumo = 0 + self.tipoDeConsumo = tipoDeConsumo + self.monitor = monitor + + def elegirHeladera(self): + h = random.randint(0,len(heladeras)-1) + return heladeras[h] + + def consumirBotella(self, heladera): + semaforoHeladeras.acquire() + if heladera.hayBotellas(): + heladera.botellas.pop(0) + self.consumo += 1 + logging.info("Estoy bebiendo "+ self.tipoDeConsumo + " de la heladera " + str(heladera.nombre) + " voy tomando "+ str(self.consumo) + "\n") + semaforoHeladeras.release() + else: + semaforoHeladeras.release() + logging.info("No hay lo que quiero tomar en la heladera " + str(heladera.nombre) + "\n") + self.monitor.wait() + + def consumirLata(self, heladera): + semaforoHeladeras.acquire() + if heladera.hayLatas(): + heladera.latas.pop(0) + self.consumo += 1 + logging.info("Estoy bebiendo "+ self.tipoDeConsumo + " de la heladera " + str(heladera.nombre) + " voy tomando "+ str(self.consumo) + "\n") + semaforoHeladeras.release() + else: + semaforoHeladeras.release() + logging.info("No hay lo que quiero tomar en la heladera " + str(heladera.nombre) + "\n") + self.monitor.wait() + + def consumir(self,heladera): + if self.tipoDeConsumo.lower() == "botella": + self.consumirBotella(heladera) + elif self.tipoDeConsumo.lower() == "lata": + self.consumirLata(heladera) + elif self.tipoDeConsumo.lower() == "ambos": + alAzar = random.choice([0,1]) + if alAzar == 0: + self.consumirBotella(heladera) + if alAzar == 1: + self.consumirLata(heladera) + time.sleep(3) + + def run(self): + while self.consumo < self.limite: + with self.monitor: + self.consumir(self.elegirHeladera()) + logging.info("Me canse de tomar me voy a dormir") + + + + +for i in range(cantidadHeladeras): + heladeras.append(Heladera(i)) +time.sleep(5) + +for i in range(cantidadProveedores): + nombre = 'Proveedor ' + str(i) + Proveedor(nombre).start() + +bb = Beode(monitorBeode,"Pepe",5,"botella") +bb.start() + +bl= Beode(monitorBeode, "Eduardo", 2, "lata") +bl.start() + +ba= Beode(monitorBeode,"Barbi", 5, "ambos") +ba.start() + + + + From c6006fc6a60b75d5ec2797001e558159a179112b Mon Sep 17 00:00:00 2001 From: fragata-adrian Date: Thu, 29 Oct 2020 17:33:10 -0300 Subject: [PATCH 07/12] listo el bonus 2 --- bonus/bonus1.py | 35 ++++++++++++-------------------- bonus/bonus2.py | 53 ++++++++++++++++++++++--------------------------- 2 files changed, 37 insertions(+), 51 deletions(-) diff --git a/bonus/bonus1.py b/bonus/bonus1.py index 138f81a..af9d9b9 100644 --- a/bonus/bonus1.py +++ b/bonus/bonus1.py @@ -9,7 +9,6 @@ latasSobrantes = 0 heladeras = [] heladeraConEspacio = 0 -semaforoHeladeras = threading.Semaphore(1) monitorBeode = threading.Condition() cantidadHeladeras = 5 @@ -64,7 +63,6 @@ def agregarBotella(self, cantidad): aPoner -= 1 except: pass - time.sleep(random.randint(3, 10)) if aPoner > 0: return aPoner @@ -82,7 +80,6 @@ def agregarLata(self, cantidad): aPoner -= 1 except: pass - time.sleep(random.randint(3, 10)) if aPoner > 0: return aPoner @@ -94,9 +91,10 @@ def estadoActual(self): class Proveedor(threading.Thread): - def __init__(self, nombre): + def __init__(self, nombre, monitor): super().__init__() self.name = nombre + self.monitor = monitor def cantAPoner(self): return random.randint(1,10) @@ -111,6 +109,7 @@ def reponer(self, heladera): sobranteBotellas = heladera.agregarBotella(botellasAPoner) sobranteLatas = heladera.agregarLata(latasAPoner) + time.sleep(random.randint(3,5)) logging.info(heladera.estadoActual()) logging.info("Sobraron " + str(sobranteBotellas) + " Botellas y " + str(sobranteLatas) + " latas.\n") @@ -119,17 +118,14 @@ def reponer(self, heladera): def run(self): global heladeraConEspacio - semaforoHeladeras.acquire() - - if hayHeladerasDisponibles(): - elegirHeladera() - with monitorBeode: + with self.monitor: + if hayHeladerasDisponibles(): + elegirHeladera() self.reponer(heladeras[heladeraConEspacio]) - monitorBeode.notify() - else: - logging.info("Las heladeras estan llenas!") - - semaforoHeladeras.release() + self.monitor.notify() + else: + logging.info("Las heladeras estan llenas!") + class Beode(threading.Thread): def __init__(self,monitor, nombre, limite,tipoDeConsumo): @@ -145,31 +141,26 @@ def elegirHeladera(self): return heladeras[h] def consumirBotella(self, heladera): - semaforoHeladeras.acquire() if heladera.hayBotellas(): heladera.botellas.pop(0) self.consumo += 1 logging.info("Estoy bebiendo "+ self.tipoDeConsumo + " de la heladera " + str(heladera.nombre) + " voy tomando "+ str(self.consumo) + "\n") - semaforoHeladeras.release() else: logging.info("No hay lo que quiero tomar en la heladera " + str(heladera.nombre) + "\n") - semaforoHeladeras.release() self.monitor.wait() def consumirLata(self, heladera): - semaforoHeladeras.acquire() if heladera.hayLatas(): heladera.latas.pop(0) self.consumo += 1 logging.info("Estoy bebiendo "+ self.tipoDeConsumo + " de la heladera " + str(heladera.nombre) + " voy tomando "+ str(self.consumo) + "\n") - semaforoHeladeras.release() else: logging.info("No hay lo que quiero tomar en la heladera " + str(heladera.nombre) + "\n") - semaforoHeladeras.release() self.monitor.wait() def consumir(self,heladera): + if self.tipoDeConsumo.lower() == "botella": self.consumirBotella(heladera) elif self.tipoDeConsumo.lower() == "lata": @@ -180,7 +171,7 @@ def consumir(self,heladera): self.consumirBotella(heladera) if alAzar == 1: self.consumirLata(heladera) - time.sleep(3) + time.sleep(random.randint(1, 3)) def run(self): while self.consumo < self.limite: @@ -205,7 +196,7 @@ def run(self): for i in range(cantidadProveedores): nombre = 'Proveedor ' + str(i) - Proveedor(nombre).start() + Proveedor(nombre, monitorBeode).start() diff --git a/bonus/bonus2.py b/bonus/bonus2.py index 73d7105..cccfb01 100644 --- a/bonus/bonus2.py +++ b/bonus/bonus2.py @@ -9,7 +9,6 @@ latasSobrantes = 0 heladeras = [] heladeraConEspacio = 0 -semaforoHeladeras = threading.Semaphore(1) monitorBeode = threading.Condition() cantidadHeladeras = 5 @@ -30,25 +29,27 @@ def elegirHeladera(): global heladeras, heladeraConEspacio if not heladeras[heladeraConEspacio].hayEspacio(): logging.info("Iniciando enfriado rapido en heladera "+ str(heladeras[heladeraConEspacio].nombre)) + time.sleep(0.5) heladeraConEspacio += 1 if heladeraConEspacio == len(heladeras): heladeraConEspacio = 0 else: logging.info("Enchufando heladera "+ str(heladeras[heladeraConEspacio].nombre)+ "\n") + time.sleep(1) def lataPinchada(): global heladeras indiceRandom = random.randint(0,len(heladeras)-1) h = heladeras[indiceRandom] - caso = random.choice([0,1,2,3,4]) - if caso == 3: - h.latas.pop(0) - print("Se ha pinchado una lata \n") + if h.hayLatas(): + caso = random.choice([0,1,2,3,4]) + if caso == 3: + h.latas.pop(0) + print("Se ha pinchado una lata en la heladera ", h.nombre, "\n") - class Heladera(): def __init__(self, nombre): self.botellas = [] @@ -108,9 +109,10 @@ def estadoActual(self): class Proveedor(threading.Thread): - def __init__(self, nombre): + def __init__(self, nombre, monitor): super().__init__() self.name = nombre + self.monitor = monitor def cantAPoner(self): return random.randint(1,10) @@ -125,6 +127,7 @@ def reponer(self, heladera): sobranteBotellas = heladera.agregarBotella(botellasAPoner) sobranteLatas = heladera.agregarLata(latasAPoner) + time.sleep(random.randint(3,5)) logging.info(heladera.estadoActual()) logging.info("Sobraron " + str(sobranteBotellas) + " Botellas y " + str(sobranteLatas) + " latas.\n") @@ -133,17 +136,13 @@ def reponer(self, heladera): def run(self): global heladeraConEspacio - semaforoHeladeras.acquire() - - if hayHeladerasDisponibles(): - elegirHeladera() - with monitorBeode: + with self.monitor: + if hayHeladerasDisponibles(): + elegirHeladera() self.reponer(heladeras[heladeraConEspacio]) - monitorBeode.notify() - else: - logging.info("Las heladeras estan llenas!") - - semaforoHeladeras.release() + self.monitor.notify() + else: + logging.info("Las heladeras estan llenas!") class Beode(threading.Thread): def __init__(self,monitor, nombre, limite,tipoDeConsumo): @@ -159,30 +158,26 @@ def elegirHeladera(self): return heladeras[h] def consumirBotella(self, heladera): - semaforoHeladeras.acquire() if heladera.hayBotellas(): heladera.botellas.pop(0) self.consumo += 1 logging.info("Estoy bebiendo "+ self.tipoDeConsumo + " de la heladera " + str(heladera.nombre) + " voy tomando "+ str(self.consumo) + "\n") - semaforoHeladeras.release() else: - semaforoHeladeras.release() logging.info("No hay lo que quiero tomar en la heladera " + str(heladera.nombre) + "\n") self.monitor.wait() + def consumirLata(self, heladera): - semaforoHeladeras.acquire() if heladera.hayLatas(): heladera.latas.pop(0) self.consumo += 1 logging.info("Estoy bebiendo "+ self.tipoDeConsumo + " de la heladera " + str(heladera.nombre) + " voy tomando "+ str(self.consumo) + "\n") - semaforoHeladeras.release() else: - semaforoHeladeras.release() logging.info("No hay lo que quiero tomar en la heladera " + str(heladera.nombre) + "\n") self.monitor.wait() def consumir(self,heladera): + if self.tipoDeConsumo.lower() == "botella": self.consumirBotella(heladera) elif self.tipoDeConsumo.lower() == "lata": @@ -193,7 +188,7 @@ def consumir(self,heladera): self.consumirBotella(heladera) if alAzar == 1: self.consumirLata(heladera) - time.sleep(3) + time.sleep(random.randint(1, 3)) def run(self): while self.consumo < self.limite: @@ -206,11 +201,6 @@ def run(self): for i in range(cantidadHeladeras): heladeras.append(Heladera(i)) -time.sleep(5) - -for i in range(cantidadProveedores): - nombre = 'Proveedor ' + str(i) - Proveedor(nombre).start() bb = Beode(monitorBeode,"Pepe",5,"botella") bb.start() @@ -221,6 +211,11 @@ def run(self): ba= Beode(monitorBeode,"Barbi", 5, "ambos") ba.start() +for i in range(cantidadProveedores): + nombre = 'Proveedor ' + str(i) + Proveedor(nombre, monitorBeode).start() + + From 352380d62d0026795f31a6997c04ebabcd77db36 Mon Sep 17 00:00:00 2001 From: Fabiola Date: Tue, 3 Nov 2020 16:54:44 -0300 Subject: [PATCH 08/12] Terminamos bonus 3 --- bonus/bonus3.py | 224 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 224 insertions(+) create mode 100644 bonus/bonus3.py diff --git a/bonus/bonus3.py b/bonus/bonus3.py new file mode 100644 index 0000000..59049bd --- /dev/null +++ b/bonus/bonus3.py @@ -0,0 +1,224 @@ +import random +import threading +import time +import logging + +logging.basicConfig(format='%(asctime)s.%(msecs)03d [%(threadName)s] - %(message)s', datefmt='%H:%M:%S', level=logging.INFO) + +botellasSobrantes = 0 +latasSobrantes = 0 +heladeras = [] +monitorBeode = threading.Condition() + +cantidadHeladeras = 5 +cantidadProveedores = 20 + + +def hayHeladerasDisponibles(): + i = 0 + resultado = False + while i < len(heladeras): + h = heladeras[i] + if h.hayEspacio(): + resultado = True + i += 1 + return resultado + +def elegirHeladera(): + global heladeras + heladeraConEspacio = 0 + heladeraMasVacia = heladeras[0] + while heladeraConEspacio < len(heladeras): + heladeraActual = heladeras[heladeraConEspacio] + if heladeraActual.hayEspacio(): + if heladeraActual.cantidadDeCervezas() < heladeraMasVacia.cantidadDeCervezas(): + heladeraMasVacia = heladeraActual + heladeraConEspacio +=1 + return heladeraMasVacia + + +def lataPinchada(): + global heladeras + indiceRandom = random.randint(0,len(heladeras)-1) + h = heladeras[indiceRandom] + if h.hayLatas(): + caso = 3 #random.choice([0,1,2,3]) + if caso == 3: + h.latas.pop(0) + print("Se ha pinchado una lata en la heladera ", h.nombre, "\n") + + + + +class Heladera(): + def __init__(self, nombre): + self.botellas = [] + self.latas = [] + self.nombre = nombre + + def hayEspacio(self): + if len(self.botellas) == 10 and len(self.latas) == 15: + return False + else: + return True + + def hayBotellas(self): + return len(self.botellas) > 0 + + def hayLatas(self): + return len(self.latas) > 0 + + def agregarBotella(self, cantidad): + aPoner = cantidad + try: + while aPoner > 0: + if len(self.botellas) == 10: + raise Exception("La heladera se lleno de botellas") + self.botellas.append(1) + aPoner -= 1 + except: + pass + time.sleep(random.randint(3, 10)) + + if aPoner > 0: + return aPoner + else: + return 0 + + def agregarLata(self, cantidad): + aPoner = cantidad + + try: + while aPoner > 0: + if len(self.latas) == 15: + raise Exception("La heladera se lleno de latas") + self.latas.append(1) + aPoner -= 1 + except: + pass + time.sleep(random.randint(3, 10)) + lataPinchada() + if aPoner > 0: + return aPoner + else: + return 0 + + def estadoActual(self): + return "La heladera "+ str(self.nombre) +" tiene " + str(len(self.botellas)) + " Botellas y "+ str(len(self.latas)) + " Latas" + + def cantidadDeCervezas(self): + cantidad = len(self.botellas) + len(self.latas) + return cantidad + + + +class Proveedor(threading.Thread): + def __init__(self, nombre, monitor): + super().__init__() + self.name = nombre + self.monitor = monitor + + def cantAPoner(self): + return random.randint(1,10) + + def reponer(self, heladera): + global botellasSobrantes, latasSobrantes + botellasAPoner = self.cantAPoner() + botellasSobrantes + latasAPoner = self.cantAPoner() + latasSobrantes + + logging.info("Ingreso " + str(botellasAPoner) + " Botellas y " + str(latasAPoner) + " Latas") + + sobranteBotellas = heladera.agregarBotella(botellasAPoner) + sobranteLatas = heladera.agregarLata(latasAPoner) + + time.sleep(random.randint(3,5)) + logging.info(heladera.estadoActual() + ". Cantidad total de cervezas = " + str(heladera.cantidadDeCervezas())) + logging.info("Sobraron " + str(sobranteBotellas) + " Botellas y " + str(sobranteLatas) + " latas.\n") + + botellasSobrantes += sobranteBotellas + latasSobrantes += sobranteLatas + + def run(self): + global heladeraConEspacio + with self.monitor: + if hayHeladerasDisponibles(): + self.reponer(elegirHeladera()) + self.monitor.notify() + else: + logging.info("Las heladeras estan llenas!") + +class Beode(threading.Thread): + def __init__(self,monitor, nombre, limite,tipoDeConsumo): + super().__init__() + self.name = nombre + self.limite = limite + self.consumo = 0 + self.tipoDeConsumo = tipoDeConsumo + self.monitor = monitor + + def elegirHeladera(self): + h = random.randint(0,len(heladeras)-1) + return heladeras[h] + + def consumirBotella(self, heladera): + if heladera.hayBotellas(): + heladera.botellas.pop(0) + self.consumo += 1 + logging.info("Estoy bebiendo "+ self.tipoDeConsumo + " de la heladera " + str(heladera.nombre) + " voy tomando "+ str(self.consumo) + "\n") + else: + logging.info("No hay lo que quiero tomar en la heladera " + str(heladera.nombre) + "\n") + self.monitor.wait() + + + def consumirLata(self, heladera): + if heladera.hayLatas(): + heladera.latas.pop(0) + self.consumo += 1 + logging.info("Estoy bebiendo "+ self.tipoDeConsumo + " de la heladera " + str(heladera.nombre) + " voy tomando "+ str(self.consumo) + "\n") + else: + logging.info("No hay lo que quiero tomar en la heladera " + str(heladera.nombre) + "\n") + self.monitor.wait() + + def consumir(self,heladera): + + if self.tipoDeConsumo.lower() == "botella": + self.consumirBotella(heladera) + elif self.tipoDeConsumo.lower() == "lata": + self.consumirLata(heladera) + elif self.tipoDeConsumo.lower() == "ambos": + alAzar = random.choice([0,1]) + if alAzar == 0: + self.consumirBotella(heladera) + if alAzar == 1: + self.consumirLata(heladera) + time.sleep(random.randint(1, 3)) + + def run(self): + while self.consumo < self.limite: + with self.monitor: + self.consumir(self.elegirHeladera()) + logging.info("Me canse de tomar me voy a dormir") + + + + +for i in range(cantidadHeladeras): + heladeras.append(Heladera(i)) + +bb = Beode(monitorBeode,"Pepe",5,"botella") +bb.start() + +bl= Beode(monitorBeode, "Eduardo", 2, "lata") +bl.start() + +ba= Beode(monitorBeode,"Barbi", 5, "ambos") +ba.start() + +for i in range(cantidadProveedores): + nombre = 'Proveedor ' + str(i) + Proveedor(nombre, monitorBeode).start() + + + + + From 4fc1deb5bade22401a3dc080a3d4d8cc06bbfdfa Mon Sep 17 00:00:00 2001 From: fragata-adrian Date: Tue, 3 Nov 2020 17:12:57 -0300 Subject: [PATCH 09/12] lata pinchada arreglada --- bonus/bonus3.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/bonus/bonus3.py b/bonus/bonus3.py index 59049bd..70833ab 100644 --- a/bonus/bonus3.py +++ b/bonus/bonus3.py @@ -42,7 +42,7 @@ def lataPinchada(): indiceRandom = random.randint(0,len(heladeras)-1) h = heladeras[indiceRandom] if h.hayLatas(): - caso = 3 #random.choice([0,1,2,3]) + caso = random.choice([0,1,2,3]) if caso == 3: h.latas.pop(0) print("Se ha pinchado una lata en la heladera ", h.nombre, "\n") @@ -97,7 +97,7 @@ def agregarLata(self, cantidad): except: pass time.sleep(random.randint(3, 10)) - lataPinchada() + if aPoner > 0: return aPoner else: @@ -139,10 +139,10 @@ def reponer(self, heladera): latasSobrantes += sobranteLatas def run(self): - global heladeraConEspacio with self.monitor: if hayHeladerasDisponibles(): self.reponer(elegirHeladera()) + lataPinchada() self.monitor.notify() else: logging.info("Las heladeras estan llenas!") From 16a7c3839c570702f0345b9e102e5d3f5ee53a8b Mon Sep 17 00:00:00 2001 From: fragata-adrian Date: Thu, 5 Nov 2020 17:51:06 -0300 Subject: [PATCH 10/12] comenzamos el bonus 4 --- bonus/bonus4.py | 291 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 291 insertions(+) create mode 100644 bonus/bonus4.py diff --git a/bonus/bonus4.py b/bonus/bonus4.py new file mode 100644 index 0000000..b4fd173 --- /dev/null +++ b/bonus/bonus4.py @@ -0,0 +1,291 @@ +import random +import threading +import time +import logging + +logging.basicConfig(format='%(asctime)s.%(msecs)03d [%(threadName)s] - %(message)s', datefmt='%H:%M:%S', level=logging.INFO) + +botellasSobrantes = 0 +latasSobrantes = 0 +heladeras = [] +monitorBeode = threading.Condition() + +cantidadHeladeras = 5 +cantidadProveedores = 20 + + +def hayHeladerasDisponibles(): + i = 0 + resultado = False + while i < len(heladeras): + h = heladeras[i] + if h.hayEspacio(): + resultado = True + i += 1 + return resultado + +def hayEspacioParaBotellas(): + i = 0 + resultado = False + while i < len(heladeras): + h = heladeras[i] + if h.hayEspacioParaBotellas(): + resultado = True + i += 1 + return resultado + +def hayEspacioParaLatas(): + i = 0 + resultado = False + while i < len(heladeras): + h = heladeras[i] + if h.hayEspacioParaLatas(): + resultado = True + i += 1 + return resultado + +def elegirHeladera(): + global heladeras + heladeraConEspacio = 0 + heladeraMasVacia = heladeras[0] + while heladeraConEspacio < len(heladeras): + heladeraActual = heladeras[heladeraConEspacio] + if heladeraActual.hayEspacio(): + if heladeraActual.cantidadDeCervezas() < heladeraMasVacia.cantidadDeCervezas(): + heladeraMasVacia = heladeraActual + heladeraConEspacio +=1 + return heladeraMasVacia + + +def lataPinchada(): + global heladeras + indiceRandom = random.randint(0,len(heladeras)-1) + h = heladeras[indiceRandom] + if h.hayLatas(): + caso = random.choice([0,1,2,3]) + if caso == 3: + h.latas.pop(0) + print("Se ha pinchado una lata en la heladera ", h.nombre, "\n") + + + +class Heladera(): + def __init__(self, nombre): + self.botellas = [] + self.latas = [] + self.nombre = nombre + + def hayEspacio(self): + return self.hayEspacioParaBotellas() and self.hayEspacioParaLatas() + + def hayEspacioParaBotellas(self): + if len(self.botellas) == 10: + return False + else: + return True + + def hayEspacioParaLatas(self): + if len(self.latas) == 15: + return False + else: + return True + + def hayBotellas(self): + return len(self.botellas) > 0 + + def hayLatas(self): + return len(self.latas) > 0 + + def agregarBotella(self, cantidad): + aPoner = cantidad + try: + while aPoner > 0: + if len(self.botellas) == 10: + raise Exception("La heladera se lleno de botellas") + self.botellas.append(1) + aPoner -= 1 + except: + pass + time.sleep(random.randint(3, 10)) + + if aPoner > 0: + return aPoner + else: + return 0 + + def agregarLata(self, cantidad): + aPoner = cantidad + + try: + while aPoner > 0: + if len(self.latas) == 15: + raise Exception("La heladera se lleno de latas") + self.latas.append(1) + aPoner -= 1 + except: + pass + time.sleep(random.randint(3, 10)) + + if aPoner > 0: + return aPoner + else: + return 0 + + def estadoActual(self): + return "La heladera "+ str(self.nombre) +" tiene " + str(len(self.botellas)) + " Botellas y "+ str(len(self.latas)) + " Latas" + + def cantidadDeCervezas(self): + cantidad = len(self.botellas) + len(self.latas) + return cantidad + + + +class Proveedor(threading.Thread): + def __init__(self, nombre, monitor): + super().__init__() + self.name = nombre + self.monitor = monitor + + def cantAPoner(self): + return random.randint(1,10) + + def reponer(self, heladera, botellasAPoner, latasAPoner): + global botellasSobrantes, latasSobrantes + + logging.info("Ingreso " + str(botellasAPoner) + " Botellas y " + str(latasAPoner) + " Latas") + + sobranteBotellas = heladera.agregarBotella(botellasAPoner) + sobranteLatas = heladera.agregarLata(latasAPoner) + + time.sleep(random.randint(3,5)) + logging.info(heladera.estadoActual() + ". Cantidad total de cervezas = " + str(heladera.cantidadDeCervezas())) + logging.info("Sobraron " + str(sobranteBotellas) + " Botellas y " + str(sobranteLatas) + " latas.\n") + + if sobranteBotellas > 0 or sobranteLatas > 0: + self.reponerSobrantes(sobranteBotellas, sobranteLatas) + + + + def reponerSobrantes(self, botellasAPoner, latasAPoner): + global botellasSobrantes, latasSobrantes + + sobranteBotellas = botellasAPoner + sobranteLatas = latasAPoner + + while sobranteBotellas > 0 or sobranteLatas > 0: + heladera = elegirHeladera() + + if botellasAPoner > 0: + if hayEspacioParaBotellas(): + print("Hay espacio para botellas", str(hayEspacioParaBotellas())) + + if heladera.hayEspacioParaBotellas(): + logging.info("Ingreso " + str(botellasAPoner) + " Botellas") + sobranteBotellas = heladera.agregarBotella(botellasAPoner) + else: + logging.info("No hay lugar para botellas en la heladera " + str(heladera.nombre)) + botellasSobrantes += sobranteBotellas + sobranteBotellas = 0 + + if latasAPoner > 0: + if hayEspacioParaLatas(): + print("Hay espacio para botellas", str(hayEspacioParaBotellas())) + + if heladera.hayEspacioParaLatas(): + logging.info("Ingreso " + str(latasAPoner) + " Latas") + sobranteLatas = heladera.agregarLata(latasAPoner) + else: + logging.info("No hay lugar para latas en la heladera " + str(heladera.nombre)) + latasSobrantes += sobranteLatas + sobranteLatas = 0 + + logging.info(heladera.estadoActual() + ". Cantidad total de cervezas = " + str(heladera.cantidadDeCervezas())) + logging.info("Sobraron " + str(sobranteBotellas) + " Botellas y " + str(sobranteLatas) + " latas.\n") + + + + + def run(self): + with self.monitor: + if hayHeladerasDisponibles(): + self.reponer(elegirHeladera(), self.cantAPoner() + botellasSobrantes, self.cantAPoner() + latasSobrantes) + lataPinchada() + self.monitor.notify() + else: + logging.info("Las heladeras estan llenas!") + +class Beode(threading.Thread): + def __init__(self,monitor, nombre, limite,tipoDeConsumo): + super().__init__() + self.name = nombre + self.limite = limite + self.consumo = 0 + self.tipoDeConsumo = tipoDeConsumo + self.monitor = monitor + + def elegirHeladera(self): + h = random.randint(0,len(heladeras)-1) + return heladeras[h] + + def consumirBotella(self, heladera): + if heladera.hayBotellas(): + heladera.botellas.pop(0) + self.consumo += 1 + logging.info("Estoy bebiendo "+ self.tipoDeConsumo + " de la heladera " + str(heladera.nombre) + " voy tomando "+ str(self.consumo) + "\n") + else: + logging.info("No hay lo que quiero tomar en la heladera " + str(heladera.nombre) + "\n") + self.monitor.wait() + + + def consumirLata(self, heladera): + if heladera.hayLatas(): + heladera.latas.pop(0) + self.consumo += 1 + logging.info("Estoy bebiendo "+ self.tipoDeConsumo + " de la heladera " + str(heladera.nombre) + " voy tomando "+ str(self.consumo) + "\n") + else: + logging.info("No hay lo que quiero tomar en la heladera " + str(heladera.nombre) + "\n") + self.monitor.wait() + + def consumir(self,heladera): + + if self.tipoDeConsumo.lower() == "botella": + self.consumirBotella(heladera) + elif self.tipoDeConsumo.lower() == "lata": + self.consumirLata(heladera) + elif self.tipoDeConsumo.lower() == "ambos": + alAzar = random.choice([0,1]) + if alAzar == 0: + self.consumirBotella(heladera) + if alAzar == 1: + self.consumirLata(heladera) + time.sleep(random.randint(1, 3)) + + def run(self): + while self.consumo < self.limite: + with self.monitor: + self.consumir(self.elegirHeladera()) + logging.info("Me canse de tomar me voy a dormir") + + + + +for i in range(cantidadHeladeras): + heladeras.append(Heladera(i)) + +bb = Beode(monitorBeode,"Pepe",5,"botella") +bb.start() + +bl= Beode(monitorBeode, "Eduardo", 2, "lata") +bl.start() + +ba= Beode(monitorBeode,"Barbi", 5, "ambos") +ba.start() + +for i in range(cantidadProveedores): + nombre = 'Proveedor ' + str(i) + Proveedor(nombre, monitorBeode).start() + + + + + From 797caf9b6969e6cac50008f23a9942aa6ff683f1 Mon Sep 17 00:00:00 2001 From: fragata-adrian <48962799+fragata-adrian@users.noreply.github.com> Date: Sat, 7 Nov 2020 13:34:28 -0300 Subject: [PATCH 11/12] Update README.md --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 5c9fc0b..3ad707f 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,5 @@ +# TP realizado por Fabiola Suarez y Fragata Adrian + # Python TP Somos los encargados de organizar una fiesta, y se nos encomendó llenar las heladeras de cerveza. From ce4669cf6162cf20ffc87109d3535fbc39a3fcea Mon Sep 17 00:00:00 2001 From: fragata-adrian Date: Sat, 7 Nov 2020 15:47:28 -0300 Subject: [PATCH 12/12] listo el bonus 4 --- bonus/bonus4.py | 53 ++++++++++++++++++++++++------------------------- 1 file changed, 26 insertions(+), 27 deletions(-) diff --git a/bonus/bonus4.py b/bonus/bonus4.py index b4fd173..5aa5b1b 100644 --- a/bonus/bonus4.py +++ b/bonus/bonus4.py @@ -10,8 +10,8 @@ heladeras = [] monitorBeode = threading.Condition() -cantidadHeladeras = 5 -cantidadProveedores = 20 +cantidadHeladeras = 10 +cantidadProveedores = 30 def hayHeladerasDisponibles(): @@ -44,17 +44,18 @@ def hayEspacioParaLatas(): i += 1 return resultado -def elegirHeladera(): - global heladeras - heladeraConEspacio = 0 - heladeraMasVacia = heladeras[0] - while heladeraConEspacio < len(heladeras): - heladeraActual = heladeras[heladeraConEspacio] +def elegirHeladera(listaHeladeras=heladeras): + i = 0 + indiceHeladeraConEspacio = 0 + heladeraMasVacia = listaHeladeras[0] + while i < len(listaHeladeras): + heladeraActual = listaHeladeras[i] if heladeraActual.hayEspacio(): if heladeraActual.cantidadDeCervezas() < heladeraMasVacia.cantidadDeCervezas(): heladeraMasVacia = heladeraActual - heladeraConEspacio +=1 - return heladeraMasVacia + indiceHeladeraConEspacio = i + i +=1 + return heladeraMasVacia, indiceHeladeraConEspacio def lataPinchada(): @@ -163,57 +164,55 @@ def reponer(self, heladera, botellasAPoner, latasAPoner): if sobranteBotellas > 0 or sobranteLatas > 0: self.reponerSobrantes(sobranteBotellas, sobranteLatas) - - def reponerSobrantes(self, botellasAPoner, latasAPoner): - global botellasSobrantes, latasSobrantes + global botellasSobrantes, latasSobrantes, heladeras + heladerasDisponibles = heladeras.copy() sobranteBotellas = botellasAPoner sobranteLatas = latasAPoner while sobranteBotellas > 0 or sobranteLatas > 0: - heladera = elegirHeladera() + heladera, indice = elegirHeladera(heladerasDisponibles) if botellasAPoner > 0: if hayEspacioParaBotellas(): - print("Hay espacio para botellas", str(hayEspacioParaBotellas())) - if heladera.hayEspacioParaBotellas(): - logging.info("Ingreso " + str(botellasAPoner) + " Botellas") + logging.info("Ingreso " + str(botellasAPoner) + " Botellas sobrantes") sobranteBotellas = heladera.agregarBotella(botellasAPoner) + else: + logging.info("No hay lugar para botellas en la heladera " + str(heladera.nombre)) else: - logging.info("No hay lugar para botellas en la heladera " + str(heladera.nombre)) botellasSobrantes += sobranteBotellas sobranteBotellas = 0 if latasAPoner > 0: if hayEspacioParaLatas(): - print("Hay espacio para botellas", str(hayEspacioParaBotellas())) - if heladera.hayEspacioParaLatas(): - logging.info("Ingreso " + str(latasAPoner) + " Latas") + logging.info("Ingreso " + str(latasAPoner) + " Latas sobrantes") sobranteLatas = heladera.agregarLata(latasAPoner) + else: + logging.info("No hay lugar para latas en la heladera " + str(heladera.nombre)) else: - logging.info("No hay lugar para latas en la heladera " + str(heladera.nombre)) latasSobrantes += sobranteLatas sobranteLatas = 0 + + heladerasDisponibles.pop(indice) logging.info(heladera.estadoActual() + ". Cantidad total de cervezas = " + str(heladera.cantidadDeCervezas())) - logging.info("Sobraron " + str(sobranteBotellas) + " Botellas y " + str(sobranteLatas) + " latas.\n") - - - + logging.info("Sobraron " + str(botellasSobrantes) + " Botellas y " + str(latasSobrantes) + " latas.\n") def run(self): with self.monitor: if hayHeladerasDisponibles(): - self.reponer(elegirHeladera(), self.cantAPoner() + botellasSobrantes, self.cantAPoner() + latasSobrantes) + heladera, indice = elegirHeladera() + self.reponer(heladera, self.cantAPoner() + botellasSobrantes, self.cantAPoner() + latasSobrantes) lataPinchada() self.monitor.notify() else: logging.info("Las heladeras estan llenas!") + class Beode(threading.Thread): def __init__(self,monitor, nombre, limite,tipoDeConsumo): super().__init__()