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

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

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

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

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

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

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

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var prev: Double?
    for number in numbers {
        if let prev = prev {
            if abs(prev - number) <= threshold {
                return true
            }
        }
        prev = number
    }
    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 prev: Double?
    for number in numbers {
        if let prev = prev {
            if abs(prev - number) <= threshold {
                return true
            }
        }
        prev = number
    }
    return false
}
```

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

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

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

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

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

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

```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 hasCloseElements = false
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            if abs(numbers[i] - numbers[j]) <= threshold {
                hasCloseElements = true
            }
        }
    }
    return hasCloseElements
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var prev: Double?
    for num in numbers {
        if let prev = prev {
            if abs(prev - num) <= threshold {
                return true
            }
        }
        prev = num
    }
    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 prev: Double?
    for num in numbers {
        if let prev = prev {
            if abs(prev - num) <= threshold {
                return true
            }
        }
        prev = num
    }
    return false
}
```

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

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

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

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

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

```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
    return []
}
```

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

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

func separateParenGroups(parenString: String) -> [String] {
    // Write your code here.
    var result = [String]()
    var temp = ""
    var count = 0
    for char in parenString {
        if char == "(" {
            count += 1
            temp += String(char)
        } else if char == ")" {
            count -= 1
            temp += String(char)
        }
        if count == 0 {
            result.append(temp)
            temp = ""
        }
    }
    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] {
    // Write your code here.
    var result = [String]()
    var temp = ""
    var count = 0
    for char in parenString {
        if char == "(" {
            count += 1
            temp += String(char)
        } else if char == ")" {
            count -= 1
            temp += String(char)
        }
        if count == 0 {
            result.append(temp)
            temp = ""
        }
    }
    return result
}
```

func separateParenGroups(parenString: String) -> [String] {
    // Write your code here.
    var result = [String]()
    var temp = ""
    var count = 0
    for char in parenString {
        if char == "(" {
            count += 1
            temp += String(char)
        } else if char == ")" {
            count -= 1
            temp += String(char)
        }
        if count == 0 {
            result.append(temp)
            temp = ""
        }
    }
    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] {
    // Write your code here.
    var result = [String]()
    var temp = ""
    var count = 0
    for char in parenString {
        if char == "(" {
            count += 1
            temp += String(char)
        } else if char == ")" {
            count -= 1
            temp += String(char)
        }
        if count == 0 {
            result.append(temp)
            temp = ""
        }
    }
    return result
}
```

func separateParenGroups(parenString: String) -> [String] {
    // Write your code here.
    var result = [String]()
    var temp = ""
    var count = 0
    for char in parenString {
        if char == "(" {
            count += 1
            temp += String(char)
        } else if char == ")" {
            count -= 1
            temp += String(char)
        }
        if count == 0 {
            result.append(temp)
            temp = ""
        }
    }
    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] {
    // Write your code here.
    var result = [String]()
    var temp = ""
    var count = 0
    for char in parenString {
        if char == "(" {
            count += 1
            temp += String(char)
        } else if char == ")" {
            count -= 1
            temp += String(char)
        }
        if count == 0 {
            result.append(temp)
            temp = ""
        }
    }
    return result
}
```

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

```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: Write your code here
    return []
}
```

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

```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
    return []
}
```

func separateParenGroups(parenString: String) -> [String] {
    // Write your code here.
    var result = [String]()
    var temp = ""
    var count = 0
    for char in parenString {
        if char == "(" {
            count += 1
            temp.append(char)
        } else if char == ")" {
            count -= 1
            temp.append(char)
        }
        if count == 0 {
            result.append(temp)
            temp = ""
        }
    }
    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] {
    // Write your code here.
    var result = [String]()
    var temp = ""
    var count = 0
    for char in parenString {
        if char == "(" {
            count += 1
            temp.append(char)
        } else if char == ")" {
            count -= 1
            temp.append(char)
        }
        if count == 0 {
            result.append(temp)
            temp = ""
        }
    }
    return result
}
```

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

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

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

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

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

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

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

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

func truncateInteger(number: Double) -> Int {
    return Int(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)
}

// 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 integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateInteger(number: Double) -> Double {
    return floor(number)
}

// 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 integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateInteger(number: Double) -> Int {
    return Int(floor(number))
}
```

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

func truncateNumber(number: Double) -> Int {
    return Int(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)
}

// 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 integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Int {
    return Int(floor(number))
}
```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    return numbers.reduce(0.0, { $0 + abs($1 - mean) }) / 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)
    return numbers.reduce(0.0, { $0 + abs($1 - mean) }) / Double(numbers.count)
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers)
    return numbers.reduce(0.0, { $0 + abs($1 - mean) }) / 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)
    return numbers.reduce(0.0, { $0 + abs($1 - mean) }) / Double(numbers.count)
}
```

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

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

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    return numbers.reduce(0.0, { $0 + abs($1 - mean) }) / 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)
    return numbers.reduce(0.0, { $0 + abs($1 - mean) }) / Double(numbers.count)
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.reduce(0) { $0 + abs($1 - mean) } / 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 = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.reduce(0) { $0 + abs($1 - mean) } / Double(numbers.count)
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0.0, +) / Double(numbers.count)
    return numbers.map { abs($0 - mean) }.reduce(0.0, +) / 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 = numbers.reduce(0.0, +) / Double(numbers.count)
    return numbers.map { abs($0 - mean) }.reduce(0.0, +) / Double(numbers.count)
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.reduce(0, { $0 + abs($1 - mean) }) / 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 = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.reduce(0, { $0 + abs($1 - mean) }) / Double(numbers.count)
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs($0 - mean) }.reduce(0, +) / 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 = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs($0 - mean) }.reduce(0, +) / Double(numbers.count)
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.reduce(0, { $0 + abs($1 - mean) }) / 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 = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.reduce(0, { $0 + abs($1 - mean) }) / Double(numbers.count)
}
```

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

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

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    var last = numbers.first
    for number in numbers.dropFirst() {
        result.append(last!)
        result.append(delimeter)
        last = number
    }
    result.append(last!)
    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]()
    var last = numbers.first
    for number in numbers.dropFirst() {
        result.append(last!)
        result.append(delimeter)
        last = number
    }
    result.append(last!)
    return result
}
```

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

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

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

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

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

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

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    return numbers.reduce([Int]()) { (result, number) in
        result + [number] + (result.isEmpty? [] : [delimeter])
    }
}

