func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            if abs(numbers[i] - numbers[j]) < threshold {
                return true
            }
        }
    }
    return false
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            if abs(numbers[i] - numbers[j]) < threshold {
                return true
            }
        }
    }
    return false
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var minDistance = Double.greatestFiniteMagnitude
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            let distance = abs(numbers[i] - numbers[j])
            if distance < minDistance {
                minDistance = distance
            }
        }
    }
    return minDistance < threshold
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var minDistance = Double.greatestFiniteMagnitude
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            let distance = abs(numbers[i] - numbers[j])
            if distance < minDistance {
                minDistance = distance
            }
        }
    }
    return minDistance < threshold
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var close = false
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            if abs(numbers[i] - numbers[j]) < threshold {
                close = true
                break
            }
        }
        if close {
            break
        }
    }
    return close
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var close = false
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            if abs(numbers[i] - numbers[j]) < threshold {
                close = true
                break
            }
        }
        if close {
            break
        }
    }
    return close
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var close = false
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            if abs(numbers[i] - numbers[j]) < threshold {
                close = true
                break
            }
        }
        if close {
            break
        }
    }
    return close
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var close = false
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            if abs(numbers[i] - numbers[j]) < threshold {
                close = true
                break
            }
        }
        if close {
            break
        }
    }
    return close
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            if abs(numbers[i] - numbers[j]) < threshold {
                return true
            }
        }
    }
    return false
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            if abs(numbers[i] - numbers[j]) < threshold {
                return true
            }
        }
    }
    return false
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var result = false
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            if abs(numbers[i] - numbers[j]) < threshold {
                result = true
                break
            }
        }
    }
    return result
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var result = false
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            if abs(numbers[i] - numbers[j]) < threshold {
                result = true
                break
            }
        }
    }
    return result
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var numbers = numbers
    numbers.sort()
    for i in 0..<numbers.count - 1 {
        if numbers[i + 1] - numbers[i] < threshold {
            return true
        }
    }
    return false
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var numbers = numbers
    numbers.sort()
    for i in 0..<numbers.count - 1 {
        if numbers[i + 1] - numbers[i] < threshold {
            return true
        }
    }
    return false
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var close = false
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            if abs(numbers[i] - numbers[j]) < threshold {
                close = true
            }
        }
    }
    return close
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var close = false
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            if abs(numbers[i] - numbers[j]) < threshold {
                close = true
            }
        }
    }
    return close
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var close = false
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            if abs(numbers[i] - numbers[j]) < threshold {
                close = true
                break
            }
        }
        if close {
            break
        }
    }
    return close
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var close = false
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            if abs(numbers[i] - numbers[j]) < threshold {
                close = true
                break
            }
        }
        if close {
            break
        }
    }
    return close
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var close = false
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            if abs(numbers[i] - numbers[j]) < threshold {
                close = true
                break
            }
        }
        if close {
            break
        }
    }
    return close
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var close = false
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            if abs(numbers[i] - numbers[j]) < threshold {
                close = true
                break
            }
        }
        if close {
            break
        }
    }
    return close
}
```

func separateParenGroups(parenString: String) -> [String] {
    // Your code here
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    // Your code here
}
```

func separateParenGroups(parenString: String) -> [String] {
    // Write your code here
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    // Write your code here
}
```

func separateParenGroups(parenString: String) -> [String] {
    // TODO: Implement this function
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    // TODO: Implement this function
}
```

func separateParenGroups(parenString: String) -> [String] {
    // Your code here
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    // Your code here
}
```

func separateParenGroups(parenString: String) -> [String] {
    // TODO: Implement this function
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    // TODO: Implement this function
}
```

func separateParenGroups(parenString: String) -> [String] {
    // Your code here
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    // Your code here
}
```

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var stack = [String]()
    var current = ""
    for char in parenString {
        if char == "(" {
            stack.append(current)
            current = ""
        } else if char == ")" {
            if stack.isEmpty {
                result.append(current)
                current = ""
            } else {
                current = stack.removeLast() + current
            }
        } else {
            current += String(char)
        }
    }
    if!current.isEmpty {
        result.append(current)
    }
    return result
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var stack = [String]()
    var current = ""
    for char in parenString {
        if char == "(" {
            stack.append(current)
            current = ""
        } else if char == ")" {
            if stack.isEmpty {
                result.append(current)
                current = ""
            } else {
                current = stack.removeLast() + current
            }
        } else {
            current += String(char)
        }
    }
    if!current.isEmpty {
        result.append(current)
    }
    return result
}
```

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var stack = [String]()
    var current = ""
    for char in parenString {
        if char == "(" {
            if current.count > 0 {
                stack.append(current)
                current = ""
            }
            stack.append("(")
        } else if char == ")" {
            if current.count > 0 {
                stack.append(current)
                current = ""
            }
            if stack.count > 0 {
                stack[stack.count - 1] += ")"
                current = stack.removeLast()
            }
        } else {
            current += String(char)
        }
    }
    if current.count > 0 {
        stack.append(current)
    }
    for item in stack {
        result.append(item)
    }
    return result
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var stack = [String]()
    var current = ""
    for char in parenString {
        if char == "(" {
            if current.count > 0 {
                stack.append(current)
                current = ""
            }
            stack.append("(")
        } else if char == ")" {
            if current.count > 0 {
                stack.append(current)
                current = ""
            }
            if stack.count > 0 {
                stack[stack.count - 1] += ")"
                current = stack.removeLast()
            }
        } else {
            current += String(char)
        }
    }
    if current.count > 0 {
        stack.append(current)
    }
    for item in stack {
        result.append(item)
    }
    return result
}
```

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var stack = [String]()
    var current = ""
    for char in parenString {
        if char == "(" {
            stack.append(current)
            current = ""
        } else if char == ")" {
            if stack.isEmpty {
                result.append(current)
                current = ""
            } else {
                current = stack.removeLast() + current
            }
        } else {
            current += String(char)
        }
    }
    if!current.isEmpty {
        result.append(current)
    }
    return result
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var stack = [String]()
    var current = ""
    for char in parenString {
        if char == "(" {
            stack.append(current)
            current = ""
        } else if char == ")" {
            if stack.isEmpty {
                result.append(current)
                current = ""
            } else {
                current = stack.removeLast() + current
            }
        } else {
            current += String(char)
        }
    }
    if!current.isEmpty {
        result.append(current)
    }
    return result
}
```

func separateParenGroups(parenString: String) -> [String] {
    // TODO: Implement this function
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    // TODO: Implement this function
}
```

func truncateNumber(number: Double) -> Double {
    return number - floor(number)
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    return number - floor(number)
}
```

func truncateNumber(number: Double) -> Double {
    return number - floor(number)
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    return number - floor(number)
}
```

func truncateNumber(number: Double) -> Double {
    return number - Double(Int(number))
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    return number - Double(Int(number))
}
```

func truncateNumber(number: Double) -> Double {
    return number - floor(number)
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    return number - floor(number)
}
```

func truncateNumber(number: Double) -> Double {
    return number - Double(Int(number))
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    return number - Double(Int(number))
}
```

func truncateNumber(number: Double) -> Double {
    return number - Double(Int(number))
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    return number - Double(Int(number))
}
```

func truncateNumber(number: Double) -> Double {
    let integerPart = Int(number)
    let decimalPart = number - Double(integerPart)
    return decimalPart
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    let integerPart = Int(number)
    let decimalPart = number - Double(integerPart)
    return decimalPart
}
```

func truncateNumber(number: Double) -> Double {
    return number - Double(Int(number))
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    return number - Double(Int(number))
}
```

func truncateNumber(number: Double) -> Double {
    return number - floor(number)
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    return number - floor(number)
}
```

func truncateNumber(number: Double) -> Double {
    return number - Double(Int(number))
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    return number - Double(Int(number))
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let differences = numbers.map { abs($0 - mean) }
    return mean(numbers: differences)
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let differences = numbers.map { abs($0 - mean) }
    return mean(numbers: differences)
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let differences = numbers.map { abs($0 - mean) }
    return mean(numbers: differences)
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let differences = numbers.map { abs($0 - mean) }
    return mean(numbers: differences)
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let differences = numbers.map { abs($0 - mean) }
    return mean(numbers: differences)
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let differences = numbers.map { abs($0 - mean) }
    return mean(numbers: differences)
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let differences = numbers.map { abs($0 - mean) }
    return mean(numbers: differences)
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let differences = numbers.map { abs($0 - mean) }
    return mean(numbers: differences)
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let sum = numbers.reduce(0.0, { $0 + abs($1 - mean) })
    return sum / Double(numbers.count)
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let sum = numbers.reduce(0.0, { $0 + abs($1 - mean) })
    return sum / Double(numbers.count)
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let sum = numbers.reduce(0.0) { $0 + abs($1 - mean) }
    return sum / Double(numbers.count)
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let sum = numbers.reduce(0.0) { $0 + abs($1 - mean) }
    return sum / Double(numbers.count)
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let sum = numbers.reduce(0.0, { $0 + abs($1 - mean) })
    return sum / Double(numbers.count)
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let sum = numbers.reduce(0.0, { $0 + abs($1 - mean) })
    return sum / Double(numbers.count)
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let sum = numbers.reduce(0.0, { $0 + abs($1 - mean) })
    return sum / Double(numbers.count)
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let sum = numbers.reduce(0.0, { $0 + abs($1 - mean) })
    return sum / Double(numbers.count)
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let sum = numbers.reduce(0.0, { $0 + abs($1 - mean) })
    return sum / Double(numbers.count)
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let sum = numbers.reduce(0.0, { $0 + abs($1 - mean) })
    return sum / Double(numbers.count)
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let sum = numbers.reduce(0.0, { $0 + abs($1 - mean) })
    return sum / Double(numbers.count)
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    let sum = numbers.reduce(0.0, { $0 + abs($1 - mean) })
    return sum / Double(numbers.count)
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result: [Int] = []
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result: [Int] = []
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result: [Int] = []
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result: [Int] = []
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result: [Int] = []
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result: [Int] = []
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}
```

func parseNestedParens(parenString: String) -> [Int] {
    // TODO: Implement this function.
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    // TODO: Implement this function.
}
```

func parseNestedParens(parenString: String) -> [Int] {
    // Your code here
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    // Your code here
}
```

func parseNestedParens(parenString: String) -> [Int] {
    // TODO: Implement this function
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    // TODO: Implement this function
}
```

func parseNestedParens(parenString: String) -> [Int] {
    // TODO: Implement this function
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    // TODO: Implement this function
}
```

func parseNestedParens(parenString: String) -> [Int] {
    var result = [Int]()
    var stack = [Int]()
    var max = 0
    for char in parenString {
        if char == "(" {
            stack.append(max)
            max = 0
        } else if char == ")" {
            max += 1
            result.append(max)
            max = stack.removeLast()
        }
    }
    return result
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    var result = [Int]()
    var stack = [Int]()
    var max = 0
    for char in parenString {
        if char == "(" {
            stack.append(max)
            max = 0
        } else if char == ")" {
            max += 1
            result.append(max)
            max = stack.removeLast()
        }
    }
    return result
}
```

func parseNestedParens(parenString: String) -> [Int] {
    // TODO: Implement this function.
    return []
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    // TODO: Implement this function.
    return []
}
```

func parseNestedParens(parenString: String) -> [Int] {
    var maxDepths = [Int]()
    var depth = 0
    var maxDepth = 0
    for char in parenString {
        if char == "(" {
            depth += 1
            if depth > maxDepth {
                maxDepth = depth
            }
        } else if char == ")" {
            depth -= 1
        }
    }
    maxDepths.append(maxDepth)
    return maxDepths
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    var maxDepths = [Int]()
    var depth = 0
    var maxDepth = 0
    for char in parenString {
        if char == "(" {
            depth += 1
            if depth > maxDepth {
                maxDepth = depth
            }
        } else if char == ")" {
            depth -= 1
        }
    }
    maxDepths.append(maxDepth)
    return maxDepths
}
```

