Encuentre la intersección de conjuntos

Clase 20 de 56 • 21 Días de Python

Clase anteriorSiguiente clase

Javier Martínez González

student•

. . . . . . .

Martín Cerda

student•

qué bonita resolución uwu

Danny Zavid Herrera Hitas

student•

Excelente solución, cabe aclarar que el operador * en cualquier iterable como sets en este caso (*sets[1:]), permite "desempacar" cada uno de los elementos contenidos en dicho iterable y los pasa como argumentos separados a la función intersection

Jose Eleazar Gavidia Diaz

student•

def find_set_intersection(sets):
  if not sets:
    return set()
  intersection = sets[0]
  for i in sets[1:]:
    intersection &= i
  return intersection

#Tests
sets = [
  {1, 2, 3, 4},
  {2, 3, 4, 5},
  {3, 4, 5, 6}
]

output = find_set_intersection(sets)
print(output)

sets = [
  {1, 2, 3, 4},
  {2, 4, 6, 8},
  {3, 6, 9, 12}
]

output = find_set_intersection(sets)
print(output)

Mauricio Urdaneta

student•

lo hice utilizando una de las propiedades de los sets el ampersan devuelva todos los elementos en común que tengan cada uno de los sets

David Esteban Giraldo Duque

student•

Mi solución: . . . . . . . . . . .

def find_set_intersection(sets):
  return set() if not sets else sets[0].intersection(*sets[1:])

Jordan Anderson Huayhua Morales

student•

Elegante tu código, ¿podrías indicarnos cómo funcion el uso de *sets? Es algo nuevo para mí.

David Esteban Giraldo Duque

student•

Gracias! En la función uso *sets[1:] para desempaquetar los elementos de la lista sets desde el índice 1 en adelante y poderlos pasar como argumentos al método intersection(). En general, es un operador que te sirve para empaquetar o desempaquetar listas y también existe el doble asterisco (**) que sirve para diccionarios. Es un concepto que puede ser confuso, pero una vez lo entiendes, sirve un montón. Lo encuentras como *args y **kwargs, por si lo quieres consultar. PD: Si sabes JavaScript, es algo similar al spread operator (...).

Juan Ramón García Santabárbara

company_admin•

Mi código funciona pero no pasa todas las pruebas, ¿alguna idea? . . . . . . .

def find_set_intersection(sets): iteracion = 1 for conjunto in sets: conjunto = set(conjunto) print(conjunto) if iteracion ==1 : interseccion = conjunto else: interseccion = interseccion & conjunto iteracion += 1 return interseccion

sets1 = [{1, 2, 3, 4},{2, 3, 4, 5},{3, 4, 5, 6}]

print(find_set_intersection(sets1))

sets2 = [{1, 2, 3, 4},{2, 4, 6, 8},{3, 6, 9, 12}]

print(find_set_intersection(sets2))

Braulio Rangel

student•

igual el mi funciona en colab, pero aqui no

Harold Zurita Simon

student•

Solución 😄… .

. . . .

def find_set_intersection(sets):
  return sets.pop().intersection(*sets) if sets else set()

Francisco Jesús Eslava Fernández

student•

. . . Listo ! 🐍👌🏼 . . . . .

def find_set_intersection(sets):
  #si la lista no esta vacía
  if (sets != []):
    #primer conjunto de la lista
    respuesta = sets[0]
    #iterando para encontrar las intersecciones
    for i in range (1,len(sets)):
      respuesta =  (respuesta & sets[i]) 
  #si la lista esta vacía    
  else:
    respuesta=set()
    
  return(respuesta)

Andres Caro

student•

sets = [

{1, 2, 3, 4},

{2, 3, 4, 5},

{3, 4, 5, 6}

]

def find_set_intersection(sets):

# Si la lista de conjuntos está vacía, retorna conjunto vacío

if not sets:

return set()

# Toma el primer conjunto como base para la intersección

current_intersection = sets[0]

# Recorre los conjuntos restantes y va calculando la intersección

for value in sets[1:]:

current_intersection = current_intersection.intersection(value)

# Devuelve la intersección de todos los conjuntos

return current_intersection

print(find_set_intersection(sets))

Emmanuel Paiva

student•

Mi solución:

def find_set_intersection(sets):
  # Tu código aquí 👈
  result_set = set()

  if len(sets) > 1:
    result_set = sets[0].intersection(sets[1])
    index = 2
    while index < len(sets):
      result_set = result_set.intersection(sets[index])
      index += 1

  return result_set

Diego Cruz

student•

Hola envio mi solucion, las pruebas me fallan sin embargo la logica concuerda con lo solicitado en el reto

def find_set_intersection(sets):
    resultado = sets[0]
    for s in sets[1:]:
        resultado = resultado & s
    if len(resultado) == 0:
        return set()
    return resultado
```def find\_set\_intersection(sets):    resultado = sets\[0]    for s in sets\[1:]:        resultado = resultado & s    if len(resultado) == 0:        return set()    return resultado

Eduardo Monzón

student•

¿Cuál de las dos opciones les parece más conveniente?

o esta

Daniel Hernandez

student•

def find_set_intersection(sets):
  # Tu código aquí 👈
  if len(sets) == 0:
    return set()

  return set.intersection(*sets)

```def find\_set\_intersection(sets):  # Tu código aquí 👈  if len(sets) == 0:    return set()
&#x20; return set.intersection(\*sets)

Harold Edward Rodriguez Navarro

student•

comparto mi código:

def find_set_intersection(sets):
    first_set = sets[0] if len(sets) else set()
    intersection = set()
    for current_set in sets:
        if len(intersection):
            intersection = intersection.intersection(current_set)
        else:
            intersection = first_set.intersection(current_set) 
    return intersection

Dender Adrian Pernia Valero

student•

Mi propuesta

Braulio Rangel

student•

Si tienes un código más reducido, dímelo

. Gracias

def find_set_intersection(sets):
  if len(sets) == 3:
    return sets[0].intersection(sets[1]).intersection(sets[2])
    # print(sets[0].intersection(sets[1]).intersection(sets[2]))
  else:
    return set()
```def find\_set\_intersection(sets):  if len(sets) == 3:    return sets\[0].intersection(sets\[1]).intersection(sets\[2])    # print(sets\[0].intersection(sets\[1]).intersection(sets\[2]))  else:    return set()

Braulio Rangel

student•

def find_set_intersection(sets): return sets[0].intersection(sets[1]).intersection(sets[2]) else: return set()

Braulio Rangel

student•

def find_set_intersection(sets):
  return sets[0].intersection(sets[1]).intersection(sets[2])
  else:
    return set()
```def find\_set\_intersection(sets):

&#x20; return sets\[0].intersection(sets\[1]).intersection(sets\[2])

&#x20; else:

&#x20;   return set()

Maga Hernandez

student•

hola lo hice así, aunque no corre aqui si en visual code.... y la verdad no se porque, si alguien sabe me lo indica? pero aqui va mi código:

Enrique Barrera

student•

Hola, recuerda que el primer elemento de la lista es sets[0] en lugar de sets[1] y también debes verificar que la lista no este vacía antes de intentar acceder a dicho elemento. Espero te sirva

Enrique Barrera

student•

def find_set_intersection(sets):
    out=set()
    
    if len(sets) == 0: 
        return out
    if len(sets)==1:
        return sets[0]
    inter=sets[0]
    for conjunto in sets[1:]:
        inter = inter & conjunto 
    return inter

Victor Javier Vidal Durón

student•

Solución corta...

def find_set_intersection(sets):
    return set.intersection(*sets) if sets else set()

Diego Beltran

student•

Me tomó un buen rato pero lo conseguí sin utilizar métodos que no hemos visto en la teoría:

def find_set_intersection(sets):
  # Tu código aquí 👈
  if len(sets) > 1:
    new_set = set(sets[0])

    for i in sets:
      new_set = i & new_set
    return(new_set)
    
  else:
    new_set = set()
    return(new_set)

Jacobo Burbano

student•

solución usando solo listas

def find_set_intersection(sets):
    array = []
    final_set = []
    for seter in sets:
        for word in seter:
            array.append(word)
    for word in array:
        if array.count(word) == len(sets):
            final_set.append(word)
    return set(final_set)

Braulio Rangel

student•

Repite el resultado bro

[3, 4, 3, 4, 3, 4]