```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] {
    return numbers.reduce([Int]()) { (result, number) in
        result + [number] + (result.isEmpty? [] : [delimeter])
    }
}
```

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

func parseNestedParens(parenString: String) -> [Int] {
    var result = [Int]()
    var currentLevel = 0
    var currentDepth = 0
    var currentParen = ""
    for char in parenString {
        if char == "(" {
            currentLevel += 1
            currentDepth = max(currentDepth, currentLevel)
            currentParen += "("
        } else if char == ")" {
            currentLevel -= 1
            currentParen += ")"
        } else {
            currentParen += String(char)
        }
        if currentLevel == 0 {
            result.append(currentDepth)
            currentDepth = 0
            currentParen = ""
        }
    }
    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 currentLevel = 0
    var currentDepth = 0
    var currentParen = ""
    for char in parenString {
        if char == "(" {
            currentLevel += 1
            currentDepth = max(currentDepth, currentLevel)
            currentParen += "("
        } else if char == ")" {
            currentLevel -= 1
            currentParen += ")"
        } else {
            currentParen += String(char)
        }
        if currentLevel == 0 {
            result.append(currentDepth)
            currentDepth = 0
            currentParen = ""
        }
    }
    return result
}
```

func parseNestedParens(parenString: String) -> [Int] {
    let parenArray = parenString.components(separatedBy: " ")
    var resultArray = [Int]()
    for paren in parenArray {
        var level = 0
        var open = 0
        for char in paren {
            if char == "(" {
                open += 1
            } else if char == ")" {
                open -= 1
            }
            if open < 0 {
                break
            }
            level += 1
        }
        resultArray.append(level)
    }
    return resultArray
}

```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] {
    let parenArray = parenString.components(separatedBy: " ")
    var resultArray = [Int]()
    for paren in parenArray {
        var level = 0
        var open = 0
        for char in paren {
            if char == "(" {
                open += 1
            } else if char == ")" {
                open -= 1
            }
            if open < 0 {
                break
            }
            level += 1
        }
        resultArray.append(level)
    }
    return resultArray
}
```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func filterBySubstring(strings: [String], substring: String) -> [String] {
    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 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 num in numbers {
        sum += num
        product *= num
    }
    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 num in numbers {
        sum += num
        product *= num
    }
    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 num in numbers {
        sum += num
        product *= num
    }
    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 num in numbers {
        sum += num
        product *= num
    }
    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 maxes = [Int]()
    var max = Int.min
    for number in numbers {
        max = max > number? max : number
        maxes.append(max)
    }
    return maxes
}

```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 maxes = [Int]()
    var max = Int.min
    for number in numbers {
        max = max > number? max : number
        maxes.append(max)
    }
    return maxes
}
```

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

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

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

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

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

```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 maxes = [Int]()
    var max = numbers[0]
    maxes.append(max)
    for i in 1..<numbers.count {
        max = max > numbers[i]? max : numbers[i]
        maxes.append(max)
    }
    return maxes
}
```

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

```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 rollingMax = [Int]()
    var max = numbers[0]
    rollingMax.append(max)
    for i in 1..<numbers.count {
        if numbers[i] > max {
            max = numbers[i]
        }
        rollingMax.append(max)
    }
    return rollingMax
}
```

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

```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 maxes = [Int]()
    var max = Int.min
    for number in numbers {
        max = max > number? max : number
        maxes.append(max)
    }
    return maxes
}
```

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

```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 maxes = [Int]()
    var max = numbers[0]
    maxes.append(max)
    for i in 1..<numbers.count {
        if numbers[i] > max {
            max = numbers[i]
        }
        maxes.append(max)
    }
    return maxes
}
```

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

```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 maxes = [Int]()
    var max = numbers[0]
    maxes.append(max)
    for i in 1..<numbers.count {
        if numbers[i] > max {
            max = numbers[i]
        }
        maxes.append(max)
    }
    return maxes
}
```

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

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

func makePalindrome(string: String) -> String {
    let palindrome = string.palindrome
    let prefix = string.prefix(upTo: palindrome.startIndex)
    let suffix = string.suffix(from: palindrome.endIndex)
    return suffix + string + prefix
}

```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 palindrome = string.palindrome
    let prefix = string.prefix(upTo: palindrome.startIndex)
    let suffix = string.suffix(from: palindrome.endIndex)
    return suffix + string + prefix
}
```

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

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

func makePalindrome(string: String) -> String {
    let reversed = String(string.reversed())
    let palindrome = string + reversed
    let palindromePrefix = palindrome.prefix(palindrome.count / 2)
    let palindromeSuffix = palindrome.suffix(palindrome.count / 2)
    if palindromeSuffix == palindromeSuffix.reversed() {
        return palindrome
    } else {
        return makePalindrome(string: String(palindromePrefix.reversed())) + palindromeSuffix
    }
}

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

func makePalindrome(string: String) -> String {
    let reversed = string.reversed()
    let prefix = string.prefix(string.count / 2)
    let postfix = string.suffix(string.count / 2)
    if postfix == postfix.reversed() {
        return string + reversed
    } else {
        return makePalindrome(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 {
    let reversed = string.reversed()
    let prefix = string.prefix(string.count / 2)
    let postfix = string.suffix(string.count / 2)
    if postfix == postfix.reversed() {
        return string + reversed
    } else {
        return makePalindrome(string: string + reversed)
    }
}
```

func makePalindrome(string: String) -> String {
    guard!string.isEmpty else { return "" }
    guard string.count > 1 else { return string }

    let reversedString = String(string.reversed())
    let palindrome = string + reversedString

    var leftIndex = 0
    var rightIndex = palindrome.count - 1
    while leftIndex < rightIndex {
        if palindrome[leftIndex]!= palindrome[rightIndex] {
            break
        }
        leftIndex += 1
        rightIndex -= 1
    }

    let prefix = String(palindrome[leftIndex..<rightIndex])
    let suffix = String(palindrome[rightIndex...])
    let reversedPrefix = String(prefix.reversed())

    return suffix + reversedPrefix + string
}

