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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func separateParenGroups(parenString: String) -> [String] {
    var parenStack = [String]()
    var result = [String]()
    var index = 0
    var parenStringLength = parenString.characters.count
    while index < parenStringLength {
        if parenString[index] == "(" {
            parenStack.append("(")
        } else if parenString[index] == ")" {
            if parenStack.count == 0 {
                result.append(parenString[index])
            } else {
                parenStack.removeLast()
            }
        }
        index += 1
    }
    return result
}

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

func separateParenGroups(parenString: String) -> [String] {
    var parenStack = [String]()
    var result = [String]()
    for character in parenString {
        if character == "(" {
            parenStack.append(character)
        } else if character == ")" {
            let lastParen = parenStack.removeLast()
            if lastParen == "(" {
                result.append(String(lastParen))
            } else {
                let paren = String(lastParen) + String(character)
                result.append(paren)
            }
        }
    }
    return result
}

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

func separateParenGroups(parenString: String) -> [String] {
    // TODO: implement me!
}

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

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

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

func separateParenGroups(parenString: String) -> [String] {
    var parenStack = [String]()
    var result = [String]()
    var index = 0
    while index < parenString.characters.count {
        let character = parenString.characters[index]
        switch character {
        case "(":
            parenStack.append("(")
        case ")":
            if parenStack.count > 0 {
                parenStack.removeLast()
            }
        default:
            break
        }
        if parenStack.count == 0 {
            let subString = parenString.substringFromIndex(index)
            let subStringRange = subString.rangeOfString("()")
            if subStringRange.location!= NSNotFound {
                result.append(subString.substringWithRange(subStringRange))
            }
        }
        index += 1
    }
    return result
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    var parenStack = [String]()
    var result = [String]()
    var index = 0
    while index < parenString.characters.count {
        let character = parenString.characters[index]
        switch character {
        case "(":
            parenStack.append("(")
        case ")":
            if parenStack.count > 0 {
                parenStack.removeLast()
            }
        default:
            break
        }
        if parenStack.count == 0 {
            let subString = parenString.substringFromIndex(index)
            let subStringRange = subString.rangeOfString("()")
            if subStringRange.location!= NSNotFound {
                result.append(subString.substringWithRange(subStringRange))
            }
        }
        index += 1
    }
    return result
}
```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func 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)
    var sum = 0.0
    for number in numbers {
        sum += abs(number - mean)
    }
    return sum / Double(numbers.count)
}

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

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    var sum = 0.0
    for number in numbers {
        sum += abs(number - mean)
    }
    return sum / Double(numbers.count)
}

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

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    var sum = 0.0
    for number in numbers {
        sum += abs(number - mean)
    }
    return sum / Double(numbers.count)
}

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

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    var sum = 0.0
    for number in numbers {
        sum += abs(number - mean)
    }
    return sum / Double(numbers.count)
}

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

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers)
    var sum = 0.0
    for number in numbers {
        sum += abs(number - mean)
    }
    return sum / Double(numbers.count)
}

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

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    var sum = 0.0
    for number in numbers {
        sum += abs(number - mean)
    }
    return sum / Double(numbers.count)
}

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

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    var sum = 0.0
    for number in numbers {
        sum += abs(number - mean)
    }
    return sum / Double(numbers.count)
}

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

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    var sum = 0.0
    for number in numbers {
        sum += abs(number - mean)
    }
    return sum / Double(numbers.count)
}

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

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    var sum = 0.0
    for number in numbers {
        sum += abs(number - mean)
    }
    return sum / Double(numbers.count)
}

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

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = mean(numbers: numbers)
    var sum = 0.0
    for number in numbers {
        sum += abs(number - mean)
    }
    return sum / Double(numbers.count)
}

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

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerate() {
        if index == 0 {
            result.append(number)
        } else {
            result.append(delimeter)
            result.append(number)
        }
    }
    return result
}

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

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for i in 0..<numbers.count {
        if i == 0 {
            result.append(numbers[i])
        } else {
            result.append(delimeter)
            result.append(numbers[i])
        }
    }
    return result
}

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

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result: [Int] = []
    for i in 0..<numbers.count {
        if i == 0 {
            result.append(numbers[i])
        } else {
            result.append(delimeter)
            result.append(numbers[i])
        }
    }
    return result
}

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

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

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

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

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

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

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for i in 0..<numbers.count {
        if i == 0 {
            result.append(numbers[i])
        } else {
            result.append(delimeter)
            result.append(numbers[i])
        }
    }
    return result
}

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

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result: [Int] = []
    for i in 0..<numbers.count {
        if i == 0 {
            result.append(numbers[i])
        } else {
            result.append(delimeter)
            result.append(numbers[i])
        }
    }
    return result
}

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

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for i in 0..<numbers.count {
        if i == 0 {
            result.append(numbers[i])
        } else {
            result.append(delimeter)
            result.append(numbers[i])
        }
    }
    return result
}

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

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for i in 0..<numbers.count {
        if i == 0 {
            result.append(numbers[i])
        } else {
            result.append(delimeter)
            result.append(numbers[i])
        }
    }
    return result
}

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

func parseNestedParens(parenString: String) -> [Int] {
    var parenStack: [Int] = []
    var parenLevel: Int = 0
    var parenLevels: [Int] = []
    for paren in parenString.split(" ") {
        if paren == "(" {
            parenStack.append(parenLevel)
            parenLevel += 1
        } else if paren == ")" {
            parenLevel -= 1
            parenStack.removeLast()
        }
        parenLevels.append(parenLevel)
    }
    return parenLevels
}

```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 parenStack: [Int] = []
    var parenLevel: Int = 0
    var parenLevels: [Int] = []
    for paren in parenString.split(" ") {
        if paren == "(" {
            parenStack.append(parenLevel)
            parenLevel += 1
        } else if paren == ")" {
            parenLevel -= 1
            parenStack.removeLast()
        }
        parenLevels.append(parenLevel)
    }
    return parenLevels
}
```

func parseNestedParens(parenString: String) -> [Int] {
    var parenStack = [Int]()
    var result = [Int]()
    for paren in parenString.split(" ").map(String.init) {
        switch paren {
        case "(":
            parenStack.append(parenStack.count)
        case ")":
            parenStack.removeLast()
        default:
            let level = parenStack.count
            result.append(level)
        }
    }
    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 parenStack = [Int]()
    var result = [Int]()
    for paren in parenString.split(" ").map(String.init) {
        switch paren {
        case "(":
            parenStack.append(parenStack.count)
        case ")":
            parenStack.removeLast()
        default:
            let level = parenStack.count
            result.append(level)
        }
    }
    return result
}
```

func parseNestedParens(parenString: String) -> [Int] {
    var parenStack = [Int]()
    var result = [Int]()
    for char in parenString.characters {
        switch char {
        case "(":
            parenStack.append(1)
        case ")":
            parenStack.removeLast()
        default:
            continue
        }
        if parenStack.isEmpty {
            result.append(parenStack.count)
        }
    }
    return result
}

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

func parseNestedParens(parenString: String) -> [Int] {
    var parenStack: [Int] = []
    var parenLevel: Int = 0
    var parenLevels: [Int] = []
    for paren in parenString.split(" ") {
        if paren == "(" {
            parenStack.append(parenLevel)
            parenLevel += 1
        } else if paren == ")" {
            parenLevel -= 1
            parenStack.removeLast()
        }
        parenLevels.append(parenLevel)
    }
    return parenLevels
}

```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 parenStack: [Int] = []
    var parenLevel: Int = 0
    var parenLevels: [Int] = []
    for paren in parenString.split(" ") {
        if paren == "(" {
            parenStack.append(parenLevel)
            parenLevel += 1
        } else if paren == ")" {
            parenLevel -= 1
            parenStack.removeLast()
        }
        parenLevels.append(parenLevel)
    }
    return parenLevels
}
```

