Swift – Establecer operaciones

Set es una colección de valores únicos. Se puede crear un conjunto usando el inicializador o la sintaxis literal del conjunto. También se puede crear un conjunto agregando una array de valores únicos a un conjunto vacío. Podemos usar un conjunto en lugar de una array cuando queremos eliminar valores duplicados. Un conjunto está desordenado y no mantiene índices, por lo que no se puede acceder a él por índice.

Establecer 

Aquí, estamos usando la array de música para almacenar los géneros musicales. El conjunto llamado música contiene los valores rock, jazz, hip-hop, etc. En general, podemos pensar en un conjunto como una colección de valores únicos. En nuestro ejemplo, tomamos la música como ejemplo y almacenamos los valores del rock, el jazz y el hip-hop en la música establecida.

Creación de un conjunto en Swift

Podemos crear un conjunto con cualquier tipo de valores que sean hashable. Hashable significa que los valores se pueden codificar y comparar. En Swift, las strings, los tipos numéricos y booleanos se pueden modificar. Para crear un nuevo conjunto, simplemente use la sintaxis literal del conjunto.

Sintaxis:

var set_name: Set<tipo> = [valor1, valor2, valor3, …]

Aquí, set_name es el nombre del conjunto y type es el tipo de los valores del conjunto.

Ejemplo:

// Swift program to create a set of strings
import Swift
  
// Creating a set of string
var setname: Set<String> = [ "a", "b", "c", "d", "e" ] 
  
// Displaying the set
print(setname)

Producción:

["a", "b", "c", "d", "e"]

Establecer operaciones 

En Swift, también podemos realizar varias operaciones de conjuntos, como unir dos conjuntos, encontrar la diferencia entre dos conjuntos, verificar si un conjunto está vacío o no y comparar dos conjuntos usando sus valores. O podemos decir que Swift proporciona métodos integrados para realizar operaciones de conjuntos como unión, intersección, diferencia y diferencia simétrica. A continuación se muestra un diagrama simple de varias operaciones de conjuntos.

Unión 

Unión es el conjunto de todos los elementos que están presentes en ambos conjuntos, no contiene elementos duplicados. Por ejemplo, tenemos dos conjuntos: el conjunto a y el conjunto b. Entonces, la unión de ambos conjuntos contiene todos los elementos que están tanto en el conjunto a como en el conjunto b. Aquí, en el diagrama anterior, la parte verde resaltada de la figura muestra que estas áreas están incluidas en el conjunto resultante. Tanto las áreas del conjunto a como del conjunto b están incluidas en la unión resultante del conjunto.

Swift proporciona un método union() incorporado para encontrar la unión de dos conjuntos. O podemos decir que este método devuelve un nuevo conjunto que contiene todos los elementos del conjunto ay del conjunto b.

Sintaxis:

conjuntoA.unión(conjuntoB)

Aquí, conjuntoA es el nombre del primer conjunto y conjuntoB es el nombre del segundo conjunto.

Ejemplo:

// Swift program to find the union of two sets
  
// Creating set A of integers
var setA: Set<Int> = [1, 2, 3, 4, 5] 
  
// Displaying set A
print("Set A:", setA)
  
// Creating set B of integers
var setB: Set<Int> = [3, 4, 5, 6, 7] 
  
// Displaying set B
print("Set B:", setB)
  
// Displaying the union of setA and setB
// Using union() method
print("Union of setA and setB:", setA.union(setB))

Producción:

Set A: [3, 4, 5, 2, 1]
Set B: [3, 4, 6, 5, 7]
Union of setA and setB: [4, 3, 6, 2, 5, 7, 1]

Aquí, como podemos ver, imprime la unión de los dos conjuntos, es decir, [4, 3, 6, 2, 5, 7, 1]. Esos elementos están en cualquiera de los dos conjuntos.

Intersección 