```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 {
    guard!string.isEmpty else { return "" }
    guard string.count > 1 else { return string }

    let reversedString = String(string.reversed())
    let palindrome = string + reversedString

    var leftIndex = 0
    var rightIndex = palindrome.count - 1
    while leftIndex < rightIndex {
        if palindrome[leftIndex]!= palindrome[rightIndex] {
            break
        }
        leftIndex += 1
        rightIndex -= 1
    }

    let prefix = String(palindrome[leftIndex..<rightIndex])
    let suffix = String(palindrome[rightIndex...])
    let reversedPrefix = String(prefix.reversed())

    return suffix + reversedPrefix + string
}
```

func makePalindrome(string: String) -> String {
    let reversed = string.reversed()
    let palindrome = string + reversed
    let palindromeIndex = palindrome.index(palindrome.startIndex, offsetBy: string.count)
    let palindromePrefix = palindrome.prefix(upTo: palindromeIndex)
    let palindromeSuffix = palindrome.suffix(from: palindromeIndex)
    return string + String(palindromeSuffix.reversed())
}

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

func makePalindrome(string: String) -> String {
    let reversedString = String(string.reversed())
    let palindrome = string + reversedString
    let palindromePrefix = palindrome.prefix(string.count)
    let palindromeSuffix = palindrome.suffix(string.count)
    if palindromeSuffix == palindromePrefix {
        return palindrome
    } else {
        return makePalindrome(string: String(palindromePrefix))
    }
}

```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 palindrome = string + reversedString
    let palindromePrefix = palindrome.prefix(string.count)
    let palindromeSuffix = palindrome.suffix(string.count)
    if palindromeSuffix == palindromePrefix {
        return palindrome
    } else {
        return makePalindrome(string: String(palindromePrefix))
    }
}
```