func parseNestedParens(parenString: String) -> [Int] {
    var maxDepth = 0
    var currentDepth = 0
    var result = [Int]()
    for char in parenString {
        if char == "(" {
            currentDepth += 1
            maxDepth = max(maxDepth, currentDepth)
        } else if char == ")" {
            currentDepth -= 1
        }
    }
    result.append(maxDepth)
    return result
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    var maxDepth = 0
    var currentDepth = 0
    var result = [Int]()
    for char in parenString {
        if char == "(" {
            currentDepth += 1
            maxDepth = max(maxDepth, currentDepth)
        } else if char == ")" {
            currentDepth -= 1
        }
    }
    result.append(maxDepth)
    return result
}
```

func parseNestedParens(parenString: String) -> [Int] {
    var maxDepths = [Int]()
    var depth = 0
    var maxDepth = 0
    for char in parenString {
        if char == "(" {
            depth += 1
            maxDepth = max(maxDepth, depth)
        } else if char == ")" {
            depth -= 1
        }
    }
    maxDepths.append(maxDepth)
    return maxDepths
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    var maxDepths = [Int]()
    var depth = 0
    var maxDepth = 0
    for char in parenString {
        if char == "(" {
            depth += 1
            maxDepth = max(maxDepth, depth)
        } else if char == ")" {
            depth -= 1
        }
    }
    maxDepths.append(maxDepth)
    return maxDepths
}
```

func parseNestedParens(parenString: String) -> [Int] {
    var maxDepth = 0
    var depth = 0
    var result = [Int]()
    for char in parenString {
        if char == "(" {
            depth += 1
            if depth > maxDepth {
                maxDepth = depth
            }
        } else if char == ")" {
            depth -= 1
        }
    }
    for _ in 0..<parenString.count {
        result.append(maxDepth)
    }
    return result
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    var maxDepth = 0
    var depth = 0
    var result = [Int]()
    for char in parenString {
        if char == "(" {
            depth += 1
            if depth > maxDepth {
                maxDepth = depth
            }
        } else if char == ")" {
            depth -= 1
        }
    }
    for _ in 0..<parenString.count {
        result.append(maxDepth)
    }
    return result
}
```

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

func filterBySubstring(strings: [String], substring: String) -> [String] {
    var result = [String]()
    for string in strings {
        if string.contains(substring) {
            result.append(string)
        }
    }
    return result
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    var result = [String]()
    for string in strings {
        if string.contains(substring) {
            result.append(string)
        }
    }
    return result
}
```

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

func filterBySubstring(strings: [String], substring: String) -> [String] {
    var result = [String]()
    for string in strings {
        if string.contains(substring) {
            result.append(string)
        }
    }
    return result
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    var result = [String]()
    for string in strings {
        if string.contains(substring) {
            result.append(string)
        }
    }
    return result
}
```

func filterBySubstring(strings: [String], substring: String) -> [String] {
    var result: [String] = []
    for string in strings {
        if string.contains(substring) {
            result.append(string)
        }
    }
    return result
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    var result: [String] = []
    for string in strings {
        if string.contains(substring) {
            result.append(string)
        }
    }
    return result
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    return (numbers.reduce(0, +), numbers.reduce(1, *))
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    return (numbers.reduce(0, +), numbers.reduce(1, *))
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    return (numbers.reduce(0, +), numbers.reduce(1, *))
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    return (numbers.reduce(0, +), numbers.reduce(1, *))
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    return (numbers.reduce(0, +), numbers.reduce(1, *))
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    return (numbers.reduce(0, +), numbers.reduce(1, *))
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    return (numbers.reduce(0, +), numbers.reduce(1, *))
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    return (numbers.reduce(0, +), numbers.reduce(1, *))
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for number in numbers {
        result.append(max)
        max = max < number? number : max
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for number in numbers {
        result.append(max)
        max = max < number? number : max
    }
    return result
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers.first!
    for number in numbers {
        result.append(max)
        max = max < number? number : max
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers.first!
    for number in numbers {
        result.append(max)
        max = max < number? number : max
    }
    return result
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for number in numbers {
        result.append(max)
        if number > max {
            max = number
        }
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for number in numbers {
        result.append(max)
        if number > max {
            max = number
        }
    }
    return result
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for number in numbers {
        result.append(max)
        max = max < number? number : max
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for number in numbers {
        result.append(max)
        max = max < number? number : max
    }
    return result
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = 0
    for number in numbers {
        max = max < number? number : max
        result.append(max)
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = 0
    for number in numbers {
        max = max < number? number : max
        result.append(max)
    }
    return result
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for number in numbers {
        result.append(max)
        if number > max {
            max = number
        }
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for number in numbers {
        result.append(max)
        if number > max {
            max = number
        }
    }
    return result
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for number in numbers {
        result.append(max)
        if number > max {
            max = number
        }
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for number in numbers {
        result.append(max)
        if number > max {
            max = number
        }
    }
    return result
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for number in numbers {
        result.append(max)
        if number > max {
            max = number
        }
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for number in numbers {
        result.append(max)
        if number > max {
            max = number
        }
    }
    return result
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for number in numbers {
        result.append(max)
        if number > max {
            max = number
        }
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for number in numbers {
        result.append(max)
        if number > max {
            max = number
        }
    }
    return result
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result: [Int] = []
    var max = numbers[0]
    for number in numbers {
        result.append(max)
        if number > max {
            max = number
        }
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result: [Int] = []
    var max = numbers[0]
    for number in numbers {
        result.append(max)
        if number > max {
            max = number
        }
    }
    return result
}
```

func makePalindrome(string: String) -> String {
    let reversed = String(string.characters.reversed())
    let reversedPrefix = string.characters.prefix(while: { $0 == reversed.characters.first! })
    let reversedSuffix = reversed.characters.suffix(while: { $0 == string.characters.first! })
    return String(reversedPrefix) + string + String(reversedSuffix)
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    let reversed = String(string.characters.reversed())
    let reversedPrefix = string.characters.prefix(while: { $0 == reversed.characters.first! })
    let reversedSuffix = reversed.characters.suffix(while: { $0 == string.characters.first! })
    return String(reversedPrefix) + string + String(reversedSuffix)
}
```

func makePalindrome(string: String) -> String {
    let reversed = String(string.characters.reversed())
    let reversedPrefix = string.characters.dropLast(reversed.characters.count)
    return String(reversedPrefix) + reversed
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    let reversed = String(string.characters.reversed())
    let reversedPrefix = string.characters.dropLast(reversed.characters.count)
    return String(reversedPrefix) + reversed
}
```

func makePalindrome(string: String) -> String {
    let reversed = String(string.reversed())
    let longestPalindrome = longestPalindrome(string: string + reversed)
    let prefix = string[string.startIndex..<longestPalindrome.startIndex]
    return String(prefix.reversed()) + string + String(reversed[reversed.startIndex..<longestPalindrome.endIndex])
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    let reversed = String(string.reversed())
    let longestPalindrome = longestPalindrome(string: string + reversed)
    let prefix = string[string.startIndex..<longestPalindrome.startIndex]
    return String(prefix.reversed()) + string + String(reversed[reversed.startIndex..<longestPalindrome.endIndex])
}
```

func makePalindrome(string: String) -> String {
    let reversed = String(string.characters.reversed())
    let reversedPrefix = string.characters.dropLast(reversed.characters.count)
    let reversedPrefixString = String(reversedPrefix)
    return reversedPrefixString + reversed
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    let reversed = String(string.characters.reversed())
    let reversedPrefix = string.characters.dropLast(reversed.characters.count)
    let reversedPrefixString = String(reversedPrefix)
    return reversedPrefixString + reversed
}
```

func makePalindrome(string: String) -> String {
    let reversed = String(string.reversed())
    let reversedPrefix = reversed.prefix(string.count)
    let reversedSuffix = reversed.suffix(string.count)
    let reversedPrefixString = String(reversedPrefix)
    let reversedSuffixString = String(reversedSuffix)
    let reversedPrefixStringReversed = String(reversedPrefixString.reversed())
    return reversedPrefixStringReversed + reversedSuffixString
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    let reversed = String(string.reversed())
    let reversedPrefix = reversed.prefix(string.count)
    let reversedSuffix = reversed.suffix(string.count)
    let reversedPrefixString = String(reversedPrefix)
    let reversedSuffixString = String(reversedSuffix)
    let reversedPrefixStringReversed = String(reversedPrefixString.reversed())
    return reversedPrefixStringReversed + reversedSuffixString
}
```

func makePalindrome(string: String) -> String {
    let reversed = String(string.reversed())
    let reversedPrefix = reversed.prefix(string.count)
    return string + String(reversedPrefix)
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    let reversed = String(string.reversed())
    let reversedPrefix = reversed.prefix(string.count)
    return string + String(reversedPrefix)
}
```

