Playground - Implementación de una singly linked list

Fue una buena practica

Archivo Node

class PatientNode:
  def __init__(self, name, age, bed_number):
    self.name = name
    self.age = age
    self.bed_number = bed_number
    self.next = None

Archivo main

from Node import PatientNode

class PatientList:
  def __init__(self, max_beds):

    self.head = None
    self.tail = None
    self.length = 0
    self.max_beds = max_beds

  def addPatient(self, name, age):

    if self.getAvailableBeds() == 0:
      raise Exception("No hay camas disponibles")

    beds = [patient['bedNumber'] for patient in self.getPatientList()]

    empty_bed = [bed for bed in range(
      1, self.max_beds+1) if not bed in beds]

    new_node = PatientNode(name, age, empty_bed[0])

    if self.head is None:
      self.head = new_node
      self.tail = new_node
    else:
      self.tail.next = new_node
      self.tail = new_node
    self.length += 1


  def removePatient(self, name):

    if self.head is None:
      return
    if self.head.name == name:
      self.head = self.head.next
      self.length -= 1
      return
    current_node = self.head
    while current_node.next:
      if current_node.next.name == name:
        current_node.next = current_node.next.next
        self.length -= 1
        return
      current_node = current_node.next


  def getPatient(self, name):

    current_node = self.head

    if current_node:
      while current_node:
        if current_node.name == name:
          return {
            'name': current_node.name,
            'age': current_node.age,
            'bedNumber': current_node.bed_number
          }
        current_node = current_node.next

    raise Exception("Paciente no encontrado")   
        
        
  def getPatientList(self):

    current_node = self.head
    patient_list = []
    
    if current_node:
      while current_node:
        patient_list.append(
          self.getPatient(current_node.name) 
        )
        current_node = current_node.next      
    return patient_list 


  def getAvailableBeds(self):

    return self.max_beds - self.length

No lo decian en la guia, pero la lista debe crecer por la cola.
Eso me hizo rehacer mi rutina de addPatient

o
o
o
o
o
o
o
o

class PatientNode:
  def __init__(self, name, age, bedNumber):
    self.data = {}
    self.data["name"]       = name
    self.data["age"]        = age
    self.data["bedNumber"] = bedNumber
    self.next = None

class PatientList:
  def __init__(self, max_beds):
    self.camas_disponibles = [x + 1 for x in range(max_beds)]
    self.cabeza = None

  def addPatient(self, name, age):
    if len(self.camas_disponibles) > 0:
      newPatient = PatientNode(name, age, self.camas_disponibles.pop(0))
      if self.cabeza == None:
        self.cabeza = newPatient
      else: 
        apuntador = self.cabeza
        anterior  = apuntador
        while apuntador != None:
          anterior = apuntador
          apuntador = apuntador.next  
        anterior.next = newPatient
    else:
      raise Exception("No hay camas disponibles")

  def removePatient(self, name):
    apuntador = self.cabeza
    anterior  = apuntador
    encontrado = False
    while not encontrado and apuntador != None:
      if apuntador.data["name"] == name:
        self.camas_disponibles.append(apuntador.data["bedNumber"])
        anterior.next = apuntador.next
        del apuntador
        encontrado = True
      else:
        anterior  = apuntador
        apuntador = apuntador.next
        
    if not encontrado:
      raise Exception("Paciente no encontrado") 
   
  def getPatient(self, name):
    salida = None
    apuntador = self.cabeza
    encontrado = False
    while not encontrado and apuntador != None:
      if apuntador.data["name"] == name:
        salida = apuntador.data
        encontrado = True
      else:
        apuntador = apuntador.next

    if encontrado:
      return salida
    else:
      raise Exception("Paciente no encontrado")
  

  def getPatientList(self):
    salida= []
    apuntador = self.cabeza 
    while apuntador != None:
      salida.append(apuntador.data)
      apuntador = apuntador.next
      
    return salida
  
  def getAvailableBeds(self):
    return len(self.camas_disponibles)
  
  def getListAvailableBeds(self):
    return self.camas_disponibles

pacientes = PatientList(8)
pacientes.addPatient("Spiderman", 30)
pacientes.addPatient("Wonderwoman",25)
pacientes.addPatient("Superman", 40)

