Conjuntos

Al parecer cuando agregamos un objeto que ya estaba, no lo cuenta y simplemente lo ignora, indicándolo como False.

SETS (Conjuntos)

• No tienen orden
• No tienen elementos duplicados

Es necesario agregar elementos comparables: si un objeto es igual o no es igual a otro.

Definición de un conjunto vacío (en este caso, un conjunto de Characters):

var letters = Set<Character>()

Para agregar elementos se debe utilizar el método .insert():

letters.insert("a")
letters.insert("h")
letters.insert("b")

Definición de un conjunto de Strings:

var favouriteGames: Set<String> = ["Final Fantasy", "WoW", "FarCry"]

Se puede utilizar el método .isEmpty para comprobar si el conjunto esta o no vacío:

if favouriteGames.isEmpty {
    print("No hay juegos favoritos")
}

Para eliminar un elemento se puede realizar de varias formas:

if let removedGame = favouriteGames.remove("FarCry") {
    print("He eliminado de la lista \(removedGame)")
}

O utilizando el método .contains():

if favouriteGames.contains("Metal Gear") {
    // eliminar u otra cosa
}

Si queremos ordenar un conjunto, se usa el método .sorted():

for vg in favouriteGames.sorted() {
    print(vg)
}

¿Qué pasa si queremos agregar un elemento que ya existe en el conjunto?

Aprovechando el RETO:

var favMovies: Set<String> = [
    "Back to the Future",
    "Matrix",
    "Star Wars"
]
favMovies	// {"Matrix", "Star Wars", "Back to the Future"}
favMovies.count	//3
favMovies.insert("Matrix")	// (inserted false, memberAfterInsert "Matrix")

Aparece el mensaje:

(inserted false, memberAfterInsert "Matrix")

(inserted false, memberAfterInsert "Ciao")```

el metodo insert regresa una tupla de un booleano y del tipo que sea el conjunto, el booleano determina si se inserto o no, y el segundo elemento de la ultima es el mismo elemento que se intento insertar, si el elemento ya existe, no importa las veces que se trate de insertar, siempre regresara false

var favouriteMovies : Set<String> = ["Taxi Driver", "Pulp Fiction", "Django Unchained", "Joker", "The Dark Knight"]
favouriteMovies.insert("Joker")
favouriteMovies.insert("Joker")
let (inserted, member) = favouriteMovies.insert("Joker")
print(inserted, member)

RETO:

En mi caso al agregar un objeto repetido, en la parte derecha marca como “inserted false” y sigue con la linea de codigo… Esto es al hacerlo con un favoriteMoviesAndSeries.insert("")

Simplemente ignora el objeto repetido.

var favoriteMoviesAndSeries : Set = ["Blade Runner 2049", "Black Mirror", "Mr. Robot", "Mr. Robot"]
favoriteMoviesAndSeries.insert("Mr. Robot")
favoriteMoviesAndSeries

favoriteMoviesAndSeries.insert("Sr. Robot")
favoriteMoviesAndSeries

 
var favoriteSerie : Set<String> = ["Elite","Los Serrano", "La que se avecina", "El internado", "El barco"]
if favoriteSerie.contains("La que se avecina"){
    
    if let removeSerie =  favoriteSerie.remove("La que se avecina"){
    print("Se elimino la Serie: \(removeSerie)")
}
    
}
for orden in favoriteSerie{
    print(orden)
}

)

El orden en un conjunto o set en Swift no está garantizado y puede variar en diferentes ejecuciones del programa. Esto se debe a que los conjuntos en Swift están implementados como estructuras sin orden específico.

La razón principal detrás de esto es la optimización de rendimiento. Al no mantener un orden específico, Swift puede realizar operaciones de conjunto, como agregar, eliminar y buscar elementos, de manera más eficiente.

En mi caso. Salta una alerta donde muestra “inserted False”, dando explicación a que no se añade al conjunto porque es un elemento duplicado.

//Reto
var favouriteSoda:Set<String> = []
favouriteSoda.insert("Coca Cola")
favouriteSoda.insert("Naranjada")
favouriteSoda.insert("Toronja")
favouriteSoda.count
favouriteSoda.sorted()
favouriteSoda.insert("Toronja")

var set: Set<Character> = ["A","B","C"]
set.insert("D")
// remover
set.remove("A")

var movies: Set <String> = ["El código enigma", "El naufrago", "Una mente brillante", "Fuga de Pretoria", "Matrix", "El Señor de los Anillos", "Shrek", "Megamente"]

func addMovie(movie: String) {
    let isInserted = movies.insert(movie)
    
    if isInserted.inserted {
        print("Se agregó \(movie) a su colección de películas favoritas.\n")
    } else {
        print("No se garegó la película \(movie), por que ya existe.\n")
    }
}
// No se agrega por que el elemento ya exite
addMovie(movie: "Shrek")

// Sí se agrega por que es case sensitive
addMovie(movie: "shrek")

for movie in movies.sorted() {
    print(movie)
}

👁️ Ojo con las mayúsculas y minúsculas

Los conjuntos ignoran los elementos repetidos, pero si no respetamos las mayúsculas y minúsculas, el conjunto pensará que es un elemento distinto y la agregara,

var favorieMovies : Set<String>()

favoriteMovies.insert("Rocky") // Agregado
favoriteMovies.insert("Rocky") // Ignorado, ya existe
favoriteMovies.insert("rocky") // Agregado

print(favoriteMovies) // ["rocky", "Rocky"]

Cuando el string ya esta agregado al array, no lo vuelve a agregar.

var numbers: Set<Int> = []

numbers.count
numbers.insert(1)

func insertOnSet(number: Int){
    let inserted = numbers.insert(number)
    if inserted.inserted {
        print("El numero se insertó correctamente")
    } else {
        print("El elemento ya existe el el set")
    }
}

insertOnSet(number: 1)

Reto:

var movieFavorite : Set<String> = ["card", "el rey leon", "pocahontas"]

movieFavorite.insert("pocahontas")

No permite agregar un mismo objeto!

También se pueden “añadir” varios elementos a la vez

var juegosFavoritos : Set<String> = []

juegosFavoritos.isEmpty

juegosFavoritos.insert("2048")

juegosFavoritos.contains("2048")

var masJuegos = ["pokémon legends Arceus","Halo","Crash Team Racing"]

for juego in masJuegos{
    juegosFavoritos.insert(juego)
}

// Conjuntos (Sets)
// no pueden ser buscados por índice [] y sus elementos no se pueden repetir.


var conjuntoEnteros = Set<String>()
conjuntoEnteros.insert("A")

var juegosFavoritos : Set<String> = []

juegosFavoritos.isEmpty

juegosFavoritos.insert("2048")

juegosFavoritos.contains("2048")

esta clase esta espectacular ❤️

var favouriteMovies : Set <String> = ["Rapidos y Furiosos", "Alicia en el pais de las maravillas", "El diario de una pasion"]
favouriteMovies.count

favouriteGames.insert("El diario de una pasion")
favouriteMovies.count```

