Encuentre la intersección de conjuntos

.
.
.
.
.
.
.

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)

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

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

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

Solución 😄…
.

.
.
.
.

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

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

.
.
.
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)

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

Mi solución al reto:

def find_set_intersection(sets):
  count_sets = len(sets)
  result = set()
  for current_set in sets:
    for element in current_set:
      is_in_set = True
      for s in range(0,count_sets):
        if not element in sets[s]:
          is_in_set = False
          break
      if is_in_set:
        result.add(element)
  return result 

Para mi aporte, agregé la opción de que te avise si hay intersección.

#Conjuntos = [{1, 2, 3, 4}, {2, 3, 4, 5}, {3, 4, 5, 6}]
Conjuntos = [{1, 2, 3, 4}, {2, 4, 6, 8}, {3, 6, 9, 12}]
def Intersecciones(Conjuntos):
intersection = Conjuntos[0] & Conjuntos[1] & Conjuntos[2]
if intersection is True:
print(f"Su intersección es:{intersection}")
else:
print(“No hay Intersección. Interseccion Vacía”)
Intersecciones(Conjuntos)

def find_set_intersection(sets):
  # Tu código aquí 👈
  new_set = []
  if len(sets) == 0:
    return set()
  else:
    for i in sets:
      if new_set == []:
        new_set = i
      else:
        new_set = new_set & i
    return new_set

response = find_set_intersection([
  {1, 2, 3, 4},
  {2, 3, 4, 5},
  {3, 4, 5, 6}
])
print(response)

Solución:

def find_set_intersection(sets):
    print(sets)
    if len(sets)==0: return set()
    else:
        intersections=sets[0]
        return(intersections.intersection(*sets[1:]))

if __name__ == '__main__':
    sets = [
       {1, 2, 3, 4},
       {2, 3, 4, 5},
       {3, 4, 5, 6}
    ]
    
    response=find_set_intersection(sets)
    print(response)

    sets = [
       {1, 2, 3, 4},
       {2, 4, 6, 8},
       {3, 6, 9, 12}
    ]
    response=find_set_intersection(sets)
    print(response)

.
.
.
.
.

Les traigo mi solución:

def find_set_intersection(sets):
  # Tu código aquí 👈
  if len(sets) == 0:
    return set()
  else:
    intersections = sets[0]
    for i in sets:
      intersections = intersections.intersection(i)
  return intersections

Así quedo mi solución.

def find_set_intersection(sets):
  final = None
  if len(sets) > 0:
    final = sets[0]
    for x in sets[1:]:
      final = final & x
  else:
    final = set()
  return final
  pass

El test con el set vacio es un gran ejemplo de en muchas ocasiones denemos blindar nuestras funciones ante entradas inesperadas.

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

  return intersection

.
.
.
.
.
.
.

def find_set_intersection(sets):
  new_set = sets[0] & sets[1] & sets[2]

  return new_set

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

result = find_set_intersection(sets)
print(result)

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

result = find_set_intersection(sets)
print(result)

Mi solución, solo que la última prueba no la pasó

.
.
.
.
.

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

.
.
.
.
.
.
.
.
Mi solución. Sé que no es la más óptima, pero seguiré trabajando para optimizar mi código futuro c:

.
.
.
.
.
.
.
.
.
.

Mi solución:

def find_set_intersection(sets):
  if not sets:
    return set()

  intersection = sets[0]
  for a_set in sets[1:]:
    intersection &= a_set

  return intersection

def find_set_intersection(sets):
  # si la lista esta vacia , devuelve un conjunto vacio 
  if not sets:
    return set()

  #Inicializamos con el primeer conjunto en la lista
  intersection = sets[0]
  # Encontrar la interseccion con los conjuntos siguientes
  for set in sets[1:]:
    intersection = intersection.intersection(set)

  return intersection


response = find_set_intersection([
  {1, 2, 3, 4},
  {2, 4, 6, 8},
  {3, 6, 9, 12}
])
print(response)

.
.
.
.
.
.

def find_set_intersection(sets):
    if not sets:
        return set()

    intersection = sets[0].intersection(*sets[1:])

    return intersection
    pass

Dejo mi aporte! (2 soluciones) En la primera trabaje con los elementos y en la segunda con los indices.

