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

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

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var sortedNumbers = numbers.sorted()
    for (index, number) in sortedNumbers.enumerated() {
        if index == sortedNumbers.count - 1 {
            break
        }
        let nextNumber = sortedNumbers[index + 1]
        if abs(number - nextNumber) < threshold {
            return true
        }
    }
    return false
}

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

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

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

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

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

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

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

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

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

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

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

func separateParenGroups(parenString: String) -> [String] {
    var stack = [Character]()
    var groups = [String]()
    var currentGroup = ""
    
    for char in parenString {
        if char == "(" {
            stack.append(char)
            currentGroup += String(char)
        } else if char == ")" {
            if stack.isEmpty {
                // Invalid input, ignore this character
            } else {
                stack.removeLast()
                currentGroup += String(char)
            }
        } else if char == " " {
            // Ignore spaces
        } else {
            currentGroup += String(char)
        }
        
        if stack.isEmpty {
            groups.append(currentGroup)
            currentGroup = ""
        }
    }
    
    return groups
}

```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 stack = [Character]()
    var groups = [String]()
    var currentGroup = ""
    
    for char in parenString {
        if char == "(" {
            stack.append(char)
            currentGroup += String(char)
        } else if char == ")" {
            if stack.isEmpty {
                // Invalid input, ignore this character
            } else {
                stack.removeLast()
                currentGroup += String(char)
            }
        } else if char == " " {
            // Ignore spaces
        } else {
            currentGroup += String(char)
        }
        
        if stack.isEmpty {
            groups.append(currentGroup)
            currentGroup = ""
        }
    }
    
    return groups
}
```

```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 stringArray = parenString.components(separatedBy: " ")
    var stringArray2 = [String]()
    var stringArray3 = [String]()
    var stringArray4 = [String]()
    var stringArray5 = [String]()
    var stringArray6 = [String]()
    var stringArray7 = [String]()
    var stringArray8 = [String]()
    var stringArray9 = [String]()
    var stringArray10 = [String]()
    var stringArray11 = [String]()
    var stringArray12 = [String]()
    var stringArray13 = [String]()
    var stringArray14 = [String]()
    var stringArray15 = [String]()
    var stringArray16 = [String]()
    var stringArray17 = [String]()
    var stringArray18 = [String]()
    var stringArray19 = [String]()
    var stringArray20 = [String]()
    var stringArray21 = [String]()
    var stringArray22 = [String]()
    var stringArray23 = [String]()
    var stringArray24 = [String]()
    var stringArray25 = [String]()
    var stringArray26 = [String]()
    var stringArray27 = [String]()
    var stringArray28 = [String]()
    var stringArray29 = [String]()
    var stringArray30 = [String]()
    var stringArray31 = [String]()
    var stringArray32 = [String]()
    var stringArray33 = [String]()
    var stringArray34 = [String]()
    var stringArray35 = [String]()
    var stringArray36 = [String]()
    var stringArray37 = [String]()
    var stringArray38 = [String]()
    var stringArray39 = [String]()
    var stringArray40 = [String]()
    var stringArray41 = [String]()
    var stringArray42 = [String]()
    var stringArray43 = [String]()
    var stringArray44 = [String]()
    var stringArray45 = [String]()
    var stringArray46 = [String]()
    var stringArray47 = [String]()
    var stringArray48 = [String]()
    var stringArray49 = [String]()
    var stringArray50 = [String]()
    var stringArray51 = [String]()
    var stringArray52 = [String]()
    var stringArray53 = [String]()
    var stringArray54 = [String]()
    var stringArray55 = [String]()
    var stringArray56 = [String]()
    var stringArray57 = [String]()
    var stringArray58 = [String]()
    var stringArray59 = [String]()
    var stringArray60 = [String]()
    var stringArray61 = [String]()
    var stringArray62 = [String]()
    var stringArray63 = [String]()
    var stringArray64 = [String]()
    var stringArray65 = [String]()
    var stringArray66 = [String]()
    var stringArray67 = [String]()
    var stringArray68 = [String]()
    var stringArray69 = [String]()
    var stringArray70 = [String]()
    var stringArray71 = [String]()
    var stringArray72 = [String]()
    var stringArray73 = [String]()
    var stringArray74 = [String]()
    var stringArray75 = [String]()
    var stringArray76 = [String]()
    var stringArray77 = [String]()
    var stringArray78 = [String]()
    var stringArray79 = [String]()
    var stringArray80 = [String]()
    var stringArray81 = [String]()
    var stringArray82 = [String]()
    var stringArray83 = [String]()
    var stringArray84 = [String]()
    var stringArray85 = [String]()
    var stringArray86 = [String]()
    var stringArray87 = [String]()
    var stringArray88 = [String]()
    var stringArray89 = [String]()
    var stringArray90 = [String]()
    var stringArray91 = [String]()
    var stringArray92 = [String]()
    var stringArray93 = [String]()
    var string

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var currentString = ""
    var openCount = 0
    var closeCount = 0
    for char in parenString {
        if char == "(" {
            openCount += 1
            currentString += String(char)
        } else if char == ")" {
            closeCount += 1
            currentString += String(char)
        } else if char == " " {
            continue
        } else {
            currentString += String(char)
        }
        if openCount == closeCount {
            result.append(currentString)
            currentString = ""
            openCount = 0
            closeCount = 0
        }
    }
    return result
}

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

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var currentString = ""
    var openParenCount = 0
    var closeParenCount = 0
    
    for char in parenString {
        if char == "(" {
            openParenCount += 1
            currentString += String(char)
        } else if char == ")" {
            closeParenCount += 1
            currentString += String(char)
        }
        
        if openParenCount == closeParenCount {
            result.append(currentString)
            currentString = ""
            openParenCount = 0
            closeParenCount = 0
        }
    }
    
    return result
}

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

func separateParenGroups(parenString: String) -> [String] {
    var result: [String] = []
    var currentString: String = ""
    var openParens: Int = 0
    for char in parenString {
        if char == "(" {
            openParens += 1
            currentString += String(char)
        } else if char == ")" {
            openParens -= 1
            currentString += String(char)
        } else if char == " " {
            continue
        } else {
            currentString += String(char)
        }
        if openParens == 0 {
            result.append(currentString)
            currentString = ""
        }
    }
    return result
}

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

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var currentString = ""
    var openCount = 0
    var closeCount = 0
    for char in parenString {
        if char == "(" {
            openCount += 1
            currentString += String(char)
        } else if char == ")" {
            closeCount += 1
            currentString += String(char)
        } else if char == " " {
            continue
        } else {
            currentString += String(char)
        }
        if openCount == closeCount {
            result.append(currentString)
            currentString = ""
            openCount = 0
            closeCount = 0
        }
    }
    return result
}

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

func separateParenGroups(parenString: String) -> [String] {
    var stack = [Character]()
    var groups = [String]()
    var currentGroup = ""
    
    for char in parenString {
        if char == "(" {
            stack.append(char)
            currentGroup.append(char)
        } else if char == ")" {
            stack.append(char)
            currentGroup.append(char)
            
            if stack.count == 0 {
                groups.append(currentGroup)
                currentGroup = ""
            }
        } else {
            currentGroup.append(char)
        }
    }
    
    return groups
}

```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 stack = [Character]()
    var groups = [String]()
    var currentGroup = ""
    
    for char in parenString {
        if char == "(" {
            stack.append(char)
            currentGroup.append(char)
        } else if char == ")" {
            stack.append(char)
            currentGroup.append(char)
            
            if stack.count == 0 {
                groups.append(currentGroup)
                currentGroup = ""
            }
        } else {
            currentGroup.append(char)
        }
    }
    
    return groups
}
```

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

```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 stack = [Character]()
    var groups = [String]()
    var currentGroup = ""
    
    for char in parenString {
        if char == "(" {
            stack.append(char)
            currentGroup += String(char)
        } else if char == ")" {
            if stack.isEmpty {
                groups.append(currentGroup)
                currentGroup = ""
            } else {
                stack.popLast()
                currentGroup += String(char)
            }
        } else {
            currentGroup += String(char)
        }
    }
    
    if !stack.isEmpty {
        groups.append(currentGroup)
    }
    
    return groups
}
```

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var currentString = ""
    var openCount = 0
    var closeCount = 0
    for char in parenString {
        if char == "(" {
            openCount += 1
            currentString += String(char)
        } else if char == ")" {
            closeCount += 1
            currentString += String(char)
        } else if char == " " {
            continue
        } else {
            currentString += String(char)
        }
        if openCount == closeCount {
            result.append(currentString)
            currentString = ""
            openCount = 0
            closeCount = 0
        }
    }
    return result
}

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

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var currentString = ""
    var openCount = 0
    var closeCount = 0
    for char in parenString {
        if char == "(" {
            openCount += 1
            currentString += String(char)
        } else if char == ")" {
            closeCount += 1
            currentString += String(char)
        } else if char == " " {
            continue
        } else {
            currentString += String(char)
        }
        if openCount == closeCount {
            result.append(currentString)
            currentString = ""
            openCount = 0
            closeCount = 0
        }
    }
    return result
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Given a positive floating

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

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

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

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

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

func truncateNumber(number: Double) -> Double {
    return number.truncatingRemainder(dividingBy: 1)
}

```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 - Int(number)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Given a positive floating

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always

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

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

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

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

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

func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(numbers.count)
}

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

// For a given array of input numbers, calculate Median Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(numbers.count)
}

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

// For a given array of input numbers, calculate Median Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(numbers.count)
}

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

// For a given array of input numbers, calculate Median Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(numbers.count)
}

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

//

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

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

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

func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(deviations.count)
}

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

// For a given array of input numbers, calculate Median Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(deviations.count)
}

// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(deviations.count)
}

// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(deviations.count)
}

// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(deviations.count)
}

// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(deviations.count)
}

// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(deviations.count)
}

// For a given array of

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

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

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

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

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

func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(deviations.count)
}

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

// For a given array of input numbers, calculate Median Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(deviations.count)
}

// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(deviations.count)
}

// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(deviations.count)
}

// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(deviations.count)
}

// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(deviations.count)
}

// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let deviations = numbers.map { abs($0 - median) }
    return deviations.reduce(0, +) / Double(deviations.count)
}

// For a given array of

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

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

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

func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let absoluteDifferences = numbers.map { abs($0 - median) }
    return absoluteDifferences.reduce(0, +) / Double(numbers.count)
}

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

// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let absoluteDifferences = numbers.map { abs($0 - median) }
    return absoluteDifferences.reduce(0, +) / Double(numbers.count)
}

// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let absoluteDifferences = numbers.map { abs($0 - median) }
    return absoluteDifferences.reduce(0, +) / Double(numbers.count)
}

// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let absoluteDifferences = numbers.map { abs($0 - median) }
    return absoluteDifferences.reduce(0, +) / Double(numbers.count)
}

// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let absoluteDifferences = numbers.map { abs($0 - median) }
    return absoluteDifferences.reduce(0, +) / Double(numbers.count)
}

// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let absoluteDifferences = numbers.map { abs($0 - median) }
    return absoluteDifferences.reduce(0, +) / Double(numbers.count)
}

// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// medianAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let absoluteDifferences = numbers.map { abs($0 - median) }
    return absoluteDifferences.reduce(0, +) / Double(numbers.count)
}

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

func medianAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    return numbers.reduce(0) { $0 + abs($1 - median) } / Double(numbers.count)
}

func meanAbsoluteDeviationAroundMedian(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return (numbers.reduce(0) { $0 + abs($1 - median) } / Double(numbers.count)) +
        (numbers.reduce(0) { $0 + abs($1 - mean) } / Double(numbers.count))
}

func medianAbsoluteDeviationAroundMean(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return (numbers.reduce(0) { $0 + abs($1 - median) } / Double(numbers.count)) +
        (numbers.reduce(0) { $0 + abs($1 - mean) } / Double(numbers.count))
}

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

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

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

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

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

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

// For a given array

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

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

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

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

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

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

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

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

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

// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// insert(numbers: [1, 2, 3], index: 1, delimeter: 4) == [1, 4, 2, 3]
func insert(numbers: [Int], index: Int, delimeter: Int) -> [Int] {
    var result = [Int]()
    for (numberIndex, number) in numbers.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Remove all duplicates from array `numbers'
// removeDuplicates(numbers: [1, 2, 3, 1, 2, 3]) == [1, 2, 3]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if !result.contains(number) {
            result.append(number)
        }
    }
    return result
}

// Remove all duplicates from array `numbers' and insert a number 'delimeter' between every two consecutive elements of the result array
// intersperse(numbers: removeDuplicates(numbers: [1, 2, 3, 1, 2, 3]), delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}

// Remove all duplicates from array `numbers' and insert a number 'delimeter' between every two consecutive elements of the result array
// intersperse(numbers: removeDuplicates(numbers: [1, 2, 3, 1, 2, 3]), delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}

// Remove all duplicates from array `numbers' and insert a number 'delimeter' between every two consecutive elements of the result array
// intersperse(numbers: removeDuplicates(numbers: [1, 2, 3, 1, 2, 3]), delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}

// Remove all duplicates from array `numbers' and insert a number 'delimeter' between every two consecutive elements of the result array
// intersperse(numbers: removeDuplicates(numbers: [1, 2, 3, 1, 2, 3]), delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}

// Remove all duplicates from array `numbers' and insert a number 'delimeter' between every two consecutive elements of the result array
// intersperse(numbers: removeDuplicates(numbers: [1, 2, 3, 1, 2, 3]), delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for (index, number) in numbers.enumerated() {
        result.append(number)
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}

// Remove all duplicates from array `numbers' and insert a number 'delimeter' between every two consecutive elements of the result array
// intersperse(numbers: removeDuplicates(numbers:

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

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

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

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

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

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

func parseNestedParens(parenString: String) -> [Int] {
    let parenArray = parenString.components(separatedBy: " ")
    var result = [Int]()
    for str in parenArray {
        var max = 0
        var count = 0
        for char in str {
            if char == "(" {
                count += 1
            } else if char == ")" {
                count -= 1
            }
            max = max(max, count)
        }
        result.append(max)
    }
    return result
}

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

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

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

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

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

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

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

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

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

// Test cases
print(parseNestedParens(parenString: "(()()) ((())) () ((())()())")) // [2, 3, 1, 3]
print(parseNestedParens(parenString: "(()()) ((())) () ((())()()) (())")) // [2, 3, 1, 3, 1]
print(parseNestedParens(parenString: "(()()) ((())) () ((())()()) (()) (())")) // [2, 3, 1, 3, 1, 1]
print(parseNestedParens(parenString: "(()()) ((())) () ((())()()) (()) (()) (())")) // [2, 3, 1, 3, 1, 1, 1]
print(parseNestedParens(parenString: "(()()) ((())) () ((())()()) (()) (()) (()) (())")) // [2, 3, 1, 3, 1, 1, 1, 1]
print(parseNestedParens(parenString: "(()()) ((())) () ((())()()) (()) (()) (()) (()) (())")) // [2, 3, 1, 3, 1, 1, 1, 1, 1]
print(parseNestedParens(parenString: "(()()) ((())) () ((())()()) (()) (()) (()) (()) (()) (())")) // [2, 3, 1, 3, 1, 1, 1, 1, 1, 1]
print(parseNestedParens(parenString: "(()()) ((())) () ((())()()) (()) (()) (()) (()) (()) (()) (())")) // [2, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1]
print(parseNestedParens(parenString: "(()()) ((())) () ((())()()) (()) (()) (()) (()) (()) (()) (()) (())")) // [2, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1]
print(parseNestedParens(parenString: "(()()) ((())) () ((())()()) (()) (()) (()) (()) (()) (()) (()) (()) (())")) // [2, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1]
print(parseNestedParens(parenString: "(()()) ((())) () ((())()()) (()) (()) (()) (()) (()) (()) (()) (()) (()) (())")) // [2, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
print(parseNestedParens(parenString: "(()()) ((())) () ((())()()) (()) (()) (()) (()) (()) (()) (()) (()) (()) (()) (())")) // [2, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
print(parseNestedParens(parenString: "(()()) ((())) () ((())()()) (()) (()) (()) (()) (()) (()) (()) (()) (()) (()) (()) (())")) // [2, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
print(parseNestedParens(parenString: "(()()) ((())) () ((())()()) (()) (()) (()) (()) (()) (()) (()) (()) (()) (()) (()) (()) (())")) // [2, 3,

func parseNestedParens(parenString: String) -> [Int] {
    var result = [Int]()
    let stringArray = parenString.components(separatedBy: " ")
    for string in stringArray {
        var max = 0
        var current = 0
        for char in string {
            if char == "(" {
                current += 1
                max = max < current ? current : max
            } else if char == ")" {
                current -= 1
            }
        }
        result.append(max)
    }
    return result
}

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

func parseNestedParens(parenString: String) -> [Int] {
    var result = [Int]()
    let parenString = parenString.replacingOccurrences(of: " ", with: "")
    var max = 0
    var count = 0
    for char in parenString {
        if char == "(" {
            count += 1
            max = max < count ? count : max
        } else {
            count -= 1
        }
    }
    result.append(max)
    return result
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

print(rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]))
```

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

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

print(rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]))
```

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

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

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

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

func rollingAvg(numbers: [Int]) -> [Double] {
    var result = [Double]()
    var sum = 0
    for number in numbers {
        sum += number
        result.append(Double(sum) / Double(numbers.count))
    }
    return result
}

func rollingMedian(numbers: [Int]) -> [Double] {
    var result = [Double]()
    var sorted = numbers
    sorted.sort()
    for number in numbers {
        let index = sorted.firstIndex(of: number)!
        let median = Double(sorted[index])
        result.append(median)
    }
    return result
}

func rollingMode(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var modes = [Int: Int]()
    for number in numbers {
        modes[number] = (modes[number] ?? 0) + 1
        result.append(modes.max(by: { $0.value < $1.value })!.key)
    }
    return result
}

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

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

// From a given array of integers, generate an array of rolling average of elements found until given moment
// in the sequence.
// rollingAvg(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 1.5, 2, 2.25, 2.5, 3, 3]
func rollingAvg(numbers: [Int]) -> [Double] {
    var result = [Double]()
    var sum = 0
    for number in numbers {
        sum += number
        result.append(Double(sum) / Double(numbers.count))
    }
    return result
}

// From a given array of integers, generate an array of rolling median of elements found until given moment
// in the sequence.
// rollingMedian(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 1.5, 2, 2, 2.5, 3, 3]
func rollingMedian(numbers: [Int]) -> [Double] {
    var result = [Double]()
    var sorted = numbers
    sorted.sort()
    for number in numbers {
        let index = sorted.firstIndex(of: number)!
        let median = Double(sorted[index])
        result.append(median)
    }
    return result
}

// From a given array of integers, generate an array of rolling mode of elements found until given moment
// in the sequence.
// rollingMode(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 1, 2, 2, 2, 3, 3]
func rollingMode(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var modes = [Int: Int]()
    for number in numbers {
        modes[number] = (modes[number] ?? 0) + 1
        result.append(modes.max(by: { $0.value < $1.value })!.key)
    }
    return result
}

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