func makePalindrome(string: String) -> String {
    var s = string
    var i = s.index(before: s.endIndex)
    var j = s.index(before: i)
    while i > s.startIndex && j > s.startIndex {
        if s[i] == s[j] {
            i = s.index(before: i)
            j = s.index(before: j)
        } else {
            break
        }
    }
    let prefix = String(s[s.startIndex..<i])
    return prefix + String(prefix.reversed()) + s
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    var s = string
    var i = s.index(before: s.endIndex)
    var j = s.index(before: i)
    while i > s.startIndex && j > s.startIndex {
        if s[i] == s[j] {
            i = s.index(before: i)
            j = s.index(before: j)
        } else {
            break
        }
    }
    let prefix = String(s[s.startIndex..<i])
    return prefix + String(prefix.reversed()) + s
}
```

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    let reversed = String(string.reversed())
    let reversedPrefix = reversed.prefix(string.count)
    let reversedSuffix = reversed.suffix(string.count)
    let reversedPrefixString = String(reversedPrefix)
    let reversedSuffixString = String(reversedSuffix)
    let reversedPrefixStringReversed = String(reversedPrefixString.reversed())
    let reversedSuffixStringReversed = String(reversedSuffixString.reversed())
    let reversedPrefixStringReversedWithSuffix = reversedPrefixStringReversed + reversedSuffixString
    let reversedPrefixStringReversedWithSuffixReversed = String(reversedPrefixStringReversedWithSuffix.reversed())
    let reversedPrefixStringReversedWithSuffixReversedWithSuffix = reversedPrefixStringReversedWithSuffixReversed + reversedSuffixString
    let reversedPrefixStringReversedWithSuffixReversedWithSuffixReversed = String(reversedPrefixStringReversedWithSuffixReversed.reversed())
    let reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffix = reversedPrefixStringReversedWithSuffixReversedWithSuffix + reversedSuffixString
    let reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversed = String(reversedPrefixStringReversedWithSuffixReversedWithSuffix.reversed())
    let reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffix = reversedPrefixStringReversedWithSuffixReversedWithSuffixReversed + reversedSuffixString
    let reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversed = String(reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffix.reversed())
    let reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffix = reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversed + reversedSuffixString
    let reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversed = String(reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffix.reversed())
    let reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffix = reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversed + reversedSuffixString
    let reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversed = String(reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffix.reversed())
    let reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffix = reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversed + reversedSuffixString
    let reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversed = String(reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffix.reversed())
    let reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffix = reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversed + reversedSuffixString
    let reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversed = String(reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffix.reversed())
    let reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffix = reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversed + reversedSuffixString
    let reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversed = String(reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffix.reversed())
    let reversedPrefixStringReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversedWithSuffixReversed

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    let reversed = String(string.characters.reversed())
    let reversedPrefix = reversed.substring(to: string.endIndex)
    let reversedSuffix = reversed.substring(from: string.startIndex)
    let reversedPrefixIndex = string.characters.index(string.startIndex, offsetBy: reversedPrefix.characters.count)
    let reversedSuffixIndex = string.characters.index(string.endIndex, offsetBy: -reversedSuffix.characters.count)
    let reversedPrefixAndSuffix = string.substring(with: Range(uncheckedBounds: (lower: string.startIndex, upper: reversedSuffixIndex)))
    let reversedPrefixAndSuffixIndex = string.characters.index(string.startIndex, offsetBy: reversedPrefixAndSuffix.characters.count)
    let reversedPrefixAndSuffixAndReversedSuffix = reversedPrefixAndSuffix + reversedSuffix
    let reversedPrefixAndSuffixAndReversedSuffixIndex = string.characters.index(string.startIndex, offsetBy: reversedPrefixAndSuffixAndReversedSuffix.characters.count)
    let reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefix = reversedPrefixAndSuffixAndReversedSuffix + reversedPrefix
    let reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixIndex = string.characters.index(string.startIndex, offsetBy: reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefix.characters.count)
    let reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedSuffix = reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefix + reversedSuffix
    let reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedSuffixIndex = string.characters.index(string.startIndex, offsetBy: reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedSuffix.characters.count)
    let reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefix = reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedSuffix + reversedPrefix
    let reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefixIndex = string.characters.index(string.startIndex, offsetBy: reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedPrefix.characters.count)
    let reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefixAndReversedSuffix = reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedPrefix + reversedSuffix
    let reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefixAndReversedSuffixIndex = string.characters.index(string.startIndex, offsetBy: reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedPrefixAndReversedSuffix.characters.count)
    let reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefix = reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedPrefixAndReversedSuffix + reversedPrefix
    let reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefixIndex = string.characters.index(string.startIndex, offsetBy: reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedPrefixAndReversedSuffixAndReversedPrefix.characters.count)
    let reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefixAndReversedSuffix = reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedPrefixAndReversedSuffixAndReversedPrefix + reversedSuffix
    let reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefixAndReversedSuffixIndex = string.characters.index(string.startIndex, offsetBy: reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedPrefixAndReversedSuffixAndReversedPrefixAndReversedSuffix.characters.count)
    let reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefix = reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedPrefixAndReversedSuffixAndReversedPrefixAndReversedSuffix + reversedPrefix
    let reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefixIndex = string.characters.index(string.startIndex, offsetBy: reversedPrefixAndSuffixAndReversedSuffixAndReversedPrefixAndReversedPrefixAndReversedSuffixAndReversedPrefixAndReversedSuffixAndReversedPrefix.characters.count)
    let reversedPrefixAndSuffix

func makePalindrome(string: String) -> String {
    let reversed = String(string.reversed())
    let reversedPrefix = reversed.prefix(string.count)
    let reversedSuffix = reversed.suffix(string.count)
    let reversedPrefixString = String(reversedPrefix)
    let reversedSuffixString = String(reversedSuffix)
    let reversedPrefixStringReversed = String(reversedPrefixString.reversed())
    return reversedPrefixStringReversed + reversedSuffixString
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    let reversed = String(string.reversed())
    let reversedPrefix = reversed.prefix(string.count)
    let reversedSuffix = reversed.suffix(string.count)
    let reversedPrefixString = String(reversedPrefix)
    let reversedSuffixString = String(reversedSuffix)
    let reversedPrefixStringReversed = String(reversedPrefixString.reversed())
    return reversedPrefixStringReversed + reversedSuffixString
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for (i, char) in a.enumerated() {
        let charB = b.index(b.startIndex, offsetBy: i)
        let charB = b[charB]
        if char == charB {
            result += "0"
        } else {
            result += "1"
        }
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for (i, char) in a.enumerated() {
        let charB = b.index(b.startIndex, offsetBy: i)
        let charB = b[charB]
        if char == charB {
            result += "0"
        } else {
            result += "1"
        }
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for (index, char) in a.enumerated() {
        let charB = b.index(b.startIndex, offsetBy: index)
        if char == charB {
            result.append("0")
        } else {
            result.append("1")
        }
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for (index, char) in a.enumerated() {
        let charB = b.index(b.startIndex, offsetBy: index)
        if char == charB {
            result.append("0")
        } else {
            result.append("1")
        }
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<a.count {
        let charA = a[a.index(a.startIndex, offsetBy: i)]
        let charB = b[b.index(b.startIndex, offsetBy: i)]
        let xor = (charA == "1"? 1 : 0) ^ (charB == "1"? 1 : 0)
        result += String(xor)
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<a.count {
        let charA = a[a.index(a.startIndex, offsetBy: i)]
        let charB = b[b.index(b.startIndex, offsetBy: i)]
        let xor = (charA == "1"? 1 : 0) ^ (charB == "1"? 1 : 0)
        result += String(xor)
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for (i, char) in a.enumerated() {
        let char2 = b.index(b.startIndex, offsetBy: i)
        let char2 = b[char2]
        if char == char2 {
            result += "0"
        } else {
            result += "1"
        }
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for (i, char) in a.enumerated() {
        let char2 = b.index(b.startIndex, offsetBy: i)
        let char2 = b[char2]
        if char == char2 {
            result += "0"
        } else {
            result += "1"
        }
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<a.count {
        let charA = a[a.index(a.startIndex, offsetBy: i)]
        let charB = b[b.index(b.startIndex, offsetBy: i)]
        if charA == charB {
            result.append("0")
        } else {
            result.append("1")
        }
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<a.count {
        let charA = a[a.index(a.startIndex, offsetBy: i)]
        let charB = b[b.index(b.startIndex, offsetBy: i)]
        if charA == charB {
            result.append("0")
        } else {
            result.append("1")
        }
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<a.count {
        if a[a.index(a.startIndex, offsetBy: i)] == b[b.index(b.startIndex, offsetBy: i)] {
            result += "0"
        } else {
            result += "1"
        }
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<a.count {
        if a[a.index(a.startIndex, offsetBy: i)] == b[b.index(b.startIndex, offsetBy: i)] {
            result += "0"
        } else {
            result += "1"
        }
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<a.count {
        let charA = a[a.index(a.startIndex, offsetBy: i)]
        let charB = b[b.index(b.startIndex, offsetBy: i)]
        if charA == charB {
            result.append("0")
        } else {
            result.append("1")
        }
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<a.count {
        let charA = a[a.index(a.startIndex, offsetBy: i)]
        let charB = b[b.index(b.startIndex, offsetBy: i)]
        if charA == charB {
            result.append("0")
        } else {
            result.append("1")
        }
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<a.count {
        let charA = a[a.index(a.startIndex, offsetBy: i)]
        let charB = b[b.index(b.startIndex, offsetBy: i)]
        if charA == charB {
            result.append("0")
        } else {
            result.append("1")
        }
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<a.count {
        let charA = a[a.index(a.startIndex, offsetBy: i)]
        let charB = b[b.index(b.startIndex, offsetBy: i)]
        if charA == charB {
            result.append("0")
        } else {
            result.append("1")
        }
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<a.count {
        let aChar = a[a.index(a.startIndex, offsetBy: i)]
        let bChar = b[b.index(b.startIndex, offsetBy: i)]
        if aChar == bChar {
            result.append("0")
        } else {
            result.append("1")
        }
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<a.count {
        let aChar = a[a.index(a.startIndex, offsetBy: i)]
        let bChar = b[b.index(b.startIndex, offsetBy: i)]
        if aChar == bChar {
            result.append("0")
        } else {
            result.append("1")
        }
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<a.count {
        if a[a.index(a.startIndex, offsetBy: i)] == b[b.index(b.startIndex, offsetBy: i)] {
            result.append("0")
        } else {
            result.append("1")
        }
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<a.count {
        if a[a.index(a.startIndex, offsetBy: i)] == b[b.index(b.startIndex, offsetBy: i)] {
            result.append("0")
        } else {
            result.append("1")
        }
    }
    return result
}
```

func longest(strings: [String]) -> String? {
    // Your code here
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    // Your code here
}
```

func longest(strings: [String]) -> String? {
    var longest = strings.first
    for string in strings {
        if string.count > longest?.count?? 0 {
            longest = string
        }
    }
    return longest
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    var longest = strings.first
    for string in strings {
        if string.count > longest?.count?? 0 {
            longest = string
        }
    }
    return longest
}
```

func longest(strings: [String]) -> String? {
    return nil
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    return nil
}
```

func longest(strings: [String]) -> String? {
    var longest = strings.first
    for string in strings {
        if string.count > longest?.count?? 0 {
            longest = string
        }
    }
    return longest
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    var longest = strings.first
    for string in strings {
        if string.count > longest?.count?? 0 {
            longest = string
        }
    }
    return longest
}
```

func longest(strings: [String]) -> String? {
    return nil
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    return nil
}
```

func longest(strings: [String]) -> String? {
    return nil
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    return nil
}
```

func longest(strings: [String]) -> String? {
    return nil
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    return nil
}
```

func longest(strings: [String]) -> String? {
    return nil
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    return nil
}
```

func longest(strings: [String]) -> String? {
    return nil
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    return nil
}
```

func longest(strings: [String]) -> String? {
    return nil
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    return nil
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 || b == 0 {
        return 0
    }
    if a == b {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: a, b: b - a)
    }
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 || b == 0 {
        return 0
    }
    if a == b {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: a, b: b - a)
    }
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 || b == 0 {
        return 0
    }
    if a == b {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: a, b: b - a)
    }
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 || b == 0 {
        return 0
    }
    if a == b {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: a, b: b - a)
    }
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    } else if b == 0 {
        return a
    } else {
        return greatestCommonDivisor(a: a % b, b: b % a)
    }
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    } else if b == 0 {
        return a
    } else {
        return greatestCommonDivisor(a: a % b, b: b % a)
    }
}
```

func allPrefixes(string: String) -> [String] {
    var result: [String] = []
    for i in 0...string.count {
        result.append(string.prefix(i))
    }
    return result
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result: [String] = []
    for i in 0...string.count {
        result.append(string.prefix(i))
    }
    return result
}
```

func allPrefixes(string: String) -> [String] {
    var result: [String] = []
    for i in 0...string.count {
        result.append(string.prefix(i))
    }
    return result
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result: [String] = []
    for i in 0...string.count {
        result.append(string.prefix(i))
    }
    return result
}
```

func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0...string.count {
        result.append(string.prefix(i))
    }
    return result
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0...string.count {
        result.append(string.prefix(i))
    }
    return result
}
```

func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0...string.count {
        result.append(string.prefix(i))
    }
    return result
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0...string.count {
        result.append(string.prefix(i))
    }
    return result
}
```

func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0...string.count {
        result.append(string.prefix(i))
    }
    return result
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0...string.count {
        result.append(string.prefix(i))
    }
    return result
}
```

func allPrefixes(string: String) -> [String] {
    var result: [String] = []
    for i in 0...string.count {
        result.append(string.prefix(i))
    }
    return result
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result: [String] = []
    for i in 0...string.count {
        result.append(string.prefix(i))
    }
    return result
}
```

func allPrefixes(string: String) -> [String] {
    var result: [String] = []
    for i in 0...string.count {
        result.append(String(string.prefix(i)))
    }
    return result
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result: [String] = []
    for i in 0...string.count {
        result.append(String(string.prefix(i)))
    }
    return result
}
```

func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0...string.count {
        result.append(string.prefix(i))
    }
    return result
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0...string.count {
        result.append(string.prefix(i))
    }
    return result
}
```

func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0...string.count {
        result.append(string.prefix(i))
    }
    return result
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0...string.count {
        result.append(string.prefix(i))
    }
    return result
}
```

func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0...string.count {
        result.append(String(string.prefix(i)))
    }
    return result
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0...string.count {
        result.append(String(string.prefix(i)))
    }
    return result
}
```

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}
```

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}
```

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}
```

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}
```

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}
```

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}
```

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}
```

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}
```

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}
```

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}
```

func countDistinctCharacters(string: String) -> Int {
    return Set(string).count
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    return Set(string).count
}
```

func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var set = Set<Character>()
    for char in string {
        if!set.contains(char) {
            set.insert(char)
            count += 1
        }
    }
    return count
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var set = Set<Character>()
    for char in string {
        if!set.contains(char) {
            set.insert(char)
            count += 1
        }
    }
    return count
}
```

func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var set = Set<Character>()
    for char in string {
        if!set.contains(char) {
            count += 1
            set.insert(char)
        }
    }
    return count
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var set = Set<Character>()
    for char in string {
        if!set.contains(char) {
            count += 1
            set.insert(char)
        }
    }
    return count
}
```

func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var characters = Set<Character>()
    for character in string {
        if!characters.contains(character) {
            count += 1
            characters.insert(character)
        }
    }
    return count
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var characters = Set<Character>()
    for character in string {
        if!characters.contains(character) {
            count += 1
            characters.insert(character)
        }
    }
    return count
}
```

func countDistinctCharacters(string: String) -> Int {
    // TODO: Write your code here
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    // TODO: Write your code here
}
```

func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var characters = [Character]()
    for char in string {
        if!characters.contains(char) {
            count += 1
            characters.append(char)
        }
    }
    return count
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var characters = [Character]()
    for char in string {
        if!characters.contains(char) {
            count += 1
            characters.append(char)
        }
    }
    return count
}
```

func countDistinctCharacters(string: String) -> Int {
    var distinctCharacters = Set<Character>()
    for character in string {
        distinctCharacters.insert(character)
    }
    return distinctCharacters.count
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var distinctCharacters = Set<Character>()
    for character in string {
        distinctCharacters.insert(character)
    }
    return distinctCharacters.count
}
```

func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var set = Set<Character>()
    for char in string {
        if set.contains(char) {
            continue
        }
        set.insert(char)
        count += 1
    }
    return count
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var set = Set<Character>()
    for char in string {
        if set.contains(char) {
            continue
        }
        set.insert(char)
        count += 1
    }
    return count
}
```

func countDistinctCharacters(string: String) -> Int {
    var distinctCharacters = Set<Character>()
    for character in string {
        distinctCharacters.insert(character)
    }
    return distinctCharacters.count
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var distinctCharacters = Set<Character>()
    for character in string {
        distinctCharacters.insert(character)
    }
    return distinctCharacters.count
}
```

func countDistinctCharacters(string: String) -> Int {
    var distinctCharacters = Set<Character>()
    for character in string {
        distinctCharacters.insert(character)
    }
    return distinctCharacters.count
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var distinctCharacters = Set<Character>()
    for character in string {
        distinctCharacters.insert(character)
    }
    return distinctCharacters.count
}
```

func parseMusic(musicString: String) -> [Int] {
    var result: [Int] = []
    var currentBeat = 0
    for char in musicString {
        switch char {
        case "o":
            currentBeat += 4
        case "o|":
            currentBeat += 2
        case ".|":
            currentBeat += 1
        default:
            break
        }
        result.append(currentBeat)
    }
    return result
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o|.| o| o|.|.|.|.| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    var result: [Int] = []
    var currentBeat = 0
    for char in musicString {
        switch char {
        case "o":
            currentBeat += 4
        case "o|":
            currentBeat += 2
        case ".|":
            currentBeat += 1
        default:
            break
        }
        result.append(currentBeat)
    }
    return result
}
```

func parseMusic(musicString: String) -> [Int] {
    var result = [Int]()
    var currentNote = 0
    for char in musicString {
        switch char {
        case "o":
            currentNote += 4
        case "o|":
            currentNote += 2
        case ".|":
            currentNote += 1
        default:
            break
        }
        result.append(currentNote)
    }
    return result
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o|.| o| o|.|.|.|.| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    var result = [Int]()
    var currentNote = 0
    for char in musicString {
        switch char {
        case "o":
            currentNote += 4
        case "o|":
            currentNote += 2
        case ".|":
            currentNote += 1
        default:
            break
        }
        result.append(currentNote)
    }
    return result
}
```

func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { $0 }
    var result = [Int]()
    var currentBeat = 0
    for note in notes {
        switch note {
        case "o":
            currentBeat += 4
        case "o|":
            currentBeat += 2
        case ".|":
            currentBeat += 1
        default:
            break
        }
        result.append(currentBeat)
    }
    return result
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o|.| o| o|.|.|.|.| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { $0 }
    var result = [Int]()
    var currentBeat = 0
    for note in notes {
        switch note {
        case "o":
            currentBeat += 4
        case "o|":
            currentBeat += 2
        case ".|":
            currentBeat += 1
        default:
            break
        }
        result.append(currentBeat)
    }
    return result
}
```

func parseMusic(musicString: String) -> [Int] {
    // your code here
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o|.| o| o|.|.|.|.| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    // your code here
}
```

func parseMusic(musicString: String) -> [Int] {
    var result = [Int]()
    let notes = musicString.split(separator: " ")
    for note in notes {
        switch note {
        case "o":
            result.append(4)
        case "o|":
            result.append(2)
        case ".|":
            result.append(1)
        default:
            break
        }
    }
    return result
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o|.| o| o|.|.|.|.| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    var result = [Int]()
    let notes = musicString.split(separator: " ")
    for note in notes {
        switch note {
        case "o":
            result.append(4)
        case "o|":
            result.append(2)
        case ".|":
            result.append(1)
        default:
            break
        }
    }
    return result
}
```

func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.components(separatedBy: " ")
    var result = [Int]()
    for note in notes {
        switch note {
        case "o":
            result.append(4)
        case "o|":
            result.append(2)
        case ".|":
            result.append(1)
        default:
            break
        }
    }
    return result
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o|.| o| o|.|.|.|.| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.components(separatedBy: " ")
    var result = [Int]()
    for note in notes {
        switch note {
        case "o":
            result.append(4)
        case "o|":
            result.append(2)
        case ".|":
            result.append(1)
        default:
            break
        }
    }
    return result
}
```

func parseMusic(musicString: String) -> [Int] {
    var result = [Int]()
    let notes = musicString.split(separator: " ")
    for note in notes {
        switch note {
        case "o":
            result.append(4)
        case "o|":
            result.append(2)
        case ".|":
            result.append(1)
        default:
            break
        }
    }
    return result
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o|.| o| o|.|.|.|.| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    var result = [Int]()
    let notes = musicString.split(separator: " ")
    for note in notes {
        switch note {
        case "o":
            result.append(4)
        case "o|":
            result.append(2)
        case ".|":
            result.append(1)
        default:
            break
        }
    }
    return result
}
```

func parseMusic(musicString: String) -> [Int] {
    var result = [Int]()
    var note = ""
    for char in musicString {
        if char == "|" {
            result.append(note.count)
            note = ""
        } else {
            note.append(char)
        }
    }
    return result
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o|.| o| o|.|.|.|.| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    var result = [Int]()
    var note = ""
    for char in musicString {
        if char == "|" {
            result.append(note.count)
            note = ""
        } else {
            note.append(char)
        }
    }
    return result
}
```

func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { $0 }
    var result: [Int] = []
    var currentNote = 0
    for note in notes {
        switch note {
        case "o":
            currentNote += 4
        case "o|":
            currentNote += 2
        case ".|":
            currentNote += 1
        default:
            break
        }
        result.append(currentNote)
    }
    return result
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o|.| o| o|.|.|.|.| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { $0 }
    var result: [Int] = []
    var currentNote = 0
    for note in notes {
        switch note {
        case "o":
            currentNote += 4
        case "o|":
            currentNote += 2
        case ".|":
            currentNote += 1
        default:
            break
        }
        result.append(currentNote)
    }
    return result
}
```

func parseMusic(musicString: String) -> [Int] {
    // Write your code here
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o|.| o| o|.|.|.|.| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    // Write your code here
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while let range = string.range(of: substring, options: [], range: index..<string.endIndex, locale: nil) {
        count += 1
        index = range.upperBound
    }
    return count
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while let range = string.range(of: substring, options: [], range: index..<string.endIndex, locale: nil) {
        count += 1
        index = range.upperBound
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while index < string.endIndex {
        if string[index..<string.index(index, offsetBy: substring.count)] == substring {
            count += 1
        }
        index = string.index(index, offsetBy: 1)
    }
    return count
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while index < string.endIndex {
        if string[index..<string.index(index, offsetBy: substring.count)] == substring {
            count += 1
        }
        index = string.index(index, offsetBy: 1)
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var startIndex = string.startIndex
    while let range = string.range(of: substring, options: [], range: startIndex..<string.endIndex, locale: nil) {
        count += 1
        startIndex = range.upperBound
    }
    return count
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var startIndex = string.startIndex
    while let range = string.range(of: substring, options: [], range: startIndex..<string.endIndex, locale: nil) {
        count += 1
        startIndex = range.upperBound
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while let range = string.range(of: substring, options: [], range: index..<string.endIndex, locale: nil) {
        count += 1
        index = range.upperBound
    }
    return count
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while let range = string.range(of: substring, options: [], range: index..<string.endIndex, locale: nil) {
        count += 1
        index = range.upperBound
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while let range = string.range(of: substring, options: [], range: index..<string.endIndex, locale: nil) {
        count += 1
        index = range.upperBound
    }
    return count
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while let range = string.range(of: substring, options: [], range: index..<string.endIndex, locale: nil) {
        count += 1
        index = range.upperBound
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var startIndex = string.startIndex
    while let range = string.range(of: substring, options: [], range: startIndex..<string.endIndex, locale: nil) {
        count += 1
        startIndex = range.upperBound
    }
    return count
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var startIndex = string.startIndex
    while let range = string.range(of: substring, options: [], range: startIndex..<string.endIndex, locale: nil) {
        count += 1
        startIndex = range.upperBound
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while index < string.endIndex {
        if string[index...] == substring {
            count += 1
            index = string.index(index, offsetBy: substring.count)
        } else {
            index = string.index(index, offsetBy: 1)
        }
    }
    return count
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while index < string.endIndex {
        if string[index...] == substring {
            count += 1
            index = string.index(index, offsetBy: substring.count)
        } else {
            index = string.index(index, offsetBy: 1)
        }
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while let range = string.range(of: substring, options: [], range: index..<string.endIndex, locale: nil) {
        count += 1
        index = range.upperBound
    }
    return count
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while let range = string.range(of: substring, options: [], range: index..<string.endIndex, locale: nil) {
        count += 1
        index = range.upperBound
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while index < string.endIndex {
        if string[index..<string.index(index, offsetBy: substring.count)] == substring {
            count += 1
        }
        index = string.index(index, offsetBy: 1)
    }
    return count
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while index < string.endIndex {
        if string[index..<string.index(index, offsetBy: substring.count)] == substring {
            count += 1
        }
        index = string.index(index, offsetBy: 1)
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while let range = string.range(of: substring, options: [], range: index..<string.endIndex, locale: nil) {
        count += 1
        index = range.upperBound
    }
    return count
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while let range = string.range(of: substring, options: [], range: index..<string.endIndex, locale: nil) {
        count += 1
        index = range.upperBound
    }
    return count
}
```

func sortNumbers(numbers: String) -> String {
    let numbers = numbers.components(separatedBy: " ")
    let sorted = numbers.sorted()
    return sorted.joined(separator: " ")
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five','six','seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let numbers = numbers.components(separatedBy: " ")
    let sorted = numbers.sorted()
    return sorted.joined(separator: " ")
}
```

func sortNumbers(numbers: String) -> String {
    let numberArray = numbers.components(separatedBy: " ")
    let sortedNumbers = numberArray.sorted()
    return sortedNumbers.joined(separator: " ")
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five','six','seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let numberArray = numbers.components(separatedBy: " ")
    let sortedNumbers = numberArray.sorted()
    return sortedNumbers.joined(separator: " ")
}
```

func sortNumbers(numbers: String) -> String {
    let numbers = numbers.components(separatedBy: " ")
    let sortedNumbers = numbers.sorted()
    return sortedNumbers.joined(separator: " ")
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five','six','seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let numbers = numbers.components(separatedBy: " ")
    let sortedNumbers = numbers.sorted()
    return sortedNumbers.joined(separator: " ")
}
```

func sortNumbers(numbers: String) -> String {
    let numberArray = numbers.components(separatedBy: " ")
    let sortedArray = numberArray.sorted()
    return sortedArray.joined(separator: " ")
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five','six','seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let numberArray = numbers.components(separatedBy: " ")
    let sortedArray = numberArray.sorted()
    return sortedArray.joined(separator: " ")
}
```

func sortNumbers(numbers: String) -> String {
    let numbers = numbers.components(separatedBy: " ")
    let sortedNumbers = numbers.sorted()
    return sortedNumbers.joined(separator: " ")
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five','six','seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let numbers = numbers.components(separatedBy: " ")
    let sortedNumbers = numbers.sorted()
    return sortedNumbers.joined(separator: " ")
}
```

func sortNumbers(numbers: String) -> String {
    let numbers = numbers.split(separator: " ").map { String($0) }
    let sortedNumbers = numbers.sorted()
    return sortedNumbers.joined(separator: " ")
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five','six','seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let numbers = numbers.split(separator: " ").map { String($0) }
    let sortedNumbers = numbers.sorted()
    return sortedNumbers.joined(separator: " ")
}
```

func sortNumbers(numbers: String) -> String {
    let numbers = numbers.split(separator: " ")
    let sortedNumbers = numbers.sorted()
    return sortedNumbers.joined(separator: " ")
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five','six','seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let numbers = numbers.split(separator: " ")
    let sortedNumbers = numbers.sorted()
    return sortedNumbers.joined(separator: " ")
}
```

func sortNumbers(numbers: String) -> String {
    let numbers = numbers.components(separatedBy: " ")
    let sortedNumbers = numbers.sorted()
    return sortedNumbers.joined(separator: " ")
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five','six','seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let numbers = numbers.components(separatedBy: " ")
    let sortedNumbers = numbers.sorted()
    return sortedNumbers.joined(separator: " ")
}
```

func sortNumbers(numbers: String) -> String {
    let numbers = numbers.components(separatedBy: " ")
    let sortedNumbers = numbers.sorted()
    return sortedNumbers.joined(separator: " ")
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five','six','seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let numbers = numbers.components(separatedBy: " ")
    let sortedNumbers = numbers.sorted()
    return sortedNumbers.joined(separator: " ")
}
```

func sortNumbers(numbers: String) -> String {
    let numberArray = numbers.components(separatedBy: " ")
    let sortedArray = numberArray.sorted()
    return sortedArray.joined(separator: " ")
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five','six','seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let numberArray = numbers.components(separatedBy: " ")
    let sortedArray = numberArray.sorted()
    return sortedArray.joined(separator: " ")
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    // TODO: Implement this function
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    // TODO: Implement this function
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    // Your code here
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    // Your code here
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    // TODO: Implement this function
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    // TODO: Implement this function
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    // TODO: Write your code here
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    // TODO: Write your code here
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    var closest = (numbers[0], numbers[1])
    for i in 1..<numbers.count {
        let current = (numbers[i-1], numbers[i])
        if abs(current.0 - current.1) < abs(closest.0 - closest.1) {
            closest = current
        }
    }
    return closest
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    var closest = (numbers[0], numbers[1])
    for i in 1..<numbers.count {
        let current = (numbers[i-1], numbers[i])
        if abs(current.0 - current.1) < abs(closest.0 - closest.1) {
            closest = current
        }
    }
    return closest
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    var closest = (numbers[0], numbers[1])
    for i in 1..<numbers.count {
        if abs(numbers[i] - closest.0) < abs(closest.1 - closest.0) {
            closest = (numbers[i], closest.0)
        }
    }
    return closest
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    var closest = (numbers[0], numbers[1])
    for i in 1..<numbers.count {
        if abs(numbers[i] - closest.0) < abs(closest.1 - closest.0) {
            closest = (numbers[i], closest.0)
        }
    }
    return closest
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    var closest = (numbers[0], numbers[1])
    for i in 0..<numbers.count - 1 {
        let current = (numbers[i], numbers[i + 1])
        let diff = abs(current.0 - current.1)
        let closestDiff = abs(closest.0 - closest.1)
        if diff < closestDiff {
            closest = current
        }
    }
    return closest
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    var closest = (numbers[0], numbers[1])
    for i in 0..<numbers.count - 1 {
        let current = (numbers[i], numbers[i + 1])
        let diff = abs(current.0 - current.1)
        let closestDiff = abs(closest.0 - closest.1)
        if diff < closestDiff {
            closest = current
        }
    }
    return closest
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    var closest = (numbers[0], numbers[1])
    var minDiff = abs(numbers[0] - numbers[1])
    for i in 0..<numbers.count-1 {
        for j in i+1..<numbers.count {
            let diff = abs(numbers[i] - numbers[j])
            if diff < minDiff {
                minDiff = diff
                closest = (numbers[i], numbers[j])
            }
        }
    }
    return closest
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    var closest = (numbers[0], numbers[1])
    var minDiff = abs(numbers[0] - numbers[1])
    for i in 0..<numbers.count-1 {
        for j in i+1..<numbers.count {
            let diff = abs(numbers[i] - numbers[j])
            if diff < minDiff {
                minDiff = diff
                closest = (numbers[i], numbers[j])
            }
        }
    }
    return closest
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    var closest = (numbers[0], numbers[1])
    for i in 1..<numbers.count {
        let current = (numbers[i-1], numbers[i])
        if abs(current.0 - current.1) < abs(closest.0 - closest.1) {
            closest = current
        }
    }
    return closest
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    var closest = (numbers[0], numbers[1])
    for i in 1..<numbers.count {
        let current = (numbers[i-1], numbers[i])
        if abs(current.0 - current.1) < abs(closest.0 - closest.1) {
            closest = current
        }
    }
    return closest
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    var closest = (numbers[0], numbers[1])
    for i in 1..<numbers.count {
        if abs(numbers[i] - closest.0) < abs(closest.1 - closest.0) {
            closest.0 = numbers[i]
        } else {
            closest.1 = numbers[i]
        }
    }
    return closest
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    var closest = (numbers[0], numbers[1])
    for i in 1..<numbers.count {
        if abs(numbers[i] - closest.0) < abs(closest.1 - closest.0) {
            closest.0 = numbers[i]
        } else {
            closest.1 = numbers[i]
        }
    }
    return closest
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    // TODO: implement this function
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    // TODO: implement this function
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    // TODO: implement this function
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    // TODO: implement this function
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    // TODO: implement this function
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    // TODO: implement this function
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    // TODO: Implement this function
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    // TODO: Implement this function
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { ($0 - min) / range }
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { ($0 - min) / range }
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    // TODO: implement this function
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    // TODO: implement this function
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    // TODO: implement this function
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    // TODO: implement this function
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { ($0 - min) / range }
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { ($0 - min) / range }
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    var min = numbers[0]
    var max = numbers[0]
    for number in numbers {
        if number < min {
            min = number
        }
        if number > max {
            max = number
        }
    }
    var result = [Double]()
    for number in numbers {
        result.append((number - min) / (max - min))
    }
    return result
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    var min = numbers[0]
    var max = numbers[0]
    for number in numbers {
        if number < min {
            min = number
        }
        if number > max {
            max = number
        }
    }
    var result = [Double]()
    for number in numbers {
        result.append((number - min) / (max - min))
    }
    return result
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    var min = numbers[0]
    var max = numbers[0]
    for number in numbers {
        if number < min {
            min = number
        }
        if number > max {
            max = number
        }
    }
    var result = [Double]()
    for number in numbers {
        result.append((number - min) / (max - min))
    }
    return result
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    var min = numbers[0]
    var max = numbers[0]
    for number in numbers {
        if number < min {
            min = number
        }
        if number > max {
            max = number
        }
    }
    var result = [Double]()
    for number in numbers {
        result.append((number - min) / (max - min))
    }
    return result
}
```

func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result = [Int]()
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result = [Int]()
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}
```

func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result: [Int] = []
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result: [Int] = []
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}
```

func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result: [Int] = []
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result: [Int] = []
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}
```

func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}
```

func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result = [Int]()
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result = [Int]()
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}
```

func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result: [Int] = []
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result: [Int] = []
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}
```

func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result: [Int] = []
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result: [Int] = []
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}
```

func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result = [Int]()
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result = [Int]()
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}
```

func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result = [Int]()
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result = [Int]()
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}
```

func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result: [Int] = []
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    var result: [Int] = []
    for value in values {
        if let intValue = value as? Int {
            result.append(intValue)
        }
    }
    return result
}
```

func strlen(string: String) -> Int {
    return string.count
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    return string.count
}
```

func strlen(string: String) -> Int {
    return string.count
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    return string.count
}
```

func strlen(string: String) -> Int {
    return string.count
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    return string.count
}
```

func strlen(string: String) -> Int {
    return string.count
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    return string.count
}
```

func strlen(string: String) -> Int {
    return string.count
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    return string.count
}
```

func strlen(string: String) -> Int {
    return string.count
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    return string.count
}
```

func strlen(string: String) -> Int {
    return string.count
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    return string.count
}
```

func strlen(string: String) -> Int {
    return string.count
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    return string.count
}
```

func strlen(string: String) -> Int {
    return string.count
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    return string.count
}
```

func strlen(string: String) -> Int {
    return string.count
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    return string.count
}
```

func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 1
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 1
}
```

func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 1 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 1
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 1 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 1
}
```

func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 0
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 0
}
```

func largestDivisor(n: Int) -> Int {
    var divisor = n - 1
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 1
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var divisor = n - 1
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 1
}
```

func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 1
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 1
}
```

func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 1
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 1
}
```

func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 1
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 1
}
```

func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 1
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 1
}
```

func largestDivisor(n: Int) -> Int {
    var divisor = n - 1
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return divisor
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var divisor = n - 1
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return divisor
}
```

func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 1 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 1
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 1 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 1
}
```

func factorize(n: Int) -> [Int] {
    var result = [Int]()
    var number = n
    var divisor = 2
    while number > 1 {
        if number % divisor == 0 {
            result.append(divisor)
            number /= divisor
        } else {
            divisor += 1
        }
    }
    return result
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var result = [Int]()
    var number = n
    var divisor = 2
    while number > 1 {
        if number % divisor == 0 {
            result.append(divisor)
            number /= divisor
        } else {
            divisor += 1
        }
    }
    return result
}
```

func factorize(n: Int) -> [Int] {
    var result: [Int] = []
    var num = n
    var i = 2
    while num > 1 {
        while num % i == 0 {
            result.append(i)
            num /= i
        }
        i += 1
    }
    return result
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var result: [Int] = []
    var num = n
    var i = 2
    while num > 1 {
        while num % i == 0 {
            result.append(i)
            num /= i
        }
        i += 1
    }
    return result
}
```

func factorize(n: Int) -> [Int] {
    var result: [Int] = []
    var num = n
    for i in 2...num {
        while num % i == 0 {
            result.append(i)
            num /= i
        }
    }
    return result
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var result: [Int] = []
    var num = n
    for i in 2...num {
        while num % i == 0 {
            result.append(i)
            num /= i
        }
    }
    return result
}
```

func factorize(n: Int) -> [Int] {
    var result = [Int]()
    var number = n
    var i = 2
    while number > 1 {
        while number % i == 0 {
            result.append(i)
            number /= i
        }
        i += 1
    }
    return result
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var result = [Int]()
    var number = n
    var i = 2
    while number > 1 {
        while number % i == 0 {
            result.append(i)
            number /= i
        }
        i += 1
    }
    return result
}
```

func factorize(n: Int) -> [Int] {
    var result = [Int]()
    var number = n
    var divisor = 2
    while number > 1 {
        while number % divisor == 0 {
            result.append(divisor)
            number /= divisor
        }
        divisor += 1
    }
    return result
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var result = [Int]()
    var number = n
    var divisor = 2
    while number > 1 {
        while number % divisor == 0 {
            result.append(divisor)
            number /= divisor
        }
        divisor += 1
    }
    return result
}
```

func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var number = n
    var divisor = 2
    while number > 1 {
        while number % divisor == 0 {
            factors.append(divisor)
            number /= divisor
        }
        divisor += 1
    }
    return factors
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var number = n
    var divisor = 2
    while number > 1 {
        while number % divisor == 0 {
            factors.append(divisor)
            number /= divisor
        }
        divisor += 1
    }
    return factors
}
```

func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var number = n
    var i = 2
    while number > 1 {
        while number % i == 0 {
            factors.append(i)
            number /= i
        }
        i += 1
    }
    return factors
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var number = n
    var i = 2
    while number > 1 {
        while number % i == 0 {
            factors.append(i)
            number /= i
        }
        i += 1
    }
    return factors
}
```

func factorize(n: Int) -> [Int] {
    var result = [Int]()
    var number = n
    var divisor = 2
    while number > 1 {
        if number % divisor == 0 {
            result.append(divisor)
            number /= divisor
        } else {
            divisor += 1
        }
    }
    return result
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var result = [Int]()
    var number = n
    var divisor = 2
    while number > 1 {
        if number % divisor == 0 {
            result.append(divisor)
            number /= divisor
        } else {
            divisor += 1
        }
    }
    return result
}
```

func factorize(n: Int) -> [Int] {
    var result = [Int]()
    var number = n
    var divisor = 2
    while number > 1 {
        if number % divisor == 0 {
            result.append(divisor)
            number /= divisor
        } else {
            divisor += 1
        }
    }
    return result
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var result = [Int]()
    var number = n
    var divisor = 2
    while number > 1 {
        if number % divisor == 0 {
            result.append(divisor)
            number /= divisor
        } else {
            divisor += 1
        }
    }
    return result
}
```

func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    var i = 2
    while n > 1 {
        while n % i == 0 {
            factors.append(i)
            n /= i
        }
        i += 1
    }
    return factors
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    var i = 2
    while n > 1 {
        while n % i == 0 {
            factors.append(i)
            n /= i
        }
        i += 1
    }
    return factors
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if!seen.contains(number) {
            result.append(number)
            seen.insert(number)
        }
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if!seen.contains(number) {
            result.append(number)
            seen.insert(number)
        }
    }
    return result
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if!result.contains(number) {
            result.append(number)
        }
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if!result.contains(number) {
            result.append(number)
        }
    }
    return result
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if!result.contains(number) {
            result.append(number)
        }
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if!result.contains(number) {
            result.append(number)
        }
    }
    return result
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if!result.contains(number) {
            result.append(number)
        }
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if!result.contains(number) {
            result.append(number)
        }
    }
    return result
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var set = Set<Int>()
    for number in numbers {
        if set.contains(number) {
            continue
        }
        result.append(number)
        set.insert(number)
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var set = Set<Int>()
    for number in numbers {
        if set.contains(number) {
            continue
        }
        result.append(number)
        set.insert(number)
    }
    return result
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if!seen.contains(number) {
            result.append(number)
            seen.insert(number)
        }
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if!seen.contains(number) {
            result.append(number)
            seen.insert(number)
        }
    }
    return result
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if!result.contains(number) {
            result.append(number)
        }
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if!result.contains(number) {
            result.append(number)
        }
    }
    return result
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if!seen.contains(number) {
            result.append(number)
            seen.insert(number)
        }
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if!seen.contains(number) {
            result.append(number)
            seen.insert(number)
        }
    }
    return result
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if!result.contains(number) {
            result.append(number)
        }
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if!result.contains(number) {
            result.append(number)
        }
    }
    return result
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if!seen.contains(number) {
            result.append(number)
            seen.insert(number)
        }
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if!seen.contains(number) {
            result.append(number)
            seen.insert(number)
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char.uppercased()
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char.uppercased()
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char.lowercased()
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char.lowercased()
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char.lowercased()
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char.lowercased()
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char.uppercased()
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char.uppercased()
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result.append(char.lowercased())
        } else {
            result.append(char.uppercased())
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result.append(char.lowercased())
        } else {
            result.append(char.uppercased())
        }
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}
```

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    var result: [String] = []
    for string in strings {
        if string.hasPrefix(prefix) {
            result.append(string)
        }
    }
    return result
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    var result: [String] = []
    for string in strings {
        if string.hasPrefix(prefix) {
            result.append(string)
        }
    }
    return result
}
```

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    var result: [String] = []
    for string in strings {
        if string.hasPrefix(prefix) {
            result.append(string)
        }
    }
    return result
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    var result: [String] = []
    for string in strings {
        if string.hasPrefix(prefix) {
            result.append(string)
        }
    }
    return result
}
```

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { (string) -> Bool in
        return string.hasPrefix(prefix)
    }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { (string) -> Bool in
        return string.hasPrefix(prefix)
    }
}
```

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    var result = [String]()
    for string in strings {
        if string.hasPrefix(prefix) {
            result.append(string)
        }
    }
    return result
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    var result = [String]()
    for string in strings {
        if string.hasPrefix(prefix) {
            result.append(string)
        }
    }
    return result
}
```

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    var result = [String]()
    for string in strings {
        if string.hasPrefix(prefix) {
            result.append(string)
        }
    }
    return result
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    var result = [String]()
    for string in strings {
        if string.hasPrefix(prefix) {
            result.append(string)
        }
    }
    return result
}
```

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    var filteredStrings = [String]()
    for string in strings {
        if string.hasPrefix(prefix) {
            filteredStrings.append(string)
        }
    }
    return filteredStrings
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    var filteredStrings = [String]()
    for string in strings {
        if string.hasPrefix(prefix) {
            filteredStrings.append(string)
        }
    }
    return filteredStrings
}
```

func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}
```

func isPrime(n: Int) -> Bool {
    guard n > 1 else { return false }
    guard n!= 2 else { return true }
    guard n % 2!= 0 else { return false }
    for i in stride(from: 3, through: Int(sqrt(Double(n))), by: 2) {
        if n % i == 0 {
            return false
        }
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    guard n > 1 else { return false }
    guard n!= 2 else { return true }
    guard n % 2!= 0 else { return false }
    for i in stride(from: 3, through: Int(sqrt(Double(n))), by: 2) {
        if n % i == 0 {
            return false
        }
    }
    return true
}
```

func isPrime(n: Int) -> Bool {
    guard n > 1 else { return false }
    guard n > 3 else { return true }
    guard n % 2!= 0 else { return false }
    guard n % 3!= 0 else { return false }
    var i = 5
    while i * i <= n {
        if n % i == 0 { return false }
        if n % (i + 2) == 0 { return false }
        i += 6
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    guard n > 1 else { return false }
    guard n > 3 else { return true }
    guard n % 2!= 0 else { return false }
    guard n % 3!= 0 else { return false }
    var i = 5
    while i * i <= n {
        if n % i == 0 { return false }
        if n % (i + 2) == 0 { return false }
        i += 6
    }
    return true
}
```

func isPrime(n: Int) -> Bool {
    if n <= 1 { return false }
    if n <= 3 { return true }
    if n % 2 == 0 { return false }
    if n % 3 == 0 { return false }
    var i = 5
    while i * i <= n {
        if n % i == 0 { return false }
        if n % (i + 2) == 0 { return false }
        i += 6
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n <= 1 { return false }
    if n <= 3 { return true }
    if n % 2 == 0 { return false }
    if n % 3 == 0 { return false }
    var i = 5
    while i * i <= n {
        if n % i == 0 { return false }
        if n % (i + 2) == 0 { return false }
        i += 6
    }
    return true
}
```

func isPrime(n: Int) -> Bool {
    if n <= 1 {
        return false
    }
    for i in 2...Int(sqrt(Double(n))) {
        if n % i == 0 {
            return false
        }
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n <= 1 {
        return false
    }
    for i in 2...Int(sqrt(Double(n))) {
        if n % i == 0 {
            return false
        }
    }
    return true
}
```

func isPrime(n: Int) -> Bool {
    guard n > 1 else { return false }
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    guard n > 1 else { return false }
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    return true
}
```

func isPrime(n: Int) -> Bool {
    if n <= 1 {
        return false
    }
    if n <= 3 {
        return true
    }
    if n % 2 == 0 || n % 3 == 0 {
        return false
    }
    var i = 5
    while i * i <= n {
        if n % i == 0 || n % (i + 2) == 0 {
            return false
        }
        i += 6
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n <= 1 {
        return false
    }
    if n <= 3 {
        return true
    }
    if n % 2 == 0 || n % 3 == 0 {
        return false
    }
    var i = 5
    while i * i <= n {
        if n % i == 0 || n % (i + 2) == 0 {
            return false
        }
        i += 6
    }
    return true
}
```

func isPrime(n: Int) -> Bool {
    guard n > 1 else { return false }
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    guard n > 1 else { return false }
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    return true
}
```

func isPrime(n: Int) -> Bool {
    guard n > 1 else { return false }
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    guard n > 1 else { return false }
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    return true
}
```

func isPrime(n: Int) -> Bool {
    if n <= 1 {
        return false
    }
    for i in 2...Int(sqrt(Double(n))) {
        if n % i == 0 {
            return false
        }
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n <= 1 {
        return false
    }
    for i in 2...Int(sqrt(Double(n))) {
        if n % i == 0 {
            return false
        }
    }
    return true
}
```

func isPrime(n: Int) -> Bool {
    if n <= 1 { return false }
    if n <= 3 { return true }
    if n % 2 == 0 || n % 3 == 0 { return false }
    var i = 5
    while i * i <= n {
        if n % i == 0 || n % (i + 2) == 0 {
            return false
        }
        i += 6
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n <= 1 { return false }
    if n <= 3 { return true }
    if n % 2 == 0 || n % 3 == 0 { return false }
    var i = 5
    while i * i <= n {
        if n % i == 0 || n % (i + 2) == 0 {
            return false
        }
        i += 6
    }
    return true
}
```

func sortThird(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l[i] = l[i].sorted()
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l[i] = l[i].sorted()
        }
    }
    return l
}
```

func sortThird(l: [Int]) -> [Int] {
    var lPrime = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            lPrime[i] = lPrime[i].sorted()
        }
    }
    return lPrime
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var lPrime = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            lPrime[i] = lPrime[i].sorted()
        }
    }
    return lPrime
}
```

func sortThird(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l[i] = l[i].sorted()
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l[i] = l[i].sorted()
        }
    }
    return l
}
```

func sortThird(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l.sort()
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l.sort()
        }
    }
    return l
}
```

func sortThird(l: [Int]) -> [Int] {
    var lPrime = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            lPrime[i] = l[i].sorted()
        }
    }
    return lPrime
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var lPrime = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            lPrime[i] = l[i].sorted()
        }
    }
    return lPrime
}
```

func sortThird(l: [Int]) -> [Int] {
    var lPrime = [Int]()
    for i in 0..<l.count {
        if i % 3!= 0 {
            lPrime.append(l[i])
        } else {
            lPrime.append(l[i].sorted())
        }
    }
    return lPrime
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var lPrime = [Int]()
    for i in 0..<l.count {
        if i % 3!= 0 {
            lPrime.append(l[i])
        } else {
            lPrime.append(l[i].sorted())
        }
    }
    return lPrime
}
```

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var lPrime = [Int]()
    for i in 0..<l.count {
        if i % 3 == 0 {
            lPrime.append(l[i])
        } else {
            lPrime.append(l[i])
            lPrime.sort()
        }
    }
    return lPrime
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var lPrime = [Int]()
    for i in 0..<l.count {
        if i % 3 == 0 {
            lPrime.append(l[i])
        } else {
            lPrime.append(l[i])
            lPrime.sort()
        }
    }
    return lPrime
}
```