El resultado 😬:
Se muestra como falso y no es agregado

Ejercicio

var favoriteMovies : Set<String> = ["Avatar", "Un Novato en Apuros", "Interestelar"]
favoriteMovies.count

favoriteMovies.insert("Avatar")

Resultado de la consola:

(inserted false, memberAfterInsert "Avatar")

//reto
var favoriteSeries : Set<String> = ["The big bang theory", "Friends", "Gravity Falls"]
favoriteSeries.insert("The big bang theory")

response = (inserted false, memberAfterInsert "The big bang theory")

Lo pone como “false” y no lo agrega

var deletedGame : String?
    
    favoriteGames.contains("Road Redemption") ? deletedGame = favoriteGames.remove("Road Redemption") : print("The game does not appear in the set")```

El método insert(), me devuelve una tupla con un valor false, indicándome que la inserción a sido denegada. Si cambio el dato por un valor que no se repita, me saldría un true.

Da false al insertar uno repetido

Al intentar incluir un elemento repetido, nos devuelve false por lo que al realizar la cuenta nuevamente se mantiene en 4 elementos.

var favouritesMovies : Set<String> = ["Back to the Future", "Figth Club", "War Games", "Interview With The Vampire"]
favouritesMovies.count
favouritesMovies.insert("War Games")
favouritesMovies.count

for mov in favouritesMovies.sorted() {
    print(mov)
}

si existe un valor en el conjuto no se puede ingresar 2 o mas veces en dicho conjunto

Indica que elemento ya existe en el Set por lo tanto no lo agrega.

Solo se pueden crear conjuntos de objetos que sean ordenables, comparables e irrepetibles.

var peliculas1 : Set = ["Buscando a Nemo", "Iron Man", "Bichos", "Batman: returns", "Shrek", "La Sirenita", "Thor"]
    var peliculas2 : Set = ["Buscando a Nemo", "Cars", "Bichos", "Bob Esponja", "Shrek2", "La Sirenita", "Thor"]
    peliculas1.subtract(peliculas2)
    print(peliculas1)

Pense que saltaria un error al insertar un item repetido en el set, pero Swift lo ha ignorado solo se ve en la parte derecha del un mensaje que dice: inserted false