// From a given array of integers, generate an array of rolling variance of elements found until given moment
// in the sequence.
// rollingVariance(numbers: [1, 2, 3, 2, 3, 4, 2]) == [0, 0.25, 0.5, 0.5, 0.5, 1, 1]
func rollingVariance(numbers: [Int]) -> [Double] {
    var result = [Double]()
    var sum = 0
    var sumOfSquares = 0
    for number in numbers {
        sum += number
        sumOfSquares += number * number
        result.append(Double(sumOfSquares) / Double(numbers.count) - Double(sum) * Double(sum) / Double(numbers

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

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

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

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

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
}

print(rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]))
```

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

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

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

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

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

func isPalindrome(string: String) -> Bool {
    let string = string.lowercased()
    let length = string.count
    
    for i in 0..<length / 2 {
        if string[string.index(string.startIndex, offsetBy: i)] != string[string.index(string.endIndex, offsetBy: -i - 1)] {
            return false
        }
    }
    
    return true
}

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

// isPalindrome(string: "") == true
// isPalindrome(string: "a") == true
// isPalindrome(string: "aa") == true
// isPalindrome(string: "ab") == false
// isPalindrome(string: "aba") == true
// isPalindrome(string: "abba") == true
// isPalindrome(string: "abcba") == true
// isPalindrome(string: "abc") == false
func isPalindrome(string: String) -> Bool {
    let string = string.lowercased()
    let length = string.count
    
    for i in 0..<length / 2 {
        if string[string.index(string.startIndex, offsetBy: i)] != string[string.index(string.endIndex, offsetBy: -i - 1)] {
            return false
        }
    }
    
    return true
}
```

func makePalindrome(string: String) -> String {
    let string = string.characters
    let stringLength = string.count
    var i = 0
    var j = stringLength - 1
    
    while i < j {
        if string[string.startIndex.advancedBy(i)] == string[string.startIndex.advancedBy(j)] {
            i += 1
            j -= 1
        } else {
            break
        }
    }
    
    let palindromicSuffixStartIndex = i
    let palindromicSuffixEndIndex = j
    
    var prefixEndIndex = palindromicSuffixEndIndex
    
    while prefixEndIndex > 0 {
        if string[string.startIndex.advancedBy(prefixEndIndex)] == string[string.startIndex.advancedBy(palindromicSuffixStartIndex)] {
            prefixEndIndex -= 1
        } else {
            break
        }
    }
    
    let prefixStartIndex = prefixEndIndex + 1
    
    let palindromicSuffix = string.suffix(stringLength - palindromicSuffixEndIndex)
    let prefix = string.prefix(prefixEndIndex)
    
    return String(palindromicSuffix) + String(prefix.reverse())
}

```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 string = string.characters
    let stringLength = string.count
    var i = 0
    var j = stringLength - 1
    
    while i < j {
        if string[string.startIndex.advancedBy(i)] == string[string.startIndex.advancedBy(j)] {
            i += 1
            j -= 1
        } else {
            break
        }
    }
    
    let palindromicSuffixStartIndex = i
    let palindromicSuffixEndIndex = j
    
    var prefixEndIndex = palindromicSuffixEndIndex
    
    while prefixEndIndex > 0 {
        if string[string.startIndex.advancedBy(prefixEndIndex)] == string[string.startIndex.advancedBy(palindromicSuffixStartIndex)] {
            prefixEndIndex -= 1
        } else {
            break
        }
    }
    
    let prefixStartIndex = prefixEndIndex + 1
    
    let palindromicSuffix = string.suffix(stringLength - palindromicSuffixEndIndex)
    let prefix = string.prefix(prefixEndIndex)
    
    return String(palindromicSuffix) + String(prefix.reverse())
}
```

func makePalindrome(string: String) -> String {
    let string = string.characters
    let stringLength = string.count
    
    var longestPalindromicSuffixLength = 0
    var longestPalindromicSuffixIndex = 0
    
    for i in 0..<stringLength {
        var palindromicSuffixLength = 0
        
        for j in 0..<stringLength - i {
            if string[string.startIndex.advancedBy(i + j)] == string[string.startIndex.advancedBy(stringLength - j - 1)] {
                palindromicSuffixLength += 1
            } else {
                break
            }
        }
        
        if palindromicSuffixLength > longestPalindromicSuffixLength {
            longestPalindromicSuffixLength = palindromicSuffixLength
            longestPalindromicSuffixIndex = i
        }
    }
    
    let stringPrefix = string[string.startIndex..<string.startIndex.advancedBy(longestPalindromicSuffixIndex)]
    let stringSuffix = string[string.startIndex.advancedBy(longestPalindromicSuffixIndex)..<string.startIndex.advancedBy(stringLength)]
    
    let stringPrefixReversed = stringPrefix.reverse()
    
    return stringPrefixReversed + stringSuffix
}

```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 string = string.characters
    let stringLength = string.count
    
    var longestPalindromicSuffixLength = 0
    var longestPalindromicSuffixIndex = 0
    
    for i in 0..<stringLength {
        var palindromicSuffixLength = 0
        
        for j in 0..<stringLength - i {
            if string[string.startIndex.advancedBy(i + j)] == string[string.startIndex.advancedBy(stringLength - j - 1)] {
                palindromicSuffixLength += 1
            } else {
                break
            }
        }
        
        if palindromicSuffixLength > longestPalindromicSuffixLength {
            longestPalindromicSuffixLength = palindromicSuffixLength
            longestPalindromicSuffixIndex = i
        }
    }
    
    let stringPrefix = string[string.startIndex..<string.startIndex.advancedBy(longestPalindromicSuffixIndex)]
    let stringSuffix = string[string.startIndex.advancedBy(longestPalindromicSuffixIndex)..<string.startIndex.advancedBy(stringLength)]
    
    let stringPrefixReversed = stringPrefix.reverse()
    
    return stringPrefixReversed + stringSuffix
}
```

func makePalindrome(string: String) -> String {
    let string = string.characters
    let length = string.count
    
    if length == 0 {
        return ""
    }
    
    var i = length - 1
    
    while i > 0 {
        let isPalindrome = isPalindrome(string: string, from: 0, to: i)
        
        if isPalindrome {
            break
        }
        
        i -= 1
    }
    
    let prefixLength = i + 1
    let suffixLength = length - prefixLength
    
    let prefix = string[0..<prefixLength]
    let suffix = string[prefixLength..<length]
    let reversedSuffix = suffix.reverse()
    
    return prefix + reversedSuffix
}

func isPalindrome(string: [Character], from: Int, to: Int) -> Bool {
    let length = to - from + 1
    
    for i in 0..<length / 2 {
        let firstIndex = from + i
        let secondIndex = to - i
        
        if string[firstIndex] != string[secondIndex] {
            return false
        }
    }
    
    return true
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    let string = string.characters
    let length = string.count
    
    if length == 0 {
        return ""
    }
    
    var i = length - 1
    
    while i > 0 {
        let isPalindrome = isPalindrome(string: string, from: 0, to: i)
        
        if isPalindrome {
            break
        }
        
        i -= 1
    }
    
    let prefixLength = i + 1
    let suffixLength = length - prefixLength
    
    let prefix = string[0..<prefixLength]
    let suffix = string[prefixLength..<length]
    let reversedSuffix = suffix.reverse()
    
    return prefix + reversedSuffix
}

func isPalindrome(string: [Character], from: Int, to: Int) -> Bool {
    let length = to - from + 1
    
    for i in 0..<length / 2 {
        let firstIndex = from + i
        let secondIndex = to - i
        
        if string[firstIndex] != string[secondIndex] {
            return false
        }
    }
    
    return true
}
```

func makePalindrome(string: String) -> String {
    let string = string.lowercased()
    let stringLength = string.count
    
    if stringLength == 0 {
        return ""
    }
    
    var longestPalindromicSuffixLength = 0
    var longestPalindromicSuffixIndex = 0
    
    for i in 0..<stringLength {
        var palindromicSuffixLength = 0
        
        for j in stride(from: stringLength - 1, through: i, by: -1) {
            if string[string.index(string.startIndex, offsetBy: i)] == string[string.index(string.startIndex, offsetBy: j)] {
                palindromicSuffixLength += 1
            } else {
                break
            }
        }
        
        if palindromicSuffixLength > longestPalindromicSuffixLength {
            longestPalindromicSuffixLength = palindromicSuffixLength
            longestPalindromicSuffixIndex = i
        }
    }
    
    let prefix = string[string.startIndex..<string.index(string.startIndex, offsetBy: longestPalindromicSuffixIndex)]
    let suffix = string[string.index(string.startIndex, offsetBy: longestPalindromicSuffixIndex)..<string.endIndex]
    
    return String(prefix) + String(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 {
    let string = string.lowercased()
    let stringLength = string.count
    
    if stringLength == 0 {
        return ""
    }
    
    var longestPalindromicSuffixLength = 0
    var longestPalindromicSuffixIndex = 0
    
    for i in 0..<stringLength {
        var palindromicSuffixLength = 0
        
        for j in stride(from: stringLength - 1, through: i, by: -1) {
            if string[string.index(string.startIndex, offsetBy: i)] == string[string.index(string.startIndex, offsetBy: j)] {
                palindromicSuffixLength += 1
            } else {
                break
            }
        }
        
        if palindromicSuffixLength > longestPalindromicSuffixLength {
            longestPalindromicSuffixLength = palindromicSuffixLength
            longestPalindromicSuffixIndex = i
        }
    }
    
    let prefix = string[string.startIndex..<string.index(string.startIndex, offsetBy: longestPalindromicSuffixIndex)]
    let suffix = string[string.index(string.startIndex, offsetBy: longestPalindromicSuffixIndex)..<string.endIndex]
    
    return String(prefix) + String(suffix.reversed())
}
```

func makePalindrome(string: String) -> String {
    let string = string.characters
    let stringLength = string.count
    
    var longestPalindromicSuffixLength = 0
    var longestPalindromicSuffixIndex = 0
    
    for suffixLength in 0..<stringLength {
        let suffixStartIndex = stringLength - suffixLength - 1
        
        var isPalindromic = true
        for i in 0..<suffixLength {
            if string[suffixStartIndex + i] != string[suffixStartIndex - i] {
                isPalindromic = false
                break
            }
        }
        
        if isPalindromic {
            longestPalindromicSuffixLength = suffixLength
            longestPalindromicSuffixIndex = suffixStartIndex
            break
        }
    }
    
    let prefix = string[0..<longestPalindromicSuffixIndex]
    let suffix = string[longestPalindromicSuffixIndex..<stringLength]
    
    let reversedPrefix = String(prefix.reverse())
    
    return reversedPrefix + String(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 {
    let string = string.characters
    let stringLength = string.count
    
    var longestPalindromicSuffixLength = 0
    var longestPalindromicSuffixIndex = 0
    
    for suffixLength in 0..<stringLength {
        let suffixStartIndex = stringLength - suffixLength - 1
        
        var isPalindromic = true
        for i in 0..<suffixLength {
            if string[suffixStartIndex + i] != string[suffixStartIndex - i] {
                isPalindromic = false
                break
            }
        }
        
        if isPalindromic {
            longestPalindromicSuffixLength = suffixLength
            longestPalindromicSuffixIndex = suffixStartIndex
            break
        }
    }
    
    let prefix = string[0..<longestPalindromicSuffixIndex]
    let suffix = string[longestPalindromicSuffixIndex..<stringLength]
    
    let reversedPrefix = String(prefix.reverse())
    
    return reversedPrefix + String(suffix)
}
```

func makePalindrome(string: String) -> String {
    let string = string.characters
    let stringLength = string.count
    
    // Find the longest palindromic suffix.
    var i = stringLength - 1
    var j = stringLength - 1
    while i > 0 && string[string.startIndex.advancedBy(i)] == string[string.startIndex.advancedBy(j)] {
        i -= 1
        j -= 1
    }
    
    // If the string is already a palindrome, return it.
    if i == 0 {
        return string
    }
    
    // If the string is not a palindrome, append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    let prefix = string[string.startIndex.advancedBy(0)..<string.startIndex.advancedBy(i)]
    let suffix = string[string.startIndex.advancedBy(i)..<string.startIndex.advancedBy(j + 1)]
    let reversedPrefix = String(prefix.reverse())
    return reversedPrefix + String(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 {
    let string = string.characters
    let stringLength = string.count
    
    // Find the longest palindromic suffix.
    var i = stringLength - 1
    var j = stringLength - 1
    while i > 0 && string[string.startIndex.advancedBy(i)] == string[string.startIndex.advancedBy(j)] {
        i -= 1
        j -= 1
    }
    
    // If the string is already a palindrome, return it.
    if i == 0 {
        return string
    }
    
    // If the string is not a palindrome, append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    let prefix = string[string.startIndex.advancedBy(0)..<string.startIndex.advancedBy(i)]
    let suffix = string[string.startIndex.advancedBy(i)..<string.startIndex.advancedBy(j + 1)]
    let reversedPrefix = String(prefix.reverse())
    return reversedPrefix + String(suffix)
}
```

func makePalindrome(string: String) -> String {
    let string = string.characters
    let length = string.count
    var i = 0
    var j = length - 1
    
    while i < j {
        if string[string.startIndex.advancedBy(i)] == string[string.startIndex.advancedBy(j)] {
            i += 1
            j -= 1
        } else {
            break
        }
    }
    
    let prefixLength = i
    let suffixLength = length - j - 1
    
    let prefix = string.prefix(prefixLength)
    let suffix = string.suffix(suffixLength)
    
    let reversedSuffix = suffix.reverse()
    
    return prefix + reversedSuffix
}

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

func makePalindrome(string: String) -> String {
    let length = string.count
    guard length > 0 else {
        return string
    }
    
    var left = 0
    var right = length - 1
    
    while left < right {
        let leftChar = string[string.index(string.startIndex, offsetBy: left)]
        let rightChar = string[string.index(string.startIndex, offsetBy: right)]
        
        if leftChar != rightChar {
            break
        }
        
        left += 1
        right -= 1
    }
    
    let palindromicSubstring = string[string.index(string.startIndex, offsetBy: left)...string.index(string.startIndex, offsetBy: right)]
    let palindromicSubstringLength = palindromicSubstring.count
    
    let prefix = string[string.startIndex..<string.index(string.startIndex, offsetBy: left)]
    let prefixLength = prefix.count
    
    let suffix = string[string.index(string.startIndex, offsetBy: right + 1)..<string.endIndex]
    let suffixLength = suffix.count
    
    let prefixReversed = String(prefix.reversed())
    
    if palindromicSubstringLength > prefixLength && palindromicSubstringLength > suffixLength {
        return string + prefixReversed
    } else if palindromicSubstringLength > prefixLength {
        return string + prefixReversed
    } else if palindromicSubstringLength > suffixLength {
        return prefixReversed + string
    } else {
        return string + prefixReversed
    }
}

```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 length = string.count
    guard length > 0 else {
        return string
    }
    
    var left = 0
    var right = length - 1
    
    while left < right {
        let leftChar = string[string.index(string.startIndex, offsetBy: left)]
        let rightChar = string[string.index(string.startIndex, offsetBy: right)]
        
        if leftChar != rightChar {
            break
        }
        
        left += 1
        right -= 1
    }
    
    let palindromicSubstring = string[string.index(string.startIndex, offsetBy: left)...string.index(string.startIndex, offsetBy: right)]
    let palindromicSubstringLength = palindromicSubstring.count
    
    let prefix = string[string.startIndex..<string.index(string.startIndex, offsetBy: left)]
    let prefixLength = prefix.count
    
    let suffix = string[string.index(string.startIndex, offsetBy: right + 1)..<string.endIndex]
    let suffixLength = suffix.count
    
    let prefixReversed = String(prefix.reversed())
    
    if palindromicSubstringLength > prefixLength && palindromicSubstringLength > suffixLength {
        return string + prefixReversed
    } else if palindromicSubstringLength > prefixLength {
        return string + prefixReversed
    } else if palindromicSubstringLength > suffixLength {
        return prefixReversed + string
    } else {
        return string + prefixReversed
    }
}

print(makePalindrome(string: "cat"))
print(makePalindrome(string: "cata"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "racecar"))
print(makePalindrome(string: "

func makePalindrome(string: String) -> String {
    let string = string.characters
    let stringLength = string.count
    
    // Find the longest palindromic suffix.
    var i = stringLength - 1
    while i > 0 && string[string.startIndex.advancedBy(i)] != string[string.startIndex.advancedBy(stringLength - 1)] {
        i -= 1
    }
    
    // If there is no palindromic suffix, return the original string.
    if i == 0 {
        return string.reduce("", combine: { $0 + String($1) })
    }
    
    // If there is a palindromic suffix, append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    var j = stringLength - 1
    while j > i && string[string.startIndex.advancedBy(j)] != string[string.startIndex.advancedBy(stringLength - 1 - (j - i))] {
        j -= 1
    }
    
    let prefix = string.prefix(j)
    let suffix = string.suffix(stringLength - j)
    
    return prefix.reduce("", combine: { $0 + String($1) }) + suffix.reverse().reduce("", combine: { $0 + String($1) })
}

```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 string = string.characters
    let stringLength = string.count
    
    // Find the longest palindromic suffix.
    var i = stringLength - 1
    while i > 0 && string[string.startIndex.advancedBy(i)] != string[string.startIndex.advancedBy(stringLength - 1)] {
        i -= 1
    }
    
    // If there is no palindromic suffix, return the original string.
    if i == 0 {
        return string.reduce("", combine: { $0 + String($1) })
    }
    
    // If there is a palindromic suffix, append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    var j = stringLength - 1
    while j > i && string[string.startIndex.advancedBy(j)] != string[string.startIndex.advancedBy(stringLength - 1 - (j - i))] {
        j -= 1
    }
    
    let prefix = string.prefix(j)
    let suffix = string.suffix(stringLength - j)
    
    return prefix.reduce("", combine: { $0 + String($1) }) + suffix.reverse().reduce("", combine: { $0 + String($1) })
}
```

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

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

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<a.characters.count {
        let aChar = a.characters.dropFirst(i).first!
        let bChar = b.characters.dropFirst(i).first!
        if aChar == bChar {
            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.characters.count {
        let aChar = a.characters.dropFirst(i).first!
        let bChar = b.characters.dropFirst(i).first!
        if aChar == bChar {
            result += "0"
        } else {
            result += "1"
        }
    }
    return result
}
```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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 longest2(strings: [String]) -> String? {
    guard let longest = strings.max(by: { $0.count < $1.count }) else {
        return nil
    }
    return longest
}

// 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 longest3(strings: [String]) -> String? {
    guard let longest = strings.max(by: { $0.count < $1.count }) else {
        return nil
    }
    return longest
}

// 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 longest4(strings: [String]) -> String? {
    guard let longest = strings.max(by: { $0.count < $1.count }) else {
        return nil
    }
    return longest
}

// 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 longest5(strings: [String]) -> String? {
    guard let longest = strings.max(by: { $0.count < $1.count }) else {
        return nil
    }
    return longest
}

// 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 longest6(strings: [String]) -> String? {
    guard let longest = strings.max(by: { $0.count < $1.count }) else {
        return nil
    }
    return longest
}