func parseNestedParens(parenString: String) -> [Int] {
    var parenStack: [Int] = []
    var parenLevel: Int = 0
    var parenLevels: [Int] = []
    for paren in parenString.split(" ") {
        if paren == "(" {
            parenStack.append(parenLevel)
            parenLevel += 1
        } else if paren == ")" {
            parenLevel -= 1
            parenLevels.append(parenStack.popLast()!)
        }
    }
    return parenLevels
}

```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 parenStack: [Int] = []
    var parenLevel: Int = 0
    var parenLevels: [Int] = []
    for paren in parenString.split(" ") {
        if paren == "(" {
            parenStack.append(parenLevel)
            parenLevel += 1
        } else if paren == ")" {
            parenLevel -= 1
            parenLevels.append(parenStack.popLast()!)
        }
    }
    return parenLevels
}
```

func parseNestedParens(parenString: String) -> [Int] {
    var parenStack: [Int] = []
    var parenLevel: Int = 0
    var parenLevels: [Int] = []
    
    for paren in parenString.split(" ") {
        if paren == "(" {
            parenStack.append(parenLevel)
            parenLevel += 1
        } else if paren == ")" {
            parenLevel -= 1
            if parenLevel == parenStack.last! {
                parenStack.removeLast()
            }
        }
        
        if parenLevel > parenStack.last! {
            parenLevels.append(parenLevel)
        }
    }
    
    return parenLevels
}

```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 parenStack: [Int] = []
    var parenLevel: Int = 0
    var parenLevels: [Int] = []
    
    for paren in parenString.split(" ") {
        if paren == "(" {
            parenStack.append(parenLevel)
            parenLevel += 1
        } else if paren == ")" {
            parenLevel -= 1
            if parenLevel == parenStack.last! {
                parenStack.removeLast()
            }
        }
        
        if parenLevel > parenStack.last! {
            parenLevels.append(parenLevel)
        }
    }
    
    return parenLevels
}
```

```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
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of the current level of nesting
    // Hint: You can use a stack to keep track of

func parseNestedParens(parenString: String) -> [Int] {
    var parenStack: [Int] = []
    var parenLevel: Int = 0
    var parenLevels: [Int] = []
    for paren in parenString.split(" ") {
        if paren == "(" {
            parenStack.append(parenLevel)
            parenLevel += 1
        } else if paren == ")" {
            parenLevel -= 1
            if parenLevel < 0 {
                parenLevel = parenStack.popLast()!
            }
        }
        parenLevels.append(parenLevel)
    }
    return parenLevels
}

```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 parenStack: [Int] = []
    var parenLevel: Int = 0
    var parenLevels: [Int] = []
    for paren in parenString.split(" ") {
        if paren == "(" {
            parenStack.append(parenLevel)
            parenLevel += 1
        } else if paren == ")" {
            parenLevel -= 1
            if parenLevel < 0 {
                parenLevel = parenStack.popLast()!
            }
        }
        parenLevels.append(parenLevel)
    }
    return parenLevels
}
```

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

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

func parseNestedParens(parenString: String) -> [Int] {
    var parenStack = [Int]()
    var parenLevels = [Int]()
    for paren in parenString.split(" ") {
        if paren.hasPrefix("(") {
            parenStack.append(parenLevels.count)
        } else if paren.hasSuffix(")") {
            let parenIndex = parenStack.last!
            parenStack.removeLast()
            parenLevels.append(parenLevels.count - parenIndex)
        }
    }
    return parenLevels
}

```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 parenStack = [Int]()
    var parenLevels = [Int]()
    for paren in parenString.split(" ") {
        if paren.hasPrefix("(") {
            parenStack.append(parenLevels.count)
        } else if paren.hasSuffix(")") {
            let parenIndex = parenStack.last!
            parenStack.removeLast()
            parenLevels.append(parenLevels.count - parenIndex)
        }
    }
    return parenLevels
}
```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func makePalindrome(string: String) -> String {
    var palindrome = string
    var reversed = string.reversed()
    var suffix = string
    var prefix = ""
    
    while suffix.hasPrefix(reversed) {
        suffix = suffix.dropFirst()
        reversed = reversed.dropLast()
    }
    
    while!suffix.isEmpty {
        prefix += String(reversed.first!)
        suffix = suffix.dropFirst()
        reversed = reversed.dropLast()
    }
    
    palindrome += reversed.reversed()
    palindrome += prefix
    
    return palindrome
}

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

func makePalindrome(string: String) -> String {
    // Find the longest palindromic suffix of the supplied string.
    let palindromeSuffix = string.reversed().prefix(while: { $0 == string[$0.index] })
    // Find the shortest prefix of the supplied string that comes before the palindromic suffix.
    let prefix = string.prefix(until: string.index(before: palindromeSuffix.endIndex))
    // Append the reverse of the prefix to the end of the supplied string.
    return String(prefix) + 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 {
    // Find the longest palindromic suffix of the supplied string.
    let palindromeSuffix = string.reversed().prefix(while: { $0 == string[$0.index] })
    // Find the shortest prefix of the supplied string that comes before the palindromic suffix.
    let prefix = string.prefix(until: string.index(before: palindromeSuffix.endIndex))
    // Append the reverse of the prefix to the end of the supplied string.
    return String(prefix) + String(palindromeSuffix.reversed())
}
```

func makePalindrome(string: String) -> String {
    let reversed = string.reversed()
    let longestPalindromicSuffix = string.prefix(while: { reversed.hasPrefix($0) && isPalindrome(string: reversed) })
    let shortestPalindromicPrefix = string.suffix(while: { string.hasPrefix($0) && isPalindrome(string: string) })
    return String(longestPalindromicSuffix) + String(shortestPalindromicPrefix.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 longestPalindromicSuffix = string.prefix(while: { reversed.hasPrefix($0) && isPalindrome(string: reversed) })
    let shortestPalindromicPrefix = string.suffix(while: { string.hasPrefix($0) && isPalindrome(string: string) })
    return String(longestPalindromicSuffix) + String(shortestPalindromicPrefix.reversed())
}
```

func makePalindrome(string: String) -> String {
    let reversed = string.reversed()
    let longestPalindrome = string.prefix(while: { reversed.hasPrefix($0) })
    return String(longestPalindrome) + String(reversed.dropLast(longestPalindrome.count))
}

```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 longestPalindrome = string.prefix(while: { reversed.hasPrefix($0) })
    return String(longestPalindrome) + String(reversed.dropLast(longestPalindrome.count))
}
```

func makePalindrome(string: String) -> String {
    // Find the longest postfix of supplied string that is a palindrome.
    var palindrome = string
    var reversed = string.reversed()
    while palindrome.hasPrefix(reversed) {
        palindrome = palindrome.dropLast(reversed.count)
        reversed = reversed.dropFirst(reversed.count)
    }

    // Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    return string + reversed.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 {
    // Find the longest postfix of supplied string that is a palindrome.
    var palindrome = string
    var reversed = string.reversed()
    while palindrome.hasPrefix(reversed) {
        palindrome = palindrome.dropLast(reversed.count)
        reversed = reversed.dropFirst(reversed.count)
    }

    // Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    return string + reversed.reversed()
}
```