print(pacientes.getPatientList())
print(pacientes.getAvailableBeds())
print(pacientes.getListAvailableBeds())

pacientes.removePatient("Wonderwoman")
print(pacientes.getPatientList())
print(pacientes.getAvailableBeds())
print(pacientes.getListAvailableBeds())

pacientes.addPatient("Batman",70)
print(pacientes.getPatientList())
print(pacientes.getAvailableBeds())
print(pacientes.getListAvailableBeds())

print(pacientes.getPatient("Spiderman"))

🛡️🛡️Escudo anti-spoilers🛡️🛡️

Mi solución al reto:

main

from Node import PatientNode

class PatientList:
  def __init__(self, max_beds):
    self.head = None 
    self.tail = None 
    self.length = 0
    self.max_beds = max_beds
    self.free_beds = []
    print("Se ha creado la lista con un maximo de camas de ",self.max_beds)

  def addPatient(self, name, age):
    if self.length >= self.max_beds:
      raise Exception("No hay camas disponibles")

    new_node = PatientNode(name, age, self.length + 1)

    if self.head is None:
      self.head = new_node
      self.tail = new_node
    else: 
      self.tail.next = new_node
      self.tail = new_node

    print("Paciente agregado")
    self.length += 1

  def __free_bed(self, bed_number):
    self.free_beds.append(bed_number) 
    self.length -= 1 
    
  def removePatient(self, name):
    if not self.head:
      raise Exception("Paciente no encontrado")

    if self.head.name == name:
      self.__free_bed(self.head.bed_number)
      self.head = self.head.next
      return

    current = self.head
    prev = None
    while current:
      if current.name == name:
        self.__free_bed(current.bed_number)
        prev.next = current.next
        return
      prev = current
      current = current.next

    raise Exception("Paciente no encontrado")

  def getPatient(self, name):
    if self.length <= 0:
      raise Exception("No hay pacientes en la lista")

    current_node = self.head

    while current_node:
      if current_node.name == name:
        return {
          "name": current_node.name,
          "age": current_node.age,
          "bedNumber": current_node.bed_number
        }
      current_node = current_node.next 
    raise Exception("Paciente no encontrado")
    

  def getPatientList(self):
    r = []
    current_node = self.head
    while current_node:
      r.append({
        "name": current_node.name,
        "age": current_node.age,
        "bedNumber": current_node.bed_number
      })
      current_node = current_node.next
    return r

  def getAvailableBeds(self):
    return self.max_beds - self.length

node

class PatientNode:
  def __init__(self, name, age, bed_number):
    self.name = name
    self.age = age 
    self.bed_number = bed_number
    self.next = None

SPOILER ALERRT
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

Mi código:

#  Node.py
class PatientNode:
    def __init__(self, name, age, bed_number):
        self.name = name
        self.age = age
        self.bed_number = bed_number
        self.next = None

#  main.py
from Node import PatientNode

class PatientList:
    def __init__(self, max_beds):
        self.max_beds = max_beds
        self.head = None
        self.available_beds = max_beds

    def addPatient(self, name, age):
        if self.available_beds == 0:
            raise Exception("No hay camas disponibles")
        
        new_bed_number = self.max_beds - self.available_beds + 1
        new_patient = PatientNode(name, age, new_bed_number)
        
        if self.head is None:
            self.head = new_patient
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = new_patient
        
        self.available_beds -= 1

    def removePatient(self, name):
        if self.head is None:
            raise Exception("Paciente no encontrado")
        
        if self.head.name == name:
            self.available_beds += 1
            self.head = self.head.next
            return
        
        current = self.head
        prev = None
        while current and current.name != name:
            prev = current
            current = current.next
        
        if current:
            self.available_beds += 1
            prev.next = current.next
        else:
            raise Exception("Paciente no encontrado")
    
    def getPatient(self, name):
        current = self.head
        while current:
            if current.name == name:
                return {'name': current.name, 'age': current.age, 'bedNumber': current.bed_number}
            current = current.next
        raise Exception("Paciente no encontrado")
    
    def getPatientList(self):
        patient_list = []
        current = self.head
        while current:
            patient_list.append({'name': current.name, 'age': current.age, 'bedNumber': current.bed_number})
            current = current.next
        return patient_list
    
    def getAvailableBeds(self):
        return self.available_beds