func sortThird(l: [Int]) -> [Int] {
    var lPrime = l
    for i in 0..<lPrime.count {
        if i % 3 == 0 {
            lPrime[i] = lPrime[i].sorted()
        }
    }
    return lPrime
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var lPrime = l
    for i in 0..<lPrime.count {
        if i % 3 == 0 {
            lPrime[i] = lPrime[i].sorted()
        }
    }
    return lPrime
}
```

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var lPrime = [Int]()
    for i in 0..<l.count {
        if i % 3 == 0 {
            lPrime.append(l[i])
        } else {
            lPrime.append(l[i])
            lPrime.sort()
        }
    }
    return lPrime
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var lPrime = [Int]()
    for i in 0..<l.count {
        if i % 3 == 0 {
            lPrime.append(l[i])
        } else {
            lPrime.append(l[i])
            lPrime.sort()
        }
    }
    return lPrime
}
```

func sortThird(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l[i] = l[i].sorted()
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l[i] = l[i].sorted()
        }
    }
    return l
}
```

func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if!unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if!unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}
```

func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if!result.contains(i) {
            result.append(i)
        }
    }
    return result
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if!result.contains(i) {
            result.append(i)
        }
    }
    return result
}
```

func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if!unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if!unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}
```

func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if!unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if!unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}
```

func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if!unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if!unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}
```

func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if!result.contains(i) {
            result.append(i)
        }
    }
    return result
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if!result.contains(i) {
            result.append(i)
        }
    }
    return result
}
```

func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if!unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if!unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}
```

func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if!unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if!unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}
```

func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if!unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if!unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}
```

func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if!unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if!unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}
```

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}
```

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}
```

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}
```

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}
```

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}
```

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}
```

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}
```

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}
```

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}
```

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in l {
        if i > max {
            max = i
        }
    }
    return max
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in l {
        if i > max {
            max = i
        }
    }
    return max
}
```

func fizzBuzz(n: Int) -> Int {
    return 0
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    return 0
}
```

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

func fizzBuzz(n: Int) -> Int {
    return 0
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    return 0
}
```

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in stride(from: 0, to: l.count, by: 2) {
        l[i] = l[i].sorted()
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in stride(from: 0, to: l.count, by: 2) {
        l[i] = l[i].sorted()
    }
    return l
}
```

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in stride(from: 0, to: l.count, by: 2) {
        l[i] = l[i].sorted()
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in stride(from: 0, to: l.count, by: 2) {
        l[i] = l[i].sorted()
    }
    return l
}
```

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in stride(from: 0, to: l.count, by: 2) {
        l[i] = l[i].sorted()
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in stride(from: 0, to: l.count, by: 2) {
        l[i] = l[i].sorted()
    }
    return l
}
```

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in stride(from: 0, to: l.count, by: 2) {
        l[i] = l[i].sorted()
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in stride(from: 0, to: l.count, by: 2) {
        l[i] = l[i].sorted()
    }
    return l
}
```

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i].sorted()
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i].sorted()
        }
    }
    return l
}
```

func sortEven(l: [Int]) -> [Int] {
    var lPrime = l
    for i in stride(from: 1, to: l.count, by: 2) {
        lPrime[i] = l[i].sorted()
    }
    return lPrime
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var lPrime = l
    for i in stride(from: 1, to: l.count, by: 2) {
        lPrime[i] = l[i].sorted()
    }
    return lPrime
}
```

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i].sorted()
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i].sorted()
        }
    }
    return l
}
```

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i].sorted()
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i].sorted()
        }
    }
    return l
}
```

func sortEven(l: [Int]) -> [Int] {
    var lPrime = l
    for i in stride(from: 0, to: l.count, by: 2) {
        lPrime[i] = l[i]
    }
    for i in stride(from: 1, to: l.count, by: 2) {
        lPrime[i] = l[i].sorted()
    }
    return lPrime
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var lPrime = l
    for i in stride(from: 0, to: l.count, by: 2) {
        lPrime[i] = l[i]
    }
    for i in stride(from: 1, to: l.count, by: 2) {
        lPrime[i] = l[i].sorted()
    }
    return lPrime
}
```

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in stride(from: 0, to: l.count, by: 2) {
        let j = i + 1
        if j < l.count {
            l.swapAt(i, j)
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in stride(from: 0, to: l.count, by: 2) {
        let j = i + 1
        if j < l.count {
            l.swapAt(i, j)
        }
    }
    return l
}
```

func primeFib(n: Int) -> Int {
    var fib = [1, 2]
    var i = 2
    while fib.count < n {
        let next = fib[i - 1] + fib[i - 2]
        if isPrime(next) {
            fib.append(next)
        }
        i += 1
    }
    return fib[n - 1]
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [1, 2]
    var i = 2
    while fib.count < n {
        let next = fib[i - 1] + fib[i - 2]
        if isPrime(next) {
            fib.append(next)
        }
        i += 1
    }
    return fib[n - 1]
}
```

func primeFib(n: Int) -> Int {
    var a = 1
    var b = 1
    var c = 0
    var i = 1
    while i < n {
        c = a + b
        if isPrime(c) {
            a = b
            b = c
            i += 1
        }
    }
    return c
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var a = 1
    var b = 1
    var c = 0
    var i = 1
    while i < n {
        c = a + b
        if isPrime(c) {
            a = b
            b = c
            i += 1
        }
    }
    return c
}
```

func primeFib(n: Int) -> Int {
    var fib = [1, 2]
    var i = 2
    while fib.count < n {
        let next = fib[i - 1] + fib[i - 2]
        if isPrime(next) {
            fib.append(next)
        }
        i += 1
    }
    return fib[n - 1]
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [1, 2]
    var i = 2
    while fib.count < n {
        let next = fib[i - 1] + fib[i - 2]
        if isPrime(next) {
            fib.append(next)
        }
        i += 1
    }
    return fib[n - 1]
}
```

func primeFib(n: Int) -> Int {
    var fib = [Int]()
    var i = 0
    var j = 1
    var k = 0
    while fib.count < n {
        k = i + j
        i = j
        j = k
        if isPrime(n: k) {
            fib.append(k)
        }
    }
    return fib[n-1]
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [Int]()
    var i = 0
    var j = 1
    var k = 0
    while fib.count < n {
        k = i + j
        i = j
        j = k
        if isPrime(n: k) {
            fib.append(k)
        }
    }
    return fib[n-1]
}
```

func primeFib(n: Int) -> Int {
    var a = 1, b = 1
    var i = 1
    while i < n {
        let c = a + b
        if isPrime(c) {
            a = b
            b = c
            i += 1
        }
    }
    return b
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var a = 1, b = 1
    var i = 1
    while i < n {
        let c = a + b
        if isPrime(c) {
            a = b
            b = c
            i += 1
        }
    }
    return b
}
```

func primeFib(n: Int) -> Int {
    var fib = [1, 2]
    var i = 2
    while fib.count < n {
        let next = fib[i - 1] + fib[i - 2]
        if isPrime(next) {
            fib.append(next)
        }
        i += 1
    }
    return fib[n - 1]
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [1, 2]
    var i = 2
    while fib.count < n {
        let next = fib[i - 1] + fib[i - 2]
        if isPrime(next) {
            fib.append(next)
        }
        i += 1
    }
    return fib[n - 1]
}
```

func primeFib(n: Int) -> Int {
    var fib = [2, 3]
    var i = 2
    while fib.count < n {
        let next = fib[i-1] + fib[i-2]
        if isPrime(next) {
            fib.append(next)
        }
        i += 1
    }
    return fib[n-1]
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [2, 3]
    var i = 2
    while fib.count < n {
        let next = fib[i-1] + fib[i-2]
        if isPrime(next) {
            fib.append(next)
        }
        i += 1
    }
    return fib[n-1]
}
```

func primeFib(n: Int) -> Int {
    var fib = [1, 2]
    var i = 2
    while fib.count < n {
        let next = fib[i-1] + fib[i-2]
        if isPrime(next) {
            fib.append(next)
        }
        i += 1
    }
    return fib[n-1]
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [1, 2]
    var i = 2
    while fib.count < n {
        let next = fib[i-1] + fib[i-2]
        if isPrime(next) {
            fib.append(next)
        }
        i += 1
    }
    return fib[n-1]
}
```

func primeFib(n: Int) -> Int {
    var fib = [1, 2]
    var i = 2
    while fib.count < n {
        let next = fib[i - 1] + fib[i - 2]
        if isPrime(next) {
            fib.append(next)
        }
        i += 1
    }
    return fib[n - 1]
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [1, 2]
    var i = 2
    while fib.count < n {
        let next = fib[i - 1] + fib[i - 2]
        if isPrime(next) {
            fib.append(next)
        }
        i += 1
    }
    return fib[n - 1]
}
```

func primeFib(n: Int) -> Int {
    var fib = [1, 2]
    var i = 2
    while fib.count < n {
        let next = fib[i - 1] + fib[i - 2]
        fib.append(next)
        i += 1
    }
    return fib[n - 1]
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [1, 2]
    var i = 2
    while fib.count < n {
        let next = fib[i - 1] + fib[i - 2]
        fib.append(next)
        i += 1
    }
    return fib[n - 1]
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    // TODO: implement this function
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    // TODO: implement this function
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    // TODO: Write your code here
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    // TODO: Write your code here
    return false
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        set.insert(i)
    }
    for i in l {
        for j in l {
            if set.contains(-i-j) {
                return true
            }
        }
    }
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        set.insert(i)
    }
    for i in l {
        for j in l {
            if set.contains(-i-j) {
                return true
            }
        }
    }
    return false
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in 0..<l.count {
        for j in i+1..<l.count {
            for k in j+1..<l.count {
                if l[i] + l[j] + l[k] == 0 {
                    set.insert(l[i])
                    set.insert(l[j])
                    set.insert(l[k])
                }
            }
        }
    }
    return set.count == 3
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in 0..<l.count {
        for j in i+1..<l.count {
            for k in j+1..<l.count {
                if l[i] + l[j] + l[k] == 0 {
                    set.insert(l[i])
                    set.insert(l[j])
                    set.insert(l[k])
                }
            }
        }
    }
    return set.count == 3
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in 0..<l.count {
        for j in i+1..<l.count {
            for k in j+1..<l.count {
                if l[i] + l[j] + l[k] == 0 {
                    return true
                }
            }
        }
    }
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in 0..<l.count {
        for j in i+1..<l.count {
            for k in j+1..<l.count {
                if l[i] + l[j] + l[k] == 0 {
                    return true
                }
            }
        }
    }
    return false
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    // TODO: Implement this function
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    // TODO: Implement this function
    return false
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    for i in 0..<l.count {
        for j in i+1..<l.count {
            for k in j+1..<l.count {
                if l[i] + l[j] + l[k] == 0 {
                    return true
                }
            }
        }
    }
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    for i in 0..<l.count {
        for j in i+1..<l.count {
            for k in j+1..<l.count {
                if l[i] + l[j] + l[k] == 0 {
                    return true
                }
            }
        }
    }
    return false
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in 0..<l.count {
        for j in i+1..<l.count {
            for k in j+1..<l.count {
                if l[i] + l[j] + l[k] == 0 {
                    set.insert(l[i])
                    set.insert(l[j])
                    set.insert(l[k])
                }
            }
        }
    }
    return set.count == 3
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in 0..<l.count {
        for j in i+1..<l.count {
            for k in j+1..<l.count {
                if l[i] + l[j] + l[k] == 0 {
                    set.insert(l[i])
                    set.insert(l[j])
                    set.insert(l[k])
                }
            }
        }
    }
    return set.count == 3
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    // TODO: Implement this function.
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    // TODO: Implement this function.
    return false
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}
```

func carRaceCollision(n: Int) -> Int {
    // TODO: Write your code here.
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    // TODO: Write your code here.
}
```