func makePalindrome(string: String) -> String {
    // Find the longest palindrome suffix.
    let suffix = string.reversed().dropFirstWhile { $0!= string.last }.reversed()
    // Find the longest palindrome prefix.
    let prefix = string.prefix(while: { $0!= string.first })
    // Append the prefix and the suffix in reverse order.
    return prefix + suffix.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 {
    // Find the longest palindrome suffix.
    let suffix = string.reversed().dropFirstWhile { $0!= string.last }.reversed()
    // Find the longest palindrome prefix.
    let prefix = string.prefix(while: { $0!= string.first })
    // Append the prefix and the suffix in reverse order.
    return prefix + suffix.reversed()
}
```

func makePalindrome(string: String) -> String {
    var palindrome = string
    var reversed = string.reversed()
    while palindrome.hasSuffix(reversed) {
        palindrome += reversed
        reversed = reversed.dropLast()
    }
    return palindrome
}

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

func makePalindrome(string: String) -> String {
    var palindrome = string
    var reversed = string.reversed()
    
    while palindrome.hasSuffix(reversed) {
        palindrome += reversed
        reversed = string.prefix(reversed.count - 1).reversed()
    }
    
    return palindrome
}

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

func makePalindrome(string: String) -> String {
    // Find the longest palindromic suffix of the supplied string.
    let palindromicSuffix = string.reversed().prefix(while: { $0 == string[$0.index] })
    // Find the longest palindromic prefix of the supplied string.
    let palindromicPrefix = string.prefix(while: { $0 == string.reversed().$0 })
    // Append the reverse of the prefix to the end of the supplied string.
    return string + palindromicPrefix.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 {
    // Find the longest palindromic suffix of the supplied string.
    let palindromicSuffix = string.reversed().prefix(while: { $0 == string[$0.index] })
    // Find the longest palindromic prefix of the supplied string.
    let palindromicPrefix = string.prefix(while: { $0 == string.reversed().$0 })
    // Append the reverse of the prefix to the end of the supplied string.
    return string + palindromicPrefix.reversed()
}
```

func makePalindrome(string: String) -> String {
    // Find the longest palindrome suffix.
    let suffix = string.reversed().prefix(while: {!$0.isEmpty })
    // Find the shortest palindrome prefix.
    let prefix = string.prefix(while: {!$0.isEmpty })
    // Append the prefix and suffix in reverse order.
    return String(prefix.reversed()) + suffix
}

```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 {
    // Find the longest palindrome suffix.
    let suffix = string.reversed().prefix(while: {!$0.isEmpty })
    // Find the shortest palindrome prefix.
    let prefix = string.prefix(while: {!$0.isEmpty })
    // Append the prefix and suffix in reverse order.
    return String(prefix.reversed()) + suffix
}
```

func stringXor(a: String, b: String) -> String {
    // TODO: implement me
}

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

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

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

func stringXor(a: String, b: String) -> String {
    return String(a.characters.map {
        if $0 == "0" {
            return "1"
        } else {
            return "0"
        }
    })
}

```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 String(a.characters.map {
        if $0 == "0" {
            return "1"
        } else {
            return "0"
        }
    })
}
```

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

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

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

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<max(a.count, b.count) {
        let aBit = a.count > i? a[i] : "0"
        let bBit = b.count > i? b[i] : "0"
        result += String(aBit.asciiValue.flatMap { $0 == "1"? "0" : "1" }.unicodeScalars.first!)
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<max(a.count, b.count) {
        let aBit = a.count > i? a[i] : "0"
        let bBit = b.count > i? b[i] : "0"
        result += String(aBit.asciiValue.flatMap { $0 == "1"? "0" : "1" }.unicodeScalars.first!)
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    // Your code here.
}

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

func stringXor(a: String, b: String) -> String {
    // TODO: implement me
}

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

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

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

func longest(strings: [String]) -> String? {
    var longest: String?
    for string in strings {
        if longest == nil || 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? {
    var longest: String?
    for string in strings {
        if longest == nil || string.count > longest.count {
            longest = string
        }
    }
    return longest
}
```

func longest(strings: [String]) -> String? {
    var longestString: String?
    var longestLength = 0
    for string in strings {
        if string.length > longestLength {
            longestString = string
            longestLength = string.length
        }
    }
    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?
    var longestLength = 0
    for string in strings {
        if string.length > longestLength {
            longestString = string
            longestLength = string.length
        }
    }
    return longestString
}
```

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

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

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

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

func longest(strings: [String]) -> String? {
    var longestString: String?
    var longestLength = 0
    for string in strings {
        if string.length > longestLength {
            longestString = string
            longestLength = string.length
        }
    }
    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?
    var longestLength = 0
    for string in strings {
        if string.length > longestLength {
            longestString = string
            longestLength = string.length
        }
    }
    return longestString
}
```

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

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

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

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

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

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

func longest(strings: [String]) -> String? {
    var longest = nil
    for string in strings {
        if longest == nil || 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? {
    var longest = nil
    for string in strings {
        if longest == nil || string.count > longest.count {
            longest = string
        }
    }
    return longest
}
```

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

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

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

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    // TODO: implement greatest common divisor algorithm
}

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

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

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    //...
}

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

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    // TODO: Implement greatest common divisor
}

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

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

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

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

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

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    //...
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func countDistinctCharacters(string: String) -> Int {
    let lowercaseString = string.lowerCased()
    var distinctCharacters = [Character]()
    for character in lowercaseString.characters {
        if!distinctCharacters.contains(character) {
            distinctCharacters.append(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 {
    let lowercaseString = string.lowerCased()
    var distinctCharacters = [Character]()
    for character in lowercaseString.characters {
        if!distinctCharacters.contains(character) {
            distinctCharacters.append(character)
        }
    }
    return distinctCharacters.count
}
```

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

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

func countDistinctCharacters(string: String) -> Int {
    let lowercaseString = string.lowerCased()
    let distinctCharacters = Set(lowercaseString.unicodeScalars)
    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 {
    let lowercaseString = string.lowerCased()
    let distinctCharacters = Set(lowercaseString.unicodeScalars)
    return distinctCharacters.count
}
```

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

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

func countDistinctCharacters(string: String) -> Int {
    // TODO: Implement this function
    var count = 0
    var set = Set<Character>()
    for character in string.characters {
        set.insert(character)
    }
    count = set.count
    return count
}

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

func countDistinctCharacters(string: String) -> Int {
    // TODO: Implement me!
}

```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: Implement me!
}
```

func countDistinctCharacters(string: String) -> Int {
    // TODO: Implement me!
}

```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: Implement me!
}
```

func countDistinctCharacters(string: String) -> Int {
    // TODO: Implement this function
}

```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: Implement this function
}
```

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

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

func countDistinctCharacters(string: String) -> Int {
    // TODO: Implement this function
}

```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: Implement this function
}
```

func parseMusic(musicString: String) -> [Int] {
    // TODO: Your implementation goes 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] {
    // TODO: Your implementation goes here
}
```

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

```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 notes: [Int] = []
    var currentBeat = 0
    for character in musicString {
        switch character {
        case 'o':
            notes.append(currentBeat)
            currentBeat += 4
        case 'o|':
            notes.append(currentBeat)
            currentBeat += 2
        case '.|':
            notes.append(currentBeat)
            currentBeat += 1
        default:
            break
        }
    }
    return notes
}
```

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

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

func parseMusic(musicString: String) -> [Int] {
    var notes = [Int]()
    var note = 0
    for character in musicString {
        switch character {
        case 'o':
            note += 4
        case '|':
            note /= 2
        case '.':
            note -= 1
        default:
            break
        }
        notes.append(note)
    }
    return notes
}

```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 notes = [Int]()
    var note = 0
    for character in musicString {
        switch character {
        case 'o':
            note += 4
        case '|':
            note /= 2
        case '.':
            note -= 1
        default:
            break
        }
        notes.append(note)
    }
    return notes
}
```

func parseMusic(musicString: String) -> [Int] {
    // Your implementation goes here
}

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

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

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

func parseMusic(musicString: String) -> [Int] {
    // Your implementation goes here
}

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

func parseMusic(musicString: String) -> [Int] {
    // Your implementation goes here
}

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

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

```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 parsedMusic = [Int]()
    var currentBeat = 0
    for character in musicString {
        switch character {
        case 'o':
            currentBeat += 4
        case '|':
            currentBeat += 2
        case '.':
            currentBeat += 1
        default:
            break
        }
        parsedMusic.append(currentBeat)
    }
    return parsedMusic
}
```

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

```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 beats = [Int]()
    var currentBeat = 0
    for char in musicString {
        switch char {
        case 'o':
            currentBeat += 4
        case '|':
            currentBeat /= 2
        default:
            break
        }
        beats.append(currentBeat)
    }
    return beats
}
```

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

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

func howManyTimes(string: String, substring: String) -> Int {
    let range = string.rangeOfString(substring, options: NSStringCompareOptions.CaseInsensitiveSearch)
    var count = 0
    while range!= nil {
        count += 1
        string = string.stringByReplacingCharactersInRange(range!, withString: "")
        range = string.rangeOfString(substring, options: NSStringCompareOptions.CaseInsensitiveSearch)
    }
    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 {
    let range = string.rangeOfString(substring, options: NSStringCompareOptions.CaseInsensitiveSearch)
    var count = 0
    while range!= nil {
        count += 1
        string = string.stringByReplacingCharactersInRange(range!, withString: "")
        range = string.rangeOfString(substring, options: NSStringCompareOptions.CaseInsensitiveSearch)
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.index(string.startIndex, advancedBy: substring.characters.count)
    while index!= string.endIndex {
        count += 1
        index = string.index(index, advancedBy: substring.characters.count)
    }
    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.index(string.startIndex, advancedBy: substring.characters.count)
    while index!= string.endIndex {
        count += 1
        index = string.index(index, advancedBy: substring.characters.count)
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.index(string.startIndex, offsetBy: 1)
    while index!= string.endIndex {
        if string.hasPrefix(substring, range: Range<String.Index>(start: index, end: index + substring.count)) {
            count += 1
        }
        index = string.index(index, offsetBy: 1)
    }
    return count
}

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

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.index(string.startIndex, advancedBy: substring.characters.count)
    while index!= string.endIndex {
        count += 1
        index = string.index(index, advancedBy: substring.characters.count)
    }
    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.index(string.startIndex, advancedBy: substring.characters.count)
    while index!= string.endIndex {
        count += 1
        index = string.index(index, advancedBy: substring.characters.count)
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.index(string.startIndex, advancedBy: 1)
    while index!= string.endIndex {
        if string.hasPrefix(substring, range: Range<String.Index>(start: index, end: index + substring.count)) {
            count += 1
        }
        index = string.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.index(string.startIndex, advancedBy: 1)
    while index!= string.endIndex {
        if string.hasPrefix(substring, range: Range<String.Index>(start: index, end: index + substring.count)) {
            count += 1
        }
        index = string.index(index, advancedBy: 1)
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.index(string.startIndex, advancedBy: 1)
    while index!= string.endIndex {
        if string.hasPrefix(substring, range: Range<String.Index>(start: index, end: index + substring.count)) {
            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.index(string.startIndex, advancedBy: 1)
    while index!= string.endIndex {
        if string.hasPrefix(substring, range: Range<String.Index>(start: index, end: index + substring.count)) {
            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 {
    let count = string.components(separatedBy: substring).count - 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 {
    let count = string.components(separatedBy: substring).count - 1
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.index(string.startIndex, advancedBy: substring.characters.count)
    while index!= string.endIndex {
        count += 1
        index = string.index(index, advancedBy: substring.characters.count)
    }
    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.index(string.startIndex, advancedBy: substring.characters.count)
    while index!= string.endIndex {
        count += 1
        index = string.index(index, advancedBy: substring.characters.count)
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    let count = string.components(separatedBy: substring).count - 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 {
    let count = string.components(separatedBy: substring).count - 1
    return count
}
```

func sortNumbers(numbers: String) -> String {
    // TODO: Implement this method
}

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

func sortNumbers(numbers: String) -> String {
    // TODO: Implement this function
}

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

func sortNumbers(numbers: String) -> String {
    // TODO: Implement this function
}

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

func sortNumbers(numbers: String) -> String {
    // TODO: Implement this method
}

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

func sortNumbers(numbers: String) -> String {
    // TODO: Implement this method
}

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

func sortNumbers(numbers: String) -> String {
    // TODO: Implement this method
}

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

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

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 {
    // 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 {
    // 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 findClosestElements(numbers: [Double]) -> (Double, Double) {
    // TODO: Implement this function
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.reduce(Double.infinity, combine: { min, num in
        return min < num? min : num
    })
    let max = numbers.reduce(Double.min, combine: { max, num in
        return max > num? max : num
    })
    return numbers.map { (num: Double) -> Double in
        return (num - min) / (max - min)
    }
}

```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.reduce(Double.infinity, combine: { min, num in
        return min < num? min : num
    })
    let max = numbers.reduce(Double.min, combine: { max, num in
        return max > num? max : num
    })
    return numbers.map { (num: Double) -> Double in
        return (num - min) / (max - min)
    }
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.reduce(Double.max) { $0 < $1? $0 : $1 }
    let max = numbers.reduce(Double.min) { $0 > $1? $0 : $1 }
    return numbers.map { $0 / (max - min) }
}

```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.reduce(Double.max) { $0 < $1? $0 : $1 }
    let max = numbers.reduce(Double.min) { $0 > $1? $0 : $1 }
    return numbers.map { $0 / (max - min) }
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.reduce(0.0, combine: { (min: Double, value: Double) -> Double in
        return min < value? min : value
    })
    let max = numbers.reduce(0.0, combine: { (max: Double, value: Double) -> Double in
        return max > value? max : value
    })
    let range = max - min
    return numbers.map { (value: Double) -> Double in
        return (value - 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.reduce(0.0, combine: { (min: Double, value: Double) -> Double in
        return min < value? min : value
    })
    let max = numbers.reduce(0.0, combine: { (max: Double, value: Double) -> Double in
        return max > value? max : value
    })
    let range = max - min
    return numbers.map { (value: Double) -> Double in
        return (value - min) / range
    }
}
```

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

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.reduce(0.0, combine: { (min: Double, number: Double) -> Double in
        return min < number? min : number
    })
    let max = numbers.reduce(0.0, combine: { (max: Double, number: Double) -> Double in
        return max > number? max : number
    })
    let range = max - min
    return numbers.map { (number: Double) -> Double in
        return (number - 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.reduce(0.0, combine: { (min: Double, number: Double) -> Double in
        return min < number? min : number
    })
    let max = numbers.reduce(0.0, combine: { (max: Double, number: Double) -> Double in
        return max > number? max : number
    })
    let range = max - min
    return numbers.map { (number: Double) -> Double in
        return (number - min) / range
    }
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.reduce(0.0, combine: { (min: Double, number: Double) -> Double in
        return min < number? min : number
    })
    let max = numbers.reduce(0.0, combine: { (max: Double, number: Double) -> Double in
        return max > number? max : number
    })
    return numbers.map { (number: Double) -> Double in
        return (number - min) / (max - min)
    }
}

```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.reduce(0.0, combine: { (min: Double, number: Double) -> Double in
        return min < number? min : number
    })
    let max = numbers.reduce(0.0, combine: { (max: Double, number: Double) -> Double in
        return max > number? max : number
    })
    return numbers.map { (number: Double) -> Double in
        return (number - min) / (max - min)
    }
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.reduce(Double.infinity, <)
    let max = numbers.reduce(Double.mininum, >)
    let scale = max - min
    return numbers.map { $0 - min }.map { $0 / scale }
}

```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.reduce(Double.infinity, <)
    let max = numbers.reduce(Double.mininum, >)
    let scale = max - min
    return numbers.map { $0 - min }.map { $0 / scale }
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.reduce(0.0, combine: { (min: Double, number: Double) -> Double in
        return min < number? min : number
    })
    let max = numbers.reduce(0.0, combine: { (max: Double, number: Double) -> Double in
        return max > number? max : number
    })
    let range = max - min
    return numbers.map { (number: Double) -> Double in
        return (number - 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.reduce(0.0, combine: { (min: Double, number: Double) -> Double in
        return min < number? min : number
    })
    let max = numbers.reduce(0.0, combine: { (max: Double, number: Double) -> Double in
        return max > number? max : number
    })
    let range = max - min
    return numbers.map { (number: Double) -> Double in
        return (number - min) / range
    }
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.reduce(Double.greatestFiniteMagnitude, { min, number in
        return min < number? min : number
    })
    let max = numbers.reduce(Double.leastNonMagnitude, { max, number in
        return max > number? max : number
    })
    return numbers.map { number in
        return (number - min) / (max - min)
    }
}

```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.reduce(Double.greatestFiniteMagnitude, { min, number in
        return min < number? min : number
    })
    let max = numbers.reduce(Double.leastNonMagnitude, { max, number in
        return max > number? max : number
    })
    return numbers.map { number in
        return (number - min) / (max - min)
    }
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.reduce(Double.greatestFiniteMagnitude, { min, num in
        return min < num? min : num
    })
    let max = numbers.reduce(Double.leastNonMagnitude, { max, num in
        return max > num? max : num
    })
    return numbers.map { (num: Double) -> Double in
        return (num - min) / (max - min)
    }
}