.
.
.
.
.
.
.
.
.
.

class PatientNode:
  def __init__(self, name, age, bed_number):
    self.name = name
    self.age = age
    self.bed_number = bed_number
    self.next = None
  def get(self):
    return {"name":self.name, "age":self.age, "bedNumber":self.bed_number}

from Node import PatientNode

class PatientList:
  def __init__(self, max_beds):
    self.max_beds = max_beds
    self.head = None
    self.tail = None
    self.size = 0

  def addPatient(self, name, age):
    if self.size == self.max_beds:
       raise Exception("No hay camas disponibles")
    newNode = PatientNode(name, age, self.size + 1)
    if self.head == None:
      self.head = newNode
      self.tail = newNode
    else:
      self.tail.next = newNode
      self.tail = newNode
    self.size += 1

  def removePatient(self, name):
    if self.head == None:
      return False
    elif self.head.name == name:
        self.head = self.head.next
        self.size -= 1
        return True
    current_node = self.head
    while current_node.next.name != name and current_node.next != None:
        current_node = current_node.next
    if current_node.next != None:
        current_node.next = current_node.next.next
        self.size -= 1
        return True
    else:
      raise Exception("Paciente no encontrado")
    
  def getPatient(self, name):
    if self.head == None:
      return False
    elif self.head.name == name:
        return self.head.get()
    current_node = self.head
    while current_node.next.name != name and current_node.next != None:
        current_node = current_node.next
    if current_node.next != None:
        return current_node.next.get()
    else:
      raise Exception("Paciente no encontrado")

  def getPatientList(self):
    patient_list = []
    current_node = self.head
    while current_node != None:
      patient_list.append(current_node.get())
      current_node = current_node.next
    return patient_list
    

  def getAvailableBeds(self):
    return self.max_beds - self.size

class PatientNode:
  def __init__(self, name, age, bed):
    self.name = name
    self.age = age
    self.bed = bed
    self.next = None

  def retorno(self):
    return {'name': self.name, 'age': self.age, 'bedNumber': self.bed}


class PatientList:

    def __init__(self, max_beds):
        self.head = None
        self.tail = None
        self.length = 0
        self.max_beds = max_beds
        self.beds = {bed: True for bed in range(1, max_beds + 1)}

    def bed_available(self):
        bed = next((bed for bed in self.beds if self.beds[bed]), None)
        self.beds[bed] = False
        if bed is None:
            raise Exception("No hay camas disponibles")
        return bed

    def addPatient(self, name, age):
        bed = self.bed_available()
        new_node = PatientNode(name, age, bed)
        if self.head is None:
            self.head = new_node
            self.tail = new_node
        else:
            self.tail.next = new_node
            self.tail = new_node
        self.length += 1

    def removePatient(self, name):
        if self.head is None:
            return
        if self.head.name == name:
            self.beds[self.head.bed] = True
            self.head = self.head.next
            self.length -= 1
            return
        current_node = self.head
        while current_node.next:
            if current_node.next.name == name:
                self.beds[current_node.next.bed] = True
                current_node.next = current_node.next.next
                self.length -= 1
                return
            current_node = current_node.next

    def getPatient(self, name):
        current_node = self.head
        while current_node:
            if current_node.name == name:
                return current_node.retorno()
            current_node = current_node.next
        if current_node is None:
            raise Exception("Paciente no encontrado")


    def getPatientList(self):
        patiens = []
        current_node = self.head
        while current_node:
            patiens.append(current_node.retorno())
            current_node = current_node.next
        return patiens

    def getAvailableBeds(self):
        return self.max_beds - self.length

Estuvo divertido el reto, espero que lo encuentren útil. Aquí mi solución.

class PatientNode:
  def __init__(self, name, age, bed_number):
    self.name = name
    self.age = age
    self.bed_number = bed_number
    self.next = None

from Node import PatientNode
    
