Arrays

// 1) Create
var nums = [1, 2, 3, 4, 5]
var names: [String] = []
let zeros = Array(repeating: 0, count: 100)
let evens = Array(stride(from: 0, to: 20, by: 2))

// 2) Access
let first = nums.first              // Optional(1)
let last  = nums.last
let idx   = nums[2]
let safe  = nums.indices.contains(99) ? nums[99] : nil

// 3) Iterate
for n in nums { print(n) }
for (i, n) in nums.enumerated() { print("\\(i): \\(n)") }

// 4) Mutate (var only)
nums.append(6)
nums.append(contentsOf: [7, 8, 9])
nums.insert(0, at: 0)
nums.remove(at: 0)
nums.removeAll(where: { $0 % 2 == 0 })
nums.swapAt(0, 1)
nums.reverse()
nums.sort()                          // in place

// 5) Functional — returns NEW arrays (originals unchanged)
let doubled  = nums.map { $0 * 2 }
let odd      = nums.filter { $0.isMultiple(of: 2) == false }
let total    = nums.reduce(0, +)
let maxN     = nums.max()           // Optional
let sorted   = nums.sorted(by: >)
let uniq     = Array(Set(nums))     // dedupe (order lost)

// 6) Slicing — ArraySlice shares storage with the parent (cheap)
let head = nums.prefix(3)
let tail = nums.suffix(3)
let mid  = nums[2..<5]
// To convert back to Array (own storage):
let arr  = Array(mid)

// 7) Multi-dimensional
var grid = Array(repeating: Array(repeating: 0, count: 10), count: 10)
grid[3][4] = 1

// 8) Map of structs — common pattern
struct User { let id: Int; let name: String }
let users = [User(id: 1, name: "Ada"), User(id: 2, name: "Bo")]
let byId  = Dictionary(uniqueKeysWithValues: users.map { ($0.id, $0) })
let names = users.map(\\.name)         // ["Ada", "Bo"] — key-path shorthand

// 9) Chunked + windowed (Swift 5.x+)
let pairs = stride(from: 0, to: nums.count, by: 2).map {
    Array(nums[$0..<min($0 + 2, nums.count)])
}

// 10) Bounded operations — be safe
func safe<T>(_ a: [T], _ i: Int) -> T? {
    a.indices.contains(i) ? a[i] : nil
}

var xs: [Int] = [1, 2, 3]
xs.append(4)
print(xs.count, xs.first ?? -1)