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.infinity
    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.infinity
    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 sortedNumbers = numbers.sorted()
    var i = 0
    var j = 1
    while i < sortedNumbers.count - 1 {
        if sortedNumbers[j] - sortedNumbers[i] < threshold {
            return true
        }
        i += 1
        j += 1
    }
    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 sortedNumbers = numbers.sorted()
    var i = 0
    var j = 1
    while i < sortedNumbers.count - 1 {
        if sortedNumbers[j] - sortedNumbers[i] < threshold {
            return true
        }
        i += 1
        j += 1
    }
    return false
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var minDistance = Double.infinity
    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.infinity
    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 {
    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 {
    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 sortedNumbers = numbers.sorted()
    for i in 0..<sortedNumbers.count - 1 {
        if abs(sortedNumbers[i] - sortedNumbers[i + 1]) < 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 sortedNumbers = numbers.sorted()
    for i in 0..<sortedNumbers.count - 1 {
        if abs(sortedNumbers[i] - sortedNumbers[i + 1]) < threshold {
            return true
        }
    }
    return false
}
```

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 {
    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 {
    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 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] {
    // 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] {
    // 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 == "(" {
            if!current.isEmpty {
                result.append(current)
                current = ""
            }
            stack.append(current)
            current = ""
        } else if char == ")" {
            if!current.isEmpty {
                result.append(current)
                current = ""
            }
            current = stack.removeLast() + current
        } else {
            current.append(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 == "(" {
            if!current.isEmpty {
                result.append(current)
                current = ""
            }
            stack.append(current)
            current = ""
        } else if char == ")" {
            if!current.isEmpty {
                result.append(current)
                current = ""
            }
            current = stack.removeLast() + current
        } else {
            current.append(char)
        }
    }
    if!current.isEmpty {
        result.append(current)
    }
    return result
}
```

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] {
    // 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] {
    // 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 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 {
    let truncatedNumber = number - Double(Int(number))
    return truncatedNumber
}

```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 truncatedNumber = number - Double(Int(number))
    return truncatedNumber
}
```

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 - 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 {
    let truncatedNumber = number - Double(Int(number))
    return truncatedNumber
}

```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 truncatedNumber = number - Double(Int(number))
    return truncatedNumber
}
```

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 {
    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 {
    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 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 op in operations {
        balance += op
        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 op in operations {
        balance += op
        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 absoluteDeviations = numbers.map { abs($0 - mean) }
    return mean(numbers: absoluteDeviations)
}

```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 absoluteDeviations = numbers.map { abs($0 - mean) }
    return mean(numbers: absoluteDeviations)
}
```

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 absoluteDeviations = numbers.map { abs($0 - mean) }
    return mean(numbers: absoluteDeviations)
}

```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 absoluteDeviations = numbers.map { abs($0 - mean) }
    return mean(numbers: absoluteDeviations)
}
```

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 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 absoluteDeviations = numbers.map { abs($0 - mean) }
    return mean(numbers: absoluteDeviations)
}

```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 absoluteDeviations = numbers.map { abs($0 - mean) }
    return mean(numbers: absoluteDeviations)
}
```

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

```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 absoluteDeviations = numbers.map { abs($0 - mean) }
    return mean(numbers: absoluteDeviations)
}
```

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 absoluteDeviations = numbers.map { abs($0 - mean) }
    return mean(numbers: absoluteDeviations)
}

```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 absoluteDeviations = numbers.map { abs($0 - mean) }
    return mean(numbers: absoluteDeviations)
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result: [Int] = []
    for i in 0..<numbers.count {
        result.append(numbers[i])
        if i < 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 i in 0..<numbers.count {
        result.append(numbers[i])
        if i < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result: [Int] = []
    for (index, number) in numbers.enumerated() {
        if index > 0 {
            result.append(delimeter)
        }
        result.append(number)
    }
    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() {
        if index > 0 {
            result.append(delimeter)
        }
        result.append(number)
    }
    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 i in 0..<numbers.count {
        result.append(numbers[i])
        if i < 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 i in 0..<numbers.count {
        result.append(numbers[i])
        if i < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result: [Int] = []
    for i in 0..<numbers.count {
        result.append(numbers[i])
        if i < 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 i in 0..<numbers.count {
        result.append(numbers[i])
        if i < 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 i in 0..<numbers.count {
        result.append(numbers[i])
        if i < 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 i in 0..<numbers.count {
        result.append(numbers[i])
        if i < 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] {
    var result = [Int]()
    let parenArray = parenString.components(separatedBy: " ")
    for paren in parenArray {
        var max = 0
        var current = 0
        for char in paren {
            if char == "(" {
                current += 1
            } else if char == ")" {
                current -= 1
            }
            if current > max {
                max = current
            }
        }
        result.append(max)
    }
    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]()
    let parenArray = parenString.components(separatedBy: " ")
    for paren in parenArray {
        var max = 0
        var current = 0
        for char in paren {
            if char == "(" {
                current += 1
            } else if char == ")" {
                current -= 1
            }
            if current > max {
                max = current
            }
        }
        result.append(max)
    }
    return result
}
```

func parseNestedParens(parenString: String) -> [Int] {
    var result = [Int]()
    let parenArray = parenString.components(separatedBy: " ")
    for paren in parenArray {
        result.append(paren.maxDepthOfNesting())
    }
    return result
}

extension String {
    func maxDepthOfNesting() -> Int {
        var maxDepth = 0
        var currentDepth = 0
        for char in self {
            if char == "(" {
                currentDepth += 1
            } else if char == ")" {
                currentDepth -= 1
            }
            if currentDepth > maxDepth {
                maxDepth = currentDepth
            }
        }
        return maxDepth
    }
}

```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]()
    let parenArray = parenString.components(separatedBy: " ")
    for paren in parenArray {
        result.append(paren.maxDepthOfNesting())
    }
    return result
}

extension String {
    func maxDepthOfNesting() -> Int {
        var maxDepth = 0
        var currentDepth = 0
        for char in self {
            if char == "(" {
                currentDepth += 1
            } else if char == ")" {
                currentDepth -= 1
            }
            if currentDepth > maxDepth {
                maxDepth = currentDepth
            }
        }
        return maxDepth
    }
}
```

func parseNestedParens(parenString: String) -> [Int] {
    var result = [Int]()
    let parenStrings = parenString.componentsSeparatedByString(" ")
    for parenString in parenStrings {
        var maxLevel = 0
        var level = 0
        for char in parenString {
            if char == "(" {
                level += 1
                if level > maxLevel {
                    maxLevel = level
                }
            } else if char == ")" {
                level -= 1
            }
        }
        result.append(maxLevel)
    }
    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]()
    let parenStrings = parenString.componentsSeparatedByString(" ")
    for parenString in parenStrings {
        var maxLevel = 0
        var level = 0
        for char in parenString {
            if char == "(" {
                level += 1
                if level > maxLevel {
                    maxLevel = level
                }
            } else if char == ")" {
                level -= 1
            }
        }
        result.append(maxLevel)
    }
    return result
}
```

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] {
    var result = [Int]()
    var max = 0
    var current = 0
    var stack = [Int]()
    for c in parenString {
        if c == "(" {
            stack.append(current)
            current = 0
        } else if c == ")" {
            current += 1
            max = max > current? max : current
        }
    }
    result.append(max)
    while!stack.isEmpty {
        max = 0
        current = 0
        while!stack.isEmpty {
            current += 1
            max = max > current? max : current
            if stack.last! == 0 {
                stack.removeLast()
                break
            }
        }
        result.append(max)
    }
    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 max = 0
    var current = 0
    var stack = [Int]()
    for c in parenString {
        if c == "(" {
            stack.append(current)
            current = 0
        } else if c == ")" {
            current += 1
            max = max > current? max : current
        }
    }
    result.append(max)
    while!stack.isEmpty {
        max = 0
        current = 0
        while!stack.isEmpty {
            current += 1
            max = max > current? max : current
            if stack.last! == 0 {
                stack.removeLast()
                break
            }
        }
        result.append(max)
    }
    return result
}
```