class PatientList:
  def __init__(self, max_beds):
      self.head =None
      self.tail =None
      self.length = 0
      self.max_beds=max_beds
      self.beds={bed+1:False for bed in range(self.max_beds)}
      self.available_beds=max_beds
  
  def find_next_available_bed(self, beds, condition):
    for bed, availability in beds.items():
        if condition(availability):
            return bed

  def addPatient(self, name, age): 
    if self.available_beds==0:
      raise Exception("No hay camas disponibles")
    else:
      next_available_bed=self.find_next_available_bed(self.beds,lambda b:b is False)
      new_node = PatientNode(name, age, next_available_bed)
      self.beds[next_available_bed]=True
      self.available_beds-=1  
      if self.head is None:    
        self.head = new_node
        self.tail = new_node        
      else:      
        self.tail.next = new_node
        self.tail = new_node
        self.length += 1

  def removePatient(self, name):
    if self.head is None:
        return
    patient_found=False
    if self.head.name == name:
        patient_found=True
        self.beds[self.head.bed_number]=False
        self.available_beds+=1
        self.head = self.head.next
        self.length -= 1
        return
    current_node = self.head
    while current_node.next:
        if current_node.next.name == name:
            patient_found=True
            self.beds[current_node.next.bed_number]=False
            self.available_beds+=1
            current_node.next = current_node.next.next
            self.length -= 1
            return
        current_node = current_node.next
    if not patient_found:
      raise Exception("Paciente no encontrado")

  def getPatient(self, name):
    if self.head is None:
        return 
    patient_found=False
    if self.head.name == name:
        patient_found=True
        return {"name":self.head.name, "age":self.head.age, "bedNumber":self.head.bed_number}
    current_node = self.head
    while current_node.next:
        if current_node.next.name == name:
            patient_found=True
            return {"name":current_node.next.name,
             "age":current_node.next.age,
             "bedNumber":current_node.next.bed_number}
        current_node = current_node.next
    if not patient_found:
      raise Exception("Paciente no encontrado")

  def getPatientList(self):
    if self.head is None:
        return
    patientList = []
    patientList.append({"name":self.head.name,"age":self.head.age, "bedNumber":self.head.bed_number})
    current_node = self.head
    while current_node.next:
        patientList.append({"name":current_node.next.name, 
        "age":current_node.next.age,
        "bedNumber": current_node.next.bed_number})
        current_node = current_node.next
    return patientList    

  def getAvailableBeds(self):
      return self.available_beds

lista = PatientList(3)
lista.addPatient("Paciente 1", 20)
lista.addPatient("Paciente 2", 30)

print(lista.getPatientList())

Solución 😄…
.

.
.
.
.
Node:

class PatientNode:
  def __init__(self, name, age, bed_number):
    self.name = name
    self.age = age
    self.bed_number = bed_number
    self.next = None

Main:

from Node import PatientNode

class PatientList:
  def __init__(self, max_beds):
    self.head = None
    self.tail = None
    self.length = 0
    self.max_beds = max_beds
    self.beds = [
      True 
      for _ in range(max_beds)
      ]

  def addPatient(self, name, age):
    if self.length == self.max_beds:
      raise Exception("No hay camas disponibles")
    bed_number = self.getAvailableBedsList()[0]
    self.beds[bed_number - 1] = False
    newPatient = PatientNode(name, age, bed_number)
    if self.head is None:
      self.head = newPatient
      self.tail = newPatient
    else:
      self.tail.next = newPatient
      self.tail = newPatient
    self.length += 1

  def removePatient(self, name):
    if self.head is None:
      raise Exception("Paciente no encontrado")
    if self.head.name == name:
      self.beds[self.head.bed_number - 1] = True 
      self.head = self.head.next
      self.length -= 1
      return
    actual = self.head
    while actual.next:
      if actual.next.name == name:
        self.beds[actual.next.bed_number - 1] = True 
        actual.next = actual.next.next
        self.length -= 1
        return
      actual = actual.next
    raise Exception("Paciente no encontrado")

  def getPatient(self, name):
    actual = self.head
    while actual:
      if actual.name == name:
        return {
          'name': actual.name,
          'age': actual.age,
          'bedNumber': actual.bed_number
          }
      actual = actual.next
    raise Exception('Paciente no encontrado')

  def getPatientList(self):
    patients = []
    actual = self.head
    while actual:
      patients.append({
        'name': actual.name,
        'age': actual.age,
        'bedNumber': actual.bed_number
      })
      actual = actual.next
    return patients

  def getAvailableBeds(self):
    return self.max_beds - self.length

  def getAvailableBedsList(self):
    return [
      index + 1
      for index, bed in enumerate(self.beds) 
      if bed
      ]

Mi solución 💻 🐍

.
.
.
.

Node.py

class PatientNode:
  def __init__(self, name, age, bed_number):
    self.name = name
    self.age = age
    self.bed_number = bed_number
    self.next = None

main.py

class PatientList:
  def __init__(self, max_beds):
    self.beds = max_beds
    self.occupied_beds = 0
    self.head = None

  def addPatient(self, name, age):
    if self.occupied_beds == self.beds:
      raise Exception("No hay camas disponibles")

    self.occupied_beds += 1
    patient = PatientNode(name, age, self.occupied_beds)

    if self.head == None:
      self.head = patient
    else:
      current = self.head
      while current.next != None:
        current = current.next
      current.next = patient

  def removePatient(self, name):
    if self.head == None:
      raise Exception( "Paciente no encontrado")
    
    deleted_patient = False
    current = self.head
    if current.name == name:
      deleted_patient = True
      self.occupied_beds -= 1
      self.head = current.next
    else:
      prev = None
      while current:
        if current.name == name:
          deleted_patient = True
          self.occupied_beds -= 1
          prev.next = current.next
          break
        prev = current
        current = current.next

    if not deleted_patient:
      raise Exception( "Paciente no encontrado")  
    
  def getPatient(self, name):
    if self.head == None:
      raise Exception( "Paciente no encontrado")
    
    current = self.head
    while current:
      if current.name == name:
        return {
          "name": current.name,
          "age": current.age,
          "bedNumber": current.bed_number
        }
        
      current = current.next
    
    raise Exception( "Paciente no encontrado")

  def getPatientList(self):
    current = self.head
    patients = []
    while current:
      patients.append({
        "name": current.name,
        "age": current.age,
        "bedNumber": current.bed_number
      })
      current = current.next

    return patients

  def getAvailableBeds(self):
    return self.beds - self.occupied_beds

test_add_patient_to_list

test_decrement_beds_available

test_throw_error_if_no_beds_available

test_remove_patient_from_list

test_increment_beds_available

test_throw_error_if_patient_not_found

test_return_patient_object

test_return_array_of_patient_objects

¡Felicidades, todas las pruebas pasaron!

Mi solucion:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

class PatientNode:
  def __init__(self, name, age, bed_number):
    # Tu código aquí 👇
    self.name = name
    self.age = age
    self.bed_number = bed_number
    self.next = None
from Node import PatientNode

class PatientList:
  def __init__(self, max_beds):
    # Tu código aquí 👇
    self.max_beds = max_beds
    self.occupied_beds = 0
    self.available_beds = {i: True for i in range(1, self.max_beds+1)}
    self.head = None
    self.tail = None
    

  def addPatient(self, name, age):
    # Tu código aquí 👇
    if self.occupied_beds == self.max_beds:
      raise Exception('No hay camas disponible')
    for i in range(1, self.max_beds+1):
      if self.available_beds[i] == True:
        new_node = PatientNode(name, age, i)
        self.occupied_beds +=1
        self.available_beds[i] = False
        break  
    if self.head is None:
      self.head = new_node
      self.tail = new_node
    else:
      self.tail.next = new_node
      self.tail = new_node  

  def removePatient(self, name):
    # Tu código aquí 👇
    if self.head is None:
      return 
    if self.head.name == name:
      self.available_beds[self.head.bed_number] = True
      self.head =  self.head.next
      self.occupied_beds -=1
      return
    current_node = self.head
    while current_node.next:
      if current_node.next.name == name:
        self.available_beds[current_node.next.bed_number] = True
        self.occupied_beds -=1
        current_node.next = current_node.next.next
        return
      current_node = current_node.next
    raise Exception('Paciente no encontrado')  

  def getPatient(self, name):
    # Tu código aquí 👇
    if self.head is None:
      return
    current_node = self.head
    while current_node:
      if current_node.name == name:
        return {
          'name': current_node.name,
          'age': current_node.age,
          'bedNumber': current_node.bed_number
        }
      current_node =current_node.next
    raise Exception('Paciente no encontrado')
    

  def getPatientList(self):
    # Tu código aquí 👇
    if self.head is None:
      return []
    patients = []  
    current_node = self.head
    while current_node:
      patients.append(self.getPatient(current_node.name))
      current_node = current_node.next
    return patients

  def getAvailableBeds(self):
    # Tu código aquí 👇
    return self.max_beds - self.occupied_beds