func makePalindrome(string: String) -> String {
    guard string.count > 1 else { return string }
    let palindrome = string.prefix(string.count / 2).reversed()
    let prefix = string.prefix(string.count / 2)
    return String(palindrome) + prefix + String(palindrome.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 {
    guard string.count > 1 else { return string }
    let palindrome = string.prefix(string.count / 2).reversed()
    let prefix = string.prefix(string.count / 2)
    return String(palindrome) + prefix + String(palindrome.reversed())
}
```

func makePalindrome(string: String) -> String {
    guard string.count > 1 else { return string }
    let reversed = String(string.reversed())
    let palindrome = string.suffix(string.count / 2)
    if palindrome == reversed {
        return string
    } else {
        return makePalindrome(string: string + reversed.prefix(string.count / 2))
    }
}

```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 {
    guard string.count > 1 else { return string }
    let reversed = String(string.reversed())
    let palindrome = string.suffix(string.count / 2)
    if palindrome == reversed {
        return string
    } else {
        return makePalindrome(string: string + reversed.prefix(string.count / 2))
    }
}
```

func makePalindrome(string: String) -> String {
    guard string.count > 1 else { return string }
    let reversed = String(string.reversed())
    let palindrome = string.suffix(string.count / 2)
    if palindrome == reversed {
        return string
    } else {
        return makePalindrome(string: string + reversed.prefix(string.count - string.count / 2))
    }
}

```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 {
    guard string.count > 1 else { return string }
    let reversed = String(string.reversed())
    let palindrome = string.suffix(string.count / 2)
    if palindrome == reversed {
        return string
    } else {
        return makePalindrome(string: string + reversed.prefix(string.count - string.count / 2))
    }
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for (index, char) in a.enumerated() {
        let bChar = b[b.index(b.startIndex, offsetBy: index)]
        result += String(char!= bChar? "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 (index, char) in a.enumerated() {
        let bChar = b[b.index(b.startIndex, offsetBy: index)]
        result += String(char!= bChar? "1" : "0")
    }
    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 {
        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 stringXor(a: String, b: String) -> String {
    var result = ""
    for (i, j) in zip(a, b) {
        result += String(i!= j? "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, j) in zip(a, b) {
        result += String(i!= j? "1" : "0")
    }
    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 stringXor(a: String, b: String) -> String {
    var result = ""
    for (i, j) in zip(a, b) {
        result += String(i!= j? "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, j) in zip(a, b) {
        result += String(i!= j? "1" : "0")
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    // TODO: Write your code here
    return ""
}

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

func stringXor(a: String, b: String) -> String {
    return ""
}

```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 {
    return ""
}
```

func stringXor(a: String, b: String) -> String {
    // TODO: Implement this function
    return ""
}

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

func stringXor(a: String, b: String) -> String {
    return ""
}

```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 {
    return ""
}
```

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

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

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

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

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

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

func longest(strings: [String]) -> String? {
    // TODO: Implement this function
    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 this function
    return nil
}
```

func longest(strings: [String]) -> String? {
    // TODO: Implement this function
    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 this function
    return nil
}
```

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

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

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

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

func longest(strings: [String]) -> String? {
    // TODO: Implement this function
    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 this function
    return nil
}
```

func longest(strings: [String]) -> String? {
    var longestString: String?
    for string in strings {
        if longestString == nil || string.count > longestString!.count {
            longestString = string
        }
    }
    return longestString
}

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

func longest(strings: [String]) -> String? {
    // TODO: Implement this function
    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 this function
    return nil
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    var a = a
    var b = b
    while b!= 0 {
        let temp = b
        b = a % b
        a = temp
    }
    return 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 {
    var a = a
    var b = b
    while b!= 0 {
        let temp = b
        b = a % b
        a = temp
    }
    return a
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    // Your code here
}

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

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    var a = a
    var b = b
    while b!= 0 {
        let temp = b
        b = a % b
        a = temp
    }
    return 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 {
    var a = a
    var b = b
    while b!= 0 {
        let temp = b
        b = a % b
        a = temp
    }
    return a
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    var a = a
    var b = b
    while b!= 0 {
        let temp = b
        b = a % b
        a = temp
    }
    return 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 {
    var a = a
    var b = b
    while b!= 0 {
        let temp = b
        b = a % b
        a = temp
    }
    return a
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    // Your code here
}

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

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

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

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

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

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 allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(string.prefix(i))
    }
    return prefixes
}

```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 prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(string.prefix(i))
    }
    return prefixes
}
```

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

```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 prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(string.prefix(i + 1))
    }
    return prefixes
}
```

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

```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 prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(string.prefix(i + 1))
    }
    return prefixes
}
```

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

```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 prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(string.prefix(i + 1))
    }
    return prefixes
}
```

func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(string.substring(to: i))
    }
    return prefixes
}

```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 prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(string.substring(to: i))
    }
    return prefixes
}
```

func allPrefixes(string: String) -> [String] {
    return string.map { String($0) }
}

```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] {
    return string.map { String($0) }
}
```

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

```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 prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(String(string.prefix(i)))
    }
    return prefixes
}
```

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

```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 prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(String(string.prefix(i)))
    }
    return prefixes
}
```

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

```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 prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(String(string.prefix(i + 1)))
    }
    return prefixes
}
```

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

```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 prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(String(string.prefix(i)))
    }
    return prefixes
}
```

func stringSequence(n: Int) -> String {
    return (0...n).map(String.init).joined(separator: " ")
}

```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 {
    return (0...n).map(String.init).joined(separator: " ")
}
```

func stringSequence(n: Int) -> String {
    return (0...n).map(String.init).joined(separator: " ")
}

```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 {
    return (0...n).map(String.init).joined(separator: " ")
}
```

func stringSequence(n: Int) -> String {
    return (0..<n).map(String.init).joined(separator: " ")
}

```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 {
    return (0..<n).map(String.init).joined(separator: " ")
}
```

func stringSequence(n: Int) -> String {
    return (0..<n).map(String.init).joined(separator: " ")
}

```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 {
    return (0..<n).map(String.init).joined(separator: " ")
}
```

func stringSequence(n: Int) -> String {
    return (0..<n).map(String.init).joined(separator: " ")
}

```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 {
    return (0..<n).map(String.init).joined(separator: " ")
}
```

func stringSequence(n: Int) -> String {
    return (0..<n).map(String.init).joined(separator: " ")
}

```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 {
    return (0..<n).map(String.init).joined(separator: " ")
}
```

func stringSequence(n: Int) -> String {
    return (0..<n).map(String.init).joined(separator: " ")
}

```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 {
    return (0..<n).map(String.init).joined(separator: " ")
}
```

func stringSequence(n: Int) -> String {
    return (0..<n).map(String.init).joined(separator: " ")
}

```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 {
    return (0..<n).map(String.init).joined(separator: " ")
}
```

func stringSequence(n: Int) -> String {
    return (0..<n).map { String($0) }.joined(separator: " ")
}

```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 {
    return (0..<n).map { String($0) }.joined(separator: " ")
}
```

func stringSequence(n: Int) -> String {
    return (0..<n).map(String.init).joined(separator: " ")
}

```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 {
    return (0..<n).map(String.init).joined(separator: " ")
}
```

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.lowercased() {
        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.lowercased() {
        distinctCharacters.insert(character)
    }
    return distinctCharacters.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.lowercased() {
        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.lowercased() {
        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 {
    var distinctCharacters = Set<Character>()
    for character in string.lowercased() {
        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.lowercased() {
        distinctCharacters.insert(character)
    }
    return distinctCharacters.count
}
```

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

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

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.lowercased() {
        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.lowercased() {
        distinctCharacters.insert(character)
    }
    return distinctCharacters.count
}
```

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

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

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

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

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

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

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

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

func parseMusic(musicString: String) -> [Int] {
    return musicString.split(separator: " ").map {
        switch $0 {
        case "o":
            return 4
        case "o|":
            return 2
        case ".|":
            return 1
        default:
            return 0
        }
    }
}

```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] {
    return musicString.split(separator: " ").map {
        switch $0 {
        case "o":
            return 4
        case "o|":
            return 2
        case ".|":
            return 1
        default:
            return 0
        }
    }
}
```

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

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

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = 0
    while index < string.count {
        let range = string.range(of: substring, range: index..<string.count)
        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 = 0
    while index < string.count {
        let range = string.range(of: substring, range: index..<string.count)
        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 index!= string.endIndex {
        if string.hasPrefix(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.hasPrefix(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 index < string.endIndex {
        if string[index] == substring[substring.startIndex] {
            var subIndex = substring.startIndex
            var subString = string[index..<string.endIndex]
            while subIndex < substring.endIndex {
                if subString[subIndex] == substring[subIndex] {
                    subIndex = subIndex.advancedBy(1)
                } else {
                    break
                }
            }
            if subIndex == substring.endIndex {
                count++
                index = index.advancedBy(1)
            } else {
                index = index.advancedBy(1)
            }
        } else {
            index = index.advancedBy(1)
        }
    }
    return count
}

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

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

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

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = 0
    while index < string.count {
        if string.hasPrefix(substring) {
            count += 1
            index += substring.count
        } else {
            index += 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 = 0
    while index < string.count {
        if string.hasPrefix(substring) {
            count += 1
            index += substring.count
        } else {
            index += 1
        }
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while index!= string.endIndex {
        if string.hasPrefix(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.hasPrefix(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 index < string.endIndex {
        if string[index] == substring[substring.startIndex] {
            var index2 = index
            var index3 = substring.startIndex
            while index2 < string.endIndex && index3 < substring.endIndex && string[index2] == substring[index3] {
                index2 = string.index(after: index2)
                index3 = substring.index(after: index3)
            }
            if index3 == substring.endIndex {
                count += 1
            }
        }
        index = string.index(after: index)
    }
    return count
}

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

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

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

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

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

func sortNumbers(numbers: String) -> String {
    // TODO: 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 {
    // TODO: Write your code here
}
```

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 {
    var sorted = [String]()
    let numbers = numbers.components(separatedBy: " ")
    for number in numbers {
        sorted.append(number)
    }
    sorted.sort()
    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 {
    var sorted = [String]()
    let numbers = numbers.components(separatedBy: " ")
    for number in numbers {
        sorted.append(number)
    }
    sorted.sort()
    return sorted.joined(separator: " ")
}
```

func sortNumbers(numbers: String) -> String {
    // TODO: Implement this function
    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: Implement this function
    return ""
}
```

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

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 sortedNumbers = numbers.components(separatedBy: " ").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 sortedNumbers = numbers.components(separatedBy: " ").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) {
    let sorted = numbers.sorted()
    let first = sorted[0]
    let last = sorted[sorted.count - 1]
    let firstIndex = sorted.firstIndex(of: first)!
    let lastIndex = sorted.firstIndex(of: last)!
    let firstDistance = abs(first - numbers[firstIndex - 1])
    let lastDistance = abs(last - numbers[lastIndex + 1])
    if firstDistance < lastDistance {
        return (first, numbers[firstIndex - 1])
    } else {
        return (last, numbers[lastIndex + 1])
    }
}