def find_set_intersection(sets):
  inte = sets[0] if sets else set()
  for s in sets[1:]:
    inte = inte.intersection(s)
  return inte

def find_set_intersection(sets):
  inte = set()
  for s in range(len(sets)):
    if s == 0:
      inte = sets[s]
    inte = inte.intersection(sets[s])
  return inte

.
.
.
.
.
.
.
.

.
.
.
.
…
.
…
.
.
.
.
…
.
.
.

def find_set_intersection(sets):
  intersec = set()
  for i in range(0, (len(sets)-1)):
    if (i == 0):
      intersec = sets[i].intersection(sets[i+1])
    else:
      intersec = (sets[i+1]).intersection(intersec)
  return intersec

sets = [
  {1, 2, 3, 4},
  {2, 3, 4, 5},
  {3, 4, 5, 6}
]
print (find_set_intersection(sets))

No es el código más lindo pero anda

.
.
.
.
.
.
.

def find_set_intersection(sets):
  qty_sets = len(sets)
  if not sets:
    return set()
  new_set = sets[0] & sets[1]
  if len(new_set) > 0:
    for item in range(qty_sets-1):
      new_set = new_set & sets[item+1]  
  return new_set if len(new_set) > 0 else set()

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

def find_set_intersection(sets):
  # Tu código aquí 👈
  if len(sets) > 1:
    intersection = sets[0]
    for i in sets[1:]:
      intersection &= i
    return intersection
  else:
    return set()

Mi aporte

.
.
.
.
.

def find_set_intersection(sets):
    
    interseccion = set()
    i = 0
    for conjunto in sets:
        if i == 0:
            conjuntoaux = conjunto
        
        else:
          interseccion = conjunto.intersection(conjuntoaux)
          #print(interseccion)
          conjuntoaux = interseccion
         
        i += 1


    return interseccion
    pass


resultado = find_set_intersection(sets=[
    {1, 2, 3, 4},
    {2, 3, 4, 5},
    {3, 4, 5, 6}
])

print(resultado)

resultado = find_set_intersection(sets=[
    {1, 2, 3, 4},
    {2, 4, 6, 8},
    {3, 6, 9, 12}
])

print(resultado)

o
o
o
o
o
o
o
o

def find_set_intersection(sets):
  l = len(sets)
  conjunto_final = set()
  if l > 1:
    conjunto_final = sets[0]
    for i in range(1,l):
      conjunto_final = conjunto_final.intersection(sets[i])
  return  conjunto_final 

sets = [
  {1, 2, 3, 4},
  {2, 3, 4, 5},
  {3, 4, 5, 6}
]
print(find_set_intersection(sets))

sets = [
  {1, 2, 3, 4},
  {2, 4, 6, 8},
  {3, 6, 9, 12}
]
print(find_set_intersection(sets))

My solucion:
*
*
*
*
*
*
*
*

from functools import reduce

def find_set_intersection(sets):
  # Tu código aquí 👈
  if sets != []:
    intersection = set(reduce(lambda x,y: x&y,sets))
    return intersection 
  else:
    intersection = set()
    return intersection

item1={1,2,3}
item2 = {1,3}
item3 = {3,4,5}
lista = [item1, item2, item3]
print(find_set_intersection(lista))

Hint: El set necesita tener un conjunto para aplicar la .intercesión & sino sera seguirá vacío.

.
.
.
.
.

def find_set_intersection(sets):

  response = set()

  if (len(sets) == 0):
    return response
  
  response = sets[0]

  for set in sets[1:] :
    response = response & set

  return response

.
.

def find_set_intersection(sets):
   if len(sets) <= 1:
      return set()
   
   intersection = sets[0]
   for i in range(1, len(sets)):
      intersection = intersection & sets[i]
      
   return intersection

si tiene 0 o 1 elementos devolverá vacio
de lo contrario devolverá la interseccion

*
*
*
*
*

def find_set_intersection(sets):
    if len(sets) > 0:            
        result = sets[0]
        for i in range(1, len(sets)):
            result = result & sets[i]
        if result != sets[0]:
            return result
        else:
            return {}
    else: 
        return set()

Usando recursividad

def find_set_intersection(sets):

  if len(sets) == 0:
    return set()

  if len(sets) == 1:
    return sets[0]
 
  return find_set_intersection([sets[0] & s for s in sets[1:]])