Contenido del curso
Encuentre la intersección de conjuntos
Javier Martínez González
Estudiante
Martín Cerda
Estudiante
Danny Zavid Herrera Hitas
Estudiante
Jose Eleazar Gavidia Diaz
Estudiante
Mauricio Urdaneta
Estudiante
David Esteban Giraldo Duque
Estudiante
Jordan Anderson Huayhua Morales
EstudianteDavid Esteban Giraldo Duque
Estudiante
Juan Ramón García Santabárbara
Company_admin
Braulio Rangel
Estudiante
Harold Zurita Simon
Estudiante
Francisco Jesús Eslava Fernández
Estudiante
Andres Caro
Estudiante
Emmanuel Paiva
Estudiante
Diego Cruz
Estudiante
Eduardo Monzón
Estudiante
Daniel Hernandez
Estudiante
Harold Edward Rodriguez Navarro
Estudiante
Dender Adrian Pernia Valero
EstudianteBraulio Rangel
EstudianteBraulio Rangel
EstudianteBraulio Rangel
Estudiante
Maga Hernandez
Estudiante
Enrique Barrera
EstudianteEnrique Barrera
Estudiante
Victor Javier Vidal Durón
Estudiante
Diego Beltran
Estudiante
Jacobo Burbano
EstudianteBraulio Rangel
Estudiante
qué bonita resolución uwu
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
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)
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
Mi solución: . . . . . . . . . . .
def find_set_intersection(sets): return set() if not sets else sets[0].intersection(*sets[1:])
Elegante tu código, ¿podrías indicarnos cómo funcion el uso de *sets? Es algo nuevo para mí.
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 (...).
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))
igual el mi funciona en colab, pero aqui no
Solución 😄… .
def find_set_intersection(sets): return sets.pop().intersection(*sets) if sets else set()
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)
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))
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
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
¿Cuál de las dos opciones les parece más conveniente?
o esta
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()   return set.intersection(\*sets)
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
Mi propuesta
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()
def find_set_intersection(sets): return sets[0].intersection(sets[1]).intersection(sets[2]) else: return set()
def find_set_intersection(sets): return sets[0].intersection(sets[1]).intersection(sets[2]) else: return set() ```def find\_set\_intersection(sets):   return sets\[0].intersection(sets\[1]).intersection(sets\[2])   else:   return set()
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:
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
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
Solución corta...
def find_set_intersection(sets): return set.intersection(*sets) if sets else set()
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)
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)
Repite el resultado bro
[3, 4, 3, 4, 3, 4]