```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 sorted = numbers.sorted()
    let first = sorted[0]
    let last = sorted[sorted.count - 1]
    let firstIndex = sorted.firstIndex(of: first)!
    let lastIndex = sorted.firstIndex(of: last)!
    let firstDistance = abs(first - numbers[firstIndex - 1])
    let lastDistance = abs(last - numbers[lastIndex + 1])
    if firstDistance < lastDistance {
        return (first, numbers[firstIndex - 1])
    } else {
        return (last, numbers[lastIndex + 1])
    }
}

findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
```

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

```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 minDiff = Double.infinity
    var minDiffIndex = 0
    var minDiffIndex2 = 0
    for i in 0..<numbers.count - 1 {
        let diff = abs(numbers[i] - numbers[i + 1])
        if diff < minDiff {
            minDiff = diff
            minDiffIndex = i
            minDiffIndex2 = i + 1
        }
    }
    return (numbers[minDiffIndex], numbers[minDiffIndex2])
}
```

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

```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 minDiff = Double.greatestFiniteMagnitude
    var minDiffIndex = 0
    var minDiffIndex2 = 0
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            let diff = abs(numbers[i] - numbers[j])
            if diff < minDiff {
                minDiff = diff
                minDiffIndex = i
                minDiffIndex2 = j
            }
        }
    }
    return (numbers[minDiffIndex], numbers[minDiffIndex2])
}

// 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 minDiff = Double.greatestFiniteMagnitude
    var minDiffIndex = 0
    var maxDiffIndex = 1
    for i in 1..<numbers.count {
        let diff = numbers[i] - numbers[i - 1]
        if diff < minDiff {
            minDiff = diff
            minDiffIndex = i - 1
            maxDiffIndex = i
        }
    }
    return (numbers[minDiffIndex], numbers[maxDiffIndex])
}

```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 minDiff = Double.greatestFiniteMagnitude
    var minDiffIndex = 0
    var maxDiffIndex = 1
    for i in 1..<numbers.count {
        let diff = numbers[i] - numbers[i - 1]
        if diff < minDiff {
            minDiff = diff
            minDiffIndex = i - 1
            maxDiffIndex = i
        }
    }
    return (numbers[minDiffIndex], numbers[maxDiffIndex])
}
```

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

```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 minDiff = Double.greatestFiniteMagnitude
    var minDiffIndex = 0
    var minDiffIndex2 = 0
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            let diff = abs(numbers[i] - numbers[j])
            if diff < minDiff {
                minDiff = diff
                minDiffIndex = i
                minDiffIndex2 = j
            }
        }
    }
    return (numbers[minDiffIndex], numbers[minDiffIndex2])
}

// 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 minDiff = Double.greatestFiniteMagnitude
    var minDiffIndex = 0
    var minDiffIndex2 = 0
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            let diff = abs(numbers[i] - numbers[j])
            if diff < minDiff {
                minDiff = diff
                minDiffIndex = i
                minDiffIndex2 = j
            }
        }
    }
    return (numbers[minDiffIndex], numbers[minDiffIndex2])
}

// 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 minDiff = Double.greatestFiniteMagnitude
    var minDiffIndex = 0
    var minDiffIndex2 = 0
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            let diff = abs(numbers[i] - numbers[j])
            if diff < minDiff {
                minDiff = diff
                minDiffIndex = i
                minDiffIndex2 = j
            }
        }
    }
    return (numbers[minDiffIndex], numbers[minDiffIndex2])
}

// 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 minDiff = Double.greatestFiniteMagnitude
    var minDiffIndex = 0
    var minDiffIndex2 = 0
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            let diff = abs(numbers[i] - numbers[j])
            if diff < minDiff {
                minDiff = diff
                minDiffIndex = i
                minDiffIndex2 = j
            }
        }
    }
    return (numbers[minDiffIndex], numbers[minDiffIndex2])
}

// 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,

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

```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 minDiff = Double.infinity
    var minDiffPair = (0, 0)
    for i in 0..<numbers.count {
        for j in i+1..<numbers.count {
            let diff = abs(numbers[i] - numbers[j])
            if diff < minDiff {
                minDiff = diff
                minDiffPair = (numbers[i], numbers[j])
            }
        }
    }
    return minDiffPair
}
```

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

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

// 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 sorted = numbers.sorted()
    let mid = sorted.count / 2
    let left = sorted[mid - 1]
    let right = sorted[mid]
    return (left, right)
}

```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 sorted = numbers.sorted()
    let mid = sorted.count / 2
    let left = sorted[mid - 1]
    let right = sorted[mid]
    return (left, right)
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    var minDiff = Double.greatestFiniteMagnitude
    var minDiffIndex = 0
    var maxDiffIndex = 1
    var minDiffElement = numbers[0]
    var maxDiffElement = numbers[1]
    for i in 0..<numbers.count {
        let diff = numbers[i] - numbers[i+1]
        if diff < minDiff {
            minDiff = diff
            minDiffIndex = i
            maxDiffIndex = i + 1
        }
    }
    return (numbers[minDiffIndex], numbers[maxDiffIndex])
}

```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 minDiff = Double.greatestFiniteMagnitude
    var minDiffIndex = 0
    var maxDiffIndex = 1
    var minDiffElement = numbers[0]
    var maxDiffElement = numbers[1]
    for i in 0..<numbers.count {
        let diff = numbers[i] - numbers[i+1]
        if diff < minDiff {
            minDiff = diff
            minDiffIndex = i
            maxDiffIndex = i + 1
        }
    }
    return (numbers[minDiffIndex], numbers[maxDiffIndex])
}
```

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

```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 minDiff = Double.infinity
    var result = (0.0, 0.0)
    for i in 0..<numbers.count - 1 {
        let diff = abs(numbers[i] - numbers[i + 1])
        if diff < minDiff {
            minDiff = diff
            result = (numbers[i], numbers[i + 1])
        }
    }
    return result
}
```

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

```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
    return []
}
```

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

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

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

```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
    return []
}
```

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) / range }
}

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

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

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

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

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

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

```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
    return []
}
```

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

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

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

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

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

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

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

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

func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.filter { $0 is Int } as! [Int]
}

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

func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.filter { $0 is Int }.map { $0 as! Int }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}
```

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

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

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

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

func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}
```

func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}
```

func strlen(string: String) -> Int {
    var length = 0
    for _ in string {
        length += 1
    }
    return length
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    var length = 0
    for _ in string {
        length += 1
    }
    return length
}
```

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

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

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

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

func largestDivisor(n: Int) -> Int {
    var largestDivisor = 1
    for i in 2...n {
        if n % i == 0 {
            largestDivisor = i
        }
    }
    return largestDivisor
}

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

func largestDivisor(n: Int) -> Int {
    var largestDivisor = 1
    for i in 2...n {
        if n % i == 0 {
            largestDivisor = i
        }
    }
    return largestDivisor
}

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

func largestDivisor(n: Int) -> Int {
    var largestDivisor = 1
    for i in 2...n {
        if n % i == 0 {
            largestDivisor = i
        }
    }
    return largestDivisor
}

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

func largestDivisor(n: Int) -> Int {
    var largestDivisor = 1
    for i in 2...n {
        if n % i == 0 {
            largestDivisor = i
        }
    }
    return largestDivisor
}

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

func largestDivisor(n: Int) -> Int {
    var largestDivisor = 1
    for i in 2...n {
        if n % i == 0 {
            largestDivisor = i
        }
    }
    return largestDivisor
}

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

func largestDivisor(n: Int) -> Int {
    var largestDivisor = 1
    for i in 2...n {
        if n % i == 0 {
            largestDivisor = i
        }
    }
    return largestDivisor
}

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

func largestDivisor(n: Int) -> Int {
    var largestDivisor = 1
    for divisor in 2...n {
        if n % divisor == 0 {
            largestDivisor = divisor
        }
    }
    return largestDivisor
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if result.contains(number) {
            continue
        }
        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) {
            continue
        }
        result.append(number)
    }
    return result
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var dict = [Int: Int]()
    for num in numbers {
        if dict[num] == nil {
            dict[num] = 1
            result.append(num)
        } else {
            dict[num]! += 1
        }
    }
    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 dict = [Int: Int]()
    for num in numbers {
        if dict[num] == nil {
            dict[num] = 1
            result.append(num)
        } else {
            dict[num]! += 1
        }
    }
    return result
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if seen.contains(number) {
            continue
        }
        seen.insert(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]()
    var seen = Set<Int>()
    for number in numbers {
        if seen.contains(number) {
            continue
        }
        seen.insert(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 {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .joined()
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .joined()
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .reduce("", +)
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .reduce("", +)
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    }
   .joined()
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    }
   .joined()
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .joined()
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .joined()
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .reduce("", +)
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .reduce("", +)
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return String($0.uppercased())
        } else {
            return String($0.lowercased())
        }
    }.reduce("", +)
}

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

func concatenate(strings: [String]) -> String {
    // TODO: Write your code here
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    // TODO: Write your code here
}
```

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 {
    return strings.reduce("", { $0 + $1 })
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.reduce("", { $0 + $1 })
}
```

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 {
    return strings.reduce("", { $0 + $1 })
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.reduce("", { $0 + $1 })
}
```

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 {
    return strings.joined(separator: "")
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined(separator: "")
}
```

func concatenate(strings: [String]) -> String {
    return strings.reduce("", +)
}

func concatenate(integers: [Int]) -> Int {
    return integers.reduce(0, +)
}

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

// Concatenate array of integers into a single integer
// concatenate(integers: [] as [Int]) == 0
// concatenate(integers: [1, 2, 3]) == 6
func concatenate(integers: [Int]) -> Int {
    return integers.reduce(0, +)
}
```

func concatenate(strings: [String]) -> String {
    return strings.reduce("", +)
}

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

func concatenate(strings: [String]) -> String {
    return strings.reduce("", +)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

```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: Write your code here
}
```

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

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

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

```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: Write your code here
}
```

func isPrime(n: Int) -> Bool {
    // TODO: Write your code here
    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 {
    // TODO: Write your code here
    return true
}
```

func isPrime(n: Int) -> Bool {
    // Write your code here.
    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 {
    // Write your code here.
    if n <= 1 {
        return false
    }
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    return true
}
```

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

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

func isPrime(n: Int) -> Bool {
    // TODO: Implement this function
    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 {
    // TODO: Implement this function
    return true
}
```

func isPrime(n: Int) -> Bool {
    // TODO: Write your code here.
    if n < 2 {
        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 {
    // TODO: Write your code here.
    if n < 2 {
        return false
    }
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    return true
}
```

func isPrime(n: Int) -> Bool {
    // TODO: Write your code here.
    var count = 0
    for i in 1...n {
        if n % i == 0 {
            count += 1
        }
    }
    return count == 2
}

```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: Write your code here.
    var count = 0
    for i in 1...n {
        if n % i == 0 {
            count += 1
        }
    }
    return count == 2
}
```

func isPrime(n: Int) -> Bool {
    // TODO: Write your code here
    return false
}

```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: Write your code here
    return false
}
```

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            i += 1
            continue
        }
        let j = i
        var k = j
        while k > 0 && l[k] < l[k - 1] {
            swap(&l[k], &l[k - 1])
            k -= 1
        }
        i += 1
    }
    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
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            i += 1
            continue
        }
        let j = i
        var k = j
        while k > 0 && l[k] < l[k - 1] {
            swap(&l[k], &l[k - 1])
            k -= 1
        }
        i += 1
    }
    return l
}
```

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

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

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

```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] {
    // TODO: Implement this function
    return []
}
```

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

```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] {
    // TODO: Implement this function
    return []
}
```

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

```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] {
    // TODO: Implement this function
    return []
}

// 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] {
    // TODO: Implement this function
    return []
}

// 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] {
    // TODO: Implement this function
    return []
}

// 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] {
    // TODO: Implement this function
    return []
}

// 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] {
    // TODO: Implement this function
    return []
}

// 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] {
    // TODO: Implement this function
    return []
}