// 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 longest7(strings: [String]) -> String? {
    guard let longest = strings.max(by: { $0.count < $1.count }) else {
        return nil
    }
    return longest
}

// 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 longest8(strings: [String]) -> String? {
    guard let longest = strings.max(by: { $0.count < $1.count }) else {
        return nil

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

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

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

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

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

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

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

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

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    var a = a
    var b = b
    while b != 0 {
        let temp = b
        b = a % b
        a = temp
    }
    return a
}

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

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    var a = a
    var b = b
    while b != 0 {
        let temp = b
        b = a % b
        a = temp
    }
    return a
}

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

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    var a = a
    var b = b
    while b != 0 {
        let temp = b
        b = a % b
        a = temp
    }
    return a
}

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

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    var a = a
    var b = b
    
    while b != 0 {
        let temp = b
        b = a % b
        a = temp
    }
    
    return a
}

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

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

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

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    var a = a
    var b = b
    while b != 0 {
        let temp = b
        b = a % b
        a = temp
    }
    return a
}

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

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    // TODO: Write your code here
    return 0
}

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

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

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

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    var a = a
    var b = b
    while b != 0 {
        let temp = b
        b = a % b
        a = temp
    }
    return a
}

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

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

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

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

func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        let suffix = String(string.suffix(i + 1))
        suffixes.append(suffix)
    }
    return suffixes
}

func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            let substring = String(string.prefix(i + 1))
            substrings.append(substring)
        }
    }
    return substrings
}

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

// Return array of all suffixes from shortest to longest of the input string
// allSuffixes(string: "abc") == ["c", "bc", "abc"]
func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        let suffix = String(string.suffix(i + 1))
        suffixes.append(suffix)
    }
    return suffixes
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            let substring = String(string.prefix(i + 1))
            substrings.append(substring)
        }
    }
    return substrings
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            let substring = String(string.prefix(i + 1))
            substrings.append(substring)
        }
    }
    return substrings
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            let substring = String(string.prefix(i + 1))
            substrings.append(substring)
        }
    }
    return substrings
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            let substring = String(string.prefix(i + 1))
            substrings.append(substring)
        }
    }
    return substrings
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            let substring = String(string.prefix(i + 1))
            substrings.append(substring)
        }
    }
    return substrings
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            let substring = String(string.prefix(i + 1))
            substrings.append(substring)
        }
    }
    return substrings
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i

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

func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        let suffix = String(string.suffix(i + 1))
        suffixes.append(suffix)
    }
    return suffixes
}

func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.prefix(j + 1))
            substrings.append(substring)
        }
    }
    return substrings
}

func allPalindromes(string: String) -> [String] {
    var palindromes = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.prefix(j + 1))
            if substring == String(substring.reversed()) {
                palindromes.append(substring)
            }
        }
    }
    return palindromes
}

func allPalindromes(string: String) -> [String] {
    var palindromes = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.prefix(j + 1))
            if substring.count >= 3 && substring == String(substring.reversed()) {
                palindromes.append(substring)
            }
        }
    }
    return palindromes
}

func allPalindromes(string: String) -> [String] {
    var palindromes = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.prefix(j + 1))
            if substring.count >= 3 && substring == String(substring.reversed()) && substring != string {
                palindromes.append(substring)
            }
        }
    }
    return palindromes
}

func allPalindromes(string: String) -> [String] {
    var palindromes = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.prefix(j + 1))
            if substring.count >= 3 && substring == String(substring.reversed()) && substring != string && substring != String(string.reversed()) {
                palindromes.append(substring)
            }
        }
    }
    return palindromes
}

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

// Return array of all suffixes from shortest to longest of the input string
// allSuffixes(string: "abc") == ["c", "bc", "abc"]
func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        let suffix = String(string.suffix(i + 1))
        suffixes.append(suffix)
    }
    return suffixes
}

// Return array of all substrings of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.prefix(j + 1))
            substrings.append(substring)
        }
    }
    return substrings
}

// Return array of all substrings of the input string that are palindromes
// allPalindromes(string: "abccba") == ["a", "b", "c", "b", "c", "c", "b", "a", "cc", "bccb", "abcba"]
func allPalindromes(string: String) -> [String] {
    var palindromes = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.prefix(j + 1))
            if substring == String(substring.reversed()) {
                palindromes.append(substring)
            }
        }
    }
    return palindromes
}

// Return array of all substrings of the input string that are palindromes and have a length of at least 3
// allPalindromes(string: "abccba") == ["bccb", "abcba"]
func allPalindromes(string: String) -> [String] {
    var palindromes = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.prefix(j + 1))
            if substring.count >= 3 && substring == String(substring.reversed()) {
                palindromes.append(substring)
            }
        }
    }
    return palindromes
}

// Return array of all substrings of the input string that are palindromes and have a length of at least 3 and are not the same as the input string
// allPalindromes(string: "abccba") == ["bccb", "abcba"]
func allPalindromes(string: String) -> [String] {
    var palindromes = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.prefix(j + 1))
            if substring.count >= 3 && substring == String(substring.reversed()) && substring != string {
                palindromes.append(substring)
            }
        }
    }
    return palindromes
}

// Return array of all substrings of the input string that are palindromes and have a length of at least 3 and are not the same as the input string and are not the same as the input string reversed
// allPalindromes(string: "abccba") == ["bccb", "abcba"]
func allPalindromes(string: String) -> [String] {
    var palindromes = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.prefix(j + 1))
            if substring.count >= 3 && substring == String(substring.reversed()) && substring != string && substring != String(string.reversed()) {
                palindromes.append(substring)
            }
        }
    }
    return palindromes
}

// Return array of all substrings of the input string that are palindromes and have a length of at least 3 and are not the same as the input string and are not the same as the input

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

func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        suffixes.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.endIndex]))
    }
    return suffixes
}

func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

func allPermutations<T>(array: [T]) -> [[T]] {
    if array.count == 0 {
        return [[]]
    }
    var permutations = [[T]]()
    for i in 0..<array.count {
        let element = array[i]
        let remainingElements = array.filter { $0 != element }
        let remainingPermutations = allPermutations(array: remainingElements)
        for permutation in remainingPermutations {
            permutations.append([element] + permutation)
        }
    }
    return permutations
}

func allCombinations<T>(array: [T]) -> [[T]] {
    if array.count == 0 {
        return [[]]
    }
    var combinations = [[T]]()
    for i in 0..<array.count {
        let element = array[i]
        let remainingElements = array.filter { $0 != element }
        let remainingCombinations = allCombinations(array: remainingElements)
        for combination in remainingCombinations {
            combinations.append([element] + combination)
        }
    }
    return combinations
}

func allSubsets<T>(array: [T]) -> [[T]] {
    if array.count == 0 {
        return [[]]
    }
    var subsets = [[T]]()
    for i in 0..<array.count {
        let element = array[i]
        let remainingElements = array.filter { $0 != element }
        let remainingSubsets = allSubsets(array: remainingElements)
        for subset in remainingSubsets {
            subsets.append([element] + subset)
        }
    }
    return subsets
}

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

// Return array of all suffixes from shortest to longest of the input string
// allSuffixes(string: "abc") == ["c", "bc", "abc"]
func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        suffixes.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.endIndex]))
    }
    return suffixes
}

// Return array of all substrings of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

// Return array of all permutations of the input array
// allPermutations(array: [1, 2, 3]) == [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
func allPermutations<T>(array: [T]) -> [[T]] {
    if array.count == 0 {
        return [[]]
    }
    var permutations = [[T]]()
    for i in 0..<array.count {
        let element = array[i]
        let remainingElements = array.filter { $0 != element }
        let remainingPermutations = allPermutations(array: remainingElements)
        for permutation in remainingPermutations {
            permutations.append([element] + permutation)
        }
    }
    return permutations
}

// Return array of all combinations of the input array
// allCombinations(array: [1, 2, 3]) == [[1], [2], [3], [1, 2], [1, 3], [2, 3], [1, 2, 3]]
func allCombinations<T>(array: [T]) -> [[T]] {
    if array.count == 0 {
        return [[]]
    }
    var combinations = [[T]]()
    for i in 0..<array.count {
        let element = array[i]
        let remainingElements = array.filter { $0 != element }
        let remainingCombinations = allCombinations(array: remainingElements)
        for combination in remainingCombinations {
            combinations.append([element] + combination)
        }
    }
    return combinations
}

// Return array of all subsets of the input array
// allSubsets(array: [1, 2, 3]) == [[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]
func allSubsets<T>(array: [T]) -> [[T]] {
    if array.count == 0 {
        return [[]]
    }
    var subsets = [[T]]()
    for i in 0..<array.count {
        let element = array[i]
        let remainingElements = array.filter { $0 != element }
        let remainingSubsets = allSubsets(array: remainingElements)
        for subset in remainingSubsets {
            subsets.append([element] + subset)
        }
    }
    return subsets
}

// Return array of all partitions of the input array
// allPartitions(array: [1, 2, 3]) == [[[1], [2, 3]], [[1, 2], [3]], [[1, 2, 3]]]
func allPartitions<T>(array: [T]) -> [[[T]]] {
    if array.count == 0 {
        return [[]]
    }
    var partitions = [[[T]]]()
    for i in 

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

func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        let suffix = String(string.suffix(i + 1))
        suffixes.append(suffix)
    }
    return suffixes
}

func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.suffix(j + 1 - i))
            substrings.append(substring)
        }
    }
    return substrings
}

func allSubstrings(string: String, n: Int) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.suffix(j + 1 - i))
            if substring.count == n {
                substrings.append(substring)
            }
        }
    }
    return substrings
}

func allPalindromes(string: String, n: Int) -> [String] {
    var palindromes = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.suffix(j + 1 - i))
            if substring.count == n && substring == String(substring.reversed()) {
                palindromes.append(substring)
            }
        }
    }
    return palindromes
}

func allAnagramPalindromes(string: String, n: Int) -> [String] {
    var anagramPalindromes = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.suffix(j + 1 - i))
            if substring.count == n && substring == String(substring.reversed()) && substring.sorted() == string.sorted() {
                anagramPalindromes.append(substring)
            }
        }
    }
    return anagramPalindromes
}

func allPermutationPalindromes(string: String, n: Int) -> [String] {
    var permutationPalindromes = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.suffix(j + 1 - i))
            if substring.count == n && substring == String(substring.reversed()) && substring.sorted() == string.sorted() && substring.permutations().contains(string) {
                permutationPalindromes.append(substring)
            }
        }
    }
    return permutationPalindromes
}

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

// Return array of all suffixes from shortest to longest of the input string
// allSuffixes(string: "abc") == ["c", "bc", "abc"]
func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        let suffix = String(string.suffix(i + 1))
        suffixes.append(suffix)
    }
    return suffixes
}

// Return array of all substrings of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.suffix(j + 1 - i))
            substrings.append(substring)
        }
    }
    return substrings
}

// Return array of all substrings of the input string with length n
// allSubstrings(string: "abc", n: 2) == ["ab", "bc"]
func allSubstrings(string: String, n: Int) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.suffix(j + 1 - i))
            if substring.count == n {
                substrings.append(substring)
            }
        }
    }
    return substrings
}

// Return array of all substrings of the input string with length n that are palindromes
// allPalindromes(string: "abc", n: 2) == ["ab", "bc"]
func allPalindromes(string: String, n: Int) -> [String] {
    var palindromes = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.suffix(j + 1 - i))
            if substring.count == n && substring == String(substring.reversed()) {
                palindromes.append(substring)
            }
        }
    }
    return palindromes
}

// Return array of all substrings of the input string with length n that are palindromes and are anagrams of the input string
// allAnagramPalindromes(string: "abc", n: 2) == ["ab", "bc"]
func allAnagramPalindromes(string: String, n: Int) -> [String] {
    var anagramPalindromes = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.suffix(j + 1 - i))
            if substring.count == n && substring == String(substring.reversed()) && substring.sorted() == string.sorted() {
                anagramPalindromes.append(substring)
            }
        }
    }
    return anagramPalindromes
}

// Return array of all substrings of the input string with length n that are palindromes and are anagrams of the input string and are permutations of the input string
// allPermutationPalindromes(string: "abc", n: 2) == ["ab", "bc"]
func allPermutationPalindromes(string: String, n: Int) -> [String] {
    var permutationPalindromes = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            let substring = String(string.suffix(j + 1 - i))
            if substring.count == n && substring == String(substring.reversed()) && substring.sorted() == string.sorted() && substring.permutations().contains(string) {
                permutationPalindromes.append(substring)
            }
        }
    }
    return permutationPalindromes
}

// Return array of all substrings of the input string with length n that are palindromes and are anagrams of the input string and are permutations of the input string and are palindromes
// allPalindromePermutationPalindromes

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

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

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

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

// Return array of all suffixes from shortest to longest of the input string
// allSuffixes(string: "abc") == ["c", "bc", "abc"]
func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        suffixes.append(String(string.suffix(i + 1)))
    }
    return suffixes
}

// Return array of all substrings of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string.prefix(j + 1)))
        }
    }
    return substrings
}

// Return array of all substrings of the input string that are palindromes
// allPalindromes(string: "abccba") == ["a", "b", "c", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c

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

func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        suffixes.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.endIndex]))
    }
    return suffixes
}

func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

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

// Return array of all suffixes from shortest to longest of the input string
// allSuffixes(string: "abc") == ["c", "bc", "abc"]
func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        suffixes.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.endIndex]))
    }
    return suffixes
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy:

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

func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        suffixes.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.endIndex]))
    }
    return suffixes
}

func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

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

// Return array of all suffixes from shortest to longest of the input string
// allSuffixes(string: "abc") == ["c", "bc", "abc"]
func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        suffixes.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.endIndex]))
    }
    return suffixes
}

// Return array of all substrings of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

// Return array of all substrings of the input string that are palindromes
// allPalindromes(string: "abccba") == ["a", "b", "c", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "b", "a", "b", "c", "c", "

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

func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        suffixes.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.endIndex]))
    }
    return suffixes
}

func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

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

// Return array of all suffixes from shortest to longest of the input string
// allSuffixes(string: "abc") == ["c", "bc", "abc"]
func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        suffixes.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.endIndex]))
    }
    return suffixes
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy:

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

func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        suffixes.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.endIndex]))
    }
    return suffixes
}

func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

func dictionaryPrefixes(string: String, dictionary: [String]) -> [String] {
    var prefixes = [String]()
    for prefix in allPrefixes(string: string) {
        if dictionary.contains(prefix) {
            prefixes.append(prefix)
        }
    }
    return prefixes
}

func dictionarySuffixes(string: String, dictionary: [String]) -> [String] {
    var suffixes = [String]()
    for suffix in allSuffixes(string: string) {
        if dictionary.contains(suffix) {
            suffixes.append(suffix)
        }
    }
    return suffixes
}

func dictionarySubstrings(string: String, dictionary: [String]) -> [String] {
    var substrings = [String]()
    for substring in allSubstrings(string: string) {
        if dictionary.contains(substring) {
            substrings.append(substring)
        }
    }
    return substrings
}

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

// Return array of all suffixes from shortest to longest of the input string
// allSuffixes(string: "abc") == ["c", "bc", "abc"]
func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        suffixes.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.endIndex]))
    }
    return suffixes
}

// Return array of all substrings of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

// Return array of all prefixes of the input string that are also in the dictionary
// dictionaryPrefixes(string: "swift", dictionary: ["swift", "strength", "swiftness"]) == ["swift"]
func dictionaryPrefixes(string: String, dictionary: [String]) -> [String] {
    var prefixes = [String]()
    for prefix in allPrefixes(string: string) {
        if dictionary.contains(prefix) {
            prefixes.append(prefix)
        }
    }
    return prefixes
}

// Return array of all suffixes of the input string that are also in the dictionary
// dictionarySuffixes(string: "swift", dictionary: ["swift", "strength", "swiftness"]) == ["swift"]
func dictionarySuffixes(string: String, dictionary: [String]) -> [String] {
    var suffixes = [String]()
    for suffix in allSuffixes(string: string) {
        if dictionary.contains(suffix) {
            suffixes.append(suffix)
        }
    }
    return suffixes
}

// Return array of all substrings of the input string that are also in the dictionary
// dictionarySubstrings(string: "swift", dictionary: ["swift", "strength", "swiftness"]) == ["swift"]
func dictionarySubstrings(string: String, dictionary: [String]) -> [String] {
    var substrings = [String]()
    for substring in allSubstrings(string: string) {
        if dictionary.contains(substring) {
            substrings.append(substring)
        }
    }
    return substrings
}

// Return array of all substrings of the input string that are also in the dictionary
// dictionarySubstrings(string: "swift", dictionary: ["swift", "strength", "swiftness"]) == ["swift"]
func dictionarySubstrings(string: String, dictionary: [String]) -> [String] {
    var substrings = [String]()
    for substring in allSubstrings(string: string) {
        if dictionary.contains(substring) {
            substrings.append(substring)
        }
    }
    return substrings
}

// Return array of all substrings of the input string that are also in the dictionary
// dictionarySubstrings(string: "swift", dictionary: ["swift", "strength", "swiftness"]) == ["swift"]
func dictionarySubstrings(string: String, dictionary: [String]) -> [String] {
    var substrings = [String]()
    for substring in allSubstrings(string: string) {
        if dictionary.contains(substring) {
            substrings.append(substring)
        }
    }
    return substrings
}

// Return array of all substrings of the input string that are also in the dictionary
// dictionarySubstrings(string: "swift", dictionary: ["swift", "strength", "swiftness"]) == ["swift"]
func dictionarySubstrings(string: String, dictionary: [String]) -> [String] {
    var substrings = [String]()
    for substring in allSubstrings(string: string) {
        if dictionary.contains(substring) {
            substrings.append(substring)
        }
    }
    return substrings

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

func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        suffixes.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.endIndex]))
    }
    return suffixes
}

func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

func allSubstringsOfLength(string: String, length: Int) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            if string.index(string.startIndex, offsetBy: j + 1) - string.index(string.startIndex, offsetBy: i) == length {
                substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
            }
        }
    }
    return substrings
}

func allSubstringsOfLengthWithoutRepeats(string: String, length: Int) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            if string.index(string.startIndex, offsetBy: j + 1) - string.index(string.startIndex, offsetBy: i) == length {
                substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
            }
        }
    }
    return substrings
}

func allSubstringsWithoutRepeats(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            if string.index(string.startIndex, offsetBy: j + 1) - string.index(string.startIndex, offsetBy: i) == length {
                substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
            }
        }
    }
    return substrings
}

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

// Return array of all suffixes from shortest to longest of the input string
// allSuffixes(string: "abc") == ["c", "bc", "abc"]
func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        suffixes.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.endIndex]))
    }
    return suffixes
}

// Return array of all substrings of the input string
// allSubstrings(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
        }
    }
    return substrings
}

// Return array of all substrings of the input string with length n
// allSubstringsOfLength(string: "abc", length: 2) == ["ab", "bc"]
func allSubstringsOfLength(string: String, length: Int) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            if string.index(string.startIndex, offsetBy: j + 1) - string.index(string.startIndex, offsetBy: i) == length {
                substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
            }
        }
    }
    return substrings
}