```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.reduce(Double.greatestFiniteMagnitude, { min, num in
        return min < num? min : num
    })
    let max = numbers.reduce(Double.leastNonMagnitude, { max, num in
        return max > num? max : num
    })
    return numbers.map { (num: Double) -> Double in
        return (num - min) / (max - min)
    }
}
```

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.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.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.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.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.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.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.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.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.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 strlen(string: String) -> Int {
    var length = 0
    for i in 0..<string.length {
        if string[i] == '\0' {
            break
        }
        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 i in 0..<string.length {
        if string[i] == '\0' {
            break
        }
        length += 1
    }
    return length
}
```

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 {
    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 {
    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 {
    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 {
    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 {
    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 {
    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 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 largestDivisor(n: Int) -> Int {
    // Your code here
}

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

func largestDivisor(n: Int) -> Int {
    var divisor: Int = n
    var divisorFound = false
    while divisor > 1 &&!divisorFound {
        if n % divisor == 0 {
            divisorFound = true
        } else {
            divisor -= 1
        }
    }
    return divisor
}

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

func largestDivisor(n: Int) -> Int {
    var divisor = n
    var divisorRemainder = divisor % 2
    while divisorRemainder!= 0 {
        divisor -= divisorRemainder
        divisorRemainder = divisor % 2
    }
    return divisor
}

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

func largestDivisor(n: Int) -> Int {
    // TODO: implement me!
}

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

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

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

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

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

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

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

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

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

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

func factorize(n: Int) -> [Int] {
    // TODO: Implement
}

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

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

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

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

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

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

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

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

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

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

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

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

func removeDuplicates(numbers: [Int]) -> [Int] {
    // TODO: Implement removeDuplicates
}

```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] {
    // TODO: Implement removeDuplicates
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    // TODO: Implement me!
}