// 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

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

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            i += 1
            continue
        }
        let j = i + 1
        if j < l.count && l[j] < l[i] {
            l.swapAt(i, j)
        }
        i += 1
    }
    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
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            i += 1
            continue
        }
        let j = i + 1
        if j < l.count && l[j] < l[i] {
            l.swapAt(i, j)
        }
        i += 1
    }
    return l
}
```

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            i += 1
            continue
        }
        let j = i + 1
        if j < l.count && l[j] < l[i] {
            l.swapAt(i, j)
        }
        i += 1
    }
    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
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            i += 1
            continue
        }
        let j = i + 1
        if j < l.count && l[j] < l[i] {
            l.swapAt(i, j)
        }
        i += 1
    }
    return l
}
```

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

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

func sortThird(l: [Int]) -> [Int] {
    var l = l
    let third = l.count / 3
    var i = 0
    while i < third {
        let j = i * 3
        let k = j + 2
        let temp = l[j]
        l[j] = l[k]
        l[k] = temp
        i += 1
    }
    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
    let third = l.count / 3
    var i = 0
    while i < third {
        let j = i * 3
        let k = j + 2
        let temp = l[j]
        l[j] = l[k]
        l[k] = temp
        i += 1
    }
    return l
}
```

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 result = [Int]()
    for item in l {
        if!result.contains(item) {
            result.append(item)
        }
    }
    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 item in l {
        if!result.contains(item) {
            result.append(item)
        }
    }
    return result
}
```

func unique(l: [Int]) -> [Int] {
    return Array(Set(l))
}

```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] {
    return Array(Set(l))
}
```

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

```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 set = Set<Int>()
    var array = [Int]()
    for i in l {
        if!set.contains(i) {
            set.insert(i)
            array.append(i)
        }
    }
    return array
}
```

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 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] {
    return Array(Set(l))
}

```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] {
    return Array(Set(l))
}
```

func unique(l: [Int]) -> [Int] {
    return Array(Set(l))
}

```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] {
    return Array(Set(l))
}
```

func maxElement(l: [Int]) -> Int {
    return l.max()?? 0
}

```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 {
    return l.max()?? 0
}
```

func maxElement(l: [Int]) -> Int {
    return l.reduce(0, 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 {
    return l.reduce(0, 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 {
    return l.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 {
    return l.max()!
}
```

func maxElement(l: [Int]) -> Int {
    return l.reduce(Int.min) { max($0, $1) }
}

```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 {
    return l.reduce(Int.min) { max($0, $1) }
}
```

func maxElement(l: [Int]) -> Int {
    return l.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 {
    return l.max()!
}
```

func maxElement(l: [Int]) -> Int {
    return l.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 {
    return l.max()!
}
```

func maxElement(l: [Int]) -> Int {
    return l.reduce(Int.min) { max($0, $1) }
}

```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 {
    return l.reduce(Int.min) { max($0, $1) }
}
```

func maxElement(l: [Int]) -> Int {
    return l.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 {
    return l.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 {
    return 0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func 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] {
    // TODO: implement this function
    return []
}

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

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

```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] {
    // TODO: Implement this function
    return []
}
```

func sortEven(l: [Int]) -> [Int] {
    return l.enumerated().map { (index, value) in
        if index % 2 == 0 {
            return value
        } else {
            return l.sorted()[index]
        }
    }
}

```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] {
    return l.enumerated().map { (index, value) in
        if index % 2 == 0 {
            return value
        } else {
            return l.sorted()[index]
        }
    }
}
```

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

```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] {
    // TODO: Implement this function
    return []
}
```

func sortEven(l: [Int]) -> [Int] {
    return l.enumerated().map { (index, value) -> Int in
        if index % 2 == 0 {
            return value
        } else {
            return l.sorted()[index]
        }
    }
}

```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] {
    return l.enumerated().map { (index, value) -> Int in
        if index % 2 == 0 {
            return value
        } else {
            return l.sorted()[index]
        }
    }
}
```

func sortEven(l: [Int]) -> [Int] {
    return l.enumerated().map { (i, x) in
        if i % 2 == 0 {
            return x
        } else {
            return l.sorted()[i]
        }
    }
}

```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] {
    return l.enumerated().map { (i, x) in
        if i % 2 == 0 {
            return x
        } else {
            return l.sorted()[i]
        }
    }
}
```

func sortEven(l: [Int]) -> [Int] {
    return l.enumerated().map { (index, value) in
        if index % 2 == 0 {
            return value
        } else {
            return l.sorted()[index]
        }
    }
}

```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] {
    return l.enumerated().map { (index, value) in
        if index % 2 == 0 {
            return value
        } else {
            return l.sorted()[index]
        }
    }
}
```

func sortEven(l: [Int]) -> [Int] {
    return l.enumerated().map { (index, value) in
        if index % 2 == 0 {
            return value
        } else {
            return l.sorted()[index]
        }
    }
}

```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] {
    return l.enumerated().map { (index, value) in
        if index % 2 == 0 {
            return value
        } else {
            return l.sorted()[index]
        }
    }
}
```

func sortEven(l: [Int]) -> [Int] {
    var l = l
    let even = l.filter { $0 % 2 == 0 }
    let odd = l.filter { $0 % 2!= 0 }
    l = even.sorted() + odd
    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
    let even = l.filter { $0 % 2 == 0 }
    let odd = l.filter { $0 % 2!= 0 }
    l = even.sorted() + odd
    return l
}
```

func sortEven(l: [Int]) -> [Int] {
    return l.enumerated().map { (i, v) in
        if i % 2 == 0 {
            return v
        } else {
            return l.sorted()[i]
        }
    }
}