// Return array of all substrings of the input string with length n and no repeated characters
// allSubstringsOfLength(string: "abc", length: 2) == ["ab", "bc"]
func allSubstringsOfLengthWithoutRepeats(string: String, length: Int) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            if string.index(string.startIndex, offsetBy: j + 1) - string.index(string.startIndex, offsetBy: i) == length {
                substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
            }
        }
    }
    return substrings
}

// Return array of all substrings of the input string with no repeated characters
// allSubstringsWithoutRepeats(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstringsWithoutRepeats(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            if string.index(string.startIndex, offsetBy: j + 1) - string.index(string.startIndex, offsetBy: i) == length {
                substrings.append(String(string[string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: j + 1)]))
            }
        }
    }
    return substrings
}

// Return array of all substrings of the input string with no repeated characters and no repeated characters
// allSubstringsWithoutRepeats(string: "abc") == ["a", "ab", "abc", "b", "bc", "c"]
func allSubstringsWithoutRepeats(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in i..<string.count {
            if string.index(string.startIndex, offsetBy: j + 1) - string.index(string.startIndex, offsetBy: i) ==

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

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

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

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

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

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

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(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 += String(i) + " "
    }
    return result
}
```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var distinct = [Character: Int]()
    for char in string {
        let char = char.lowercased()
        if distinct[char] == nil {
            distinct[char] = 1
            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 distinct = [Character: Int]()
    for char in string {
        let char = char.lowercased()
        if distinct[char] == nil {
            distinct[char] = 1
            count += 1
        }
    }
    return count
}
```

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

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

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

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

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

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

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

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

func countDistinctCharacters(string: String) -> Int {
    var charSet = Set<Character>()
    for char in string.lowercased() {
        charSet.insert(char)
    }
    return charSet.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 charSet = Set<Character>()
    for char in string.lowercased() {
        charSet.insert(char)
    }
    return charSet.count
}
```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    while index != string.endIndex {
        if let range = string.range(of: substring, options: .caseInsensitive, range: index..<string.endIndex) {
            count += 1
            index = range.upperBound
        } else {
            break
        }
    }
    return count
}

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

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = string.startIndex
    
    while index != string.endIndex {
        if let range = string.range(of: substring, options: .caseInsensitive, range: string.startIndex..<index) {
            count += 1
            index = range.upperBound
        } else {
            break
        }
    }
    
    return count
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func sortNumbers(numbers: String) -> String {
    var numbersArray = numbers.components(separatedBy: " ")
    numbersArray.sort()
    return numbersArray.joined(separator: " ")
}

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

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

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

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

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

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

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

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

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

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

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

func sortNumbers(numbers: String) -> String {
    let numbersArray = numbers.components(separatedBy: " ")
    let numbersArraySorted = numbersArray.sorted(by: { $0 < $1 })
    return numbersArraySorted.joined(separator: " ")
}

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

func sortNumbers(numbers: String) -> String {
    var numbersArray = numbers.components(separatedBy: " ")
    numbersArray.sort()
    return numbersArray.joined(separator: " ")
}

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

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    let sorted = numbers.sorted()
    let first = sorted.first!
    let last = sorted.last!
    let middle = sorted[sorted.count / 2]
    let firstMiddle = abs(first - middle)
    let lastMiddle = abs(last - middle)
    if firstMiddle < lastMiddle {
        return (first, middle)
    } else {
        return (last, middle)
    }
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    let sorted = numbers.sorted()
    let first = sorted.first!
    let last = sorted.last!
    let middle = sorted[sorted.count / 2]
    let firstMiddle = abs(first - middle)
    let lastMiddle = abs(last - middle)
    if firstMiddle < lastMiddle {
        return (first, middle)
    } else {
        return (last, middle)
    }
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    let sorted = numbers.sorted()
    let count = sorted.count
    let mid = count / 2
    let first = sorted[mid]
    let second = sorted[mid + 1]
    return (first, second)
}

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

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    let sorted = numbers.sorted()
    let first = sorted.first!
    let last = sorted.last!
    let middle = sorted.count / 2
    let second = sorted[middle]
    let third = sorted[middle - 1]
    let firstSecond = abs(first - second)
    let firstThird = abs(first - third)
    let secondThird = abs(second - third)
    if firstSecond < firstThird && firstSecond < secondThird {
        return (first, second)
    } else if firstThird < firstSecond && firstThird < secondThird {
        return (first, third)
    } else {
        return (second, third)
    }
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    let sorted = numbers.sorted()
    let first = sorted.first!
    let last = sorted.last!
    let middle = sorted.count / 2
    let second = sorted[middle]
    let third = sorted[middle - 1]
    let firstSecond = abs(first - second)
    let firstThird = abs(first - third)
    let secondThird = abs(second - third)
    if firstSecond < firstThird && firstSecond < secondThird {
        return (first, second)
    } else if firstThird < firstSecond && firstThird < secondThird {
        return (first, third)
    } else {
        return (second, third)
    }
}
```

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

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

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

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

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

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

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    let sortedNumbers = numbers.sorted()
    let first = sortedNumbers.first!
    let last = sortedNumbers.last!
    let middle = sortedNumbers.count / 2
    let middleValue = sortedNumbers[middle]
    let middleValueBefore = sortedNumbers[middle - 1]
    let middleValueAfter = sortedNumbers[middle + 1]
    let middleValueBeforeDistance = abs(middleValue - middleValueBefore)
    let middleValueAfterDistance = abs(middleValue - middleValueAfter)
    let middleValueDistance = abs(middleValue - middleValueBefore) < abs(middleValue - middleValueAfter) ? middleValueBefore : middleValueAfter
    let closestElements = (middleValueBeforeDistance < middleValueAfterDistance ? (middleValueBefore, middleValueDistance) : (middleValueDistance, middleValueAfter))
    return (closestElements.0, closestElements.1)
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    let sortedNumbers = numbers.sorted()
    let first = sortedNumbers.first!
    let last = sortedNumbers.last!
    let middle = sortedNumbers.count / 2
    let middleValue = sortedNumbers[middle]
    let middleValueBefore = sortedNumbers[middle - 1]
    let middleValueAfter = sortedNumbers[middle + 1]
    let middleValueBeforeDistance = abs(middleValue - middleValueBefore)
    let middleValueAfterDistance = abs(middleValue - middleValueAfter)
    let middleValueDistance = abs(middleValue - middleValueBefore) < abs(middleValue - middleValueAfter) ? middleValueBefore : middleValueAfter
    let closestElements = (middleValueBeforeDistance < middleValueAfterDistance ? (middleValueBefore, middleValueDistance) : (middleValueDistance, middleValueAfter))
    return (closestElements.0, closestElements.1)
}
```

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

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

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

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

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    let sorted = numbers.sorted()
    let first = sorted.first!
    let last = sorted.last!
    let middle = sorted.count / 2
    let firstHalf = sorted[0..<middle]
    let secondHalf = sorted[middle..<sorted.count]
    let firstHalfSorted = firstHalf.sorted(by: { abs($0 - first) < abs($0 - last) })
    let secondHalfSorted = secondHalf.sorted(by: { abs($0 - first) < abs($0 - last) })
    let firstHalfClosest = firstHalfSorted.first!
    let secondHalfClosest = secondHalfSorted.first!
    return (firstHalfClosest, secondHalfClosest)
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    let sorted = numbers.sorted()
    let first = sorted.first!
    let last = sorted.last!
    let middle = sorted.count / 2
    let firstHalf = sorted[0..<middle]
    let secondHalf = sorted[middle..<sorted.count]
    let firstHalfSorted = firstHalf.sorted(by: { abs($0 - first) < abs($0 - last) })
    let secondHalfSorted = secondHalf.sorted(by: { abs($0 - first) < abs($0 - last) })
    let firstHalfClosest = firstHalfSorted.first!
    let secondHalfClosest = secondHalfSorted.first!
    return (firstHalfClosest, secondHalfClosest)
}
```

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

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

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

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

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

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

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

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

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

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

func rescaleToUnit(numbers: [Double]) -> [Double] {
    guard numbers.count > 1 else {
        return numbers
    }

    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min

    return numbers.map {
        ($0 - min) / range
    }
}

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

    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min

    return numbers.map {
        ($0 - min) / range
    }
}

// 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] {
    guard numbers.count > 1 else {
        return numbers
    }

    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min

    return numbers.map {
        ($0 - min) / range
    }
}

// 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] {
    guard numbers.count > 1 else {
        return numbers
    }

    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min

    return numbers.map {
        ($0 - min) / range
    }
}

// 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] {
    guard numbers.count > 1 else {
        return numbers
    }

    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min

    return numbers.map {
        ($0 - min) / range
    }
}

// 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] {
    guard numbers.count > 1 else {
        return numbers
    }

    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min

    return numbers.map {
        ($0 - min) / range
    }
}

// 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] {
    guard numbers.count > 1 else {
        return numbers
    }

    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min

    return numbers.map {
        ($0 - min) / range
    }
}

// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func strcount(string: String, character: Character) -> Int {
    var count = 0
    for c in string.characters {
        if c == character {
            count += 1
        }
    }
    return count
}

func strremove(string: String, character: Character) -> String {
    var result = ""
    for c in string.characters {
        if c != character {
            result += String(c)
        }
    }
    return result
}

func strreplace(string: String, oldCharacter: Character, newCharacter: Character) -> String {
    var result = ""
    for c in string.characters {
        if c == oldCharacter {
            result += String(newCharacter)
        } else {
            result += String(c)
        }
    }
    return result
}

func strreplacestring(string: String, oldCharacter: Character, newString: String) -> String {
    var result = ""
    for c in string.characters {
        if c == oldCharacter {
            result += newString
        } else {
            result += String(c)
        }
    }
    return result
}

func strreplacestrings(string: String, oldString: String, newString: String) -> String {
    var result = ""
    var index = 0
    while index < string.characters.count {
        let substring = string.substringWithRange(Range<String.Index>(start: string.startIndex.advancedBy(index), end: string.startIndex.advancedBy(index + oldString.characters.count)))
        if substring == oldString {
            result += newString
            index += oldString.characters.count
        } else {
            result += String(string.characters[string.startIndex.advancedBy(index)])
            index += 1
        }
    }
    return result
}

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

// Return number of occurrences of a given character in a string
// strcount(string: "abc", character: "a") == 1
// strcount(string: "abc", character: "b") == 1
// strcount(string: "abc", character: "c") == 1
// strcount(string: "abc", character: "d") == 0
func strcount(string: String, character: Character) -> Int {
    var count = 0
    for c in string.characters {
        if c == character {
            count += 1
        }
    }
    return count
}

// Return a string with all occurrences of a given character removed
// strremove(string: "abc", character: "a") == "bc"
// strremove(string: "abc", character: "b") == "ac"
// strremove(string: "abc", character: "c") == "ab"
// strremove(string: "abc", character: "d") == "abc"
func strremove(string: String, character: Character) -> String {
    var result = ""
    for c in string.characters {
        if c != character {
            result += String(c)
        }
    }
    return result
}

// Return a string with all occurrences of a given character replaced with a new character
// strreplace(string: "abc", oldCharacter: "a", newCharacter: "d") == "dbc"
// strreplace(string: "abc", oldCharacter: "b", newCharacter: "d") == "adc"
// strreplace(string: "abc", oldCharacter: "c", newCharacter: "d") == "abd"
// strreplace(string: "abc", oldCharacter: "d", newCharacter: "d") == "abc"
func strreplace(string: String, oldCharacter: Character, newCharacter: Character) -> String {
    var result = ""
    for c in string.characters {
        if c == oldCharacter {
            result += String(newCharacter)
        } else {
            result += String(c)
        }
    }
    return result
}

// Return a string with all occurrences of a given character replaced with a new string
// strreplacestring(string: "abc", oldCharacter: "a", newString: "d") == "dbc"
// strreplacestring(string: "abc", oldCharacter: "b", newString: "d") == "adc"
// strreplacestring(string: "abc", oldCharacter: "c", newString: "d") == "abd"
// strreplacestring(string: "abc", oldCharacter: "d", newString: "d") == "abc"
func strreplacestring(string: String, oldCharacter: Character, newString: String) -> String {
    var result = ""
    for c in string.characters {
        if c == oldCharacter {
            result += newString
        } else {
            result += String(c)
        }
    }
    return result
}

// Return a string with all occurrences of a given string replaced with a new string
// strreplacestrings(string: "abc", oldString: "a", newString: "d") == "dbc"
// strreplacestrings(string: "abc", oldString: "b", newString: "d") == "adc"
// strreplacestrings(string: "abc", oldString: "c", newString: "d") == "abd"
// strreplacestrings(string: "abc", oldString: "d", newString: "d") == "abc"
func strreplacestrings(string: String, oldString: String, newString: String) -> String {
    var result = ""
    var index = 0
    while index < string.characters.count {
        let substring = string.substringWithRange(Range<String.Index>(start: string.startIndex.advancedBy(index), end: string.startIndex.advancedBy(index + oldString.characters.count)))
        if substring == oldString {
            result += newString
            index += oldString.characters.count
        } else {
            result += String(string.characters[string.startIndex.advancedBy(index)])
            index += 1
        }
    }
    return result
}

// Return a string with all occurrences of a given string replaced with a new string
// strreplacestrings

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

func strnlen(string: String, n: Int) -> Int {
    var count = 0
    for _ in string {
        count += 1
        if count == n {
            break
        }
    }
    return count
}

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

// Return length of given string
// strnlen(string: "", n: 0) == 0
// strnlen(string: "abc", n: 3) == 3
func strnlen(string: String, n: Int) -> Int {
    var count = 0
    for _ in string {
        count += 1
        if count == n {
            break
        }
    }
    return count
}

// Return length of given string
// strnlen(string: "", n: 0) == 0
// strnlen(string: "abc", n: 3) == 3
func strnlen(string: String, n: Int) -> Int {
    var count = 0
    for _ in string {
        count += 1
        if count == n {
            break
        }
    }
    return count
}

// Return length of given string
// strnlen(string: "", n: 0) == 0
// strnlen(string: "abc", n: 3) == 3
func strnlen(string: String, n: Int) -> Int {
    var count = 0
    for _ in string {
        count += 1
        if count == n {
            break
        }
    }
    return count
}

// Return length of given string
// strnlen(string: "", n: 0) == 0
// strnlen(string: "abc", n: 3) == 3
func strnlen(string: String, n: Int) -> Int {
    var count = 0
    for _ in string {
        count += 1
        if count == n {
            break
        }
    }
    return count
}

// Return length of given string
// strnlen(string: "", n: 0) == 0
// strnlen(string: "abc", n: 3) == 3
func strnlen(string: String, n: Int) -> Int {
    var count = 0
    for _ in string {
        count += 1
        if count == n {
            break
        }
    }
    return count
}

// Return length of given string
// strnlen(string: "", n: 0) == 0
// strnlen(string: "abc", n: 3) == 3
func strnlen(string: String, n: Int) -> Int {
    var count = 0
    for _ in string {
        count += 1
        if count == n {
            break
        }
    }
    return count
}

// Return length of given string
// strnlen(string: "", n: 0) == 0
// strnlen(string: "abc", n: 3) == 3
func strnlen(string: String, n: Int) -> Int {
    var count = 0
    for _ in string {
        count += 1
        if count == n {
            break
        }
    }
    return count
}

// Return length of given string
// strnlen(string: "", n: 0) == 0
// strnlen(string: "abc", n: 3) == 3
func strnlen(string: String, n: Int) -> Int {
    var count = 0
    for _ in string {
        count += 1
        if count == n {
            break
        }
    }
    return count
}

// Return length of given string
// strnlen(string: "", n: 0) == 0
// strnlen(string: "abc", n: 3) == 3
func strnlen(string: String, n: Int) -> Int {
    var count = 0
    for _ in string {
        count += 1
        if count == n {
            break
        }
    }
    return count
}