.
.
.
.
.

class PatientNode:
  def __init__(self, name, age, bed_number):
    self.name = name
    self.age = age
    self.bed_number = bed_number
    self.next = None

from Node import PatientNode

class PatientList:
  def __init__(self, max_beds):
    self.max_beds = max_beds
    self.bed_count = 0
    self.head = None

  def addPatient(self, name, age):
    if self.bed_count >= self.max_beds:
      raise Exception("No hay camas disponibles")

    self.bed_count+=1
    new_patient = PatientNode(name,age,self.bed_count)

    if not self.head:
      self.head = new_patient
    else:
      current = self.head
      while current.next:
        current = current.next
      current.next = new_patient


  def removePatient(self, name):
    if not self.head:
      raise Exception("Paciente no encontrado")

    if self.head.name == name:
      self.head = self.head.next
      self.bed_count -= 1
      return

    current = self.head
    prev = None
    while current:
      if current.name == name:
        prev.next = current.next
        self.bed_count -= 1
        return
      prev = current
      current = current.next

    raise Exception("Paciente no encontrado")

  def getPatient(self, name):
    current = self.head
    while current:
      if current.name == name:
        return {
          'name': current.name,
          'age': current.age,
          'bedNumber': current.bed_number
        }
      current = current.next

    raise Exception("Paciente no encontrado")

  def getPatientList(self):
    patient_list = []
    current = self.head
    while current:
      patient_list.append({
        'name': current.name,
        'age': current.age,
        'bedNumber': current.bed_number
      })
      current = current.next
    return patient_list

  def getAvailableBeds(self):
    return self.max_beds - self.bed_count

SPOILER
.
.
.
.

.
.
.
.
.
.
.
.
.
.

from Node import PatientNode

class PatientList:
  def __init__(self, max_beds):
    # Tu código aquí 👇
    self.max_beds = max_beds
    self.enabled_beds = max_beds
    self.primera = None
    pass

  def addPatient(self, name, age):
    # Tu código aquí 👇
    if self.enabled_beds == 0:
      raise Exception("No hay camas disponibles")

    if self.primera is None:
      self.primera = PatientNode(name, age, 1)
    else:
      node = self.primera

      while not node.next_patient is None:
        node = node.next_patient
      
      node.next_patient = PatientNode(name, age, node.bed_number+1)

    self.enabled_beds = self.enabled_beds - 1 
    pass

  def removePatient(self, name):
    # Tu código aquí 👇
    if self.primera.name is name:
      self.primera = self.primera.next_patient
      return

    node = self.primera
    while not node.next_patient.name is name:
      node = node.next_patient
    
    node.next_patient = node.next_patient.next_patient
    self.enabled_beds = self.enabled_beds + 1

    pass

  def getPatient(self, name):
    # Tu código aquí 👇
    node = self.primera
    while not node is None and not node.name is name:
      node = node.next_patient

    if node is None:
      raise Exception("Paciente no encontrado")
    return {
      "name": node.name,
      "age": node.age,
      "bedNumber": node.bed_number
    }
    
    pass

  def getPatientList(self):
    # Tu código aquí 👇
    patientList = []
    node = self.primera
    while not node.next_patient is None:
      patientList.append({
        "name": node.name,
        "age": node.age,
        "bedNumber": node.bed_number
      })
      node = node.next_patient

    patientList.append({
        "name": node.name,
        "age": node.age,
        "bedNumber": node.bed_number
      })
    
    return patientList
    pass

  def getAvailableBeds(self):
    # Tu código aquí 👇
    return self.enabled_beds
    pass

list = PatientList(3)
list.addPatient("Paciente 1", 20)
list.addPatient("Paciente 2", 30)

print(list.getPatientList())

class PatientNode:
  def __init__(self, name, age, bed_number):
    # Tu código aquí 👇
    self.name = name
    self.age = age
    self.bed_number = bed_number
    self.next_patient = None
    pass

.
.
.
.
.
No pude con uno de los test