func carRaceCollision(n: Int) -> Int {
    // TODO: Write your code here.
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    // TODO: Write your code here.
}
```

func carRaceCollision(n: Int) -> Int {
    // TODO: Implement this function.
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    // TODO: Implement this function.
}
```

func carRaceCollision(n: Int) -> Int {
    // TODO: Implement this function.
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    // TODO: Implement this function.
}
```

func carRaceCollision(n: Int) -> Int {
    // TODO: implement this function
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    // TODO: implement this function
}
```

func carRaceCollision(n: Int) -> Int {
    // TODO: implement this function
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    // TODO: implement this function
}
```

func carRaceCollision(n: Int) -> Int {
    // TODO: implement this function
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    // TODO: implement this function
}
```

func carRaceCollision(n: Int) -> Int {
    // TODO: Implement this function.
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    // TODO: Implement this function.
}
```

func carRaceCollision(n: Int) -> Int {
    // TODO: Implement this function
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    // TODO: Implement this function
}
```

func carRaceCollision(n: Int) -> Int {
    // TODO: Write your code here.
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    // TODO: Write your code here.
}
```

func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}
```

func incrList(l: [Int]) -> [Int] {
    return l.map { $0 + 1 }
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    return l.map { $0 + 1 }
}
```

func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}
```

func incrList(l: [Int]) -> [Int] {
    return l.map { $0 + 1 }
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    return l.map { $0 + 1 }
}
```

func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}
```

func incrList(l: [Int]) -> [Int] {
    return l.map { $0 + 1 }
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    return l.map { $0 + 1 }
}
```

func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(l[i] + 1)
    }
    return result
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(l[i] + 1)
    }
    return result
}
```

func incrList(l: [Int]) -> [Int] {
    var newList = [Int]()
    for i in l {
        newList.append(i + 1)
    }
    return newList
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var newList = [Int]()
    for i in l {
        newList.append(i + 1)
    }
    return newList
}
```

func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}
```

func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    // TODO: implement this function
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    // TODO: implement this function
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var num = x
    while num > 0 {
        let remainder = num % base
        result = "\(remainder)" + result
        num /= base
    }
    return result
}

```swift
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var num = x
    while num > 0 {
        let remainder = num % base
        result = "\(remainder)" + result
        num /= base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var num = x
    while num > 0 {
        result = String(num % base) + result
        num /= base
    }
    return result
}

```swift
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var num = x
    while num > 0 {
        result = String(num % base) + result
        num /= base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var remainder = x
    while remainder > 0 {
        result = "\(remainder % base)" + result
        remainder /= base
    }
    return result
}

```swift
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var remainder = x
    while remainder > 0 {
        result = "\(remainder % base)" + result
        remainder /= base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var num = x
    while num > 0 {
        result = "\(num % base)" + result
        num /= base
    }
    return result
}

```swift
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var num = x
    while num > 0 {
        result = "\(num % base)" + result
        num /= base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var remainder = x
    while remainder > 0 {
        result = "\(remainder % base)" + result
        remainder /= base
    }
    return result
}

```swift
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var remainder = x
    while remainder > 0 {
        result = "\(remainder % base)" + result
        remainder /= base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var num = x
    while num > 0 {
        result = "\(num % base)" + result
        num /= base
    }
    return result
}

```swift
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var num = x
    while num > 0 {
        result = "\(num % base)" + result
        num /= base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var num = x
    while num > 0 {
        result = String(num % base) + result
        num /= base
    }
    return result
}

```swift
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var num = x
    while num > 0 {
        result = String(num % base) + result
        num /= base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var remainder = x
    while remainder > 0 {
        result = "\(remainder % base)" + result
        remainder /= base
    }
    return result
}

```swift
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var remainder = x
    while remainder > 0 {
        result = "\(remainder % base)" + result
        remainder /= base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var remainder = x
    while remainder > 0 {
        result = "\(remainder % base)" + result
        remainder /= base
    }
    return result
}

```swift
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var remainder = x
    while remainder > 0 {
        result = "\(remainder % base)" + result
        remainder /= base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var remainder = x
    while remainder > 0 {
        result = "\(remainder % base)" + result
        remainder /= base
    }
    return result
}

```swift
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var remainder = x
    while remainder > 0 {
        result = "\(remainder % base)" + result
        remainder /= base
    }
    return result
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}
```

func fib4(n: Int) -> Int {
    // TODO: Write your code here
    return 0
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    // TODO: Write your code here
    return 0
}
```

func fib4(n: Int) -> Int {
    // Write your code here
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    // Write your code here
}
```

func fib4(n: Int) -> Int {
    // TODO: Write your code here
    return 0
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    // TODO: Write your code here
    return 0
}
```

func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    var i = 0
    while i < n {
        let temp = a + b + c + d
        a = b
        b = c
        c = d
        d = temp
        i += 1
    }
    return a
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    var i = 0
    while i < n {
        let temp = a + b + c + d
        a = b
        b = c
        c = d
        d = temp
        i += 1
    }
    return a
}
```

func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    for _ in 0..<n {
        a = b
        b = c
        c = d
        d = a + b + c
    }
    return d
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    for _ in 0..<n {
        a = b
        b = c
        c = d
        d = a + b + c
    }
    return d
}
```

func fib4(n: Int) -> Int {
    // Write your code here.
    if n == 0 {
        return 0
    }
    if n == 1 {
        return 0
    }
    if n == 2 {
        return 2
    }
    if n == 3 {
        return 0
    }
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    for i in 4...n {
        d = a + b + c + d
        a = b
        b = c
        c = d
    }
    return d
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    // Write your code here.
    if n == 0 {
        return 0
    }
    if n == 1 {
        return 0
    }
    if n == 2 {
        return 2
    }
    if n == 3 {
        return 0
    }
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    for i in 4...n {
        d = a + b + c + d
        a = b
        b = c
        c = d
    }
    return d
}
```

func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    for _ in 0..<n {
        d = a + b + c
        a = b
        b = c
        c = d
    }
    return d
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    for _ in 0..<n {
        d = a + b + c
        a = b
        b = c
        c = d
    }
    return d
}
```

func fib4(n: Int) -> Int {
    // TODO: Write your code here
    return 0
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    // TODO: Write your code here
    return 0
}
```

func fib4(n: Int) -> Int {
    // TODO: Write your code here
    return 0
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    // TODO: Write your code here
    return 0
}
```

func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    for _ in 0..<n {
        a = b
        b = c
        c = d
        d = a + b + c
    }
    return d
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    for _ in 0..<n {
        a = b
        b = c
        c = d
        d = a + b + c
    }
    return d
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let mid = sorted.count / 2
    if sorted.count % 2 == 0 {
        return Double(sorted[mid] + sorted[mid - 1]) / 2.0
    } else {
        return Double(sorted[mid])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let mid = sorted.count / 2
    if sorted.count % 2 == 0 {
        return Double(sorted[mid] + sorted[mid - 1]) / 2.0
    } else {
        return Double(sorted[mid])
    }
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    let mid = count / 2
    if count % 2 == 0 {
        return Double(sorted[mid] + sorted[mid - 1]) / 2
    } else {
        return Double(sorted[mid])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    let mid = count / 2
    if count % 2 == 0 {
        return Double(sorted[mid] + sorted[mid - 1]) / 2
    } else {
        return Double(sorted[mid])
    }
}
```

func median(l: [Int]) -> Double {
    // TODO: implement
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    // TODO: implement
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let middle = sorted.count / 2
    if sorted.count % 2 == 0 {
        return Double(sorted[middle] + sorted[middle - 1]) / 2.0
    } else {
        return Double(sorted[middle])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let middle = sorted.count / 2
    if sorted.count % 2 == 0 {
        return Double(sorted[middle] + sorted[middle - 1]) / 2.0
    } else {
        return Double(sorted[middle])
    }
}
```

func median(l: [Int]) -> Double {
    // TODO: implement this function
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    // TODO: implement this function
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let mid = sorted.count / 2
    if sorted.count % 2 == 0 {
        return Double(sorted[mid] + sorted[mid - 1]) / 2
    } else {
        return Double(sorted[mid])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let mid = sorted.count / 2
    if sorted.count % 2 == 0 {
        return Double(sorted[mid] + sorted[mid - 1]) / 2
    } else {
        return Double(sorted[mid])
    }
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let mid = sorted.count / 2
    if sorted.count % 2 == 0 {
        return Double(sorted[mid] + sorted[mid - 1]) / 2.0
    } else {
        return Double(sorted[mid])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let mid = sorted.count / 2
    if sorted.count % 2 == 0 {
        return Double(sorted[mid] + sorted[mid - 1]) / 2.0
    } else {
        return Double(sorted[mid])
    }
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        let index = count / 2
        return Double(sorted[index - 1] + sorted[index]) / 2
    } else {
        let index = (count + 1) / 2
        return Double(sorted[index - 1])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        let index = count / 2
        return Double(sorted[index - 1] + sorted[index]) / 2
    } else {
        let index = (count + 1) / 2
        return Double(sorted[index - 1])
    }
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let mid = sorted.count / 2
    if sorted.count % 2 == 0 {
        return Double(sorted[mid] + sorted[mid - 1]) / 2.0
    } else {
        return Double(sorted[mid])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let mid = sorted.count / 2
    if sorted.count % 2 == 0 {
        return Double(sorted[mid] + sorted[mid - 1]) / 2.0
    } else {
        return Double(sorted[mid])
    }
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let mid = sorted.count / 2
    if sorted.count % 2 == 0 {
        return Double(sorted[mid] + sorted[mid - 1]) / 2
    } else {
        return Double(sorted[mid])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let mid = sorted.count / 2
    if sorted.count % 2 == 0 {
        return Double(sorted[mid] + sorted[mid - 1]) / 2
    } else {
        return Double(sorted[mid])
    }
}
```

func isPalindrome(text: String) -> Bool {
    let text = text.lowercased()
    let reversed = String(text.reversed())
    return text == reversed
}

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    let text = text.lowercased()
    let reversed = String(text.reversed())
    return text == reversed
}
```

func isPalindrome(text: String) -> Bool {
    let reversed = String(text.reversed())
    return text == reversed
}

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    let reversed = String(text.reversed())
    return text == reversed
}
```

func isPalindrome(text: String) -> Bool {
    let text = text.lowercased()
    let characters = Array(text)
    let reversedCharacters = characters.reversed()
    let reversedText = String(reversedCharacters)
    return text == reversedText
}

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    let text = text.lowercased()
    let characters = Array(text)
    let reversedCharacters = characters.reversed()
    let reversedText = String(reversedCharacters)
    return text == reversedText
}
```

func isPalindrome(text: String) -> Bool {
    let text = text.lowercased()
    let characters = Array(text)
    let reversedCharacters = Array(text.reversed())
    return characters == reversedCharacters
}

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    let text = text.lowercased()
    let characters = Array(text)
    let reversedCharacters = Array(text.reversed())
    return characters == reversedCharacters
}
```

func isPalindrome(text: String) -> Bool {
    let reversed = String(text.reversed())
    return text == reversed
}

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    let reversed = String(text.reversed())
    return text == reversed
}
```

func isPalindrome(text: String) -> Bool {
    let reversed = String(text.reversed())
    return text == reversed
}

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    let reversed = String(text.reversed())
    return text == reversed
}
```

func isPalindrome(text: String) -> Bool {
    return text == String(text.reversed())
}

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    return text == String(text.reversed())
}
```

func isPalindrome(text: String) -> Bool {
    return text == String(text.reversed())
}

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    return text == String(text.reversed())
}
```

func isPalindrome(text: String) -> Bool {
    let reversed = String(text.reversed())
    return text == reversed
}

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    let reversed = String(text.reversed())
    return text == reversed
}
```

func isPalindrome(text: String) -> Bool {
    return text == String(text.reversed())
}

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    return text == String(text.reversed())
}
```