```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] {
    // TODO: Implement me!
}
```

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

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

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

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

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = [Int: Bool]()
    for number in numbers {
        if!seen[number] {
            seen[number] = true
            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 = [Int: Bool]()
    for number in numbers {
        if!seen[number] {
            seen[number] = true
            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 seen = [Int: Int]()
    for number in numbers {
        seen[number] = seen[number]?.advancedBy(1)?? 0 + 1
        if seen[number] == 1 {
            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 = [Int: Int]()
    for number in numbers {
        seen[number] = seen[number]?.advancedBy(1)?? 0 + 1
        if seen[number] == 1 {
            result.append(number)
        }
    }
    return result
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = [Int: Int]()
    for number in numbers {
        seen[number] = seen[number]?.advancedBy(1)?? 0 + 1
        if seen[number] == 1 {
            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 = [Int: Int]()
    for number in numbers {
        seen[number] = seen[number]?.advancedBy(1)?? 0 + 1
        if seen[number] == 1 {
            result.append(number)
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var flipped = [Character]()
    for character in string.characters {
        if character.isLowercase {
            flipped.append(Character(string.uppercaseString.characters.last!))
        } else {
            flipped.append(Character(string.lowercaseString.characters.last!))
        }
    }
    return String(flipped)
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var flipped = [Character]()
    for character in string.characters {
        if character.isLowercase {
            flipped.append(Character(string.uppercaseString.characters.last!))
        } else {
            flipped.append(Character(string.lowercaseString.characters.last!))
        }
    }
    return String(flipped)
}
```

func flipCase(string: String) -> String {
    // TODO: Implement flipCase
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    // TODO: Implement flipCase
}
```

func flipCase(string: String) -> String {
    let lowercase = string.lowercaseString
    let uppercase = string.uppercaseString
    return lowercase.enumerate().reduce("") { (result, element) -> String in
        if element.1 == false {
            return result + uppercase[element.0]
        } else {
            return result + lowercase[element.0]
        }
    }
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    let lowercase = string.lowercaseString
    let uppercase = string.uppercaseString
    return lowercase.enumerate().reduce("") { (result, element) -> String in
        if element.1 == false {
            return result + uppercase[element.0]
        } else {
            return result + lowercase[element.0]
        }
    }
}
```

func flipCase(string: String) -> String {
    var flippedString = ""
    for character in string {
        if character.isLowercase {
            flippedString.append(String(character.uppercaseString))
        } else {
            flippedString.append(String(character.lowercaseString))
        }
    }
    return flippedString
}

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

func flipCase(string: String) -> String {
    var flipped = [Character]()
    for character in string.characters {
        if character.isLowercase {
            flipped.append(Character(string.uppercaseString.characterAtIndex(string.lowercaseString.indexOf(character))))
        } else {
            flipped.append(Character(string.lowercaseString.characterAtIndex(string.uppercaseString.indexOf(character))))
        }
    }
    return String(flipped)
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var flipped = [Character]()
    for character in string.characters {
        if character.isLowercase {
            flipped.append(Character(string.uppercaseString.characterAtIndex(string.lowercaseString.indexOf(character))))
        } else {
            flipped.append(Character(string.lowercaseString.characterAtIndex(string.uppercaseString.indexOf(character))))
        }
    }
    return String(flipped)
}
```

func flipCase(string: String) -> String {
    var flippedString = string
    for index in 0..<string.characters.count {
        if string.lowercaseString.hasPrefix(string.characters[index]) {
            flippedString.removeAtIndex(index)
            flippedString.insert(string.uppercaseString[index], atIndex: index)
        } else {
            flippedString.removeAtIndex(index)
            flippedString.insert(string.lowercaseString[index], atIndex: index)
        }
    }
    return flippedString
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var flippedString = string
    for index in 0..<string.characters.count {
        if string.lowercaseString.hasPrefix(string.characters[index]) {
            flippedString.removeAtIndex(index)
            flippedString.insert(string.uppercaseString[index], atIndex: index)
        } else {
            flippedString.removeAtIndex(index)
            flippedString.insert(string.lowercaseString[index], atIndex: index)
        }
    }
    return flippedString
}
```

func flipCase(string: String) -> String {
    var flipped = [Character]()
    for character in string.characters {
        if character.isLowercase {
            flipped.append(Character(string.uppercaseString.characters.last!))
        } else {
            flipped.append(Character(string.lowercaseString.characters.last!))
        }
    }
    return String(flipped)
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var flipped = [Character]()
    for character in string.characters {
        if character.isLowercase {
            flipped.append(Character(string.uppercaseString.characters.last!))
        } else {
            flipped.append(Character(string.lowercaseString.characters.last!))
        }
    }
    return String(flipped)
}
```

func flipCase(string: String) -> String {
    let lowercase = string.lowercased()
    let uppercase = string.uppercased()
    return lowercase.map {
        if $0.isLowercase {
            return String(uppercase.characters.startIndex.advancedBy($0.advancedIndex(lowercase)))
        } else {
            return String(lowercase.characters.startIndex.advancedBy($0.advancedIndex(uppercase)))
        }
    }
}

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

func flipCase(string: String) -> String {
    let lowercase = string.lowercaseString
    let uppercase = string.uppercaseString
    return lowercase.enumerate()
       .reduce(String()) {
            (partial, element) -> String in
            let (index, character) = element
            if character.isLowercase {
                return partial + uppercase[index]
            } else {
                return partial + lowercase[index]
            }
    }
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    let lowercase = string.lowercaseString
    let uppercase = string.uppercaseString
    return lowercase.enumerate()
       .reduce(String()) {
            (partial, element) -> String in
            let (index, character) = element
            if character.isLowercase {
                return partial + uppercase[index]
            } else {
                return partial + lowercase[index]
            }
    }
}
```

func flipCase(string: String) -> String {
    var flippedString = ""
    for character in string {
        if character.isLowercase {
            flippedString.append(String(character.uppercaseString))
        } else {
            flippedString.append(String(character.lowercaseString))
        }
    }
    return flippedString
}

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

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result.append(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.append(string)
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result.append(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.append(string)
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result.append(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.append(string)
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result.append(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.append(string)
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result.append(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.append(string)
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result.append(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.append(string)
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result.append(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.append(string)
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result.append(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.append(string)
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result.append(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.append(string)
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result.append(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.append(string)
    }
    return result
}
```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func isPrime(n: Int) -> Bool {
    if n <= 1 {
        return false
    }
    if n <= 3 {
        return true
    }
    if n % 2 == 0 || n % 3 == 0 {
        return false
    }
    for i in 5..<Int.max / 2 {
        if i * i > n {
            break
        }
        if n % i == 0 || n % (i + 2) == 0 {
            return false
        }
    }
    return true
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var seen = [Int]()
    for i in l {
        if!seen.contains(i) {
            seen.append(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]()
    var seen = [Int]()
    for i in l {
        if!seen.contains(i) {
            seen.append(i)
            result.append(i)
        }
    }
    return result
}
```

func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var seen = [Int]()
    for i in l {
        if!seen.contains(i) {
            result.append(i)
            seen.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]()
    var seen = [Int]()
    for i in l {
        if!seen.contains(i) {
            result.append(i)
            seen.append(i)
        }
    }
    return result
}
```

func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var seen = [Int: Bool]()
    for i in l {
        if!seen[i] {
            seen[i] = true
            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]()
    var seen = [Int: Bool]()
    for i in l {
        if!seen[i] {
            seen[i] = true
            result.append(i)
        }
    }
    return result
}
```

func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var map = [Int: Bool]()
    for i in l {
        if!map[i] {
            result.append(i)
            map[i] = true
        }
    }
    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]()
    var map = [Int: Bool]()
    for i in l {
        if!map[i] {
            result.append(i)
            map[i] = true
        }
    }
    return result
}
```

func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var map = [Int: Bool]()
    for i in l {
        if!map[i] {
            result.append(i)
            map[i] = true
        }
    }
    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]()
    var map = [Int: Bool]()
    for i in l {
        if!map[i] {
            result.append(i)
            map[i] = true
        }
    }
    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] {
    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 maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1...l.count-1 {
        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-1 {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}
```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            if i % 11 == 0 {
                count += 1
            } else {
                count += 2
            }
        }
    }
    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 {
            if i % 11 == 0 {
                count += 1
            } else {
                count += 2
            }
        }
    }
    return count
}
```

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            if i % 11 == 0 {
                count += 1
            }
            if 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 {
            if i % 11 == 0 {
                count += 1
            }
            if 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 {
            if i % 11 == 0 {
                count += 1
            }
            if 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 {
            if i % 11 == 0 {
                count += 1
            }
            if 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 {
            if i % 11 == 0 {
                count += 1
            } else if 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 {
            if i % 11 == 0 {
                count += 1
            } else if 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 {
            if i % 11 == 0 {
                count += 1
            }
            if 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 {
            if i % 11 == 0 {
                count += 1
            }
            if 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 {
            if i % 11 == 0 {
                count += 1
            } else if 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 {
            if i % 11 == 0 {
                count += 1
            } else if 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 {
            if i % 11 == 0 {
                count += 1
            } else if 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 {
            if i % 11 == 0 {
                count += 1
            } else if i % 13 == 0 {
                count += 1
            }
        }
    }
    return count
}
```

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 0...n-1 {
        if i % 11 == 0 || i % 13 == 0 {
            if i % 3 == 0 {
                count += 1
            } else if i % 5 == 0 {
                count += 1
            } else if i % 7 == 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 0...n-1 {
        if i % 11 == 0 || i % 13 == 0 {
            if i % 3 == 0 {
                count += 1
            } else if i % 5 == 0 {
                count += 1
            } else if i % 7 == 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 {
            if i % 11 == 0 {
                count += 1
            } else if 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 {
            if i % 11 == 0 {
                count += 1
            } else if 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 {
            if i % 11 == 0 {
                count += 1
            }
            if 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 {
            if i % 11 == 0 {
                count += 1
            }
            if i % 13 == 0 {
                count += 1
            }
        }
    }
    return count
}
```

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

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

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

```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 sorted = l
    for i in 0..<l.count/2 {
        if i % 2 == 0 {
            var j = i + 1
            while j < l.count {
                if l[j] < l[i] {
                    var temp = l[j]
                    l[j] = l[i]
                    l[i] = temp
                }
                j += 2
            }
        }
    }
    return sorted
}
```

func sortEven(l: [Int]) -> [Int] {
    var result = [Int]()
    for (i, v) in l.enumerate() {
        if i % 2 == 0 {
            result.append(v)
        }
    }
    result.sort()
    return result
}

```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 result = [Int]()
    for (i, v) in l.enumerate() {
        if i % 2 == 0 {
            result.append(v)
        }
    }
    result.sort()
    return result
}
```

func sortEven(l: [Int]) -> [Int] {
    var result = [Int]()
    for (i, v) in l.enumerate() {
        if i % 2 == 0 {
            result.append(v)
        }
    }
    result.sort()
    return result
}

```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 result = [Int]()
    for (i, v) in l.enumerate() {
        if i % 2 == 0 {
            result.append(v)
        }
    }
    result.sort()
    return result
}
```

func sortEven(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            // Sort the even indicies
            result.sortInPlace { $0 > $1 }
        }
    }
    return result
}

```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 result = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            // Sort the even indicies
            result.sortInPlace { $0 > $1 }
        }
    }
    return result
}
```

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

```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 sorted = l
    for i in 0..<l.count/2 {
        if l[i]!= l[i*2] {
            sorted[i*2] = l[i]
        }
    }
    return sorted
}
```

func sortEven(l: [Int]) -> [Int] {
    var result = [Int]()
    for (index, value) in enumerate(l) {
        if index % 2 == 0 {
            result.append(value)
        }
    }
    result.sort()
    return result
}

```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 result = [Int]()
    for (index, value) in enumerate(l) {
        if index % 2 == 0 {
            result.append(value)
        }
    }
    result.sort()
    return result
}
```

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

```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 sorted = l
    for i in 0..<l.count/2 {
        if i % 2 == 0 {
            if l[i] > l[i+1] {
                sorted[i] = l[i+1]
                sorted[i+1] = l[i]
            }
        }
    }
    return sorted
}
```

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

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

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

```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 result = l
    for i in 0..<l.count/2 {
        if i % 2 == 0 {
            if l[i] > l[i+1] {
                result[i] = l[i+1]
                result[i+1] = l[i]
            }
        }
    }
    return result
}
```

func primeFib(n: Int) -> Int {
    let fib = fibonacci(n)
    for i in 2..<fib {
        if fib % i == 0 {
            return i
        }
    }
    return fib
}

```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 {
    let fib = fibonacci(n)
    for i in 2..<fib {
        if fib % i == 0 {
            return i
        }
    }
    return fib
}
```

func primeFib(n: Int) -> Int {
    if n < 1 {
        fatalError("n must be greater than 0")
    }
    
    var fib1 = 1
    var fib2 = 1
    var fib3 = 0
    var fib4 = 0
    
    for i in 1...n {
        fib4 = fib3
        fib3 = fib2
        fib2 = fib1
        fib1 = fib1 + fib2
        if isPrime(fib1) {
            return fib1
        }
    }
    
    fatalError("n must be less than the number of Fibonacci numbers")
}

```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 {
    if n < 1 {
        fatalError("n must be greater than 0")
    }
    
    var fib1 = 1
    var fib2 = 1
    var fib3 = 0
    var fib4 = 0
    
    for i in 1...n {
        fib4 = fib3
        fib3 = fib2
        fib2 = fib1
        fib1 = fib1 + fib2
        if isPrime(fib1) {
            return fib1
        }
    }
    
    fatalError("n must be less than the number of Fibonacci numbers")
}
```

func primeFib(n: Int) -> Int {
    // TODO: implement me!
}

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

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

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

func primeFib(n: Int) -> Int {
    var fib = fibonacci(n)
    var prime = prime(n)
    return fib * prime
}

```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 = fibonacci(n)
    var prime = prime(n)
    return fib * prime
}
```

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

func primeFib(n: Int) -> Int {
    // TODO: implement me!
}

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

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

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

func primeFib(n: Int) -> Int {
    let fib = fibonacci(n)
    for i in 0..<fib.count {
        if!isPrime(fib[i]) {
            return fib[i]
        }
    }
    return fib[fib.count - 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 {
    let fib = fibonacci(n)
    for i in 0..<fib.count {
        if!isPrime(fib[i]) {
            return fib[i]
        }
    }
    return fib[fib.count - 1]
}
```

func primeFib(n: Int) -> Int {
    // TODO: implement me!
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func triplesSumToZero(l: [Int]) -> Bool {
    var sum = 0
    for i in l {
        sum += i
    }
    if sum < 0 {
        return false
    }
    for i in l {
        for j in l {
            if i == j {
                continue
            }
            if i + j == -sum {
                return true
            }
        }
    }
    return false
}

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

func carRaceCollision(n: Int) -> Int {
    // TODO: Implement me!
}

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

```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.
    // You should use a for loop to iterate through the cars.
    // You should use a while loop to check if two cars collide.
    // You should use a break statement to exit the while loop when two cars collide.
    // You should use a continue statement to skip the rest of the cars when two cars collide.
    // You should use a return statement to return the number of collisions.
    // You should use a guard statement to handle the case when n <= 0.
    // You should use a guard statement to handle the case when n == 1.
    // You should use a guard statement to handle the case when n > 1.
    // You should use a guard statement to handle the case when n > 2.
    // You should use a guard statement to handle the case when n > 3.
    // You should use a guard statement to handle the case when n > 4.
    // You should use a guard statement to handle the case when n > 5.
    // You should use a guard statement to handle the case when n > 6.
    // You should use a guard statement to handle the case when n > 7.
    // You should use a guard statement to handle the case when n > 8.
    // You should use a guard statement to handle the case when n > 9.
    // You should use a guard statement to handle the case when n > 10.
    // You should use a guard statement to handle the case when n > 11.
    // You should use a guard statement to handle the case when n > 12.
    // You should use a guard statement to handle the case when n > 13.
    // You should use a guard statement to handle the case when n > 14.
    // You should use a guard statement to handle the case when n > 15.
    // You should use a guard statement to handle the case when n > 16.
    // You should use a guard statement to handle the case when n > 17.
    // You should use a guard statement to handle the case when n > 18.
    // You should use a guard statement to handle the case when n > 19.
    // You should use a guard statement to handle the case when n > 20.
    // You should use a guard statement to handle the case when n > 21.
    // You should use a guard statement to handle the case when n > 22.
    // You should use a guard statement to handle the case when n > 23.
    // You should use a guard statement to handle the case when n > 24.
    // You should use a guard statement to handle the case when n > 25.
    // You should use a guard statement to handle the case when n > 26.
    // You should use a guard statement to handle the case when n > 27.
    // You should use a guard statement to handle the case when n > 28.
    // You should use a guard statement to handle the case when n > 29.
    // You should use a guard statement to handle the case when n > 30.
    // You should use a guard statement to handle the case when n > 31.
    // You should use a guard statement to handle the case when n > 32.
    // You should use a guard statement to handle the case when n > 33.
    // You should use a guard statement to handle the case when n > 34.
    // You should use a guard statement to handle the case when n > 35.
    // You should use a guard statement to handle the case when n > 36.
    // You should use a guard statement to handle the case when n > 37.
    // You should use a guard statement to handle the case when n > 38.
    // You should use a guard statement to handle the case when n > 39.
    // You should use a guard statement to handle the case when n > 40.
    // You should use a guard statement to handle the case when n > 41.
    // You should use a guard statement to handle the case when n > 42.
    // You should use a guard statement to handle the case when n > 43.
    // You should use a guard statement to handle the case when n > 44.
    // You should use a guard statement to handle the case when n > 45.
    // You should use a guard statement to handle the case when n > 46.
    // You should use a guard statement to handle the case when n > 47.
    // You should use a guard statement to handle the case when n > 48.
    // You should use a guard statement to handle the case when n > 49.
    // You should use

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 {
    return n * (n - 1) / 2
}

```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 {
    return n * (n - 1) / 2
}
```

```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.
    // You can use the following variables to help you:
    //   - cars: An array of cars.
    //   - collisions: The number of collisions.
    //   - left: The cars moving left to right.
    //   - right: The cars moving right to left.
    //   - leftIndex: The index of the car that's moving left to right.
    //   - rightIndex: The index of the car that's moving right to left.
    //   - leftSpeed: The speed of the cars moving left to right.
    //   - rightSpeed: The speed of the cars moving right to left.
    //   - leftCar: The car that's moving left to right.
    //   - rightCar: The car that's moving right to left.
    //   - leftDistance: The distance between the left car and the right car.
    //   - rightDistance: The distance between the left car and the right car.
    //   - leftCarSpeed: The speed of the left car.
    //   - rightCarSpeed: The speed of the right car.
    //   - leftCarDistance: The distance between the left car and the right car.
    //   - rightCarDistance: The distance between the left car and the right car.
    //   - leftCarCollision: Whether the left car collided.
    //   - rightCarCollision: Whether the right car collided.
    //   - leftCarCollisionDistance: The distance between the left car and the right car.
    //   - rightCarCollisionDistance: The distance between the left car and the right car.
    //   - leftCarCollisionSpeed: The speed of the left car.
    //   - rightCarCollisionSpeed: The speed of the right car.
    //   - leftCarCollisionDistance: The distance between the left car and the right car.
    //   - rightCarCollisionDistance: The distance between the left car and the right car.
    //   - leftCarCollisionSpeed: The speed of the left car.
    //   - rightCarCollisionSpeed: The speed of the right car.
    //   - leftCarCollisionDistance: The distance between the left car and the right car.
    //   - rightCarCollisionDistance: The distance between the left car and the right car.
    //   - leftCarCollisionSpeed: The speed of the left car.
    //   - rightCarCollisionSpeed: The speed of the right car.
    //   - leftCarCollisionDistance: The distance between the left car and the right car.
    //   - rightCarCollisionDistance: The distance between the left car and the right car.
    //   - leftCarCollisionSpeed: The speed of the left car.
    //   - rightCarCollisionSpeed: The speed of the right car.
    //   - leftCarCollisionDistance: The distance between the left car and the right car.
    //   - rightCarCollisionDistance: The distance between the left car and the right car.
    //   - leftCarCollisionSpeed: The speed of the left car.
    //   - rightCarCollisionSpeed: The speed of the right car.
    //   - leftCarCollisionDistance: The distance between the left car and the right car.
    //   - rightCarCollisionDistance: The distance between the left car and the right car.
    //   - leftCarCollisionSpeed: The speed of the left car.
    //   - rightCarCollisionSpeed: The speed of the right car.
    //   - leftCarCollisionDistance: The distance between the left car and the right car.
    //   - rightCarCollisionDistance: The distance between the left car and the right car.
    //   - leftCarCollisionSpeed: The speed of the left car.
    //   - rightCarCollisionSpeed: The speed of the right car.
    //   - leftCarCollisionDistance: The distance between the left car and the right car.
    //   - rightCarCollisionDistance: The distance between the left car and the right car.
    //   - leftCarCollisionSpeed: The speed of the left car.
    //   - rightCarCollisionSpeed: The speed of the right car.
    //   - leftCarCollisionDistance: The distance between the left car and the right car.
    //   - rightCarCollisionDistance: The distance between the left car and the right car.
    //   - leftCarCollisionSpeed:

func carRaceCollision(n: Int) -> Int {
    // TODO: Implement me!
}

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

func carRaceCollision(n: Int) -> Int {
    // TODO: Implement me!
}

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

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 {
    return n * (n - 1) / 2
}

```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 {
    return n * (n - 1) / 2
}
```

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

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}
```

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

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}
```

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

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}
```

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

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}
```

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

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}
```

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

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}
```

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

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}
```

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

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}
```

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

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}
```

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

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i + 1)
    }
    return result
}
```

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

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

func pairsSumToZero(l: [Int]) -> Bool {
    var sum = 0
    for i in 0..<l.count {
        for j in 0..<l.count {
            if i!= j {
                sum = l[i] + l[j]
                if sum == 0 {
                    return true
                }
            }
        }
    }
    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 sum = 0
    for i in 0..<l.count {
        for j in 0..<l.count {
            if i!= j {
                sum = l[i] + l[j]
                if sum == 0 {
                    return true
                }
            }
        }
    }
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    var sum = 0
    for i in 0..<l.count {
        for j in 0..<l.count {
            if i!= j {
                sum = l[i] + l[j]
                if sum == 0 {
                    return true
                }
            }
        }
    }
    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 sum = 0
    for i in 0..<l.count {
        for j in 0..<l.count {
            if i!= j {
                sum = l[i] + l[j]
                if sum == 0 {
                    return true
                }
            }
        }
    }
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    var sum = 0
    for i in 0..<l.count {
        for j in 0..<l.count {
            if i!= j {
                sum = l[i] + l[j]
                if sum == 0 {
                    return true
                }
            }
        }
    }
    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 sum = 0
    for i in 0..<l.count {
        for j in 0..<l.count {
            if i!= j {
                sum = l[i] + l[j]
                if sum == 0 {
                    return true
                }
            }
        }
    }
    return false
}
```

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

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

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 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 {
    var sum = 0
    for i in 0..<l.count {
        for j in 0..<l.count {
            if i!= j {
                sum = l[i] + l[j]
                if sum == 0 {
                    return true
                }
            }
        }
    }
    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 sum = 0
    for i in 0..<l.count {
        for j in 0..<l.count {
            if i!= j {
                sum = l[i] + l[j]
                if sum == 0 {
                    return true
                }
            }
        }
    }
    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 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 changeBase(x: Int, base: Int) -> String {
    // Your code here.
}

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

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var number = x
    var digits = "0123456789ABCDEF"
    
    while number > 0 {
        result = String(digits[number % base]) + result
        number /= 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 number = x
    var digits = "0123456789ABCDEF"
    
    while number > 0 {
        result = String(digits[number % base]) + result
        number /= base
    }
    
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var remainder = x
    var power = 1
    while remainder > 0 {
        var digit = remainder % base
        if digit < 10 {
            result = String(UnicodeScalar(digit + 48)) + result
        } else {
            result = String(UnicodeScalar(digit + 87)) + result
        }
        remainder = remainder / base
        power = power * 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
    var power = 1
    while remainder > 0 {
        var digit = remainder % base
        if digit < 10 {
            result = String(UnicodeScalar(digit + 48)) + result
        } else {
            result = String(UnicodeScalar(digit + 87)) + result
        }
        remainder = remainder / base
        power = power * base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    // TODO:
    // 1. convert x to string
    // 2. convert base to string
    // 3. replace x with base
    // 4. return x
}

```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 {
    // TODO:
    // 1. convert x to string
    // 2. convert base to string
    // 3. replace x with base
    // 4. return x
}
```

func changeBase(x: Int, base: Int) -> String {
    // TODO:
    // return string representation after the conversion.
    // base numbers are less than 10.
    var result = ""
    var temp = x
    var i = 0
    while temp > 0 {
        var remainder = temp % base
        if remainder > 9 {
            remainder = remainder - 10
        }
        result = String(format: "%d%@", remainder, result)
        temp = temp / 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 {
    // TODO:
    // return string representation after the conversion.
    // base numbers are less than 10.
    var result = ""
    var temp = x
    var i = 0
    while temp > 0 {
        var remainder = temp % base
        if remainder > 9 {
            remainder = remainder - 10
        }
        result = String(format: "%d%@", remainder, result)
        temp = temp / base
    }
    return result
}
```

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

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var number = x
    var baseDigits = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
    var baseDigits2 = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"]
    
    while number > 0 {
        result = baseDigits[number % base] + result
        number /= 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 number = x
    var baseDigits = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
    var baseDigits2 = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"]
    
    while number > 0 {
        result = baseDigits[number % base] + result
        number /= base
    }
    
    return result
}
```

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

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var remainder = x
    var divider = 1
    
    while remainder > 0 {
        let digit = remainder % base
        remainder = remainder / base
        
        result = String(format: "%d%@", digit, result)
        divider = divider * 10
    }
    
    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
    var divider = 1
    
    while remainder > 0 {
        let digit = remainder % base
        remainder = remainder / base
        
        result = String(format: "%d%@", digit, result)
        divider = divider * 10
    }
    
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var number = x
    var digit = 0
    while number > 0 {
        digit = number % base
        number = number / base
        result = String(format: "%d%@", digit, 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 number = x
    var digit = 0
    while number > 0 {
        digit = number % base
        number = number / base
        result = String(format: "%d%@", digit, result)
    }
    return result
}
```

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

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

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