func parseNestedParens(parenString: String) -> [Int] {
    var result: [Int] = []
    let parenStrings = parenString.components(separatedBy: " ")
    for parenString in parenStrings {
        var maxLevel = 0
        var level = 0
        for char in parenString {
            if char == "(" {
                level += 1
                if level > maxLevel {
                    maxLevel = level
                }
            } else {
                level -= 1
            }
        }
        result.append(maxLevel)
    }
    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] = []
    let parenStrings = parenString.components(separatedBy: " ")
    for parenString in parenStrings {
        var maxLevel = 0
        var level = 0
        for char in parenString {
            if char == "(" {
                level += 1
                if level > maxLevel {
                    maxLevel = level
                }
            } else {
                level -= 1
            }
        }
        result.append(maxLevel)
    }
    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] {
    // 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]()
    let groups = parenString.components(separatedBy: " ")
    for group in groups {
        var stack = [Character]()
        for char in group {
            if char == "(" {
                stack.append(char)
            } else if char == ")" {
                stack.removeLast()
            }
        }
        result.append(stack.count)
    }
    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]()
    let groups = parenString.components(separatedBy: " ")
    for group in groups {
        var stack = [Character]()
        for char in group {
            if char == "(" {
                stack.append(char)
            } else if char == ")" {
                stack.removeLast()
            }
        }
        result.append(stack.count)
    }
    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 { (string) -> Bool in
        return string.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 { (string) -> Bool in
        return string.contains(substring)
    }
}
```

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { (string) -> Bool in
        return string.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 { (string) -> Bool in
        return string.contains(substring)
    }
}
```

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { (string) -> Bool in
        return string.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 { (string) -> Bool in
        return string.contains(substring)
    }
}
```

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { (string) -> Bool in
        return string.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 { (string) -> Bool in
        return string.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 { (string) -> Bool in
        return string.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 { (string) -> Bool in
        return string.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 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) {
    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) {
    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 rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = 0
    for number in numbers {
        max = max > number? max : number
        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? max : number
        result.append(max)
    }
    return result
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = 0
    for number in numbers {
        max = max > number? max : number
        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? max : number
        result.append(max)
    }
    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 = numbers.first!
    for number in numbers {
        if number > max {
            max = number
        }
        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 = numbers.first!
    for number in numbers {
        if number > max {
            max = number
        }
        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 = 0
    for number in numbers {
        max = max > number? max : number
        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? max : number
        result.append(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: Int = 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: Int = 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.first!
    for number in numbers {
        if number > max {
            max = number
        }
        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 = numbers.first!
    for number in numbers {
        if number > max {
            max = number
        }
        result.append(max)
    }
    return result
}
```

func makePalindrome(string: String) -> String {
    var result = string
    var i = string.count - 1
    while i > 0 {
        let prefix = string[0..<i]
        let suffix = string[i..<string.count]
        if isPalindrome(string: suffix) {
            result = String(prefix) + String(suffix.reversed())
            break
        }
        i -= 1
    }
    return result
}

func isPalindrome(string: String) -> Bool {
    var i = 0
    var j = string.count - 1
    while i < j {
        if string[i]!= string[j] {
            return false
        }
        i += 1
        j -= 1
    }
    return true
}

```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 result = string
    var i = string.count - 1
    while i > 0 {
        let prefix = string[0..<i]
        let suffix = string[i..<string.count]
        if isPalindrome(string: suffix) {
            result = String(prefix) + String(suffix.reversed())
            break
        }
        i -= 1
    }
    return result
}

// Check if a string is a palindrome.
// isPalindrome(string: "") == true
// isPalindrome(string: "cat") == false
// isPalindrome(string: "cata") == true
func isPalindrome(string: String) -> Bool {
    var i = 0
    var j = string.count - 1
    while i < j {
        if string[i]!= string[j] {
            return false
        }
        i += 1
        j -= 1
    }
    return true
}
```

func makePalindrome(string: String) -> String {
    var result = string
    var i = string.count - 1
    while i > 0 {
        let prefix = string[0..<i]
        let suffix = string[i..<string.count]
        if suffix == suffix.reversed() {
            result = prefix.reversed() + suffix
            break
        }
        i -= 1
    }
    return result
}

```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 result = string
    var i = string.count - 1
    while i > 0 {
        let prefix = string[0..<i]
        let suffix = string[i..<string.count]
        if suffix == suffix.reversed() {
            result = prefix.reversed() + suffix
            break
        }
        i -= 1
    }
    return result
}
```

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

func longestPalindrome(string: String) -> String {
    let reversedString = String(string.characters.reversed())
    let palindrome1 = longestPalindrome(string: string)
    let palindrome2 = longestPalindrome(string: reversedString)
    if palindrome1 == palindrome2 {
        return palindrome1
    } else {
        return palindrome1.characters.count > palindrome2.characters.count? palindrome1 : palindrome2
    }
}

```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 reversedString = String(string.characters.reversed())
    let longestPalindrome = longestPalindrome(string: string + reversedString)
    let palindrome = String(longestPalindrome.characters.dropLast(reversedString.characters.count))
    return palindrome
}

// Find the longest palindrome that is a substring of a supplied string.
// Algorithm idea is simple:
// - Find the longest palindrome that is a substring of a string.
// - Find the longest palindrome that is a substring of a reversed string.
// - If the palindromes are equal, return the palindrome.
// - If the palindromes are not equal, return the longer palindrome.
// longestPalindrome(string: "") == ""
// longestPalindrome(string: "cat") == "cat"
// longestPalindrome(string: "cata") == "ata"
// longestPalindrome(string: "cata") == "ata"
func longestPalindrome(string: String) -> String {
    let reversedString = String(string.characters.reversed())
    let palindrome1 = longestPalindrome(string: string)
    let palindrome2 = longestPalindrome(string: reversedString)
    if palindrome1 == palindrome2 {
        return palindrome1
    } else {
        return palindrome1.characters.count > palindrome2.characters.count? palindrome1 : palindrome2
    }
}

// Find the longest palindrome that is a substring of a supplied string.
// Algorithm idea is simple:
// - Find the longest palindrome that is a substring of a string.
// - Find the longest palindrome that is a substring of a reversed string.
// - If the palindromes are equal, return the palindrome.
// - If the palindromes are not equal, return the longer palindrome.
// longestPalindrome(string: "") == ""
// longestPalindrome(string: "cat") == "cat"
// longestPalindrome(string: "cata") == "ata"
// longestPalindrome(string: "cata") == "ata"
func longestPalindrome(string: String) -> String {
    let reversedString = String(string.characters.reversed())
    let palindrome1 = longestPalindrome(string: string)
    let palindrome2 = longestPalindrome(string: reversedString)
    if palindrome1 == palindrome2 {
        return palindrome1
    } else {
        return palindrome1.characters.count > palindrome2.characters.count? palindrome1 : palindrome2
    }
}

// Find the longest palindrome that is a substring of a supplied string.
// Algorithm idea is simple:
// - Find the longest palindrome that is a substring of a string.
// - Find the longest palindrome that is a substring of a reversed string.
// - If the palindromes are equal, return the palindrome.
// - If the palindromes are not equal, return the longer palindrome.
// longestPalindrome(string: "") == ""
// longestPalindrome(string: "cat") == "cat"
// longestPalindrome(string: "cata") == "ata"
// longestPalindrome(string: "cata") == "ata"
func longestPalindrome(string: String) -> String {
    let reversedString = String(string.characters.reversed())
    let palindrome1 = longestPalindrome(string: string)
    let palindrome2 = longestPalindrome(string: reversedString)
    if palindrome1 == palindrome2 {
        return palindrome1
    } else {
        return palindrome1.characters.count > palindrome2.characters.count? palindrome1 : palindrome2
    }
}

// Find the longest palindrome that is a substring of a supplied string.
// Algorithm idea is simple:
// - Find the longest palindrome that is a substring of a string.
// - Find the longest palindrome that is a substring of a reversed string.
// - If the palindromes are equal, return the palindrome.
// - If the palindromes are not equal, return the longer palindrome.
// longestPalindrome(string: "") == ""
// longestPalindrome(string: "cat") == "cat"
// longestPalindrome(string: "cata") == "ata"
// longestPalindrome(string: "cata") == "ata"
func longestPalindrome(string: String) -> String {
    let reversedString = String(string.characters.reversed())
    let palindrome1 = longestPalindrome(string: string)
    let palindrome2 = longestPalindrome(string: reversedString)
    if palindrome1

func makePalindrome(string: String) -> String {
    var result = string
    var i = 0
    while i < result.count {
        let prefix = result.prefix(i)
        let suffix = result.suffix(result.count - i)
        if isPalindrome(string: String(suffix)) {
            result = String(prefix) + String(suffix.reversed())
            break
        }
        i += 1
    }
    return result
}

func isPalindrome(string: String) -> Bool {
    return string == String(string.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 {
    var result = string
    var i = 0
    while i < result.count {
        let prefix = result.prefix(i)
        let suffix = result.suffix(result.count - i)
        if isPalindrome(string: String(suffix)) {
            result = String(prefix) + String(suffix.reversed())
            break
        }
        i += 1
    }
    return result
}

func isPalindrome(string: String) -> Bool {
    return string == String(string.reversed())
}
```

func makePalindrome(string: String) -> String {
    var result = string
    var reversed = ""
    var i = string.count - 1
    while i >= 0 {
        reversed.append(string[i])
        i -= 1
    }
    if string == reversed {
        return result
    }
    result.append(reversed)
    return result
}

```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 result = string
    var reversed = ""
    var i = string.count - 1
    while i >= 0 {
        reversed.append(string[i])
        i -= 1
    }
    if string == reversed {
        return result
    }
    result.append(reversed)
    return result
}
```

func makePalindrome(string: String) -> String {
    var result = string
    var prefix = ""
    var suffix = ""
    for i in 0..<string.count {
        let prefix = string.substring(to: string.index(string.startIndex, offsetBy: i))
        let suffix = string.substring(from: string.index(string.endIndex, offsetBy: -i))
        if prefix == suffix.reverse() {
            result = prefix + suffix.reverse()
            break
        }
    }
    return result
}

```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 result = string
    var prefix = ""
    var suffix = ""
    for i in 0..<string.count {
        let prefix = string.substring(to: string.index(string.startIndex, offsetBy: i))
        let suffix = string.substring(from: string.index(string.endIndex, offsetBy: -i))
        if prefix == suffix.reverse() {
            result = prefix + suffix.reverse()
            break
        }
    }
    return result
}
```

```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 prefix = ""
    var suffix = ""
    var palindrome = string
    var isPalindrome = false
    var isPrefix = false
    var isSuffix = false
    var isPalindromeFound = false
    var isPalindromeFoundInSuffix = false
    var isPalindromeFoundInPrefix = false
    var isPalindromeFoundInString = false
    var isPalindromeFoundInStringSuffix = false
    var isPalindromeFoundInStringPrefix = false
    var isPalindromeFoundInStringSuffixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringSuffixPrefix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindromeFoundInStringPrefixPrefix = false
    var isPalindromeFoundInStringSuffixSuffix = false
    var isPalindromeFoundInStringPrefixSuffix = false
    var isPalindrome

func makePalindrome(string: String) -> String {
    let reversedString = String(string.reversed())
    let longestPalindrome = longestPalindrome(string: string)
    let prefix = string.substring(to: string.index(string.startIndex, offsetBy: longestPalindrome.count))
    return prefix + reversedString
}

func longestPalindrome(string: String) -> String {
    var longestPalindrome = ""
    for i in 0..<string.count {
        let left = string.index(string.startIndex, offsetBy: i)
        let right = string.index(string.startIndex, offsetBy: string.count - i - 1)
        let substring = string[left...right]
        if substring == String(substring.reversed()) {
            longestPalindrome = substring
        }
    }
    return longestPalindrome
}

```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 reversedString = String(string.reversed())
    let longestPalindrome = longestPalindrome(string: string)
    let prefix = string.substring(to: string.index(string.startIndex, offsetBy: longestPalindrome.count))
    return prefix + reversedString
}

// Find the longest palindrome in a string.
// Algorithm idea is simple:
// - Start with the first character.
// - Expand the palindrome to the left and right until it stops being a palindrome.
// longestPalindrome(string: "cat") == "c"
// longestPalindrome(string: "cata") == "a"
// longestPalindrome(string: "cata") == "a"
func longestPalindrome(string: String) -> String {
    var longestPalindrome = ""
    for i in 0..<string.count {
        let left = string.index(string.startIndex, offsetBy: i)
        let right = string.index(string.startIndex, offsetBy: string.count - i - 1)
        let substring = string[left...right]
        if substring == String(substring.reversed()) {
            longestPalindrome = substring
        }
    }
    return longestPalindrome
}
```

func makePalindrome(string: String) -> String {
    var palindrome = string
    var i = 0
    while i < palindrome.count {
        let prefix = palindrome.prefix(i)
        let suffix = palindrome.suffix(palindrome.count - i)
        if suffix == suffix.reversed() {
            palindrome = String(prefix) + String(suffix.reversed())
            break
        }
        i += 1
    }
    return palindrome
}

```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 palindrome = string
    var i = 0
    while i < palindrome.count {
        let prefix = palindrome.prefix(i)
        let suffix = palindrome.suffix(palindrome.count - i)
        if suffix == suffix.reversed() {
            palindrome = String(prefix) + String(suffix.reversed())
            break
        }
        i += 1
    }
    return palindrome
}
```

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

```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 reversedString = String(string.characters.reversed())
    let reversedPrefix = string.characters.dropLast(reversedString.characters.count)
    return String(reversedPrefix) + string + reversedString
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<a.count {
        let charA = a[i]
        let charB = b[i]
        if charA == 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 in 0..<a.count {
        let charA = a[i]
        let charB = b[i]
        if charA == charB {
            result += "0"
        } else {
            result += "1"
        }
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<max(a.count, b.count) {
        let aChar = a.count > i? a[a.index(a.startIndex, offsetBy: i)] : "0"
        let bChar = b.count > i? b[b.index(b.startIndex, offsetBy: i)] : "0"
        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..<max(a.count, b.count) {
        let aChar = a.count > i? a[a.index(a.startIndex, offsetBy: i)] : "0"
        let bChar = b.count > i? b[b.index(b.startIndex, offsetBy: i)] : "0"
        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 {
        let charA = a[i]
        let charB = b[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[i]
        let charB = b[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..<max(a.count, b.count) {
        let aChar = i < a.count? a[a.index(a.startIndex, offsetBy: i)] : "0"
        let bChar = i < b.count? b[b.index(b.startIndex, offsetBy: i)] : "0"
        let xor = (aChar == "1"? 1 : 0) ^ (bChar == "1"? 1 : 0)
        result.append(xor == 1? "1" : "0")
    }
    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..<max(a.count, b.count) {
        let aChar = i < a.count? a[a.index(a.startIndex, offsetBy: i)] : "0"
        let bChar = i < b.count? b[b.index(b.startIndex, offsetBy: i)] : "0"
        let xor = (aChar == "1"? 1 : 0) ^ (bChar == "1"? 1 : 0)
        result.append(xor == 1? "1" : "0")
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<max(a.count, b.count) {
        let aChar = a.index(a.startIndex, offsetBy: i)
        let bChar = b.index(b.startIndex, offsetBy: i)
        let aValue = a[aChar]
        let bValue = b[bChar]
        let xor = (aValue == bValue)? "0" : "1"
        result.append(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..<max(a.count, b.count) {
        let aChar = a.index(a.startIndex, offsetBy: i)
        let bChar = b.index(b.startIndex, offsetBy: i)
        let aValue = a[aChar]
        let bValue = b[bChar]
        let xor = (aValue == bValue)? "0" : "1"
        result.append(xor)
    }
    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)
        let charB = b[charB]
        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)
        let charB = b[charB]
        if char == charB {
            result.append("0")
        } else {
            result.append("1")
        }
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for (index, char) in a.enumerated() {
        if char == b[index] {
            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() {
        if char == b[index] {
            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[i]
        let charB = b[i]
        let xor = charA == charB? "0" : "1"
        result.append(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[i]
        let charB = b[i]
        let xor = charA == charB? "0" : "1"
        result.append(xor)
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<a.count {
        let charA = a[i]
        let charB = b[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[i]
        let charB = b[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[i] == b[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[i] == b[i] {
            result.append("0")
        } else {
            result.append("1")
        }
    }
    return result
}
```

func longest(strings: [String]) -> String? {
    // Your code goes 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 goes here
}
```

func longest(strings: [String]) -> String? {
    // TODO: implement
}

```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? {
    // TODO: implement
}
```

func longest(strings: [String]) -> String? {
    return strings.max(by: { $0.count < $1.count })
}

```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 strings.max(by: { $0.count < $1.count })
}
```

func longest(strings: [String]) -> String? {
    // TODO: implement
}

```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? {
    // TODO: implement
}
```

func longest(strings: [String]) -> String? {
    // TODO: implement
}

```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? {
    // TODO: implement
}
```

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 strings.max { $0.count < $1.count }
}

```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 strings.max { $0.count < $1.count }
}
```

func longest(strings: [String]) -> String? {
    // TODO: implement me
    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? {
    // TODO: implement me
    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 strings.max(by: { $0.count < $1.count })
}

```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 strings.max(by: { $0.count < $1.count })
}
```

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 b == 0 {
        return a
    } else {
        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
    } else {
        return greatestCommonDivisor(a: b, b: a % b)
    }
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    // TODO: implement this function
}

```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 {
    // TODO: implement this function
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    } else {
        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
    } else {
        return greatestCommonDivisor(a: b, b: a % b)
    }
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    // 1. If b is zero, return a
    if b == 0 {
        return a
    }
    // 2. Otherwise, return greatestCommonDivisor(a: b, b: a % b)
    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 {
    // 1. If b is zero, return a
    if b == 0 {
        return a
    }
    // 2. Otherwise, return greatestCommonDivisor(a: b, b: a % b)
    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 {
    // 1. Find a remainder of a and b
    let remainder = a % b
    // 2. If remainder is zero, then b is the greatest common divisor
    if remainder == 0 {
        return b
    }
    // 3. Otherwise, find a greatest common divisor of b and remainder
    return greatestCommonDivisor(a: b, b: remainder)
}

```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 {
    // 1. Find a remainder of a and b
    let remainder = a % b
    // 2. If remainder is zero, then b is the greatest common divisor
    if remainder == 0 {
        return b
    }
    // 3. Otherwise, find a greatest common divisor of b and remainder
    return greatestCommonDivisor(a: b, b: remainder)
}
```

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 index in 0...string.count {
        result.append(string.prefix(index))
    }
    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 index in 0...string.count {
        result.append(string.prefix(index))
    }
    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(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(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(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 index in 0...string.count {
        result.append(String(string.prefix(index)))
    }
    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 index in 0...string.count {
        result.append(String(string.prefix(index)))
    }
    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 1...string.count {
        let prefix = string.prefix(i)
        result.append(String(prefix))
    }
    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 1...string.count {
        let prefix = string.prefix(i)
        result.append(String(prefix))
    }
    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 {
    // 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 {
    // 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 {
    // 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 = Set<Character>()
    for character in string {
        if!characters.contains(character) {
            characters.insert(character)
            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 characters = Set<Character>()
    for character in string {
        if!characters.contains(character) {
            characters.insert(character)
            count += 1
        }
    }
    return count
}
```

func countDistinctCharacters(string: String) -> Int {
    return Set(string.lowercased()).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.lowercased()).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 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 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] = []
    for char in musicString {
        switch char {
        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] = []
    for char in musicString {
        switch char {
        case "o":
            result.append(4)
        case "o|":
            result.append(2)
        case ".|":
            result.append(1)
        default:
            break
        }
    }
    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 parseMusic(musicString: String) -> [Int] {
    var result: [Int] = []
    for char in musicString {
        switch char {
        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] = []
    for char in musicString {
        switch char {
        case "o":
            result.append(4)
        case "o|":
            result.append(2)
        case ".|":
            result.append(1)
        default:
            break
        }
    }
    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] {
    // 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]()
    var currentNote = 0
    for char in musicString {
        switch char {
        case "o":
            currentNote += 4
        case "o|":
            currentNote += 2
        case ".|":
            currentNote += 1
        default:
            break
        }
        if char == " " {
            result.append(currentNote)
            currentNote = 0
        }
    }
    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
        }
        if char == " " {
            result.append(currentNote)
            currentNote = 0
        }
    }
    return result
}
```

func parseMusic(musicString: String) -> [Int] {
    var result: [Int] = []
    var temp: String = ""
    for char in musicString {
        if char == "o" {
            result.append(4)
        } else if char == "o|" {
            result.append(2)
        } else if char == ".|" {
            result.append(1)
        } else {
            temp += String(char)
        }
    }
    if temp!= "" {
        result.append(Int(temp)!)
    }
    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 temp: String = ""
    for char in musicString {
        if char == "o" {
            result.append(4)
        } else if char == "o|" {
            result.append(2)
        } else if char == ".|" {
            result.append(1)
        } else {
            temp += String(char)
        }
    }
    if temp!= "" {
        result.append(Int(temp)!)
    }
    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
        }
        if char == " " {
            result.append(currentNote)
            currentNote = 0
        }
    }
    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
        }
        if char == " " {
            result.append(currentNote)
            currentNote = 0
        }
    }
    return result
}
```

func parseMusic(musicString: String) -> [Int] {
    var result = [Int]()
    var beats = 0
    for char in musicString {
        switch char {
        case "o":
            beats += 4
        case "o|":
            beats += 2
        case ".|":
            beats += 1
        default:
            break
        }
        if char == " " || char == "|" {
            result.append(beats)
            beats = 0
        }
    }
    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 beats = 0
    for char in musicString {
        switch char {
        case "o":
            beats += 4
        case "o|":
            beats += 2
        case ".|":
            beats += 1
        default:
            break
        }
        if char == " " || char == "|" {
            result.append(beats)
            beats = 0
        }
    }
    return result
}
```

func parseMusic(musicString: String) -> [Int] {
    var result: [Int] = []
    let notes = musicString.split(separator: " ")
    for note in notes {
        if note == "o" {
            result.append(4)
        } else if note == "o|" {
            result.append(2)
        } else if note == ".|" {
            result.append(1)
        }
    }
    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 {
        if note == "o" {
            result.append(4)
        } else if note == "o|" {
            result.append(2)
        } else if note == ".|" {
            result.append(1)
        }
    }
    return result
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while let range = string.range(of: substring, range: index..<string.endIndex) {
        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, range: index..<string.endIndex) {
        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, range: startIndex..<string.endIndex) {
        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, range: startIndex..<string.endIndex) {
        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 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 index < string.endIndex {
        if string.substring(from: 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.substring(from: 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 {
        let range = string.range(of: substring, range: index..<string.endIndex)
        if let range = range {
            count += 1
            index = range.upperBound
        } else {
            break
        }
    }
    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 {
        let range = string.range(of: substring, range: index..<string.endIndex)
        if let range = range {
            count += 1
            index = range.upperBound
        } else {
            break
        }
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while let range = string.range(of: substring, range: index..<string.endIndex) {
        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, range: index..<string.endIndex) {
        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 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 {
    // Write your code here.
}

```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 {
    // Write your code here.
}
```

func sortNumbers(numbers: String) -> String {
    // Your code here
}

```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 {
    // Your code here
}
```

func sortNumbers(numbers: String) -> String {
    let numbers = numbers.split(separator: " ")
    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.split(separator: " ")
    let sorted = numbers.sorted()
    return sorted.joined(separator: " ")
}
```

func sortNumbers(numbers: String) -> String {
    // TODO: Write your code here
    return ""
}

```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 {
    // TODO: Write your code here
    return ""
}
```

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 {
    // Write your code here.
    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 {
    // Write your code here.
    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 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 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) {
    return (0, 0)
}

```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) {
    return (0, 0)
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    let sortedNumbers = numbers.sorted()
    var closestElements = (sortedNumbers[0], sortedNumbers[1])
    var closestDistance = abs(closestElements.0 - closestElements.1)
    for i in 1..<sortedNumbers.count - 1 {
        let distance = abs(sortedNumbers[i] - sortedNumbers[i + 1])
        if distance < closestDistance {
            closestDistance = distance
            closestElements = (sortedNumbers[i], sortedNumbers[i + 1])
        }
    }
    return closestElements
}

```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) {
    let sortedNumbers = numbers.sorted()
    var closestElements = (sortedNumbers[0], sortedNumbers[1])
    var closestDistance = abs(closestElements.0 - closestElements.1)
    for i in 1..<sortedNumbers.count - 1 {
        let distance = abs(sortedNumbers[i] - sortedNumbers[i + 1])
        if distance < closestDistance {
            closestDistance = distance
            closestElements = (sortedNumbers[i], sortedNumbers[i + 1])
        }
    }
    return closestElements
}
```

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: 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: 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) {
    var closest = (numbers[0], numbers[1])
    for i in 0..<numbers.count - 1 {
        let (a, b) = (numbers[i], numbers[i + 1])
        if abs(a - b) < abs(closest.0 - closest.1) {
            closest = (a, b)
        }
    }
    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 (a, b) = (numbers[i], numbers[i + 1])
        if abs(a - b) < abs(closest.0 - closest.1) {
            closest = (a, b)
        }
    }
    return closest
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    var closestNumbers = (Double.greatestFiniteMagnitude, Double.greatestFiniteMagnitude)
    for i in 0..<numbers.count {
        let number = numbers[i]
        if number < closestNumbers.0 {
            closestNumbers.0 = number
            closestNumbers.1 = numbers[i + 1]
        } else if number < closestNumbers.1 {
            closestNumbers.1 = number
        }
    }
    return closestNumbers
}

```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 closestNumbers = (Double.greatestFiniteMagnitude, Double.greatestFiniteMagnitude)
    for i in 0..<numbers.count {
        let number = numbers[i]
        if number < closestNumbers.0 {
            closestNumbers.0 = number
            closestNumbers.1 = numbers[i + 1]
        } else if number < closestNumbers.1 {
            closestNumbers.1 = number
        }
    }
    return closestNumbers
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    var closest = (numbers[0], numbers[1])
    for i in 1..<numbers.count {
        let diff = abs(numbers[i] - closest.0)
        if diff < 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 {
        let diff = abs(numbers[i] - closest.0)
        if diff < abs(closest.1 - closest.0) {
            closest = (numbers[i], closest.0)
        }
    }
    return closest
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    let sortedNumbers = numbers.sorted()
    let firstNumber = sortedNumbers[0]
    let lastNumber = sortedNumbers[sortedNumbers.count - 1]
    let distance = lastNumber - firstNumber
    let midPoint = firstNumber + distance / 2
    var closestNumbers = (firstNumber, lastNumber)
    for number in sortedNumbers {
        if abs(number - midPoint) < abs(lastNumber - firstNumber) {
            closestNumbers = (number, lastNumber)
        }
    }
    return closestNumbers
}

```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) {
    let sortedNumbers = numbers.sorted()
    let firstNumber = sortedNumbers[0]
    let lastNumber = sortedNumbers[sortedNumbers.count - 1]
    let distance = lastNumber - firstNumber
    let midPoint = firstNumber + distance / 2
    var closestNumbers = (firstNumber, lastNumber)
    for number in sortedNumbers {
        if abs(number - midPoint) < abs(lastNumber - firstNumber) {
            closestNumbers = (number, lastNumber)
        }
    }
    return closestNumbers
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 - min }
       .map { $0 / 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 }
       .map { $0 / range }
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 - min }
       .map { $0 / 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 }
       .map { $0 / range }
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 - min }
       .map { $0 / 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 }
       .map { $0 / 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 rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 - min }
       .map { $0 / 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 }
       .map { $0 / 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] {
    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 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] {
    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 value = value as? Int {
            result.append(value)
        }
    }
    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 value = value as? Int {
            result.append(value)
        }
    }
    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.characters.count
}

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

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

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

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

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

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

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    return string.characters.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.characters.count
}

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

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

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

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

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

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

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

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

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

func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 1 {
        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
    while divisor > 1 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return divisor
}
```

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
    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
    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 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 - 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 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 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 > 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 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 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 n = n
    var factors = [Int]()
    var i = 2
    while n > 1 {
        if n % i == 0 {
            factors.append(i)
            n /= i
        } else {
            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 n = n
    var factors = [Int]()
    var i = 2
    while n > 1 {
        if n % i == 0 {
            factors.append(i)
            n /= i
        } else {
            i += 1
        }
    }
    return factors
}
```

func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var num = n
    var i = 2
    while num > 1 {
        if num % i == 0 {
            factors.append(i)
            num /= i
        } else {
            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 num = n
    var i = 2
    while num > 1 {
        if num % i == 0 {
            factors.append(i)
            num /= i
        } else {
            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 result = [Int]()
    var n = n
    var i = 2
    while n > 1 {
        if n % i == 0 {
            result.append(i)
            n /= i
        } else {
            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 n = n
    var i = 2
    while n > 1 {
        if n % i == 0 {
            result.append(i)
            n /= i
        } else {
            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 n = n
    var factors = [Int]()
    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 n = n
    var factors = [Int]()
    var i = 2
    while n > 1 {
        while n % i == 0 {
            factors.append(i)
            n /= i
        }
        i += 1
    }
    return factors
}
```

func factorize(n: Int) -> [Int] {
    var result = [Int]()
    var number = n
    for i in 2...number {
        while number % i == 0 {
            result.append(i)
            number /= 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 number = n
    for i in 2...number {
        while number % i == 0 {
            result.append(i)
            number /= i
        }
    }
    return result
}
```

func factorize(n: Int) -> [Int] {
    var result = [Int]()
    var number = n
    for i in 2...number {
        while number % i == 0 {
            result.append(i)
            number /= 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 number = n
    for i in 2...number {
        while number % i == 0 {
            result.append(i)
            number /= i
        }
    }
    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]()
    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 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]()
    var set = Set<Int>()
    for number in numbers {
        if!set.contains(number) {
            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) {
            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) {
            continue
        }
        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) {
            continue
        }
        result.append(number)
        seen.insert(number)
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.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 character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isUppercase {
            result.append(character.lowercased())
        } else {
            result.append(character.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 character in string {
        if character.isUppercase {
            result.append(character.lowercased())
        } else {
            result.append(character.uppercased())
        }
    }
    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.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.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 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 += 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.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 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 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 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] {
    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 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 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 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] {
    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 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 {
    // TODO: implement this function
}

```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 {
    // TODO: implement this function
}
```

func isPrime(n: Int) -> Bool {
    if n <= 1 {
        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 {
    if n <= 1 {
        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
}
```

```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 {
    // 1 is not a prime number
    if n == 1 {
        return false
    }
    // 2 is a prime number
    if n == 2 {
        return true
    }
    // 3 is a prime number
    if n == 3 {
        return true
    }
    // 4 is not a prime number
    if n == 4 {
        return false
    }
    // 5 is a prime number
    if n == 5 {
        return true
    }
    // 6 is not a prime number
    if n == 6 {
        return false
    }
    // 7 is a prime number
    if n == 7 {
        return true
    }
    // 8 is not a prime number
    if n == 8 {
        return false
    }
    // 9 is not a prime number
    if n == 9 {
        return false
    }
    // 10 is not a prime number
    if n == 10 {
        return false
    }
    // 11 is a prime number
    if n == 11 {
        return true
    }
    // 12 is not a prime number
    if n == 12 {
        return false
    }
    // 13 is a prime number
    if n == 13 {
        return true
    }
    // 14 is not a prime number
    if n == 14 {
        return false
    }
    // 15 is not a prime number
    if n == 15 {
        return false
    }
    // 16 is not a prime number
    if n == 16 {
        return false
    }
    // 17 is a prime number
    if n == 17 {
        return true
    }
    // 18 is not a prime number
    if n == 18 {
        return false
    }
    // 19 is a prime number
    if n == 19 {
        return true
    }
    // 20 is not a prime number
    if n == 20 {
        return false
    }
    // 21 is not a prime number
    if n == 21 {
        return false
    }
    // 22 is not a prime number
    if n == 22 {
        return false
    }
    // 23 is a prime number
    if n == 23 {
        return true
    }
    // 24 is not a prime number
    if n == 24 {
        return false
    }
    // 25 is not a prime number
    if n == 25 {
        return false
    }
    // 26 is not a prime number
    if n == 26 {
        return false
    }
    // 27 is not a prime number
    if n == 27 {
        return false
    }
    // 28 is not a prime number
    if n == 28 {
        return false
    }
    // 29 is a prime number
    if n == 29 {
        return true
    }
    // 30 is not a prime number
    if n == 30 {
        return false
    }
    // 31 is a prime number
    if n == 31 {
        return true
    }
    // 32 is not a prime number
    if n == 32 {
        return false
    }
    // 33 is not a prime number
    if n == 33 {
        return false
    }
    // 34 is not a prime number
    if n == 34 {
        return false
    }
    // 35 is not a prime number
    if n == 35 {
        return false
    }
    // 36 is not a prime number
    if n == 36 {
        return false
    }
    // 37 is a prime number
    if n == 37 {
        return true
    }
    // 38 is not a prime number
    if n == 38 {
        return false
    }
    // 39 is not a prime number
    if n == 39 {
        return false
    }
    // 40 is not a prime number
    if n == 40 {
        return false
    }
    // 41 is a prime number
    if n == 41 {
        return true
    }
    // 42 is not a prime number
    if n == 42 {
        return false
    }
    // 43 is a prime number
    if n == 43 {
        return true
    }
    // 44 is not a prime number
    if n == 44 {
        return false
    }
    // 45 is not a prime number
    if n == 45 {
        return false
    }
    // 46 is not a prime number
    if n == 46 {
        return 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
}

```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 {
    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 {
    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
    }
    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 {
    if n <= 1 {
        return false
    }
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    return true
}
```

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

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

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] = 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 lPrime = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            lPrime[i] = lPrime.sorted()[i]
        }
    }
    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.sorted()[i]
        }
    }
    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.sorted()[i]
        }
    }
    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.sorted()[i]
        }
    }
    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 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 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 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 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 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 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 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 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 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 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 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 lPrime = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            lPrime[i] = l[i]
        } else {
            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 0..<l.count {
        if i % 2 == 0 {
            lPrime[i] = l[i]
        } else {
            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 lPrime = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            lPrime[i] = l[i]
        } else {
            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 0..<l.count {
        if i % 2 == 0 {
            lPrime[i] = l[i]
        } else {
            lPrime[i] = l[i].sorted()
        }
    }
    return lPrime
}
```

func sortEven(l: [Int]) -> [Int] {
    var lPrime = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            lPrime[i] = l[i]
        } else {
            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 0..<l.count {
        if i % 2 == 0 {
            lPrime[i] = l[i]
        } else {
            lPrime[i] = l[i].sorted()
        }
    }
    return lPrime
}
```

func sortEven(l: [Int]) -> [Int] {
    var lPrime = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            lPrime[i] = l[i]
        } else {
            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 0..<l.count {
        if i % 2 == 0 {
            lPrime[i] = l[i]
        } else {
            lPrime[i] = l[i].sorted()
        }
    }
    return lPrime
}
```

func sortEven(l: [Int]) -> [Int] {
    var lPrime = l
    for i in 0..<lPrime.count {
        if i % 2 == 0 {
            lPrime[i] = l[i]
        } else {
            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 0..<lPrime.count {
        if i % 2 == 0 {
            lPrime[i] = l[i]
        } else {
            lPrime[i] = l[i].sorted()
        }
    }
    return lPrime
}
```

func sortEven(l: [Int]) -> [Int] {
    var lPrime = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            lPrime[i] = l[i]
        } else {
            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 0..<l.count {
        if i % 2 == 0 {
            lPrime[i] = l[i]
        } else {
            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.sorted()[i / 2]
        }
    }
    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.sorted()[i / 2]
        }
    }
    return l
}
```

func sortEven(l: [Int]) -> [Int] {
    var lPrime = l
    for i in 0..<lPrime.count {
        if i % 2 == 0 {
            lPrime[i] = 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 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 0..<lPrime.count {
        if i % 2 == 0 {
            lPrime[i] = l[i]
        }
    }
    lPrime.sort()
    return lPrime
}
```

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

func primeFib(n: Int) -> Int {
    var fib = [1, 2]
    var i = 2
    while fib.count < n {
        if isPrime(fib[i-1] + fib[i-2]) {
            fib.append(fib[i-1] + fib[i-2])
        }
        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 {
        if isPrime(fib[i-1] + fib[i-2]) {
            fib.append(fib[i-1] + fib[i-2])
        }
        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 a = 1, b = 1, c = 0
    for _ in 1..<n {
        c = a + b
        a = b
        b = c
    }
    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, b = 1, c = 0
    for _ in 1..<n {
        c = a + b
        a = b
        b = c
    }
    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 = [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 primeFib(n: Int) -> Int {
    var a = 1
    var b = 1
    var c = 0
    for _ in 1...n {
        c = a + b
        a = b
        b = c
    }
    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
    for _ in 1...n {
        c = a + b
        a = b
        b = c
    }
    return c
}
```

func primeFib(n: Int) -> Int {
    var a = 1
    var b = 1
    var c = 0
    var i = 1
    while i < n {
        c = a + b
        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
        a = b
        b = c
        i += 1
    }
    return c
}
```

func primeFib(n: Int) -> Int {
    var a = 0
    var b = 1
    var c = 0
    for _ in 0..<n {
        c = a + b
        a = b
        b = c
    }
    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 = 0
    var b = 1
    var c = 0
    for _ in 0..<n {
        c = a + b
        a = b
        b = c
    }
    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 a = 1, b = 1
    for _ in 1..<n {
        let c = a + b
        if isPrime(c) {
            a = b
            b = c
        }
    }
    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
    for _ in 1..<n {
        let c = a + b
        if isPrime(c) {
            a = b
            b = c
        }
    }
    return b
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    // TODO: implement me
    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 me
    return false
}
```

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 {
  // 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: 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 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 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 {
    // TODO: implement me
    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 me
    return false
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.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 seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}
```

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 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 {
    //...
}

```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 {
    //...
}
```

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: 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 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 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] {
    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 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 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 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 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 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 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 x = x
    while x > 0 {
        result = String(x % base) + result
        x /= 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 x = x
    while x > 0 {
        result = String(x % base) + result
        x /= base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var remainder = x
    while remainder > 0 {
        result = String(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 = String(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 x = x
    while x > 0 {
        result = "\(x % base)" + result
        x /= 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 x = x
    while x > 0 {
        result = "\(x % base)" + result
        x /= 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 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 = String(remainder % base) + result
        remainder = 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 = String(remainder % base) + result
        remainder = remainder / base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var remainder = x
    while remainder > 0 {
        result = String(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 = String(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
}

func trapezoidArea(a: Int, b: Int, h: Int) -> Double {
    return Double(a + b) * h / 2
}

func rectangleArea(a: Int, b: Int) -> Double {
    return Double(a * b)
}

func triangleArea(a: Int, b: Int, c: Int) -> Double {
    let p = (a + b + c) / 2
    return sqrt(Double(p * (p - a) * (p - b) * (p - c)))
}

```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
}

// Given length of two sides and return area for a trapezoid.
// trapezoidArea(a: 5, b: 3, h: 3) == 12
func trapezoidArea(a: Int, b: Int, h: Int) -> Double {
    return Double(a + b) * h / 2
}

// Given length of two sides and return area for a rectangle.
// rectangleArea(a: 5, b: 3) == 15
func rectangleArea(a: Int, b: Int) -> Double {
    return Double(a * b)
}

// Given length of three sides and return area for a triangle.
// triangleArea(a: 5, b: 3, c: 4) == 6
func triangleArea(a: Int, b: Int, c: Int) -> Double {
    let p = (a + b + c) / 2
    return sqrt(Double(p * (p - a) * (p - b) * (p - c)))
}

// Given length of three sides and return area for a triangle.
// triangleArea(a: 5, b: 3, c: 4) == 6
func triangleArea(a: Int, b: Int, c: Int) -> Double {
    let p = (a + b + c) / 2
    return sqrt(Double(p * (p - a) * (p - b) * (p - c)))
}

// Given length of three sides and return area for a triangle.
// triangleArea(a: 5, b: 3, c: 4) == 6
func triangleArea(a: Int, b: Int, c: Int) -> Double {
    let p = (a + b + c) / 2
    return sqrt(Double(p * (p - a) * (p - b) * (p - c)))
}

// Given length of three sides and return area for a triangle.
// triangleArea(a: 5, b: 3, c: 4) == 6
func triangleArea(a: Int, b: Int, c: Int) -> Double {
    let p = (a + b + c) / 2
    return sqrt(Double(p * (p - a) * (p - b) * (p - c)))
}

// Given length of three sides and return area for a triangle.
// triangleArea(a: 5, b: 3, c: 4) == 6
func triangleArea(a: Int, b: Int, c: Int) -> Double {
    let p = (a + b + c) / 2
    return sqrt(Double(p * (p - a) * (p - b) * (p - c)))
}

// Given length of three sides and return area for a triangle.
// triangleArea(a: 5, b: 3, c: 4) == 6
func triangleArea(a: Int, b: Int, c: Int) -> Double {
    let p = (a + b + c) / 2
    return sqrt(Double(p * (p - a) * (p - b) * (p - c)))
}

// Given length of three sides and return area for a triangle.
// triangleArea(a: 5, b: 3, c: 4) == 6
func triangleArea(a: Int, b: Int, c: Int) -> Double {
    let p = (a + b + c) / 2
    return sqrt(Double(p * (p - a) * (p - b) * (p - c)))
}

// Given length of three sides and return area for a triangle.
// triangleArea(a: 5, b: 3, c: 4) == 6
func triangleArea(a: Int, b: Int, c: Int) -> Double {
    let p = (a + b + c) / 2
    return sqrt(Double(p * (p - a) * (p - b) * (p - c)))
}

// Given length of three sides and return area for a triangle.
// triangleArea(a: 5, b: 3, c: 4) == 6
func triangleArea(a: Int, b: Int, c: Int) -> Double {
    let p = (a + b + c) / 2
    return sqrt(

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

func squareArea(a: Int) -> Double {
    return Double(a * a)
}

func rectangleArea(a: Int, h: Int) -> Double {
    return Double(a * h)
}

func trapezoidArea(a: Int, b: Int, h: Int) -> Double {
    return Double((a + b) * h) / 2
}

func parallelogramArea(a: Int, h: Int) -> Double {
    return Double(a * h)
}

func rhombusArea(a: Int, h: Int) -> Double {
    return Double(a * h)
}

```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
}

// Given length of a side and height return area for a square.
// squareArea(a: 5) == 25
func squareArea(a: Int) -> Double {
    return Double(a * a)
}

// Given length of a side and height return area for a rectangle.
// rectangleArea(a: 5, h: 3) == 15
func rectangleArea(a: Int, h: Int) -> Double {
    return Double(a * h)
}

// Given length of a side and height return area for a trapezoid.
// trapezoidArea(a: 5, b: 3, h: 3) == 15
func trapezoidArea(a: Int, b: Int, h: Int) -> Double {
    return Double((a + b) * h) / 2
}

// Given length of a side and height return area for a parallelogram.
// parallelogramArea(a: 5, h: 3) == 15
func parallelogramArea(a: Int, h: Int) -> Double {
    return Double(a * h)
}

// Given length of a side and height return area for a rhombus.
// rhombusArea(a: 5, h: 3) == 15
func rhombusArea(a: Int, h: Int) -> Double {
    return Double(a * h)
}
```

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
}

func squareArea(a: Int) -> Double {
    return Double(a * a)
}

func rectangleArea(a: Int, h: Int) -> Double {
    return Double(a * h)
}

func trapezoidArea(a: Int, b: Int, h: Int) -> Double {
    return Double((a + b) * h) / 2
}

func parallelogramArea(a: Int, h: Int) -> Double {
    return Double(a * h)
}

func rhombusArea(a: Int, h: Int) -> Double {
    return Double(a * h)
}

func kiteArea(a: Int, h: Int) -> Double {
    return Double(a * h)
}

func circleArea(r: Int) -> Double {
    return Double(Double.pi * Double(r * r))
}

func ellipseArea(a: Int, b: Int) -> Double {
    return Double(Double.pi * Double(a * b))
}

func sphereArea(r: Int) -> Double {
    return Double(4 * Double.pi * Double(r * r * r))
}

func coneArea(r: Int, h: Int) -> Double {
    return Double(Double.pi * Double(r * r) * Double(h))
}

func cylinderArea(r: Int, h: Int) -> Double {
    return Double(2 * Double.pi * Double(r * r) * Double(h))
}

func pyramidArea(r: Int, h: Int) -> Double {
    return Double(Double.pi * Double(r * r) * Double(h))
}

func cubeArea(a: Int) -> Double {
    return Double(a * a * a)
}

```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
}

// Given length of a side and high return area for a square.
// squareArea(a: 5) == 25
func squareArea(a: Int) -> Double {
    return Double(a * a)
}

// Given length of a side and high return area for a rectangle.
// rectangleArea(a: 5, h: 3) == 15
func rectangleArea(a: Int, h: Int) -> Double {
    return Double(a * h)
}

// Given length of a side and high return area for a trapezoid.
// trapezoidArea(a: 5, b: 3, h: 2) == 10
func trapezoidArea(a: Int, b: Int, h: Int) -> Double {
    return Double((a + b) * h) / 2
}

// Given length of a side and high return area for a parallelogram.
// parallelogramArea(a: 5, h: 3) == 15
func parallelogramArea(a: Int, h: Int) -> Double {
    return Double(a * h)
}

// Given length of a side and high return area for a rhombus.
// rhombusArea(a: 5, h: 3) == 15
func rhombusArea(a: Int, h: Int) -> Double {
    return Double(a * h)
}

// Given length of a side and high return area for a kite.
// kiteArea(a: 5, h: 3) == 15
func kiteArea(a: Int, h: Int) -> Double {
    return Double(a * h)
}

// Given length of a side and high return area for a circle.
// circleArea(r: 5) == 78.53981633974483
func circleArea(r: Int) -> Double {
    return Double(Double.pi * Double(r * r))
}

// Given length of a side and high return area for a ellipse.
// ellipseArea(a: 5, b: 3) == 37.69908169872414
func ellipseArea(a: Int, b: Int) -> Double {
    return Double(Double.pi * Double(a * b))
}

// Given length of a side and high return area for a sphere.
// sphereArea(r: 5) == 523.5987755982989
func sphereArea(r: Int) -> Double {
    return Double(4 * Double.pi * Double(r * r * r))
}

// Given length of a side and high return area for a cone.
// coneArea(r: 5, h: 3) == 37.69908169872414
func coneArea(r: Int, h: Int) -> Double {
    return Double(Double.pi * Double(r * r) * Double(h))
}

// Given length of a side and high return area for a cylinder.
// cylinderArea(r: 5, h: 3) == 37.69908169872414
func cylinderArea(r: Int, h: Int) -> Double {
    return Double(2 * Double.pi * Double(r * r) * Double(h))
}

// Given length of a side and high return area for a pyramid.
// pyramidArea(r: 5, h: 3) == 37.69908169872414
func pyramidArea(r: Int, h: Int) -> Double {
    return Double(Double.pi * Double(r * r) * Double(h))
}

// Given length of a side and high return area for a cube.
// cubeArea(a: 5) == 125
func cubeArea(a: Int) -> Double {
    return Double(a * a * a)
}

// Given length of a side and high return area for a cuboid.
// cuboidArea(a: 5, b: 3, c: 2) == 30
func cuboidArea(a: Int, b

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 {
    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 {
    if n < 0 {
        return 0
    }
    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 _ in 0..<n-3 {
        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 {
    if n < 0 {
        return 0
    }
    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 _ in 0..<n-3 {
        d = a + b + c
        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 i 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 i in 0..<n {
        d = a + b + c
        a = b
        b = c
        c = d
    }
    return d
}
```

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.
}

```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.
}
```

func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    for i 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 i in 0..<n {
        d = a + b + c
        a = b
        b = c
        c = d
    }
    return d
}
```

func fib4(n: Int) -> Int {
    if n == 0 {
        return 0
    } else if n == 1 {
        return 0
    } else if n == 2 {
        return 2
    } else if n == 3 {
        return 0
    } else {
        return fib4(n: n - 1) + fib4(n: n - 2) + fib4(n: n - 3) + fib4(n: n - 4)
    }
}

```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 {
    if n == 0 {
        return 0
    } else if n == 1 {
        return 0
    } else if n == 2 {
        return 2
    } else if n == 3 {
        return 0
    } else {
        return fib4(n: n - 1) + fib4(n: n - 2) + fib4(n: n - 3) + fib4(n: n - 4)
    }
}
```

func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 0
    var d = 0
    var e = 0
    for i in 1...n {
        e = a + b + c + d
        a = b
        b = c
        c = d
        d = e
    }
    return e
}

```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 = 0
    var d = 0
    var e = 0
    for i in 1...n {
        e = a + b + c + d
        a = b
        b = c
        c = d
        d = e
    }
    return e
}
```

func fib4(n: Int) -> Int {
    var fibs = [0, 0, 2, 0]
    if n < 3 {
        return fibs[n]
    }
    for i in 3...n {
        fibs.append(fibs[i-1] + fibs[i-2] + fibs[i-3] + fibs[i-4])
    }
    return fibs[n]
}

```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 fibs = [0, 0, 2, 0]
    if n < 3 {
        return fibs[n]
    }
    for i in 3...n {
        fibs.append(fibs[i-1] + fibs[i-2] + fibs[i-3] + fibs[i-4])
    }
    return fibs[n]
}
```

func fib4(n: Int) -> Int {
    if n <= 1 {
        return 0
    }
    if n <= 3 {
        return 2
    }
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    for i in 3...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 {
    if n <= 1 {
        return 0
    }
    if n <= 3 {
        return 2
    }
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    for i in 3...n {
        d = a + b + c
        a = b
        b = c
        c = d
    }
    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 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()
    if sorted.count % 2 == 0 {
        let middle = sorted.count / 2
        return Double(sorted[middle] + sorted[middle - 1]) / 2
    } else {
        let middle = sorted.count / 2
        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()
    if sorted.count % 2 == 0 {
        let middle = sorted.count / 2
        return Double(sorted[middle] + sorted[middle - 1]) / 2
    } else {
        let middle = sorted.count / 2
        return Double(sorted[middle])
    }
}
```

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 {
    // 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()
    if sorted.count % 2 == 0 {
        let index = sorted.count / 2
        return (Double(sorted[index - 1]) + Double(sorted[index])) / 2
    } else {
        let index = sorted.count / 2
        return Double(sorted[index])
    }
}

```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()
    if sorted.count % 2 == 0 {
        let index = sorted.count / 2
        return (Double(sorted[index - 1]) + Double(sorted[index])) / 2
    } else {
        let index = sorted.count / 2
        return Double(sorted[index])
    }
}
```

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()
    if sorted.count % 2 == 0 {
        let mid = sorted.count / 2
        return Double(sorted[mid - 1] + sorted[mid]) / 2.0
    } else {
        let mid = (sorted.count + 1) / 2
        return Double(sorted[mid - 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()
    if sorted.count % 2 == 0 {
        let mid = sorted.count / 2
        return Double(sorted[mid - 1] + sorted[mid]) / 2.0
    } else {
        let mid = (sorted.count + 1) / 2
        return Double(sorted[mid - 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
    } 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 middle = sorted.count / 2
    if sorted.count % 2 == 0 {
        return Double(sorted[middle] + sorted[middle - 1]) / 2
    } 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
    } else {
        return Double(sorted[middle])
    }
}
```

func isPalindrome(text: String) -> Bool {
    var left = 0
    var right = text.count - 1
    while left < right {
        if text[left]!= text[right] {
            return false
        }
        left += 1
        right -= 1
    }
    return true
}

```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 {
    var left = 0
    var right = text.count - 1
    while left < right {
        if text[left]!= text[right] {
            return false
        }
        left += 1
        right -= 1
    }
    return true
}
```