```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] {
    return l.enumerated().map { (i, v) in
        if i % 2 == 0 {
            return v
        } else {
            return l.sorted()[i]
        }
    }
}
```

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

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

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

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

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

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, 1]
    while fib.count < n {
        fib.append(fib[fib.count - 1] + fib[fib.count - 2])
    }
    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, 1]
    while fib.count < n {
        fib.append(fib[fib.count - 1] + fib[fib.count - 2])
    }
    return fib[n - 1]
}
```

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

func primeFib(n: Int) -> Int {
    var a = 1
    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 = 1
    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 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 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 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 triplesSumToZero(l: [Int]) -> Bool {
    // your code here
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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 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 carRaceCollision(n: Int) -> Int {
    var collisions = 0
    for i in 1...n {
        for j in 1...n {
            if i!= j {
                collisions += 1
            }
        }
    }
    return collisions
}

```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 {
    var collisions = 0
    for i in 1...n {
        for j in 1...n {
            if i!= j {
                collisions += 1
            }
        }
    }
    return collisions
}
```

func carRaceCollision(n: Int) -> Int {
    var collisions = 0
    for i in 0..<n {
        for j in 0..<n {
            if i!= j {
                collisions += 1
            }
        }
    }
    return collisions
}

```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 {
    var collisions = 0
    for i in 0..<n {
        for j in 0..<n {
            if i!= j {
                collisions += 1
            }
        }
    }
    return collisions
}
```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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] {
    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] {
    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] {
    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] {
    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] {
    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] {
    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] {
    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] {
    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] {
    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 pairsSumToZero(l: [Int]) -> Bool {
    // Write your code here.
}

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

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

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

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

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

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

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

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

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

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 remainder = x
    while remainder >= base {
        let digit = remainder % base
        result = String(digit) + result
        remainder /= base
    }
    result = String(remainder) + result
    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 >= base {
        let digit = remainder % base
        result = String(digit) + result
        remainder /= base
    }
    result = String(remainder) + result
    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 x = x
    while x > 0 {
        let remainder = x % base
        result = "\(remainder)" + 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 {
        let remainder = x % base
        result = "\(remainder)" + result
        x /= base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    return String(x, radix: base)
}

```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 {
    return String(x, radix: base)
}
```

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

```swift
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var num = x
    while num > 0 {
        result = "\(num % base)" + result
        num /= base
    }
    return result
}
```

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

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a) * Double(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) * Double(h) / 2
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a) * Double(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) * Double(h) / 2
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a) * Double(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) * Double(h) / 2
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a) * Double(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) * Double(h) / 2
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a) * Double(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) * Double(h) / 2
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a) * Double(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) * Double(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) * Double(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) * Double(h) / 2
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a) * Double(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) * Double(h) / 2
}
```

func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 0
    var d = 0
    var result = 0
    for _ in 0..<n {
        result = a + b + c + d
        a = b
        b = c
        c = d
        d = result
    }
    return result
}

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

func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 0
    var d = 0
    var i = 0
    while i < n {
        let temp = a
        a = b
        b = c
        c = d
        d = temp + b + c + d
        i += 1
    }
    return a
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 0
    var d = 0
    var i = 0
    while i < n {
        let temp = a
        a = b
        b = c
        c = d
        d = temp + b + c + d
        i += 1
    }
    return a
}
```

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

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

func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 0
    var d = 0
    var result = 0
    for _ in 0..<n {
        result = a + b + c + d
        a = b
        b = c
        c = d
        d = result
    }
    return result
}

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

func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 0
    var d = 0
    var result = 0
    for i in 0..<n {
        if i == 0 {
            a = 0
        } else if i == 1 {
            b = 0
        } else if i == 2 {
            c = 2
        } else if i == 3 {
            d = 0
        } else {
            result = a + b + c + d
            a = b
            b = c
            c = d
            d = result
        }
    }
    return result
}

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

func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 0
    var d = 0
    var result = 0
    for _ in 0..<n {
        result = a + b + c + d
        a = b
        b = c
        c = d
        d = result
    }
    return result
}

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

func fib4(n: Int) -> Int {
    var fib4 = [Int: Int]()
    fib4[0] = 0
    fib4[1] = 0
    fib4[2] = 2
    for i in 3...n {
        fib4[i] = fib4[i-1]! + fib4[i-2]! + fib4[i-3]! + fib4[i-4]!
    }
    return fib4[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 fib4 = [Int: Int]()
    fib4[0] = 0
    fib4[1] = 0
    fib4[2] = 2
    for i in 3...n {
        fib4[i] = fib4[i-1]! + fib4[i-2]! + fib4[i-3]! + fib4[i-4]!
    }
    return fib4[n]!
}
```

func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 0
    var d = 0
    var result = 0
    for _ in 0..<n {
        result = a + b + c + d
        a = b
        b = c
        c = d
        d = result
    }
    return result
}

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

func fib4(n: Int) -> Int {
    var fib4 = [Int: Int]()
    fib4[0] = 0
    fib4[1] = 0
    fib4[2] = 2
    fib4[3] = 0
    for i in 4...n {
        fib4[i] = fib4[i-1]! + fib4[i-2]! + fib4[i-3]! + fib4[i-4]!
    }
    return fib4[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 fib4 = [Int: Int]()
    fib4[0] = 0
    fib4[1] = 0
    fib4[2] = 2
    fib4[3] = 0
    for i in 4...n {
        fib4[i] = fib4[i-1]! + fib4[i-2]! + fib4[i-3]! + fib4[i-4]!
    }
    return fib4[n]!
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let mid = sorted.count / 2
    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
    return Double(sorted[mid])
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let mid = sorted.count / 2
    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
    return Double(sorted[mid])
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let mid = sorted.count / 2
    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
    return Double(sorted[mid])
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    let mid = count / 2
    if count % 2 == 0 {
        return Double(sorted[mid] + sorted[mid - 1]) / 2
    } else {
        return Double(sorted[mid])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    let mid = count / 2
    if count % 2 == 0 {
        return Double(sorted[mid] + sorted[mid - 1]) / 2
    } else {
        return Double(sorted[mid])
    }
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    let middle = count / 2
    if count % 2 == 1 {
        return Double(sorted[middle])
    } else {
        return Double(sorted[middle - 1] + sorted[middle]) / 2
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    let middle = count / 2
    if count % 2 == 1 {
        return Double(sorted[middle])
    } else {
        return Double(sorted[middle - 1] + sorted[middle]) / 2
    }
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        let middle = count / 2
        return Double(sorted[middle] + sorted[middle - 1]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        let middle = count / 2
        return Double(sorted[middle] + sorted[middle - 1]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        return Double(sorted[count / 2] + sorted[count / 2 - 1]) / 2.0
    } else {
        return Double(sorted[count / 2])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        return Double(sorted[count / 2] + sorted[count / 2 - 1]) / 2.0
    } else {
        return Double(sorted[count / 2])
    }
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        return Double(sorted[count / 2] + sorted[count / 2 - 1]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        return Double(sorted[count / 2] + sorted[count / 2 - 1]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 1 {
        return Double(sorted[count / 2])
    } else {
        return Double(sorted[count / 2] + sorted[count / 2 - 1]) / 2.0
    }
}