La intersección es el conjunto que contiene solo los elementos comunes presentes en ambos conjuntos. Por ejemplo, tenemos dos conjuntos: el conjunto a y el conjunto b. Entonces, la intersección contiene los elementos comunes presentes tanto en el conjunto a como en el conjunto b. Aquí, la parte verde resaltada del diagrama muestra el área que es común en ambos conjuntos. Entonces, la intersección resultante de ambos conjuntos solo tiene elementos comunes.

Swift proporciona un método de intersection() incorporado para encontrar la intersección de dos conjuntos. O podemos decir que este método devuelve un nuevo conjunto que contiene todos los elementos comunes del conjunto a y el conjunto b.

Sintaxis:

conjuntoA.intersección(conjuntoB)

Aquí, conjuntoA es el nombre del primer conjunto y conjuntoB es el nombre del segundo conjunto. 

Ejemplo:

// Swift program to find the intersection of two sets
  
// Creating set A of integers
var setA: Set<Int> = [1, 2, 3, 4, 5] 
  
// Displaying set A
print("Set A:", setA)
  
// Creating set B of integers
var setB: Set<Int> = [3, 4, 5, 6, 7] 
  
// Displaying set B
print("Set B:", setB)
  
// Displaying the intersection of setA and setB
// Using intersection() method
print("Intersection of setA and setB:", setA.intersection(setB)) 

Producción:

Set A: [3, 2, 4, 5, 1]
Set B: [7, 3, 4, 5, 6]
Intersection of setA and setB: [4, 3, 5]

Aquí, como podemos ver, imprime la intersección de los dos conjuntos, es decir, [4, 3, 5]. Esos elementos están en los dos conjuntos solamente.

Restar 

La resta es el conjunto de elementos que están en el primer conjunto pero no en el segundo conjunto. Por ejemplo, tenemos dos conjuntos: el conjunto a y el conjunto b. Entonces, la resta contiene los elementos presentes en el conjunto a pero no en el conjunto b. Aquí, la parte verde resaltada del diagrama muestra el área que se incluye en el conjunto resultante después de la operación de resta realizada entre los dos conjuntos.

Swift proporciona un método Subtracting() incorporado para encontrar la diferencia entre dos conjuntos. O podemos decir que este método devuelve un nuevo conjunto que contiene los elementos que están presentes en el conjunto a pero no en el conjunto b.

Sintaxis:

setA.restar(setB)

Aquí, conjuntoA es el nombre del primer conjunto y conjuntoB es el nombre del segundo conjunto.

Ejemplo:

// Swift program to find the subtracting of two sets
  
// Creating set A of integers
var setA: Set<Int> = [1, 2, 3, 4, 5] 
  
// Displaying set A
print("Set A:", setA)
  
// Creating set B of integers
var setB: Set<Int> = [3, 4, 5, 6, 7] 
  
// Displaying set B
print("Set B:", setB)
  
// Displaying the subtracting of setA and setB
// Using subtracting() method
print("Subtracting of setA and setB:", setA.subtracting(setB)) 

Producción:

Set A: [4, 5, 1, 2, 3]
Set B: [3, 4, 5, 7, 6]
Subtracting of setA and setB: [1, 2]

Aquí, como podemos ver, imprime la diferencia de los dos conjuntos, es decir, [1, 2]. Esos elementos están presentes en el primer conjunto pero no en el segundo conjunto.

diferencia simétrica 

La diferencia simétrica es el conjunto de todos los elementos que están en cualquiera de los dos conjuntos pero no en ambos. Por ejemplo, tenemos dos conjuntos: el conjunto a y el conjunto b. Entonces, la diferencia simétrica contiene los elementos presentes en cualquiera de los dos conjuntos pero no en ambos. Aquí, la parte verde resaltada del diagrama muestra el área que se incluye en el conjunto resultante después de realizar la operación de diferencia simétrica en ambos conjuntos. En esta operación se ignoran los elementos que son comunes a ambos conjuntos.

Swift proporciona un método de diferencia simétrica() incorporado para crear un nuevo conjunto con valores en cualquiera de los conjuntos, pero no en ambos. Donde a y b representan los dos conjuntos en los que estamos realizando una operación de diferencia simétrica. 

Sintaxis:

conjuntoA.diferenciasimétrica(conjuntoB)

Aquí, conjuntoA es el nombre del primer conjunto y conjuntoB es el nombre del segundo conjunto.

Ejemplo:

// Swift program to find the symmetricDifference of two sets
  
// Creating set A of integers
var setA: Set<Int> = [1, 2, 3, 4, 5] 
  
// Displaying set A
print("Set A:", setA)
  
// Creating set B of integers
var setB: Set<Int> = [3, 4, 5, 6, 7] 
  
// Displaying set B
print("Set B:", setB)
  
// Displaying the symmetricDifference of setA and setB
// Using symmetricDifference() method
print("SymmetricDifference of setA and setB:", 
      setA.symmetricDifference(setB)) 

Producción:  

Set A: [3, 1, 2, 4, 5]
Set B: [6, 5, 3, 7, 4]
SymmetricDifference of setA and setB: [6, 1, 2, 7]

Aquí, como podemos ver, imprime la diferencia simétrica de los dos conjuntos, es decir, [6, 1, 2, 7]. Aquellos elementos que están en cualquiera de los dos conjuntos pero no en ambos.

Comprobar si dos conjuntos son iguales 

Swift proporciona un operador ==. Este operador se utiliza para comprobar si ambos conjuntos son iguales o no. Este operador devolverá verdadero si ambos conjuntos son iguales. O devolverá falso si ambos conjuntos no son iguales.

Sintaxis:

conjuntoA == conjuntoB

Aquí, conjuntoA es el nombre del primer conjunto y conjuntoB es el nombre del segundo conjunto.

Ejemplo:

// Swift program to check the given sets are equal or not 
  
// Creating set A of integers
var setA: Set<Int> = [1, 2, 3, 4, 5] 
  
// Displaying set A
print("Set A:", setA)
  
// Creating set B of integers
var setB: Set<Int> = [3, 4, 5, 6, 7] 
  
// Displaying set B
print("Set B:", setB)
  
// Checking setA is equal to setB
// Using == operator 
print("Is setA is equal to setB: ", 
      setA == setB) 

Producción:

Set A: [2, 4, 5, 3, 1]
Set B: [4, 5, 6, 7, 3]
Is setA is equal to setB:  false

Comprobar subconjunto de un conjunto

Se dice que un conjunto es un subconjunto de otro conjunto si todos los elementos del primer conjunto están presentes en el segundo conjunto, como se muestra en la siguiente imagen. Swift proporciona un método integrado isSubset(). Este método se utiliza para comprobar si todos los valores de un conjunto b están disponibles en el conjunto a. Este método devolverá verdadero si el conjunto es un subconjunto; de lo contrario, devolverá falso.

Sintaxis:

conjuntoB.esSubconjunto(de: conjuntoA)

Aquí, setB es el conjunto que queremos comprobar si es un subconjunto de setA o no.

Ejemplo:

// Swift program to check the given set is the subset or not  
  
// Creating set A of integers
var setA: Set<Int> = [1, 2, 3, 4, 5] 
  
// Displaying set A
print("Set A:", setA)
  
// Creating set B of integers
var setB: Set<Int> = [3, 4, 5, 6, 7] 
  
// Displaying set B
print("Set B:", setB)
  
// Checking setB is the subset of setA
// Using isSubset() method
print("Is setB is the subset of setA and setB:", 
      setB.isSubset(of: setA)) 

Producción:

Set A: [3, 2, 1, 4, 5]
Set B: [4, 6, 3, 5, 7]
Is setB is the subset of setA and setB: false