Examples 09-13

Author: tib

contents/[09]arrays/index.md

@@ -4,3 +4,151 @@ description: ""
 order: 9
 ---
 
+An array is a collection that holds values in a specific order.
+
+Arrays in Swift can store values of any standard data type, including `String`, `Int`, `Double`, and `Bool`. Swift's type inference makes it easy to create arrays without explicitly specifying their types:
+
+```swift
+// Array of String elements, type inferred
+let names = ["Kitti", "Tibi", "Havoc"]
+
+// Array of Int elements, explicit type annotation
+let integers: Array<Int> = [1, 2, 3]
+
+// Array of Double elements, short type syntax
+let doubles: [Double] = [2.6, 3.4, 4.8]
+
+// Array of Bool elements, type inferred
+let booleans = [true, false]
+
+// Array of String elements, empty array
+let empty: [String] = []
+```
+
+We can even create an array by using a range or repeating an element:
+
+```swift
+let smallNumbers = Array(0...10)
+
+let helloArray = Array(repeating: "hello", count: 10)
+```
+You can easily check whether an array is empty, see how many items it holds, and grab elements by their index. Swift lets you access the first and last items, look up the valid index range, and even pick a random element. You can also find out if an array includes a certain value or get the index of a specific item:
+
+```swift
+let numbers = [42, 7, 13, 99, 5]
+
+// Checks if the array contains no elements
+print(numbers.isEmpty)
+
+// Returns the total number of elements in the array
+print(numbers.count)
+
+// Retrieves the element at a specific index position
+print(numbers[0])
+print(numbers[1])
+print(numbers[2])
+
+// Provides the valid index range for the array
+print(numbers.indices)
+
+// Accesses the first and last elements, respectively
+print(numbers.first!)
+print(numbers.last!)
+
+// Returns a set number of elements from the start or end
+print(numbers.prefix(2))
+print(numbers.suffix(2))
+
+// Selects a random element from the array
+print(numbers.randomElement()!)
+
+// Checks if a specific value exists in the array
+print(numbers.contains(13))
+print(numbers.contains(100))
+
+// Returns the index of an element, or nil if not found
+print(numbers.firstIndex(of: 7)!)
+
+// Returns the smallest and largest values in the array
+print(numbers.min()!)
+print(numbers.max()!)
+```
+
+To modify an array, it must be declared as a variable using the `var` keyword, since constant arrays cannot be changed. These functions allow you to update, add, or insert elements when working with mutable arrays:
+
+```swift
+// Updates the element at a specific index
+var dailyActivities = ["Eat", "Repeat"]
+dailyActivities[1] = "Sleep"
+
+// Adds a single element to the end of the array
+dailyActivities.append("Yoga")
+
+// Adds multiple elements to the end of the array
+dailyActivities.append(contentsOf: ["Rest", "Repeat"])
+
+// Concatenates another array to the end of the array
+dailyActivities += ["Rest", "Repeat"]
+
+// Inserts an element at a specified position in the array
+dailyActivities.insert("Learn", at: 0)
+dailyActivities.insert("Drink", at: dailyActivities.count)
+```
+
+Swift provides plenty of ways to remove elements from an array, such as removing the first item, removing the last item, removing at a specific index or removing a range of elements:
+
+```swift
+// Removes the first N elements from the array
+dailyActivities.removeFirst()
+dailyActivities.removeFirst(2)
+
+// Removes the last N elements from the array
+dailyActivities.removeLast()
+dailyActivities.removeLast(2)
+
+// Removes the element at a specific index
+dailyActivities.remove(at: 2)
+
+// Removes a range of elements from the array
+dailyActivities.removeSubrange(2...3)
+
+// Removes all elements from the array
+dailyActivities.removeAll()
+```
+
+These mutating functions modify the original array:
+
+```swift
+// Swaps the elements at the specified indices
+dailyActivities.swapAt(0, 2)
+
+// Reverses the order of the elements in the array
+dailyActivities.reverse()
+
+// Sorts the elements of the array in ascending order
+dailyActivities.sort()
+
+// Randomly shuffles the elements in the array
+dailyActivities.shuffle()
+```
+
+Non-mutating functions always return a new array. In Swift, there are both mutating and non-mutating versions of functions like `sort()` and `sorted()`. This naming convention helps you know which functions change the original array and which do not.
+
+
+```swift
+let numbers = [42, 7, 13, 99, 5]
+
+// Sorted array
+let sortedNumbers = numbers.sorted()
+
+// Reversed collection
+let reversedNumbers = numbers.reversed()
+
+// Shuffled array
+let shuffledNumbers = numbers.shuffled()
+```
+
+Non-mutating functions leave the original array unchanged. This means you can use them on constant values, since they do not modify the original array but instead give you a new one.
+
+
+

contents/[10]sets/index.md

@@ -4,46 +4,108 @@ description: ""
 order: 10
 ---
 
+In Swift, a Set is a collection type that stores unique values of the same type in _no particular order_. Unlike arrays, sets don't allow duplicate values, and since they don't preserve the order of elements, we call them unordered collections. Also, in some cases, sets are faster than arrays. There are several ways to create sets:
 
-foo
+```swift
+// using the full syntax
+let set1: Set<String> = []
+// using the short syntax
+let set2 = Set<String>()
+// using type inference
+let set3: Set = ["A", "B"]
+```
+
+Note that duplicate values are automatically removed when creating a set. You can also check set properties and access elements in ways similar to arrays, such as verifying if the set is empty, counting its elements, or retrieving a random element:
 
 ```swift
-let x = 5
-let y = 5
-var z = 0
+let numbers: Set<Int> = [1, 2, 3, 2, 1]   
 
-z = x + y // addition
-print(z) // => 10
+// Check if the set is empty
+print(numbers.isEmpty)       
 
-z = x - y // subtraction
-print(z) // => 0
+// Get the number of elements in the set 
+print(numbers.count)
 
-z = x * y // multiplication
-print(z) // => 25
+// Get a random element from the set
+print(numbers.randomElement()!)
+```
+You can insert elements into a set, remove specific elements, remove any element, or clear all elements. You can also check if a set contains a particular value:
 
-z = x / y // division
-print(z) // => 1
+```swift
+var roles: Set = ["view", "edit"]
 
+// Add a new element to the set
+roles.insert("manage")       
 
-var x = 10
+// Remove an exact element from the set 
+roles.remove("edit")       
 
-x += 2 // addition
-print(x) // => 12
+// Remove the first element from the set
+roles.removeFirst()
 
-x -= 2 // subtraction
-print(x) // => 10
+// Remove all elements from the set
+roles.removeAll()
 
-x *= 2 // multiplication
-print(x) // => 20
+// Check if a specific element exists in the set
+print(roles.contains("view")) 
+```
+
+Sets don’t preserve order, but you can sort them into an array:
+
+```swift
+var numbers: Set<Int> = [21, 34, 54, 12]
 
-x /= 2 // division
-print(x) // => 10
+let ascendingNumbers = numbers.sorted()
+print(ascendingNumbers)
+
+let descendingNumbers = numbers.sorted(by: >)
+print(descendingNumbers)
 ```
 
-bar
+They also support fast set operations:
+
+```swift
+let first: Set = [1, 2, 3, 5]
+let second: Set = [0, 2, 3, 4]
+
+// Combine all unique elements from both sets
+print(first.union(second))            
 
-```sh
-swift main.swift
+// Find elements present in both sets
+print(first.intersection(second))     
+
+// Get elements in 'first' that are not in 'second'
+print(first.subtracting(second))      
+
+// Find elements that are in either set, but not both
+print(first.symmetricDifference(second))
 ```
 
-baz
+Relationship checks are also built in:
+
+```swift
+let a: Set = [1, 2]
+let b: Set = [1, 2, 3, 4]
+
+// Check if all elements in 'a' are also contained in 'b'
+print(a.isSubset(of: b))
+
+// Check if 'b' contains every element in 'a'
+print(b.isSuperset(of: a))
+
+// Check if 'a' and another set share no common elements
+print(a.isDisjoint(with: [5, 6]))
+```
+
+Sets are sometimes faster than arrays for membership checks and set operations because they use hash-based storage, allowing for constant-time lookups and modifications.
+
+
+
+
+
+
+
+
+
+
+