// Return length of given string
// strnlen(string: "", n: 0) == 0
// strnlen(string: "abc", n: 3) == 3
func strnlen(string: String, n: Int) -> Int {
    var count = 0
    for _ in string {
        count

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

func strchar(string: String, char: String) -> Int {
    var count = 0
    for c in string.characters {
        if String(c) == char {
            count += 1
        }
    }
    return count
}

func strchar(string: String, char: Character) -> Int {
    var count = 0
    for c in string.characters {
        if c == char {
            count += 1
        }
    }
    return count
}

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

// Return the number of occurrences of a given character in a string
// strchar(string: "abc", char: "a") == 1
// strchar(string: "abc", char: "b") == 1
// strchar(string: "abc", char: "c") == 1
// strchar(string: "abc", char: "d") == 0
func strchar(string: String, char: String) -> Int {
    var count = 0
    for c in string.characters {
        if String(c) == char {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of a given character in a string
// strchar(string: "abc", char: "a") == 1
// strchar(string: "abc", char: "b") == 1
// strchar(string: "abc", char: "c") == 1
// strchar(string: "abc", char: "d") == 0
func strchar(string: String, char: Character) -> Int {
    var count = 0
    for c in string.characters {
        if c == char {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of a given character in a string
// strchar(string: "abc", char: "a") == 1
// strchar(string: "abc", char: "b") == 1
// strchar(string: "abc", char: "c") == 1
// strchar(string: "abc", char: "d") == 0
func strchar(string: String, char: String) -> Int {
    var count = 0
    for c in string.characters {
        if String(c) == char {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of a given character in a string
// strchar(string: "abc", char: "a") == 1
// strchar(string: "abc", char: "b") == 1
// strchar(string: "abc", char: "c") == 1
// strchar(string: "abc", char: "d") == 0
func strchar(string: String, char: String) -> Int {
    var count = 0
    for c in string.characters {
        if String(c) == char {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of a given character in a string
// strchar(string: "abc", char: "a") == 1
// strchar(string: "abc", char: "b") == 1
// strchar(string: "abc", char: "c") == 1
// strchar(string: "abc", char: "d") == 0
func strchar(string: String, char: String) -> Int {
    var count = 0
    for c in string.characters {
        if String(c) == char {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of a given character in a string
// strchar(string: "abc", char: "a") == 1
// strchar(string: "abc", char: "b") == 1
// strchar(string: "abc", char: "c") == 1
// strchar(string: "abc", char: "d") == 0
func strchar(string: String, char: String) -> Int {
    var count = 0
    for c in string.characters {
        if String(c) == char {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of a given character in a string
// strchar(string: "abc", char: "a") == 1
// strchar(string: "abc", char: "b") == 1
// strchar(string: "abc", char: "c") == 1
// strchar(string: "abc", char: "d") == 0
func strchar(string: String, char: String) -> Int {
    var count = 0
    for c in string.characters {
        if String(c) == char {
            count += 1
        }
    }

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

func strReplace(string: String, old: String, new: String) -> String {
  var result = ""
  for char in string {
    if String(char) == old {
      result += new
    } else {
      result += String(char)
    }
  }
  return result
}

func strRemove(string: String, old: String) -> String {
  return strReplace(string: string, old: old, new: "")
}

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

// Return a new string with all occurrences of a character replaced with another
// strReplace(string: "abc", old: "a", new: "z") == "zbc"
func strReplace(string: String, old: String, new: String) -> String {
  var result = ""
  for char in string {
    if String(char) == old {
      result += new
    } else {
      result += String(char)
    }
  }
  return result
}

// Return a new string with all occurrences of a character removed
// strRemove(string: "abc", old: "a") == "bc"
func strRemove(string: String, old: String) -> String {
  return strReplace(string: string, old: old, new: "")
}

// Return a new string with all occurrences of a character removed
// strRemove(string: "abc", old: "a") == "bc"
func strRemove(string: String, old: String) -> String {
  return strReplace(string: string, old: old, new: "")
}

// Return a new string with all occurrences of a character removed
// strRemove(string: "abc", old: "a") == "bc"
func strRemove(string: String, old: String) -> String {
  return strReplace(string: string, old: old, new: "")
}

// Return a new string with all occurrences of a character removed
// strRemove(string: "abc", old: "a") == "bc"
func strRemove(string: String, old: String) -> String {
  return strReplace(string: string, old: old, new: "")
}

// Return a new string with all occurrences of a character removed
// strRemove(string: "abc", old: "a") == "bc"
func strRemove(string: String, old: String) -> String {
  return strReplace(string: string, old: old, new: "")
}

// Return a new string with all occurrences of a character removed
// strRemove(string: "abc", old: "a") == "bc"
func strRemove(string: String, old: String) -> String {
  return strReplace(string: string, old: old, new: "")
}

// Return a new string with all occurrences of a character removed
// strRemove(string: "abc", old: "a") == "bc"
func strRemove(string: String, old: String) -> String {
  return strReplace(string: string, old: old, new: "")
}

// Return a new string with all occurrences of a character removed
// strRemove(string: "abc", old: "a") == "bc"
func strRemove(string: String, old: String) -> String {
  return strReplace(string: string, old: old, new: "")
}

// Return a new string with all occurrences of a character removed
// strRemove(string: "abc", old: "a") == "bc"
func strRemove(string: String, old: String) -> String {
  return strReplace(string: string, old: old, new: "")
}

// Return a new string with all occurrences of a character removed
// strRemove(string: "abc", old: "a") == "bc"
func strRemove(string: String, old: String) -> String {
  return strReplace(string: string, old: old, new: "")
}

// Return a new string with all occurrences of a character removed
// strRemove(string: "abc", old: "a") == "bc"
func strRemove(string: String, old: String) -> String {
  return strReplace(string: string, old: old, new: "")
}

// Return a new string with all occurrences of a character removed
// strRemove(string: "abc", old: "a") == "bc"
func strRemove(string: String, old: String) -> String {
  return strReplace(string: string, old: old, new: "")
}

// Return a new string with all occurrences of a character removed
// strRemove(string: "abc", old: "a") == "bc"
func strRemove(string: String, old: String) -> String {
  return strReplace(string: string, old: old, new: "")
}

// Return a new string with all occurrences of a

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

func strcount(string: String, character: Character) -> Int {
    var count = 0
    for c in string {
        if c == character {
            count += 1
        }
    }
    return count
}

func strcount(string: String, substring: String) -> Int {
    var count = 0
    var i = 0
    while i < strlen(string: string) {
        if string.hasPrefix(substring, range: Range(start: string.startIndex.advancedBy(i), end: string.endIndex)) {
            count += 1
            i += strlen(string: substring)
        } else {
            i += 1
        }
    }
    return count
}

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

// Return the number of times a character appears in a string
// strcount(string: "abc", character: "a") == 1
// strcount(string: "abc", character: "b") == 1
// strcount(string: "abc", character: "c") == 1
// strcount(string: "abc", character: "d") == 0
func strcount(string: String, character: Character) -> Int {
    var count = 0
    for c in string {
        if c == character {
            count += 1
        }
    }
    return count
}

// Return the number of times a substring appears in a string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    var i = 0
    while i < strlen(string: string) {
        if string.hasPrefix(substring, range: Range(start: string.startIndex.advancedBy(i), end: string.endIndex)) {
            count += 1
            i += strlen(string: substring)
        } else {
            i += 1
        }
    }
    return count
}

// Return the number of times a substring appears in a string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    var i = 0
    while i < strlen(string: string) {
        if string.hasPrefix(substring, range: Range(start: string.startIndex.advancedBy(i), end: string.endIndex)) {
            count += 1
            i += strlen(string: substring)
        } else {
            i += 1
        }
    }
    return count
}

// Return the number of times a substring appears in a string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    var i = 0
    while i < strlen(string: string) {
        if string.hasPrefix(substring, range: Range(start: string.startIndex.advancedBy(i), end: string.endIndex)) {
            count += 1
            i += strlen(string: substring)
        } else {
            i += 1
        }
    }
    return count
}

// Return the number of times a substring appears in a string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    var i = 0
    while i < strlen(string: string) {
        if string.hasPrefix(substring, range: Range(start: string.startIndex.advancedBy(i), end: string.endIndex)) {
            count += 1
            i += strlen(string: substring)
        } else {
            i += 1
        }
    }
    return count
}

// Return the number of times a substring appears in a string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c

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

func strcount(string: String, character: Character) -> Int {
    var count = 0
    for c in string {
        if c == character {
            count += 1
        }
    }
    return count
}

func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        if string.substring(with: Range(NSMakeRange(i, strlen(string: substring)))) == substring {
            count += 1
        }
    }
    return count
}

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

// Return number of occurrences of a given character in a string
// strcount(string: "abc", character: "a") == 1
// strcount(string: "abc", character: "b") == 1
// strcount(string: "abc", character: "c") == 1
// strcount(string: "abc", character: "d") == 0
func strcount(string: String, character: Character) -> Int {
    var count = 0
    for c in string {
        if c == character {
            count += 1
        }
    }
    return count
}

// Return number of occurrences of a given substring in a string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        if string.substring(with: Range(NSMakeRange(i, strlen(string: substring)))) == substring {
            count += 1
        }
    }
    return count
}

// Return number of occurrences of a given substring in a string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        if string.substring(with: Range(NSMakeRange(i, strlen(string: substring)))) == substring {
            count += 1
        }
    }
    return count
}

// Return number of occurrences of a given substring in a string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        if string.substring(with: Range(NSMakeRange(i, strlen(string: substring)))) == substring {
            count += 1
        }
    }
    return count
}

// Return number of occurrences of a given substring in a string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        if string.substring(with: Range(NSMakeRange(i, strlen(string: substring)))) == substring {
            count += 1
        }
    }
    return count
}

// Return number of occurrences of a given substring in a string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        if string.substring(with: Range(NSMakeRange

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

func strcount(string: String, character: Character) -> Int {
    var count = 0
    for c in string {
        if c == character {
            count += 1
        }
    }
    return count
}

func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        var found = true
        for j in 0..<strlen(string: substring) {
            if string[string.index(string.startIndex, offsetBy: i + j)] != substring[substring.index(substring.startIndex, offsetBy: j)] {
                found = false
                break
            }
        }
        if found {
            count += 1
        }
    }
    return count
}

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

// Return the number of occurrences of a given character in a string
// strcount(string: "abc", character: "a") == 1
// strcount(string: "abc", character: "b") == 1
// strcount(string: "abc", character: "c") == 1
// strcount(string: "abc", character: "d") == 0
func strcount(string: String, character: Character) -> Int {
    var count = 0
    for c in string {
        if c == character {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of a given substring in a string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        var found = true
        for j in 0..<strlen(string: substring) {
            if string[string.index(string.startIndex, offsetBy: i + j)] != substring[substring.index(substring.startIndex, offsetBy: j)] {
                found = false
                break
            }
        }
        if found {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of a given substring in a string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        var found = true
        for j in 0..<strlen(string: substring) {
            if string[string.index(string.startIndex, offsetBy: i + j)] != substring[substring.index(substring.startIndex, offsetBy: j)] {
                found = false
                break
            }
        }
        if found {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of a given substring in a string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        var found = true
        for j in 0..<strlen(string: substring) {
            if string[string.index(string.startIndex, offsetBy: i + j)] != substring[substring.index(substring.startIndex, offsetBy: j)] {
                found = false
                break
            }
        }
        if found {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of a given substring in a string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        var found = true
        for j in 0..<strlen(string: substring) {
            if string[string.index(string.startIndex

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

func strcount(string: String, char: Character) -> Int {
    var count = 0
    for c in string {
        if c == char {
            count += 1
        }
    }
    return count
}

func strreplace(string: String, old: Character, new: Character) -> String {
    var result = ""
    for c in string {
        if c == old {
            result += String(new)
        } else {
            result += String(c)
        }
    }
    return result
}

func strremove(string: String, char: Character) -> String {
    var result = ""
    for c in string {
        if c != char {
            result += String(c)
        }
    }
    return result
}

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

// Return number of occurrences of a given character in a string
// strcount(string: "abc", char: "a") == 1
// strcount(string: "abc", char: "b") == 1
// strcount(string: "abc", char: "c") == 1
// strcount(string: "abc", char: "d") == 0
func strcount(string: String, char: Character) -> Int {
    var count = 0
    for c in string {
        if c == char {
            count += 1
        }
    }
    return count
}

// Return a new string with all occurrences of a given character replaced with another character
// strreplace(string: "abc", old: "a", new: "d") == "dbc"
// strreplace(string: "abc", old: "b", new: "d") == "adc"
// strreplace(string: "abc", old: "c", new: "d") == "abd"
// strreplace(string: "abc", old: "d", new: "d") == "abc"
func strreplace(string: String, old: Character, new: Character) -> String {
    var result = ""
    for c in string {
        if c == old {
            result += String(new)
        } else {
            result += String(c)
        }
    }
    return result
}

// Return a new string with all occurrences of a given character removed
// strremove(string: "abc", char: "a") == "bc"
// strremove(string: "abc", char: "b") == "ac"
// strremove(string: "abc", char: "c") == "ab"
// strremove(string: "abc", char: "d") == "abc"
func strremove(string: String, char: Character) -> String {
    var result = ""
    for c in string {
        if c != char {
            result += String(c)
        }
    }
    return result
}

// Return a new string with all occurrences of a given character removed
// strremove(string: "abc", char: "a") == "bc"
// strremove(string: "abc", char: "b") == "ac"
// strremove(string: "abc", char: "c") == "ab"
// strremove(string: "abc", char: "d") == "abc"
func strremove(string: String, char: Character) -> String {
    var result = ""
    for c in string {
        if c != char {
            result += String(c)
        }
    }
    return result
}

// Return a new string with all occurrences of a given character removed
// strremove(string: "abc", char: "a") == "bc"
// strremove(string: "abc", char: "b") == "ac"
// strremove(string: "abc", char: "c") == "ab"
// strremove(string: "abc", char: "d") == "abc"
func strremove(string: String, char: Character) -> String {
    var result = ""
    for c in string {
        if c != char {
            result += String(c)
        }
    }
    return result
}

// Return a new string with all occurrences of a given character removed
// strremove(string: "abc", char: "a") == "bc"
// strremove(string: "abc", char: "b") == "ac"
// strremove(string: "abc", char: "c") == "ab"
// strremove(string: "abc", char: "d") == "abc"
func strremove(string: String, char: Character) -> String {
    var result = ""
    for c in string {
        if c != char {
            result += String(c)
        }
    }
    return result
}

// Return a new string with all occurrences of a given character removed
// strremove(string: "abc", char: "a") == "bc"
// strremove(string: "abc", char: "b") == "ac"
// strremove(string: "abc", char: "c") == "ab"
// strremove(string: "abc", char: "d

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

func strcount(string: String, character: Character) -> Int {
    var count = 0
    for c in string {
        if c == character {
            count += 1
        }
    }
    return count
}

func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        if string.substring(with: string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: i + strlen(string: substring))) == substring {
            count += 1
        }
    }
    return count
}

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

// Return number of occurrences of given character in given string
// strcount(string: "abc", character: "a") == 1
// strcount(string: "abc", character: "b") == 1
// strcount(string: "abc", character: "c") == 1
// strcount(string: "abc", character: "d") == 0
func strcount(string: String, character: Character) -> Int {
    var count = 0
    for c in string {
        if c == character {
            count += 1
        }
    }
    return count
}

// Return number of occurrences of given substring in given string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        if string.substring(with: string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: i + strlen(string: substring))) == substring {
            count += 1
        }
    }
    return count
}

// Return number of occurrences of given substring in given string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        if string.substring(with: string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: i + strlen(string: substring))) == substring {
            count += 1
        }
    }
    return count
}

// Return number of occurrences of given substring in given string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        if string.substring(with: string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: i + strlen(string: substring))) == substring {
            count += 1
        }
    }
    return count
}

// Return number of occurrences of given substring in given string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        if string.substring(with: string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: i + strlen(string: substring))) == substring {
            count += 1
        }
    }
    return count
}

// Return number of occurrences of given substring in given string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc",

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

func strcount(string: String, character: Character) -> Int {
    var count = 0
    for c in string {
        if c == character {
            count += 1
        }
    }
    return count
}

func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        if string.substring(with: string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: i + strlen(string: substring))) == substring {
            count += 1
        }
    }
    return count
}

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

// Return the number of occurrences of a given character in a string
// strcount(string: "abc", character: "a") == 1
// strcount(string: "abc", character: "b") == 1
// strcount(string: "abc", character: "c") == 1
// strcount(string: "abc", character: "d") == 0
func strcount(string: String, character: Character) -> Int {
    var count = 0
    for c in string {
        if c == character {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of a given substring in a string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        if string.substring(with: string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: i + strlen(string: substring))) == substring {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of a given character in a string
// strcount(string: "abc", character: "a") == 1
// strcount(string: "abc", character: "b") == 1
// strcount(string: "abc", character: "c") == 1
// strcount(string: "abc", character: "d") == 0
func strcount(string: String, character: Character) -> Int {
    var count = 0
    for c in string {
        if c == character {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of a given substring in a string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        if string.substring(with: string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: i + strlen(string: substring))) == substring {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of a given character in a string
// strcount(string: "abc", character: "a") == 1
// strcount(string: "abc", character: "b") == 1
// strcount(string: "abc", character: "c") == 1
// strcount(string: "abc", character: "d") == 0
func strcount(string: String, character: Character) -> Int {
    var count = 0
    for c in string {
        if c == character {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of a given substring in a string
// strcount(string: "abc", substring: "a") == 1
// strcount(string: "abc", substring: "b") == 1
// strcount(string: "abc", substring: "c") == 1
// strcount(string: "abc", substring: "d") == 0
func strcount(string: String, substring: String) -> Int {
    var count = 0
    for i in 0..<strlen(string: string) - strlen(string: substring) + 1 {
        if string.substring(with: string.index(string.startIndex, offsetBy: i)..<string.index(string.startIndex, offsetBy: i + strlen(string: substring))) == substring

func largestDivisor(n: Int) -> Int {
  for i in stride(from: n, to: 1, by: -1) {
    if n % i == 0 {
      return i
    }
  }
  return 0
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
  for i in stride(from: n, to: 1, by: -1) {
    if n % i == 0 {
      return i
    }
  }
  return 0
}
```

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

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

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

// largestDivisor(n: 15)
// largestDivisor(n: 12)
// largestDivisor(n: 100)
// largestDivisor(n: 99)
// largestDivisor(n: 1000000000)
// largestDivisor(n: 1000000000000000000)
// largestDivisor(n: 100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

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

func largestDivisor(n: Int) -> Int {
    for i in stride(from: n, to: 0, by: -1) {
        if n % i == 0 {
            return i
        }
    }
    return 0
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    for i in stride(from: n, to: 0, by: -1) {
        if n % i == 0 {
            return i
        }
    }
    return 0
}
```

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

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

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

// largestDivisor(n: 15)
```

func largestDivisor(n: Int) -> Int {
  for i in stride(from: n, to: 0, by: -1) {
    if n % i == 0 {
      return i
    }
  }
  return 0
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
  for i in stride(from: n, to: 0, by: -1) {
    if n % i == 0 {
      return i
    }
  }
  return 0
}
```

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

// largestDivisor(n: 15)
```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// flipCase(string: "Hello")
// flipCase(string: "hELLO")
// flipCase(string: "Hello, World!")
// flipCase(string: "12345")
// flipCase(string: "12345.67890")
// flipCase(string: "12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 1

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

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

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

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

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

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

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

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

// flipCase(string: "Hello")
```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func filterBySuffix(strings: [String], suffix: String) -> [String] {
    return strings.filter { $0.hasSuffix(suffix) }
}

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

func filterByString(strings: [String], string: String) -> [String] {
    return strings.filter { $0 == string }
}

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

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

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

// Filter an input array of strings only for ones that are equal to a given string.
// filterByString(strings: [] as [String], string: "a") == [] as [String]
// filterByString(strings: ["abc", "bcd", "cde", "array"], string: "array") == ["array"]
func filterByString(strings: [String], string: String) -> [String] {
    return strings.filter { $0 == string }
}

// Filter an input array of strings only for ones that are equal to a given string.
// filterByString(strings: [] as [String], string: "a") == [] as [String]
// filterByString(strings: ["abc", "bcd", "cde", "array"], string: "array") == ["array"]
func filterByString(strings: [String], string: String) -> [String] {
    return strings.filter { $0 == string }
}

// Filter an input array of strings only for ones that are equal to a given string.
// filterByString(strings: [] as [String], string: "a") == [] as [String]
// filterByString(strings: ["abc", "bcd", "cde", "array"], string: "array") == ["array"]
func filterByString(strings: [String], string: String) -> [String] {
    return strings.filter { $0 == string }
}

// Filter an input array of strings only for ones that are equal to a given string.
// filterByString(strings: [] as [String], string: "a") == [] as [String]
// filterByString(strings: ["abc", "bcd", "cde", "array"], string: "array") == ["array"]
func filterByString(strings: [String], string: String) -> [String] {
    return strings.filter { $0 == string }
}

// Filter an input array of strings only for ones that are equal to a given string.
// filterByString(strings: [] as [String], string: "a") == [] as [String]
// filterByString(strings: ["abc", "bcd", "cde", "array"], string: "array") == ["array"]
func filterByString(strings: [String], string: String) -> [String] {
    return strings.filter { $0 == string }
}

// Filter an input array of strings only for ones that are equal to a given string.
// filterByString(strings: [] as [String], string: "a") == [] as [String]
// filterByString(strings: ["abc", "bcd", "cde", "array"], string: "array") == ["array"]
func filterByString(strings: [String], string: String) -> [String] {
    return strings.filter { $0 == string }
}

// Filter an input array of strings only for ones that are equal to a given string.
// filterByString(strings: [] as [String], string: "a") == [] as [String]
// filterByString(strings: ["abc", "bcd", "cde", "array"], string: "array") == ["array"]
func filterByString(strings: [String], string: String) -> [String] {
    return strings.filter { $0 == string }
}

// Filter an input array of strings only for ones that are equal to a given string.
// filterByString(strings: [] as [String], string: "a") == [] as [String]
//

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

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

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

func filterBySuffix(strings: [String], suffix: String) -> [String] {
    return strings.filter { $0.hasSuffix(suffix) }
}

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

func filterByString(strings: [String], string: String) -> [String] {
    return strings.filter { $0 == string }
}

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

// Filter an input array of strings only for ones that end with a given suffix.
// filterBySuffix(strings: [] as [String], suffix: "a") == [] as [String]
// filterBySuffix(strings: ["abc", "bcd", "cde", "array"], suffix: "y") == ["array"]
func filterBySuffix(strings: [String], suffix: String) -> [String] {
    return strings.filter { $0.hasSuffix(suffix) }
}

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

// Filter an input array of strings only for ones that are equal to a given string.
// filterByString(strings: [] as [String], string: "a") == [] as [String]
// filterByString(strings: ["abc", "bcd", "cde", "array"], string: "array") == ["array"]
func filterByString(strings: [String], string: String) -> [String] {
    return strings.filter { $0 == string }
}

// Filter an input array of strings only for ones that are equal to a given string.
// filterByString(strings: [] as [String], string: "a") == [] as [String]
// filterByString(strings: ["abc", "bcd", "cde", "array"], string: "array") == ["array"]
func filterByString(strings: [String], string: String) -> [String] {
    return strings.filter { $0 == string }
}

// Filter an input array of strings only for ones that are equal to a given string.
// filterByString(strings: [] as [String], string: "a") == [] as [String]
// filterByString(strings: ["abc", "bcd", "cde", "array"], string: "array") == ["array"]
func filterByString(strings: [String], string: String) -> [String] {
    return strings.filter { $0 == string }
}

// Filter an input array of strings only for ones that are equal to a given string.
// filterByString(strings: [] as [String], string: "a") == [] as [String]
// filterByString(strings: ["abc", "bcd", "cde", "array"], string: "array") == ["array"]
func filterByString(strings: [String], string: String) -> [String] {
    return strings.filter { $0 == string }
}

// Filter an input array of strings only for ones that are equal to a given string.
// filterByString(strings: [] as [String], string: "a") == [] as [String]
// filterByString(strings: ["abc", "bcd", "cde", "array"], string: "array") == ["array"]
func filterByString(strings: [String], string: String) -> [String] {
    return strings.filter { $0 == string }
}

// Filter an input array of strings only for ones that are equal to a given string.
// filterByString(strings: [] as [String], string: "a") == [] as [String]
// filterByString(strings: ["abc", "bcd", "cde", "array"], string: "array") == ["array"]
func filterByString(strings: [String], string: String) -> [String] {
    return strings.filter { $0 == string }
}

// Filter an input array of strings only for ones that are equal to a given string.
// filterByString(strings: [] as [String], string: "a") == [] as [String]
// filterByString(strings: ["abc", "bcd", "cde", "array"], string: "array") == ["array"]
func filterByString(strings: [String], string: String) -> [String] {
    return strings.filter { $0 == string }
}

// Filter an input array of strings only for ones that are equal to a given string.
// filterByString(strings: [] as [String], string: "a") == [] as [String]
//

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var l2 = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l2[i] = 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 indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var l2 = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l2[i] = l[i]
        }
    }
    l2.sort()
    return l2
}
```

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

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

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

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

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var l2 = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l2[i] = 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 indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var l2 = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l2[i] = l[i]
        }
    }
    l2.sort()
    return l2
}
```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func count(l: [Int], element: Int) -> Int {
    var count = 0
    for i in l {
        if i == element {
            count += 1
        }
    }
    return count
}

func indexOf(l: [Int], element: Int) -> Int {
    for i in 0..<l.count {
        if l[i] == element {
            return i
        }
    }
    return -1
}

func lastIndexOf(l: [Int], element: Int) -> Int {
    for i in (0..<l.count).reversed() {
        if l[i] == element {
            return i
        }
    }
    return -1
}

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

// Return the number of times an element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], element: 3) == 3
func count(l: [Int], element: Int) -> Int {
    var count = 0
    for i in l {
        if i == element {
            count += 1
        }
    }
    return count
}

// Return the index of the first occurrence of an element in an array
// indexOf(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], element: 3) == 1
func indexOf(l: [Int], element: Int) -> Int {
    for i in 0..<l.count {
        if l[i] == element {
            return i
        }
    }
    return -1
}

// Return the index of the last occurrence of an element in an array
// lastIndexOf(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], element: 3) == 5
func lastIndexOf(l: [Int], element: Int) -> Int {
    for i in (0..<l.count).reversed() {
        if l[i] == element {
            return i
        }
    }
    return -1
}

// Return the index of the first occurrence of an element in an array
// indexOf(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], element: 3) == 1
func indexOf(l: [Int], element: Int) -> Int {
    for i in 0..<l.count {
        if l[i] == element {
            return i
        }
    }
    return -1
}

// Return the index of the last occurrence of an element in an array
// lastIndexOf(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], element: 3) == 5
func lastIndexOf(l: [Int], element: Int) -> Int {
    for i in (0..<l.count).reversed() {
        if l[i] == element {
            return i
        }
    }
    return -1
}

// Return the index of the first occurrence of an element in an array
// indexOf(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], element: 3) == 1
func indexOf(l: [Int], element: Int) -> Int {
    for i in 0..<l.count {
        if l[i] == element {
            return i
        }
    }
    return -1
}

// Return the index of the last occurrence of an element in an array
// lastIndexOf(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], element: 3) == 5
func lastIndexOf(l: [Int], element: Int) -> Int {
    for i in (0..<l.count).reversed() {
        if l[i] == element {
            return i
        }
    }
    return -1
}

// Return the index of the first occurrence of an element in an array
// indexOf(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], element: 3) == 1
func indexOf(l: [Int], element: Int) -> Int {
    for i in 0..<l.count {
        if l[i] == element {
            return i
        }
    }
    return -1
}

// Return the index of the last occurrence of an element in an array
// lastIndexOf(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], element: 3) == 

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

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

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

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

print(unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]))
```

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

func count(l: [Int], n: Int) -> Int {
    var count = 0
    for i in l {
        if i == n {
            count += 1
        }
    }
    return count
}

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

// Return the number of times an element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], n: 3) == 3
func count(l: [Int], n: Int) -> Int {
    var count = 0
    for i in l {
        if i == n {
            count += 1
        }
    }
    return count
}

// Return the number of times an element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], n: 3) == 3
func count(l: [Int], n: Int) -> Int {
    var count = 0
    for i in l {
        if i == n {
            count += 1
        }
    }
    return count
}

// Return the number of times an element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], n: 3) == 3
func count(l: [Int], n: Int) -> Int {
    var count = 0
    for i in l {
        if i == n {
            count += 1
        }
    }
    return count
}

// Return the number of times an element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], n: 3) == 3
func count(l: [Int], n: Int) -> Int {
    var count = 0
    for i in l {
        if i == n {
            count += 1
        }
    }
    return count
}

// Return the number of times an element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], n: 3) == 3
func count(l: [Int], n: Int) -> Int {
    var count = 0
    for i in l {
        if i == n {
            count += 1
        }
    }
    return count
}

// Return the number of times an element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], n: 3) == 3
func count(l: [Int], n: Int) -> Int {
    var count = 0
    for i in l {
        if i == n {
            count += 1
        }
    }
    return count
}

// Return the number of times an element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], n: 3) == 3
func count(l: [Int], n: Int) -> Int {
    var count = 0
    for i in l {
        if i == n {
            count += 1
        }
    }
    return count
}

// Return the number of times an element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], n: 3) == 3
func count(l: [Int], n: Int) -> Int {
    var count = 0
    for i in l {
        if i == n {
            count += 1
        }
    }
    return count
}

// Return the number of times an element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], n: 3) == 3
func count(l: [Int], n: Int) -> Int {
    var count = 0
    for i in l {

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

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

func count(l: [Int]) -> Int {
    var count = 0
    for _ in l {
        count += 1
    }
    return count
}

func sum(l: [Int]) -> Int {
    var sum = 0
    for i in l {
        sum += i
    }
    return sum
}

func average(l: [Int]) -> Double {
    var sum = 0
    for i in l {
        sum += i
    }
    return Double(sum) / Double(l.count)
}

func indexOf(l: [Int], element: Int) -> Int {
    for (index, value) in l.enumerated() {
        if value == element {
            return index
        }
    }
    return -1
}

func lastIndexOf(l: [Int], element: Int) -> Int {
    for (index, value) in l.enumerated().reversed() {
        if value == element {
            return index
        }
    }
    return -1
}

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

// Return minimum element in the array.
// minElement(l: [1, 2, 3]) == 1
// minElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == -10
func minElement(l: [Int]) -> Int {
    var min = l[0]
    for i in l {
        if i < min {
            min = i
        }
    }
    return min
}

// Return the number of elements in the array.
// count(l: [1, 2, 3]) == 3
// count(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 11
func count(l: [Int]) -> Int {
    var count = 0
    for _ in l {
        count += 1
    }
    return count
}

// Return the sum of all elements in the array.
// sum(l: [1, 2, 3]) == 6
// sum(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 106
func sum(l: [Int]) -> Int {
    var sum = 0
    for i in l {
        sum += i
    }
    return sum
}

// Return the average of all elements in the array.
// average(l: [1, 2, 3]) == 2
// average(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 10.636363636363636
func average(l: [Int]) -> Double {
    var sum = 0
    for i in l {
        sum += i
    }
    return Double(sum) / Double(l.count)
}

// Return the index of the first occurrence of the element in the array.
// indexOf(l: [1, 2, 3], element: 2) == 1
// indexOf(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10], element: 0) == 7
func indexOf(l: [Int], element: Int) -> Int {
    for (index, value) in l.enumerated() {
        if value == element {
            return index
        }
    }
    return -1
}

// Return the index of the last occurrence of the element in the array.
// lastIndexOf(l: [1, 2, 3], element: 2) == 1
// lastIndexOf(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10], element: 0) == 7
func lastIndexOf(l: [Int], element: Int) -> Int {
    for (index, value) in l.enumerated().reversed() {
        if value == element {
            return index
        }
    }
    return -1
}

// Return the index of the first occurrence of the element in the array.
// indexOf(l: [1, 2, 3], element: 2) == 1
// indexOf(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10], element: 0) == 7
func indexOf(l: [Int], element: Int) -> Int {
    for (index, value) in l.enumerated() {
        if value == element {
            return index
        }
    }
    return -1
}

// Return the index of the last occurrence of the element in the array.
// lastIndexOf(l: [1, 2, 3], element: 2) == 1
// lastIndexOf

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func sortEven(l: [Int]) -> [Int] {
    var lPrime = l
    for i in stride(from: 0, to: l.count, by: 2) {
        let even = lPrime[i]
        var j = i + 1
        while j < lPrime.count && lPrime[j] < even {
            j += 2
        }
        lPrime.insert(even, at: j)
        lPrime.remove(at: i)
    }
    return lPrime
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

print(primeFib(n: 1))
print(primeFib(n: 2))
print(primeFib(n: 3))
print(primeFib(n: 4))
print(primeFib(n: 5))
```

func primeFib(n: Int) -> Int {
  var fib = [1, 1]
  var i = 0
  while fib.count < n {
    fib.append(fib[i] + fib[i + 1])
    i += 1
  }
  var i = 0
  while i < fib.count {
    var isPrime = true
    for j in 2..<fib[i] {
      if fib[i] % j == 0 {
        isPrime = false
        break
      }
    }
    if isPrime {
      return fib[i]
    }
    i += 1
  }
  return 0
}

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

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

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

func main() {
  let n = 1000000
  print(primeFib(n: n))
}

```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 = [0, 1]
  var i = 2
  while fib.count < n {
    fib.append(fib[i-1] + fib[i-2])
    i += 1
  }
  return fib.filter { isPrime($0) }[n-1]
}

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

// main prints the n-th prime Fibonacci number.
func main() {
  let n = 1000000
  print(primeFib(n: n))
}

main()
```

func primeFib(n: Int) -> Int {
    var fib = [1, 1]
    var i = 2
    while fib.count < n {
        fib.append(fib[i - 1] + fib[i - 2])
        i += 1
    }
    var i = 0
    while i < fib.count {
        var j = 2
        while j < fib[i] {
            if fib[i] % j == 0 {
                fib.remove(at: i)
                break
            }
            j += 1
        }
        i += 1
    }
    return fib[n - 1]
}

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

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [1, 1]
    var i = 0
    while fib.count < n {
        fib.append(fib[i] + fib[i + 1])
        i += 1
    }
    var i = 0
    while fib[i] % 2 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 3 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 5 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 7 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 11 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 13 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 17 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 19 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 23 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 29 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 31 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 37 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 41 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 43 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 47 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 53 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 59 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 61 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 67 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 71 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 73 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 79 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 83 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 89 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 97 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 101 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 103 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 107 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 109 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 113 == 0 {
        i += 1
    }
    var i = 0
    while fib[i] % 127 == 0 {
        i += 1
    }
    var i = 0

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

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

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

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

print(primeFib(n: 1))
print(primeFib(n: 2))
print(primeFib(n: 3))
print(primeFib(n: 4))
print(primeFib(n: 5))
print(primeFib(n: 6))
print(primeFib(n: 7))
print(primeFib(n: 8))
print(primeFib(n: 9))
print(primeFib(n: 10))
print(primeFib(n: 11))
print(primeFib(n: 12))
print(primeFib(n: 13))
print(primeFib(n: 14))
print(primeFib(n: 15))
print(primeFib(n: 16))
print(primeFib(n: 17))
print(primeFib(n: 18))
print(primeFib(n: 19))
print(primeFib(n: 20))
print(primeFib(n: 21))
print(primeFib(n: 22))
print(primeFib(n: 23))
print(primeFib(n: 24))
print(primeFib(n: 25))
print(primeFib(n: 26))
print(primeFib(n: 27))
print(primeFib(n: 28))
print(primeFib(n: 29))
print(primeFib(n: 30))
print(primeFib(n: 31))
print(primeFib(n: 32))
print(primeFib(n: 33))
print(primeFib(n: 34))
print(primeFib(n: 35))
print(primeFib(n: 36))
print(primeFib(n: 37))
print(primeFib(n: 38))
print(primeFib(n: 39))
print(primeFib(n: 40))
print(primeFib(n: 41))
print(primeFib(n: 42))
print(primeFib(n: 43))
print(primeFib(n: 44))
print(primeFib(n: 45))
print(primeFib(n: 46))
print(primeFib(n: 47))
print(primeFib(n: 48))
print(primeFib(n: 49))
print(primeFib(n: 50))
print(primeFib(n: 51))
print(primeFib(n: 52))
print(primeFib(n: 53))
print(primeFib(n: 54))
print(primeFib(n: 55))
print(primeFib(n: 56))
print(primeFib(n: 57))
print(primeFib(n: 58))
print(primeFib(n: 59))
print(primeFib(n: 60))
print(primeFib(n: 61))
print(primeFib(n: 62))
print(primeFib(n: 63))
print(primeFib(n: 64))
print(primeFib(n: 65))
print(primeFib(n: 66))
print(primeFib(n: 67))
print(primeFib(n: 68))
print(primeFib(n: 69))
print(primeFib(n: 70))
print(primeFib(n

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

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

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

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

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

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

print(primeFib(n: 1))
print(primeFib(n: 2))
print(primeFib(n: 3))
print(primeFib(n: 4))
print(primeFib(n: 5))
```

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

```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]()
    fib.append(1)
    fib.append(2)
    var i = 2
    while fib.count < n {
        fib.append(fib[i-1] + fib[i-2])
        i += 1
    }
    var j = 0
    while j < fib.count {
        var isPrime = true
        var k = 2
        while k < fib[j] {
            if fib[j] % k == 0 {
                isPrime = false
                break
            }
            k += 1
        }
        if isPrime {
            return fib[j]
        }
        j += 1
    }
    return 0
}
```

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

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

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

// isPrime returns true if n is a prime number.
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    
    return true
}
```

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

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

// Test cases
print(triplesSumToZero(l: [1, 3, 5, 0]))
print(triplesSumToZero(l: [1, 3, -2, 1]))
print(triplesSumToZero(l: [1, 2, 3, 7]))
print(triplesSumToZero(l: [2, 4, -5, 3, 9, 7]))
print(triplesSumToZero(l: [1]))
```

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

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

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

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

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

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    // TODO: Write your code here.
}

// Uncomment the line below when you're ready to try out your function.
print(triplesSumToZero(l: [1, 3, -2, 1]))
```

func triplesSumToZero(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in 0..<l.count {
        for j in i+1..<l.count {
            let sum = l[i] + l[j]
            if seen.contains(-sum) {
                return true
            }
            seen.insert(sum)
        }
    }
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in 0..<l.count {
        for j in i+1..<l.count {
            let sum = l[i] + l[j]
            if seen.contains(-sum) {
                return true
            }
            seen.insert(sum)
        }
    }
    return false
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    // TODO: Write your code here
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    // TODO: Write your code here
    return false
}

// triplesSumToZero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    // TODO: Write your code here
    return false
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    // TODO: your code here
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    // TODO: your code here
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    var seen: Set<Int> = []
    for i in 0..<l.count {
        for j in i+1..<l.count {
            let sum = l[i] + l[j]
            if seen.contains(-sum) {
                return true
            }
            seen.insert(sum)
        }
    }
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var seen: Set<Int> = []
    for i in 0..<l.count {
        for j in i+1..<l.count {
            let sum = l[i] + l[j]
            if seen.contains(-sum) {
                return true
            }
            seen.insert(sum)
        }
    }
    return false
}
```

func triplesSumToZero(l: [Int]) -> Bool {
  // TODO: Write your code here.
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
  // TODO: Write your code here.
}

// Example 1
print(triplesSumToZero(l: [1, 3, 5, 0]))

// Example 2
print(triplesSumToZero(l: [1, 3, -2, 1]))

// Example 3
print(triplesSumToZero(l: [1, 2, 3, 7]))

// Example 4
print(triplesSumToZero(l: [2, 4, -5, 3, 9, 7]))

// Example 5
print(triplesSumToZero(l: [1]))
```

func triplesSumToZero(l: [Int]) -> Bool {
    var seen: Set<Int> = []
    for i in 0..<l.count {
        for j in i+1..<l.count {
            let sum = l[i] + l[j]
            if seen.contains(-sum) {
                return true
            }
            seen.insert(sum)
        }
    }
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var seen: Set<Int> = []
    for i in 0..<l.count {
        for j in i+1..<l.count {
            let sum = l[i] + l[j]
            if seen.contains(-sum) {
                return true
            }
            seen.insert(sum)
        }
    }
    return false
}
```

func carRaceCollision(n: Int) -> Int {
    var left = 0
    var right = n - 1
    var count = 0
    while left < right {
        count += 1
        left += 1
        right -= 1
    }
    return count
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var left = 0
    var right = n - 1
    var count = 0
    while left < right {
        count += 1
        left += 1
        right -= 1
    }
    return count
}
```

func carRaceCollision(n: Int) -> Int {
    var count = 0
    for i in 0..<n {
        for j in 0..<n {
            if i != j {
                count += 1
            }
        }
    }
    return count
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var count = 0
    for i in 0..<n {
        for j in 0..<n {
            if i != j {
                count += 1
            }
        }
    }
    return count
}

print(carRaceCollision(n: 3))
```

func carRaceCollision(n: Int) -> Int {
    var leftCars = [Int]()
    var rightCars = [Int]()
    for i in 0..<n {
        leftCars.append(i)
        rightCars.append(n - i - 1)
    }
    var leftIndex = 0
    var rightIndex = 0
    var collisions = 0
    while leftIndex < n && rightIndex < n {
        if leftCars[leftIndex] < rightCars[rightIndex] {
            leftIndex += 1
        } else {
            rightIndex += 1
        }
        if leftCars[leftIndex] == rightCars[rightIndex] {
            collisions += 1
            leftIndex += 1
            rightIndex += 1
        }
    }
    return collisions
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var leftCars = [Int]()
    var rightCars = [Int]()
    for i in 0..<n {
        leftCars.append(i)
        rightCars.append(n - i - 1)
    }
    var leftIndex = 0
    var rightIndex = 0
    var collisions = 0
    while leftIndex < n && rightIndex < n {
        if leftCars[leftIndex] < rightCars[rightIndex] {
            leftIndex += 1
        } else {
            rightIndex += 1
        }
        if leftCars[leftIndex] == rightCars[rightIndex] {
            collisions += 1
            leftIndex += 1
            rightIndex += 1
        }
    }
    return collisions
}
```

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var left = 0
    var right = n - 1
    var count = 0
    while left < right {
        if left == right {
            break
        }
        if left + 1 == right {
            count += 1
            break
        }
        if left + 2 == right {
            count += 1
            break
        }
        if left + 3 == right {
            count += 1
            break
        }
        if left + 4 == right {
            count += 1
            break
        }
        if left + 5 == right {
            count += 1
            break
        }
        if left + 6 == right {
            count += 1
            break
        }
        if left + 7 == right {
            count += 1
            break
        }
        if left + 8 == right {
            count += 1
            break
        }
        if left + 9 == right {
            count += 1
            break
        }
        if left + 10 == right {
            count += 1
            break
        }
        if left + 11 == right {
            count += 1
            break
        }
        if left + 12 == right {
            count += 1
            break
        }
        if left + 13 == right {
            count += 1
            break
        }
        if left + 14 == right {
            count += 1
            break
        }
        if left + 15 == right {
            count += 1
            break
        }
        if left + 16 == right {
            count += 1
            break
        }
        if left + 17 == right {
            count += 1
            break
        }
        if left + 18 == right {
            count += 1
            break
        }
        if left + 19 == right {
            count += 1
            break
        }
        if left + 20 == right {
            count += 1
            break
        }
        if left + 21 == right {
            count += 1
            break
        }
        if left + 22 == right {
            count += 1
            break
        }
        if left + 23 == right {
            count += 1
            break
        }
        if left + 24 == right {
            count += 1
            break
        }
        if left + 25 == right {
            count += 1
            break
        }
        if left + 26 == right {
            count += 1
            break
        }
        if left + 27 == right {
            count += 1
            break
        }
        if left + 28 == right {
            count += 1
            break
        }
        if left + 29 == right {
            count += 1
            break
        }
        if left + 30 == right {
            count += 1
            break
        }
        if left + 31 == right {
            count += 1
            break
        }
        if left + 32 == right {
            count += 1
            break
        }
        if left + 33 == right {
            count += 1
            break
        }
        if left + 34 == right {
            count += 1
            break
        }
        if left + 35 == right {
            count += 1
            break
        }
        if left + 36 == right {
            count += 1
            break
        }
        if left + 37 == right {
            count += 1
            break
        }
        if left + 38 == right {
            count += 1
            break
        }
        if left + 39 == right {
            count += 1
            break
        }
        if left + 40 == right {
            count += 1
            break
        }
        if left + 41 == right {
            count += 1
            break
        }
        if left + 42 == right {
            count += 1
            break
        }
        if left + 43 == right {
            count += 1
            break
        }

func carRaceCollision(n: Int) -> Int {
    var count = 0
    for i in 0..<n {
        for j in 0..<n {
            if i != j {
                count += 1
            }
        }
    }
    return count
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var count = 0
    for i in 0..<n {
        for j in 0..<n {
            if i != j {
                count += 1
            }
        }
    }
    return count
}
```

func carRaceCollision(n: Int) -> Int {
    var collisions = 0
    var left = 0
    var right = n - 1
    while left < right {
        collisions += 1
        left += 1
        right -= 1
    }
    return collisions
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var collisions = 0
    var left = 0
    var right = n - 1
    while left < right {
        collisions += 1
        left += 1
        right -= 1
    }
    return collisions
}
```

func carRaceCollision(n: Int) -> Int {
    var left = Array(repeating: 0, count: n)
    var right = Array(repeating: 0, count: n)
    var count = 0
    for i in 0..<n {
        left[i] = i
        right[i] = n - 1 - i
    }
    for i in 0..<n {
        for j in 0..<n {
            if left[i] == right[j] {
                count += 1
            }
        }
    }
    return count
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var left = Array(repeating: 0, count: n)
    var right = Array(repeating: 0, count: n)
    var count = 0
    for i in 0..<n {
        left[i] = i
        right[i] = n - 1 - i
    }
    for i in 0..<n {
        for j in 0..<n {
            if left[i] == right[j] {
                count += 1
            }
        }
    }
    return count
}
```

func carRaceCollision(n: Int) -> Int {
    var collisions = 0
    var left = 0
    var right = n - 1
    
    while left < right {
        collisions += 1
        left += 1
        right -= 1
    }
    
    return collisions
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var collisions = 0
    var left = 0
    var right = n - 1
    
    while left < right {
        collisions += 1
        left += 1
        right -= 1
    }
    
    return collisions
}
```

func carRaceCollision(n: Int) -> Int {
    var count = 0
    for i in 0..<n {
        for j in 0..<n {
            if i != j {
                count += 1
            }
        }
    }
    return count
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var count = 0
    for i in 0..<n {
        for j in 0..<n {
            if i != j {
                count += 1
            }
        }
    }
    return count
}
```

func carRaceCollision(n: Int) -> Int {
    var count = 0
    for i in 0..<n {
        for j in 0..<n {
            if i != j {
                count += 1
            }
        }
    }
    return count
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var count = 0
    for i in 0..<n {
        for j in 0..<n {
            if i != j {
                count += 1
            }
        }
    }
    return count
}
```

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 = l
    for i in 0..<l.count {
        result[i] = l[i] + 1
    }
    return result
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] = l[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] {
    return l.map { $0 + 1 }
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    return l.map { $0 + 1 }
}
```

func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] = l[i] + 1
    }
    return result
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] = l[i] + 1
    }
    return result
}
```

func pairsSumToZero(l: [Int]) -> Bool {
  var seen = Set<Int>()
  for num in l {
    if seen.contains(-num) {
      return true
    }
    seen.insert(num)
  }
  return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
  var seen = Set<Int>()
  for num in l {
    if seen.contains(-num) {
      return true
    }
    seen.insert(num)
  }
  return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
  var seen = Set<Int>()
  for i in l {
    if seen.contains(-i) {
      return true
    }
    seen.insert(i)
  }
  return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
  var seen = Set<Int>()
  for i in l {
    if seen.contains(-i) {
      return true
    }
    seen.insert(i)
  }
  return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
  // TODO: Write your code here.
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
  // TODO: Write your code here.
}

// Uncomment the lines below when you're ready to try out your function!
print(pairsSumToZero(l: [1, 3, 5, 0]))
print(pairsSumToZero(l: [1, 3, -2, 1]))
print(pairsSumToZero(l: [1, 2, 3, 7]))
print(pairsSumToZero(l: [2, 4, -5, 3, 5, 7]))
print(pairsSumToZero(l: [1]))
```

func pairsSumToZero(l: [Int]) -> Bool {
    // TODO: Write your code here
    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: Write your code here
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
  var seen = Set<Int>()
  for num in l {
    if seen.contains(-num) {
      return true
    }
    seen.insert(num)
  }
  return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
  var seen = Set<Int>()
  for num in l {
    if seen.contains(-num) {
      return true
    }
    seen.insert(num)
  }
  return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    // TODO: Write your code here
    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: Write your code here
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    // TODO: Write your code here
    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: Write your code here
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    // TODO: Write your code here.
    return false
}

func pairsSumToZero2(l: [Int]) -> Bool {
    // TODO: Write your code here.
    return false
}

func pairsSumToZero3(l: [Int]) -> Bool {
    // TODO: Write your code here.
    return false
}

func pairsSumToZero4(l: [Int]) -> Bool {
    // TODO: Write your code here.
    return false
}

func pairsSumToZero5(l: [Int]) -> Bool {
    // TODO: Write your code here.
    return false
}

func pairsSumToZero6(l: [Int]) -> Bool {
    // TODO: Write your code here.
    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: Write your code here.
    return false
}

// pairsSumToZero2 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.
// pairsSumToZero2(l: [1, 3, 5, 0]) == false
// pairsSumToZero2(l: [1, 3, -2, 1]) == false
// pairsSumToZero2(l: [1, 2, 3, 7]) == false
// pairsSumToZero2(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero2(l: [1]) == false
func pairsSumToZero2(l: [Int]) -> Bool {
    // TODO: Write your code here.
    return false
}

// pairsSumToZero3 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.
// pairsSumToZero3(l: [1, 3, 5, 0]) == false
// pairsSumToZero3(l: [1, 3, -2, 1]) == false
// pairsSumToZero3(l: [1, 2, 3, 7]) == false
// pairsSumToZero3(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero3(l: [1]) == false
func pairsSumToZero3(l: [Int]) -> Bool {
    // TODO: Write your code here.
    return false
}

// pairsSumToZero4 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.
// pairsSumToZero4(l: [1, 3, 5, 0]) == false
// pairsSumToZero4(l: [1, 3, -2, 1]) == false
// pairsSumToZero4(l: [1, 2, 3, 7]) == false
// pairsSumToZero4(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero4(l: [1]) == false
func pairsSumToZero4(l: [Int]) -> Bool {
    // TODO: Write your code here.
    return false
}

// pairsSumToZero5 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.
// pairsSumToZero5(l: [1, 3, 5, 0]) == false
// pairsSumToZero5(l: [1, 3, -2, 1]) == false
// pairsSumToZero5(l: [1, 2, 3, 7]) == false
// pairsSumToZero5(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero5(l: [1]) == false
func pairsSumToZero5(l: [Int]) -> Bool {
    // TODO: Write your code here.
    return false
}

// pairsSumToZero6 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.
// pairsSumToZero6(l: [1, 3, 5, 0]) == false
// pairsSumToZero6(l: [1, 3, -2, 1]) == false
// pairsSumToZero6(l: [1, 2, 3, 7]) == false
// pairsSumToZero6(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero6(l: [1]) == false
func pairsSumToZero6(l: [Int]) -> Bool {
    // TODO: Write your code here.
    return false
}

// pairsSumToZero7 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.
// pairsSumToZero7(l: [1, 3, 

func pairsSumToZero(l: [Int]) -> Bool {
  var seen = Set<Int>()
  for num in l {
    if seen.contains(num) {
      return true
    }
    seen.insert(-num)
  }
  return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
  var seen = Set<Int>()
  for num in l {
    if seen.contains(num) {
      return true
    }
    seen.insert(-num)
  }
  return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    // TODO: Write your code here
    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: Write your code here
    return false
}

// Test cases
print(pairsSumToZero(l: [1, 3, 5, 0]))
print(pairsSumToZero(l: [1, 3, -2, 1]))
print(pairsSumToZero(l: [1, 2, 3, 7]))
print(pairsSumToZero(l: [2, 4, -5, 3, 5, 7]))
print(pairsSumToZero(l: [1]))
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var temp = x
    while temp > 0 {
        result = "\(temp % base)" + 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 {
    var result = ""
    var temp = x
    while temp > 0 {
        result = "\(temp % base)" + result
        temp = temp / base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var number = x
    while number > 0 {
        result = String(number % base) + result
        number = 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
    while number > 0 {
        result = String(number % base) + result
        number = number / base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var x = x
    while x > 0 {
        result = "\(x % base)" + result
        x = x / base
    }
    return result
}

```swift
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var x = x
    while x > 0 {
        result = "\(x % base)" + result
        x = x / base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var temp = x
    while temp > 0 {
        result = String(temp % base) + 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 {
    var result = ""
    var temp = x
    while temp > 0 {
        result = String(temp % base) + result
        temp = temp / base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var temp = x
    while temp > 0 {
        result = String(temp % base) + 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 {
    var result = ""
    var temp = x
    while temp > 0 {
        result = String(temp % base) + result
        temp = temp / base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var temp = x
    while temp > 0 {
        result = String(temp % base) + 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 {
    var result = ""
    var temp = x
    while temp > 0 {
        result = String(temp % base) + result
        temp = temp / base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var temp = x
    while temp > 0 {
        result = String(temp % base) + 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 {
    var result = ""
    var temp = x
    while temp > 0 {
        result = String(temp % base) + result
        temp = temp / base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var temp = x
    while temp > 0 {
        result = String(temp % base) + 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 {
    var result = ""
    var temp = x
    while temp > 0 {
        result = String(temp % base) + result
        temp = temp / base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var x = x
    while x > 0 {
        result = "\(x % base)" + result
        x = x / base
    }
    return result
}

```swift
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var x = x
    while x > 0 {
        result = "\(x % base)" + result
        x = x / base
    }
    return result
}
```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var temp = x
    while temp > 0 {
        result = String(temp % base) + 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 {
    var result = ""
    var temp = x
    while temp > 0 {
        result = String(temp % base) + result
        temp = temp / base
    }
    return result
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5

func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

// Given

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}

```swift
// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2.0
}
```

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

func triangleArea(a: Double, h: Double) -> Double {
    return a * h / 2
}

func triangleArea(a: Float, h: Float) -> Float {
    return a * h / 2
}

func triangleArea(a: CGFloat, h: CGFloat) -> CGFloat {
    return a * h / 2
}

func triangleArea(a: Int32, h: Int32) -> Int32 {
    return a * h / 2
}

func triangleArea(a: Int64, h: Int64) -> Int64 {
    return a * h / 2
}

func triangleArea(a: UInt, h: UInt) -> UInt {
    return a * h / 2
}

func triangleArea(a: UInt32, h: UInt32) -> UInt32 {
    return a * h / 2
}

func triangleArea(a: UInt64, h: UInt64) -> UInt64 {
    return a * h / 2
}

func triangleArea(a: Int8, h: Int8) -> Int8 {
    return a * h / 2
}

func triangleArea(a: UInt8, h: UInt8) -> UInt8 {
    return a * h / 2
}

func triangleArea(a: Int16, h: Int16) -> Int16 {
    return a * h / 2
}

func triangleArea(a: UInt16, h: UInt16) -> UInt16 {
    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 Double(a * h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Double, h: Double) -> Double {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Float, h: Float) -> Float {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: CGFloat, h: CGFloat) -> CGFloat {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int32, h: Int32) -> Int32 {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int64, h: Int64) -> Int64 {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: UInt, h: UInt) -> UInt {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: UInt32, h: UInt32) -> UInt32 {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: UInt64, h: UInt64) -> UInt64 {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int8, h: Int8) -> Int8 {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: UInt8, h: UInt8) -> UInt8 {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int16, h: Int16) -> Int16 {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: UInt16, h: UInt16) -> UInt16 {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int32, h: Int32) -> Int32 {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: UInt32, h: UInt32) -> UInt32 {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Int64, h: Int64) -> Int64 {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a) * Double(h) / 2
}

func triangleArea(a: Double, h: Double) -> Double {
    return a * h / 2
}

func triangleArea(a: Float, h: Float) -> Float {
    return a * h / 2
}

func triangleArea(a: CGFloat, h: CGFloat) -> CGFloat {
    return a * h / 2
}

func triangleArea(a: Int, h: Int) -> Int {
    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 Double(a) * Double(h) / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Double, h: Double) -> Double {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Float, h: Float) -> Float {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: CGFloat, h: CGFloat) -> CGFloat {
    return a * h / 2
}

// 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) -> Int {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Double, h: Double) -> Double {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Float, h: Float) -> Float {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: CGFloat, h: CGFloat) -> CGFloat {
    return a * h / 2
}

// 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) -> Int {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Double, h: Double) -> Double {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Float, h: Float) -> Float {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: CGFloat, h: CGFloat) -> CGFloat {
    return a * h / 2
}

// 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) -> Int {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Double, h: Double) -> Double {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: Float, h: Float) -> Float {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.
// triangleArea(a: 5, h: 3) == 7.5
func triangleArea(a: CGFloat, h: CGFloat) -> CGFloat {
    return a * h / 2
}

// 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) -> Int {
    return a * h / 2
}

// Given length of a side and high return area for a triangle.

func fib4(n: Int) -> Int {
    var fib4 = [0, 0, 2, 0]
    for i in 4...n {
        fib4.append(fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4])
    }
    return fib4[n]
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var fib4 = [0, 0, 2, 0]
    for i in 4...n {
        fib4.append(fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4])
    }
    return fib4[n]
}
```

func fib4(n: Int) -> Int {
    var fib4 = [0, 0, 2, 0]
    for i in 4...n {
        fib4.append(fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4])
    }
    return fib4[n]
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var fib4 = [0, 0, 2, 0]
    for i in 4...n {
        fib4.append(fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4])
    }
    return fib4[n]
}
```

func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    var e = 0
    for i in 0..<n {
        if i % 4 == 0 {
            a = b
        } else if i % 4 == 1 {
            b = c
        } else if i % 4 == 2 {
            c = d
        } else if i % 4 == 3 {
            d = e
        }
        e = a + b + c + d
    }
    return e
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    var e = 0
    for i in 0..<n {
        if i % 4 == 0 {
            a = b
        } else if i % 4 == 1 {
            b = c
        } else if i % 4 == 2 {
            c = d
        } else if i % 4 == 3 {
            d = e
        }
        e = a + b + c + d
    }
    return e
}
```

func fib4(n: Int) -> Int {
    var fib4 = [0, 0, 2, 0]
    for i in 4...n {
        fib4.append(fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4])
    }
    return fib4[n]
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var fib4 = [0, 0, 2, 0]
    for i in 4...n {
        fib4.append(fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4])
    }
    return fib4[n]
}
```

func fib4(n: Int) -> Int {
    var fib4 = [0, 0, 2, 0]
    for i in 4...n {
        fib4.append(fib4[i - 1] + fib4[i - 2] + fib4[i - 3] + fib4[i - 4])
    }
    return fib4[n]
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var fib4 = [0, 0, 2, 0]
    for i in 4...n {
        fib4.append(fib4[i - 1] + fib4[i - 2] + fib4[i - 3] + fib4[i - 4])
    }
    return fib4[n]
}
```

func fib4(n: Int) -> Int {
    var fib4 = [0, 0, 2, 0]
    for i in 4...n {
        fib4.append(fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4])
    }
    return fib4[n]
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var fib4 = [0, 0, 2, 0]
    for i in 4...n {
        fib4.append(fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4])
    }
    return fib4[n]
}
```

func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    for _ in 0..<n {
        let temp = a
        a = b
        b = c
        c = d
        d = temp + b + c + d
    }
    return d
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    for _ in 0..<n {
        let temp = a
        a = b
        b = c
        c = d
        d = temp + b + c + d
    }
    return d
}
```

func fib4(n: Int) -> Int {
    var fib4 = [0, 0, 2, 0]
    for i in 4...n {
        fib4.append(fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4])
    }
    return fib4[n]
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var fib4 = [0, 0, 2, 0]
    for i in 4...n {
        fib4.append(fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4])
    }
    return fib4[n]
}
```

func fib4(n: Int) -> Int {
    var fib4 = [0, 0, 2, 0]
    for i in 4...n {
        fib4.append(fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4])
    }
    return fib4[n]
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var fib4 = [0, 0, 2, 0]
    for i in 4...n {
        fib4.append(fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4])
    }
    return fib4[n]
}
```

func fib4(n: Int) -> Int {
    var fib4 = [0, 0, 2, 0]
    for i in 4...n {
        fib4.append(fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4])
    }
    return fib4[n]
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var fib4 = [0, 0, 2, 0]
    for i in 4...n {
        fib4.append(fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4])
    }
    return fib4[n]
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        return Double(sorted[count / 2 - 1] + sorted[count / 2]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        return Double(sorted[count / 2 - 1] + sorted[count / 2]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        return Double(sorted[count / 2 - 1] + sorted[count / 2]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        return Double(sorted[count / 2 - 1] + sorted[count / 2]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        return Double(sorted[count / 2 - 1] + sorted[count / 2]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        return Double(sorted[count / 2 - 1] + sorted[count / 2]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        return Double(sorted[count / 2 - 1] + sorted[count / 2]) / 2.0
    } else {
        return Double(sorted[count / 2])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        return Double(sorted[count / 2 - 1] + sorted[count / 2]) / 2.0
    } else {
        return Double(sorted[count / 2])
    }
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = l.count
    if count % 2 == 0 {
        let mid = count / 2
        return Double(sorted[mid] + sorted[mid - 1]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = l.count
    if count % 2 == 0 {
        let mid = count / 2
        return Double(sorted[mid] + sorted[mid - 1]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}

// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = l.count
    if count % 2 == 0 {
        let mid = count / 2
        return Double(sorted[mid] + sorted[mid - 1]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}

// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = l.count
    if count % 2 == 0 {
        let mid = count / 2
        return Double(sorted[mid] + sorted[mid - 1]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}

// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = l.count
    if count % 2 == 0 {
        let mid = count / 2
        return Double(sorted[mid] + sorted[mid - 1]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}

// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = l.count
    if count % 2 == 0 {
        let mid = count / 2
        return Double(sorted[mid] + sorted[mid - 1]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}

// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = l.count
    if count % 2 == 0 {
        let mid = count / 2
        return Double(sorted[mid] + sorted[mid - 1]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}

// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = l.count
    if count % 2 == 0 {
        let mid = count / 2
        return Double(sorted[mid] + sorted[mid - 

func median(l: [Int]) -> Double {
    var l = l
    l.sort()
    let count = l.count
    if count % 2 == 0 {
        return Double(l[count / 2 - 1] + l[count / 2]) / 2.0
    } else {
        return Double(l[count / 2])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    var l = l
    l.sort()
    let count = l.count
    if count % 2 == 0 {
        return Double(l[count / 2 - 1] + l[count / 2]) / 2.0
    } else {
        return Double(l[count / 2])
    }
}
```

func median(l: [Int]) -> Double {
    var l = l
    l.sort()
    let count = l.count
    if count % 2 == 0 {
        return Double(l[count / 2 - 1] + l[count / 2]) / 2
    } else {
        return Double(l[count / 2])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    var l = l
    l.sort()
    let count = l.count
    if count % 2 == 0 {
        return Double(l[count / 2 - 1] + l[count / 2]) / 2
    } else {
        return Double(l[count / 2])
    }
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = l.count
    if count % 2 == 0 {
        return Double(sorted[count / 2 - 1] + sorted[count / 2]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = l.count
    if count % 2 == 0 {
        return Double(sorted[count / 2 - 1] + sorted[count / 2]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}
```

func median(l: [Int]) -> Double {
    let l = l.sorted()
    let count = l.count
    if count % 2 == 0 {
        let mid = count / 2
        return Double(l[mid] + l[mid - 1]) / 2
    } else {
        return Double(l[count / 2])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let l = l.sorted()
    let count = l.count
    if count % 2 == 0 {
        let mid = count / 2
        return Double(l[mid] + l[mid - 1]) / 2
    } else {
        return Double(l[count / 2])
    }
}
```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        return Double(sorted[count / 2 - 1] + sorted[count / 2]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        return Double(sorted[count / 2 - 1] + sorted[count / 2]) / 2
    } else {
        return Double(sorted[count / 2])
    }
}
```

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    let text = text.lowercased()
    let text = text.replacingOccurrences(of: " ", with: "")
    let text = text.replacingOccurrences(of: "!", with: "")
    let text = text.replacingOccurrences(of: "?", with: "")
    let text = text.replacingOccurrences(of: ".", with: "")
    let text = text.replacingOccurrences(of: ",", with: "")
    let text = text.replacingOccurrences(of: ":", with: "")
    let text = text.replacingOccurrences(of: ";", with: "")
    let text = text.replacingOccurrences(of: "(", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of:

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    let text = text.lowercased()
    let textWithoutSpaces = text.replacingOccurrences(of: " ", with: "")
    let textWithoutSpecialCharacters = textWithoutSpaces.replacingOccurrences(of: "[^a-zA-Z0-9]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpaces = textWithoutSpecialCharacters.replacingOccurrences(of: " ", with: "")
    let textWithoutSpecialCharactersAndSpacesAndNumbers = textWithoutSpecialCharactersAndSpaces.replacingOccurrences(of: "[0-9]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercase = textWithoutSpecialCharactersAndSpacesAndNumbers.replacingOccurrences(of: "[A-Z]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercase = textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercase.replacingOccurrences(of: "[a-z]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbers = textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercase.replacingOccurrences(of: "[0-9]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercase = textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbers.replacingOccurrences(of: "[A-Z]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercase = textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercase.replacingOccurrences(of: "[a-z]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbers = textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercase.replacingOccurrences(of: "[0-9]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercase = textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbers.replacingOccurrences(of: "[A-Z]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercase = textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercase.replacingOccurrences(of: "[a-z]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbers = textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercase.replacingOccurrences(of: "[0-9]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercase = textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbers.replacingOccurrences(of: "[A-Z]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercase = textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercase.replacingOccurrences(of: "[a-z]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbers = textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAndLowercase.replacingOccurrences(of: "[0-9]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndUppercaseAndLowercaseAndNumbersAndUppercaseAnd

func isPalindrome(text: String) -> Bool {
    let text = text.lowercased()
    let textArray = Array(text)
    let textArrayReversed = textArray.reversed()
    
    for (index, char) in textArray.enumerated() {
        if char != textArrayReversed[index] {
            return false
        }
    }
    
    return true
}

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    let text = text.lowercased()
    let textArray = Array(text)
    let textArrayReversed = textArray.reversed()
    
    for (index, char) in textArray.enumerated() {
        if char != textArrayReversed[index] {
            return false
        }
    }
    
    return true
}
```

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
  let text = text.lowercased()
  let text = text.replacingOccurrences(of: " ", with: "")
  let text = text.replacingOccurrences(of: ",", with: "")
  let text = text.replacingOccurrences(of: ".", with: "")
  let text = text.replacingOccurrences(of: "!", with: "")
  let text = text.replacingOccurrences(of: "?", with: "")
  let text = text.replacingOccurrences(of: ":", with: "")
  let text = text.replacingOccurrences(of: ";", with: "")
  let text = text.replacingOccurrences(of: "(", with: "")
  let text = text.replacingOccurrences(of: ")", with: "")
  let text = text.replacingOccurrences(of: "[", with: "")
  let text = text.replacingOccurrences(of: "]", with: "")
  let text = text.replacingOccurrences(of: "{", with: "")
  let text = text.replacingOccurrences(of: "}", with: "")
  let text = text.replacingOccurrences(of: "1", with: "")
  let text = text.replacingOccurrences(of: "2", with: "")
  let text = text.replacingOccurrences(of: "3", with: "")
  let text = text.replacingOccurrences(of: "4", with: "")
  let text = text.replacingOccurrences(of: "5", with: "")
  let text = text.replacingOccurrences(of: "6", with: "")
  let text = text.replacingOccurrences(of: "7", with: "")
  let text = text.replacingOccurrences(of: "8", with: "")
  let text = text.replacingOccurrences(of: "9", with: "")
  let text = text.replacingOccurrences(of: "0", with: "")
  let text = text.replacingOccurrences(of: "!", with: "")
  let text = text.replacingOccurrences(of: "@", with: "")
  let text = text.replacingOccurrences(of: "#", with: "")
  let text = text.replacingOccurrences(of: "$", with: "")
  let text = text.replacingOccurrences(of: "%", with: "")
  let text = text.replacingOccurrences(of: "^", with: "")
  let text = text.replacingOccurrences(of: "&", with: "")
  let text = text.replacingOccurrences(of: "*", with: "")
  let text = text.replacingOccurrences(of: "(", with: "")
  let text = text.replacingOccurrences(of: ")", with: "")
  let text = text.replacingOccurrences(of: "-", with: "")
  let text = text.replacingOccurrences(of: "_", with: "")
  let text = text.replacingOccurrences(of: "=", with: "")
  let text = text.replacingOccurrences(of: "+", with: "")
  let text = text.replacingOccurrences(of: ":", with: "")
  let text = text.replacingOccurrences(of: ";", with: "")
  let text = text.replacingOccurrences(of: "/", with: "")
  let text = text.replacingOccurrences(of: "\\", with: "")
  let text = text.replacingOccurrences(of: "|", with: "")
  let text = text.replacingOccurrences(of: "?", with: "")
  let text = text.replacingOccurrences(of: ">", with: "")
  let text = text.replacingOccurrences(of: "<", with: "")
  let text = text.replacingOccurrences(of: " ", with: "")
  let text = text.replacingOccurrences(of: "\n", with: "")
  let text = text.replacingOccurrences(of: "\t", with: "")
  let text = text.replacingOccurrences(of: "\r", with: "")
  let text = text.replacingOccurrences(of: "\"", with: "")
  let text = text.replacingOccurrences(of: "\'", with: "")
  let text = text.replacingOccurrences(of: "\r", with: "")
  let text = text.replacingOccurrences(of: "\n", with: "")
  let text = text.replacingOccurrences(of: "\t", with: "")
  let text = text.replacingOccurrences(of: "\r", with: "")
  let text = text.replacingOccurrences(of: "\n", with: "")
  let text = text.replacingOccurrences(of: "\t", with: "")
  let text = text.replacingOccurrences(of: "\r", with: "")
  let text = text.replacingOccurrences(of:

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    let text = text.lowercased()
    let text = text.replacingOccurrences(of: " ", with: "")
    let text = text.replacingOccurrences(of: ",", with: "")
    let text = text.replacingOccurrences(of: ".", with: "")
    let text = text.replacingOccurrences(of: "!", with: "")
    let text = text.replacingOccurrences(of: "?", with: "")
    let text = text.replacingOccurrences(of: ":", with: "")
    let text = text.replacingOccurrences(of: ";", with: "")
    let text = text.replacingOccurrences(of: "(", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: "[", with: "")
    let text = text.replacingOccurrences(of: "]", with: "")
    let text = text.replacingOccurrences(of: "{", with: "")
    let text = text.replacingOccurrences(of: "}", with: "")
    let text = text.replacingOccurrences(of: "!", with: "")
    let text = text.replacingOccurrences(of: "@", with: "")
    let text = text.replacingOccurrences(of: "#", with: "")
    let text = text.replacingOccurrences(of: "$", with: "")
    let text = text.replacingOccurrences(of: "%", with: "")
    let text = text.replacingOccurrences(of: "^", with: "")
    let text = text.replacingOccurrences(of: "&", with: "")
    let text = text.replacingOccurrences(of: "*", with: "")
    let text = text.replacingOccurrences(of: "/", with: "")
    let text = text.replacingOccurrences(of: "\\", with: "")
    let text = text.replacingOccurrences(of: "|", with: "")
    let text = text.replacingOccurrences(of: "`", with: "")
    let text = text.replacingOccurrences(of: "~", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with:

func isPalindrome(text: String) -> Bool {
    let text = text.lowercased()
    let textWithoutSpaces = text.replacingOccurrences(of: " ", with: "")
    let textWithoutSpecialCharacters = textWithoutSpaces.replacingOccurrences(of: "[^a-zA-Z0-9]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpaces = textWithoutSpecialCharacters.replacingOccurrences(of: " ", with: "")
    let textWithoutSpecialCharactersAndSpacesReversed = String(textWithoutSpecialCharactersAndSpaces.reversed())
    return textWithoutSpecialCharactersAndSpaces == textWithoutSpecialCharactersAndSpacesReversed
}

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    let text = text.lowercased()
    let textWithoutSpaces = text.replacingOccurrences(of: " ", with: "")
    let textWithoutSpecialCharacters = textWithoutSpaces.replacingOccurrences(of: "[^a-zA-Z0-9]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpaces = textWithoutSpecialCharacters.replacingOccurrences(of: " ", with: "")
    let textWithoutSpecialCharactersAndSpacesReversed = String(textWithoutSpecialCharactersAndSpaces.reversed())
    return textWithoutSpecialCharactersAndSpaces == textWithoutSpecialCharactersAndSpacesReversed
}
```

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    let text = text.lowercased()
    let text = text.replacingOccurrences(of: " ", with: "")
    let text = text.replacingOccurrences(of: ",", with: "")
    let text = text.replacingOccurrences(of: ".", with: "")
    let text = text.replacingOccurrences(of: "!", with: "")
    let text = text.replacingOccurrences(of: "?", with: "")
    let text = text.replacingOccurrences(of: ":", with: "")
    let text = text.replacingOccurrences(of: ";", with: "")
    let text = text.replacingOccurrences(of: "(", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: "[", with: "")
    let text = text.replacingOccurrences(of: "]", with: "")
    let text = text.replacingOccurrences(of: "{", with: "")
    let text = text.replacingOccurrences(of: "}", with: "")
    let text = text.replacingOccurrences(of: "1", with: "")
    let text = text.replacingOccurrences(of: "2", with: "")
    let text = text.replacingOccurrences(of: "3", with: "")
    let text = text.replacingOccurrences(of: "4", with: "")
    let text = text.replacingOccurrences(of: "5", with: "")
    let text = text.replacingOccurrences(of: "6", with: "")
    let text = text.replacingOccurrences(of: "7", with: "")
    let text = text.replacingOccurrences(of: "8", with: "")
    let text = text.replacingOccurrences(of: "9", with: "")
    let text = text.replacingOccurrences(of: "0", with: "")
    let text = text.replacingOccurrences(of: "!", with: "")
    let text = text.replacingOccurrences(of: "@", with: "")
    let text = text.replacingOccurrences(of: "#", with: "")
    let text = text.replacingOccurrences(of: "$", with: "")
    let text = text.replacingOccurrences(of: "%", with: "")
    let text = text.replacingOccurrences(of: "^", with: "")
    let text = text.replacingOccurrences(of: "&", with: "")
    let text = text.replacingOccurrences(of: "*", with: "")
    let text = text.replacingOccurrences(of: "(", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: "-", with: "")
    let text = text.replacingOccurrences(of: "_", with: "")
    let text = text.replacingOccurrences(of: "+", with: "")
    let text = text.replacingOccurrences(of: "=", with: "")
    let text = text.replacingOccurrences(of: "/", with: "")
    let text = text.replacingOccurrences(of: "\\", with: "")
    let text = text.replacingOccurrences(of: "|", with: "")
    let text = text.replacingOccurrences(of: ":", with: "")
    let text = text.replacingOccurrences(of: ";", with: "")
    let text = text.replacingOccurrences(of: "<", with: "")
    let text = text.replacingOccurrences(of: ">", with: "")
    let text = text.replacingOccurrences(of: "?", with: "")
    let text = text.replacingOccurrences(of: "!", with: "")
    let text = text.replacingOccurrences(of: "\"", with: "")
    let text = text.replacingOccurrences(of: "'", with: "")
    let text = text.replacingOccurrences(of: "`", with: "")
    let text = text.replacingOccurrences(of: "~", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´", with: "")
    let text = text.replacingOccurrences(of: "´",

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    let text = text.lowercased()
    let textWithoutSpaces = text.replacingOccurrences(of: " ", with: "")
    let textWithoutSpecialCharacters = textWithoutSpaces.replacingOccurrences(of: "[^A-Za-z0-9]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpaces = textWithoutSpecialCharacters.replacingOccurrences(of: " ", with: "")
    let textWithoutSpecialCharactersAndSpacesAndNumbers = textWithoutSpecialCharactersAndSpaces.replacingOccurrences(of: "[0-9]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuation = textWithoutSpecialCharactersAndSpacesAndNumbers.replacingOccurrences(of: "[^A-Za-z]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercase = textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuation.replacingOccurrences(of: "[A-Z]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercase = textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercase.replacingOccurrences(of: "[a-z]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbers = textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercase.replacingOccurrences(of: "[0-9]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuation = textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbers.replacingOccurrences(of: "[^A-Za-z0-9]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercase = textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuation.replacingOccurrences(of: "[A-Z]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercaseAndLowercase = textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercase.replacingOccurrences(of: "[a-z]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbers = textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercaseAndLowercase.replacingOccurrences(of: "[0-9]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuation = textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbers.replacingOccurrences(of: "[^A-Za-z0-9]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercase = textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuation.replacingOccurrences(of: "[A-Z]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercaseAndLowercase = textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercase.replacingOccurrences(of: "[a-z]", with: "", options: .regularExpression)
    let textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbers = textWithoutSpecialCharactersAndSpacesAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercaseAndLowercaseAndNumbersAndPunctuationAndUppercaseAndLowercase.replacingOccurrences(of: "[0-9]", with: "", options

```swift
// Checks if given string is a palindrome
// isPalindrome(text: "") == true
// isPalindrome(text: "aba") == true
// isPalindrome(text: "aaaaa") == true
// isPalindrome(text: "zbcd") == false
func isPalindrome(text: String) -> Bool {
    let text = text.lowercased()
    let text = text.replacingOccurrences(of: " ", with: "")
    let text = text.replacingOccurrences(of: "!", with: "")
    let text = text.replacingOccurrences(of: "?", with: "")
    let text = text.replacingOccurrences(of: ".", with: "")
    let text = text.replacingOccurrences(of: ",", with: "")
    let text = text.replacingOccurrences(of: ":", with: "")
    let text = text.replacingOccurrences(of: ";", with: "")
    let text = text.replacingOccurrences(of: "(", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: ")", with: "")
    let text = text.replacingOccurrences(of: