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

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
}

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

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
}

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

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

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

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

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

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

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

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

// Check if in given array of numbers, are

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

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

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

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

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
}

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

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

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var parenStack = [String]()
    var parenString = parenString
    
    while !parenString.isEmpty {
        let paren = parenString.removeFirst()
        if paren == "(" {
            parenStack.append(paren)
        } else if paren == ")" {
            if let lastParen = parenStack.popLast() {
                if lastParen == "(" {
                    result.append(parenString)
                    parenString = ""
                } else {
                    parenString.removeFirst()
                }
            }
        }
    }
    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 parenStack = [String]()
    var parenString = parenString
    
    while !parenString.isEmpty {
        let paren = parenString.removeFirst()
        if paren == "(" {
            parenStack.append(paren)
        } else if paren == ")" {
            if let lastParen = parenStack.popLast() {
                if lastParen == "(" {
                    result.append(parenString)
                    parenString = ""
                } else {
                    parenString.removeFirst()
                }
            }
        }
    }
    return result
}

// 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 parenStack = [String]()
    var parenString = parenString
    
    while !parenString.isEmpty {
        let paren = parenString.removeFirst()
        if paren == "(" {
            parenStack.append(paren)
        } else if paren == ")" {
            if let lastParen = parenStack.popLast() {
                if lastParen == "(" {
                    result.append(parenString)
                    parenString = ""
                } else {
                    parenString.removeFirst()
                }
            }
        }
    }
    return result
}
<|file_separator|>

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

// 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 currentGroup = ""
    var openParenCount = 0
    for char in parenString {
        if char == "(" {
            openParenCount += 1
            if openParenCount == 1 {
                currentGroup = ""
            }
            currentGroup += String(char)
        } else if char == ")" {
            openParenCount -= 1
            currentGroup += String(char)
            if openParenCount == 0 {
                result.append(currentGroup)
                currentGroup = ""
            }
        } else {
            currentGroup += String(char)
        }
    }
    return result
}

// 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 currentGroup = ""
    var openParenCount = 0
    for char in parenString {
        if char == "(" {
            openParenCount += 1
            if openParenCount == 1 {
                currentGroup = ""
            }
            currentGroup += String(char)
        } else if char == ")" {
            openParenCount -= 1
            currentGroup += String(char)
            if openParenCount == 0 {
                result.append(currentGroup)
                currentGroup = ""
            }
        } else {
            currentGroup += String(char)
        }
    }
    return result
}

// 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 currentGroup = ""
    var openParenCount = 0
    for char in parenString {
        if char == "(" {
            openParenCount += 1
            if openParenCount == 1 {
                currentGroup = ""
            }
            currentGroup += String(char)
        } else if char == ")" {
            openParenCount -= 1
            currentGroup += String(char)
            if openParenCount == 0 {
                result.append(currentGroup)
                currentGroup = ""
            }
        } else {
            currentGroup += String(char)
        }
    }
    return result
}

// 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 parenGroups = [String]()
    var parenGroup = ""
    
    for char in parenString {
        if char == "(" {
            parenGroup += "("
        } else if char == ")" {
            parenGroup += ")"
        }
        
        if parenGroup.count == 2 {
            parenGroups.append(parenGroup)
            parenGroup = ""
        }
    }
    
    return parenGroups
}

```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 parenGroups = [String]()
    var parenGroup = ""
    
    for char in parenString {
        if char == "(" {
            parenGroup += "("
        } else if char == ")" {
            parenGroup += ")"
        }
        
        if parenGroup.count == 2 {
            parenGroups.append(parenGroup)
            parenGroup = ""
        }
    }
    
    return parenGroups
}

// 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 parenGroups = [String]()
    var parenGroup = ""
    
    for char in parenString {
        if char == "(" {
            parenGroup += "("
        } else if char == ")" {
            parenGroup += ")"
        }
        
        if parenGroup.count == 2 {
            parenGroups.append(parenGroup)
            parenGroup = ""
        }
    }
    
    return parenGroups
}

// 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 parenGroups = [String]()
    var parenGroup = ""
    
    for char in parenString {
        if char == "(" {
            parenGroup += "("
        } else if char == ")" {
            parenGroup += ")"
        }
        
        if parenGroup.count == 2 {
            parenGroups.append(parenGroup)
            parenGroup = ""
        }
    }
    
    return parenGroups
}
<|file_separator|>

func separateParenGroups(parenString: String) -> [String] {
    var parenGroups = [String]()
    var parenGroup = ""
    for char in parenString {
        if char == "(" {
            parenGroup += String(char)
        } else if char == ")" {
            parenGroup += String(char)
            parenGroups.append(parenGroup)
            parenGroup = ""
        }
    }
    return parenGroups
}

```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 parenGroups = [String]()
    var parenGroup = ""
    for char in parenString {
        if char == "(" {
            parenGroup += String(char)
        } else if char == ")" {
            parenGroup += String(char)
            parenGroups.append(parenGroup)
            parenGroup = ""
        }
    }
    return parenGroups
}
<|file_separator|>

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var currentGroup = ""
    var openParenCount = 0
    var closeParenCount = 0
    for char in parenString {
        if char == "(" {
            openParenCount += 1
            currentGroup += String(char)
        } else if char == ")" {
            closeParenCount += 1
            currentGroup += String(char)
            if openParenCount == closeParenCount {
                result.append(currentGroup)
                currentGroup = ""
                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 currentGroup = ""
    var openParenCount = 0
    var closeParenCount = 0
    for char in parenString {
        if char == "(" {
            openParenCount += 1
            currentGroup += String(char)
        } else if char == ")" {
            closeParenCount += 1
            currentGroup += String(char)
            if openParenCount == closeParenCount {
                result.append(currentGroup)
                currentGroup = ""
                openParenCount = 0
                closeParenCount = 0
            }
        }
    }
    return result
}
<|file_separator|>

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var parenStack = [String]()
    var parenGroup = ""
    for paren in parenString {
        if paren == "(" {
            parenStack.append(String(paren))
            parenGroup += String(paren)
        } else if paren == ")" {
            parenGroup += String(paren)
            if parenStack.count > 0 {
                parenStack.popLast()
                result.append(parenGroup)
                parenGroup = ""
            }
        }
    }
    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 parenStack = [String]()
    var parenGroup = ""
    for paren in parenString {
        if paren == "(" {
            parenStack.append(String(paren))
            parenGroup += String(paren)
        } else if paren == ")" {
            parenGroup += String(paren)
            if parenStack.count > 0 {
                parenStack.popLast()
                result.append(parenGroup)
                parenGroup = ""
            }
        }
    }
    return result
}
<|file_separator|>

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

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

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

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

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

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

func separateParenGroups(parenString: String) -> [String] {
    var parenGroups: [String] = []
    var parenGroup: String = ""
    var parenGroupOpen: Bool = false
    var parenGroupClose: Bool = false
    
    for char in parenString {
        if char == "(" {
            parenGroupOpen = true
            parenGroupClose = false
        } else if char == ")" {
            parenGroupClose = true
            parenGroupOpen = false
        } else {
            if parenGroupOpen {
                parenGroup += String(char)
            } else if parenGroupClose {
                parenGroup += String(char)
            }
        }
        
        if parenGroupOpen && parenGroupClose {
            parenGroups.append(parenGroup)
            parenGroup = ""
            parenGroupOpen = false
            parenGroupClose = false
        }
    }
    
    return parenGroups
}

```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 parenGroups: [String] = []
    var parenGroup: String = ""
    var parenGroupOpen: Bool = false
    var parenGroupClose: Bool = false
    
    for char in parenString {
        if char == "(" {
            parenGroupOpen = true
            parenGroupClose = false
        } else if char == ")" {
            parenGroupClose = true
            parenGroupOpen = false
        } else {
            if parenGroupOpen {
                parenGroup += String(char)
            } else if parenGroupClose {
                parenGroup += String(char)
            }
        }
        
        if parenGroupOpen && parenGroupClose {
            parenGroups.append(parenGroup)
            parenGroup = ""
            parenGroupOpen = false
            parenGroupClose = false
        }
    }
    
    return parenGroups
}
<|file_separator|>

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

// 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 currentGroup = ""
    var currentParenCount = 0
    for char in parenString {
        if char == "(" {
            currentParenCount += 1
        } else if char == ")" {
            currentParenCount -= 1
        }
        if currentParenCount == 0 {
            result.append(currentGroup)
            currentGroup = ""
        } else {
            currentGroup += String(char)
        }
    }
    return result
}

// 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 currentGroup = ""
    var currentParenCount = 0
    for char in parenString {
        if char == "(" {
            currentParenCount += 1
        } else if char == ")" {
            currentParenCount -= 1
        }
        if currentParenCount == 0 {
            result.append(currentGroup)
            currentGroup = ""
        } else {
            currentGroup += String(char)
        }
    }
    return result
}

// 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 currentGroup = ""
    var currentParenCount = 0
    for char in parenString {
        if char == "(" {
            currentParenCount += 1
        } else if char == ")" {
            currentParenCount -= 1
        }
        if currentParenCount == 0 {
            result.append(currentGroup)
            currentGroup = ""
        } else {
            currentGroup += String(char)
        }
    }
    return result
}

// 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 currentGroup = ""
    var currentParenCount = 0
    for char in parenString {
        if char == "(" {
            currentParenCount += 1
        } else if char == ")" {
            currentParenCount -= 1
        }
        if currentParenCount == 0 {
            result.append(currentGroup)
            currentGroup = ""
        } else {
            currentGroup += String(char)
        }
    }
    return result
}

//

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

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

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

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

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))
}
<|file_separator|>

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

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

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

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

// Given a positive integer, 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) == 3
func truncateNumber(number: Int) -> Int {
    return number - Int(number)
}

// Given a positive integer, 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: Float) -> Float {
    return number - Float(Int(number))
}
<|file_separator|>

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

func productArray(array: [Int]) -> [Int] {
    var productArray = [Int]()
    var product = 1
    for i in 0..<array.count {
        product *= array[i]
    }
    for i in 0..<array.count {
        productArray.append(product / array[i])
    }
    return productArray
}

func lowestPositiveInteger(array: [Int]) -> Int {
    var array = array
    var i = 0
    while i < array.count {
        if array[i] > 0 && array[i] <= array.count && array[i] != array[array[i] - 1] {
            let temp = array[i]
            array[i] = array[array[i] - 1]
            array[temp - 1] = temp
        } else {
            i += 1
        }
    }
    for i in 0..<array.count {
        if array[i] != i + 1 {
            return i + 1
        }
    }
    return array.count + 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 - Double(Int(number))
}

// Given an array of integers, return a new array such that each element at index i of the new array is the product of all the numbers in the original array except the one at i.
// For example, if our input was [1, 2, 3, 4, 5], the expected output would be [120, 60, 40, 30, 24]. If our input was [3, 2, 1], the expected output would be [2, 3, 6].
// Follow-up: what if you can't use division?
func productArray(array: [Int]) -> [Int] {
    var productArray = [Int]()
    var product = 1
    for i in 0..<array.count {
        product *= array[i]
    }
    for i in 0..<array.count {
        productArray.append(product / array[i])
    }
    return productArray
}

// Given an array of integers, find the first missing positive integer in linear time and constant space. In other words, find the lowest positive integer that does not exist in the array. The array can contain duplicates and negative numbers as well.
// For example, the input [3, 4, -1, 1] should give 2. The input [1, 2, 0] should give 3.
// You can modify the input array in-place.
func lowestPositiveInteger(array: [Int]) -> Int {
    var array = array
    var i = 0
    while i < array.count {
        if array[i] > 0 && array[i] <= array.count && array[i] != array[array[i] - 1] {
            let temp = array[i]
            array[i] = array[array[i] - 1]
            array[temp - 1] = temp
        } else {
            i += 1
        }
    }
    for i in 0..<array.count {
        if array[i] != i + 1 {
            return i + 1
        }
    }
    return array.count + 1
}

// Given an array of integers, find the first missing positive integer in linear time and constant space. In other words, find the lowest positive integer that does not exist in the array. The array can contain duplicates and negative numbers as well.
// For example, the input [3, 4, -1, 1] should give 2. The input [1, 2, 0] should give 3.
// You can modify the input array in-place.
func lowestPositiveInteger(array: [Int]) -> Int {
    var array = array
    var i = 0
    while i < array.count {
        if array[i] > 0 && array[i] <= array.count && array[i] != array[array[i] - 1] {
            let temp = array[i]
            array[i] = array[array[i] - 1]
            array[temp - 1] = temp
        } else {
            i += 1
        }
    }
    for i in 0..<array.count {
        if array[i] != i + 1 {
            return i + 1
        }
    }
    return array.count + 1
}

// Given a list of integers, write a function that returns the largest sum of non-adjacent numbers. Numbers can be 0 or negative.
// For example, [2, 4, 6, 2, 5] should return 13, since we pick 2, 6, and 5. [5, 1, 1, 5] should return 10, since we pick 5 and 5.
// Follow-up: Can you do this in O(N) time and constant space?
func largestSum(array: [Int]) -> Int {
    var largestSum = 0
    var largestSumWithPrevious = 0
    for i in 0..<array.count {
        if i == 0 {
            largestSumWithPrevious = array[i]
        } else if i == 1 {
            largestSum = array[i]
        } else {
            let temp = largestSumWithPrevious
            largestSumWithPrevious = max(largestSum, largestSumWithPrevious + array[i])
            largestSum = max

func truncateNumber(number: Double) -> Double {
    return number - (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 - (number.truncatingRemainder(dividingBy: 1))
}
<|file_separator|>

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

func nextSmallestNumber(number: Int) -> Int {
    var number = number
    var digits = [Int]()
    while number > 0 {
        digits.append(number % 10)
        number /= 10
    }
    digits.reverse()
    var i = 0
    while i < digits.count - 1 && digits[i] == 9 {
        i += 1
    }
    digits[i] += 1
    for j in i + 1..<digits.count {
        digits[j] = 0
    }
    var result = 0
    for digit in digits {
        result = result * 10 + digit
    }
    return result
}

func nextLargestNumber(number: Int) -> Int {
    var number = number
    var digits = [Int]()
    while number > 0 {
        digits.append(number % 10)
        number /= 10
    }
    digits.reverse()
    var i = 0
    while i < digits.count - 1 && digits[i] == 9 {
        i += 1
    }
    digits[i] += 1
    for j in i + 1..<digits.count {
        digits[j] = 0
    }
    var result = 0
    for digit in digits {
        result = result * 10 + digit
    }
    return result
}

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

// Given a positive integer, return the next smallest positive integer
// containing the same number of digits.
// nextSmallestNumber(number: 123) == 123
// nextSmallestNumber(number: 1234) == 1234
// nextSmallestNumber(number: 12345) == 1235
// nextSmallestNumber(number: 123456) == 1236
// nextSmallestNumber(number: 1234567) == 123457
// nextSmallestNumber(number: 12345678) == 123467
// nextSmallestNumber(number: 123456789) == 123567
// nextSmallestNumber(number: 1234567890) == 1234678
func nextSmallestNumber(number: Int) -> Int {
    var number = number
    var digits = [Int]()
    while number > 0 {
        digits.append(number % 10)
        number /= 10
    }
    digits.reverse()
    var i = 0
    while i < digits.count - 1 && digits[i] == 9 {
        i += 1
    }
    digits[i] += 1
    for j in i + 1..<digits.count {
        digits[j] = 0
    }
    var result = 0
    for digit in digits {
        result = result * 10 + digit
    }
    return result
}

// Given a positive integer, return the next largest positive integer
// containing the same number of digits.
// nextLargestNumber(number: 123) == 123
// nextLargestNumber(number: 1234) == 1243
// nextLargestNumber(number: 12345) == 13245
// nextLargestNumber(number: 123456) == 134256
// nextLargestNumber(number: 1234567) == 134567
// nextLargestNumber(number: 12345678) == 1354678
// nextLargestNumber(number: 123456789) == 1356789
// nextLargestNumber(number: 1234567890) == 13567890
func nextLargestNumber(number: Int) -> Int {
    var number = number
    var digits = [Int]()
    while number > 0 {
        digits.append(number % 10)
        number /= 10
    }
    digits.reverse()
    var i = 0
    while i < digits.count - 1 && digits[i] == 9 {
        i += 1
    }
    digits[i] += 1
    for j in i + 1..<digits.count {
        digits[j] = 0
    }
    var result = 0
    for digit in digits {
        result = result * 10 + digit
    }
    return result
}

// Given a positive integer, return the next smallest positive integer
// containing the same number of digits.
// nextSmallestNumber(number: 123) == 123
// nextSmallestNumber(number: 1234) == 1234
// nextSmallestNumber(number: 12345) == 1235
// nextSmallestNumber(number: 123456) == 1236
// nextSmallestNumber(number: 1234567) == 123457
// nextSmallestNumber(number: 12345678) == 123467
// nextSmallestNumber(number: 123456789) == 123567
// nextSmallestNumber(number: 1234567890) == 1234678
func nextSmallestNumber(number: Int) -> Int {
    var number = number
    var digits = [Int]()
    while number > 0 {
        digits.

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.truncatingRemainder(dividingBy: 1)
}
<|file_separator|>

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

func nextSmallest(number: Int) -> Int {
    let numberString = String(number)
    var numberArray = Array(numberString)
    var i = numberArray.count - 1
    while i > 0 && numberArray[i] == "9" {
        numberArray[i] = "0"
        i -= 1
    }
    if i == 0 && numberArray[i] == "9" {
        return -1
    }
    numberArray[i] = String(Int(numberArray[i])! + 1)
    return Int(String(numberArray))!
}

func nextLargest(number: Int) -> Int {
    let numberString = String(number)
    var numberArray = Array(numberString)
    var i = numberArray.count - 1
    while i > 0 && numberArray[i] == "9" {
        numberArray[i] = "0"
        i -= 1
    }
    if i == 0 && numberArray[i] == "9" {
        return -1
    }
    numberArray[i] = String(Int(numberArray[i])! + 1)
    return Int(String(numberArray))!
}

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

// Given a positive integer, return the next smallest positive integer
// containing the same number of digits.
// nextSmallest(number: 123) == 123
// nextSmallest(number: 1234) == 124
// nextSmallest(number: 12345) == 125
// nextSmallest(number: 123456) == 135
// nextSmallest(number: 1234567) == 135
func nextSmallest(number: Int) -> Int {
    let numberString = String(number)
    var numberArray = Array(numberString)
    var i = numberArray.count - 1
    while i > 0 && numberArray[i] == "9" {
        numberArray[i] = "0"
        i -= 1
    }
    if i == 0 && numberArray[i] == "9" {
        return -1
    }
    numberArray[i] = String(Int(numberArray[i])! + 1)
    return Int(String(numberArray))!
}

// Given a positive integer, return the next largest positive integer
// containing the same number of digits.
// nextLargest(number: 123) == 132
// nextLargest(number: 1234) == 142
// nextLargest(number: 12345) == 152
// nextLargest(number: 123456) == 162
// nextLargest(number: 1234567) == 172
func nextLargest(number: Int) -> Int {
    let numberString = String(number)
    var numberArray = Array(numberString)
    var i = numberArray.count - 1
    while i > 0 && numberArray[i] == "9" {
        numberArray[i] = "0"
        i -= 1
    }
    if i == 0 && numberArray[i] == "9" {
        return -1
    }
    numberArray[i] = String(Int(numberArray[i])! + 1)
    return Int(String(numberArray))!
}

// Given a positive integer, return the next smallest positive integer
// containing the same number of digits.
// nextSmallest(number: 123) == 123
// nextSmallest(number: 1234) == 124
// nextSmallest(number: 12345) == 125
// nextSmallest(number: 123456) == 135
// nextSmallest(number: 1234567) == 135
func nextSmallest(number: Int) -> Int {
    let numberString = String(number)
    var numberArray = Array(numberString)
    var i = numberArray.count - 1
    while i > 0 && numberArray[i] == "9" {
        numberArray[i] = "0"
        i -= 1
    }
    if i == 0 && numberArray[i] == "9" {
        return -1
    }
    numberArray[i] = String(Int(numberArray[i])! + 1)
    return Int(String(numberArray))!
}

// Given a positive integer, return the next largest positive integer
// containing the same number of digits.
// nextLargest(number: 123) == 132
// nextLargest(number: 1234) == 142
// nextLargest(number: 12345) == 152
// nextLargest(number: 123456) == 162
// nextLargest(number: 1234567) == 172
func nextLargest(number: Int) -> Int {
    let numberString = String(number)
    var numberArray = Array(numberString)
    var i = numberArray.count - 1
    while i > 0 && numberArray[i] == "9" {
        numberArray[i] = "0"
        i -= 1
    }
    if i == 0 && numberArray[i] == "9" {
        return -1
    }
    

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

func nextSmallestNumber(number: Int) -> Int {
    var number = number
    var digits = [Int]()
    while number > 0 {
        digits.append(number % 10)
        number /= 10
    }
    digits.reverse()
    var i = 0
    while i < digits.count - 1 && digits[i] == 9 {
        i += 1
    }
    digits[i] += 1
    for j in i + 1..<digits.count {
        digits[j] = 0
    }
    return Int(digits.reduce("", { $0 + String($1) }))
}

func nextLargestNumber(number: Int) -> Int {
    var number = number
    var digits = [Int]()
    while number > 0 {
        digits.append(number % 10)
        number /= 10
    }
    digits.reverse()
    var i = 0
    while i < digits.count - 1 && digits[i] == 9 {
        i += 1
    }
    digits[i] += 1
    for j in i + 1..<digits.count {
        digits[j] = 0
    }
    return Int(digits.reduce("", { $0 + String($1) }))
}

func nextSmallestNumber(number: Int) -> Int {
    var number = number
    var digits = [Int]()
    while number > 0 {
        digits.append(number % 10)
        number /= 10
    }
    digits.reverse()
    var i = 0
    while i < digits.count - 1 && digits[i] == 0 {
        i += 1
    }
    digits[i] -= 1
    for j in i + 1..<digits.count {
        digits[j] = 9
    }
    return Int(digits.reduce("", { $0 + String($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 - Double(Int(number))
}

// Given a positive integer, return the next smallest positive integer
// containing the same number of digits.
// nextSmallestNumber(number: 12345) == 12354
// nextSmallestNumber(number: 123456789) == 123467890
func nextSmallestNumber(number: Int) -> Int {
    var number = number
    var digits = [Int]()
    while number > 0 {
        digits.append(number % 10)
        number /= 10
    }
    digits.reverse()
    var i = 0
    while i < digits.count - 1 && digits[i] == 9 {
        i += 1
    }
    digits[i] += 1
    for j in i + 1..<digits.count {
        digits[j] = 0
    }
    return Int(digits.reduce("", { $0 + String($1) }))
}

// Given a positive integer, return the next largest positive integer
// containing the same number of digits.
// nextLargestNumber(number: 12345) == 12365
// nextLargestNumber(number: 123456789) == 123467890
func nextLargestNumber(number: Int) -> Int {
    var number = number
    var digits = [Int]()
    while number > 0 {
        digits.append(number % 10)
        number /= 10
    }
    digits.reverse()
    var i = 0
    while i < digits.count - 1 && digits[i] == 9 {
        i += 1
    }
    digits[i] += 1
    for j in i + 1..<digits.count {
        digits[j] = 0
    }
    return Int(digits.reduce("", { $0 + String($1) }))
}

// Given a positive integer, return the next smallest positive integer
// containing the same number of digits.
// nextSmallestNumber(number: 12345) == 12354
// nextSmallestNumber(number: 123456789) == 123467890
func nextSmallestNumber(number: Int) -> Int {
    var number = number
    var digits = [Int]()
    while number > 0 {
        digits.append(number % 10)
        number /= 10
    }
    digits.reverse()
    var i = 0
    while i < digits.count - 1 && digits[i] == 0 {
        i += 1
    }
    digits[i] -= 1
    for j in i + 1..<digits.count {
        digits[j] = 9
    }
    return Int(digits.reduce("", { $0 + String($1) }))
}

// Given a positive integer, return the next largest positive integer
// containing the same number of digits.
// nextLargestNumber(number: 12345) == 12365
// nextLargestNumber(number: 123456789) == 123467890
func nextLargestNumber(number: Int) -> Int {
    var number = number
    var digits = [Int]()
    while number > 0 {
        digits.append(number % 10)
        number /= 10
    }
    digits.reverse()
    var i = 0
    while i < digits.count - 1 && digits[i] == 9 {
        i += 1
    }
    digits[i] += 1
    for j in i + 1..<digits.count {
        digits[j] = 0
    }
    return Int(digits.reduce("", { $0 + String($1) }))
}

// Given a positive integer, return the next smallest positive integer
// containing the same number of digits.
// nextSmallestNumber(number: 12345) == 12354
// nextSmallestNumber(number: 123456789) == 123467890
func nextSmallestNumber(number: Int) -> Int {
    var number = number
    var digits = [

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

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

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

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

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for i in operations {
        balance += i
        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 i in operations {
        balance += i
        if balance < 0 {
            return true
        }
    }
    return false
}
<|file_separator|>

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

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

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for i in operations {
        balance += i
        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 i in operations {
        balance += i
        if balance < 0 {
            return true
        }
    }
    return false
}
<|file_separator|>

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

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

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

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

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

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

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

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

func mode(numbers: [Double]) -> Double {
    let counts = numbers.reduce(into: [:]) { counts, number in
        counts[number, default: 0] += 1
    }
    return counts.max { $0.value < $1.value }!.key
}

func range(numbers: [Double]) -> Double {
    return numbers.max()! - numbers.min()!
}

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

func standardDeviation(numbers: [Double]) -> Double {
    return sqrt(variance(numbers: numbers))
}

func quartiles(numbers: [Double]) -> [Double] {
    let sorted = numbers.sorted()
    let count = sorted.count
    if count % 2 == 1 {
        return [sorted[count / 2 - 1], sorted[count / 2], sorted[count / 2 + 1]]
    }
    return [sorted[count / 2 - 1], sorted[count / 2], sorted[count / 2]]
}

func interquartileRange(numbers: [Double]) -> Double {
    let quartiles = quartiles(numbers: numbers)
    return quartiles[2] - quartiles[0]
}

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

// For a given array of input numbers, calculate the median of this dataset.
// Median is the middle number in a sorted list of numbers.
// median(numbers: [1.0, 2.0, 3.0, 4.0]) == 2.5
func median(numbers: [Double]) -> Double {
    let sorted = numbers.sorted()
    let count = sorted.count
    if count % 2 == 1 {
        return sorted[count / 2]
    }
    return (sorted[count / 2 - 1] + sorted[count / 2]) / 2
}

// For a given array of input numbers, calculate the mode of this dataset.
// Mode is the number that appears most often in a list of numbers.
// mode(numbers: [1.0, 2.0, 3.0, 4.0]) == 2.0
func mode(numbers: [Double]) -> Double {
    let counts = numbers.reduce(into: [:]) { counts, number in
        counts[number, default: 0] += 1
    }
    return counts.max { $0.value < $1.value }!.key
}

// For a given array of input numbers, calculate the range of this dataset.
// Range is the difference between the largest and smallest numbers in a list.
// range(numbers: [1.0, 2.0, 3.0, 4.0]) == 3.0
func range(numbers: [Double]) -> Double {
    return numbers.max()! - numbers.min()!
}

// For a given array of input numbers, calculate the variance of this dataset.
// Variance is the average of the squared differences between each number and
// the mean of the dataset.
// variance(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func variance(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { pow($0 - mean, 2) }.reduce(0, +) / Double(numbers.count)
}

// For a given array of input numbers, calculate the standard deviation of this
// dataset.
// Standard deviation is the square root of the variance of the dataset.
// standardDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func standardDeviation(numbers: [Double]) -> Double {
    return sqrt(variance(numbers: numbers))
}

// For a given array of input numbers, calculate the quartiles of this dataset.
// Quartile is the median of the three middle numbers in a sorted list of numbers.
// quartiles(numbers: [1.0, 2.0, 3.0, 4.0]) == [1.5, 2.5, 3.5]
func quartiles(numbers: [Double]) -> [Double] {
    let sorted = numbers.sorted()
    let count = sorted.count
    if count % 2 == 1 {
        return [sorted[count / 2 - 1], sorted[count / 2], sorted[count / 2 + 1]]
    }
    return [sorted[count / 2 - 1], sorted[count / 2], sorted[count / 2]]
}

// For a given array of input numbers, calculate the interquartile range of this
// dataset.
// Interquartile range is the difference between the 75th percentile and the
// 25th percentile.
// interquartileRange(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func interquartileRange(numbers: [Double]) -> Double {
    let quartiles = quartiles(numbers: numbers)
    return quartiles[2] - quartiles[0]
}

// For a given array of input numbers, calculate the outliers of this dataset.
// Outlier is a number that is more than 1.5 standard deviations from the mean.
// outliers(numbers: [1.0, 2.0, 3.0, 4.0]) == [2.0, 3.

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

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

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

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

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

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

func mode(numbers: [Double]) -> Double {
    let sortedNumbers = numbers.sorted()
    var mode = sortedNumbers[0]
    var modeCount = 1
    var currentCount = 1
    for i in 1..<sortedNumbers.count {
        if sortedNumbers[i] == sortedNumbers[i - 1] {
            currentCount += 1
        } else {
            if currentCount > modeCount {
                mode = sortedNumbers[i - 1]
                modeCount = currentCount
            }
            currentCount = 1
        }
    }
    if currentCount > modeCount {
        mode = sortedNumbers[sortedNumbers.count - 1]
    }
    return mode
}

func range(numbers: [Double]) -> Double {
    let sortedNumbers = numbers.sorted()
    return sortedNumbers[sortedNumbers.count - 1] - sortedNumbers[0]
}

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

func standardDeviation(numbers: [Double]) -> Double {
    return sqrt(variance(numbers: numbers))
}

func quartiles(numbers: [Double]) -> [Double] {
    let sortedNumbers = numbers.sorted()
    let middleIndex = sortedNumbers.count / 2
    if sortedNumbers.count % 2 == 0 {
        return [sortedNumbers[middleIndex - 1], sortedNumbers[middleIndex], sortedNumbers[middleIndex + 1]]
    } else {
        return [sortedNumbers[middleIndex], sortedNumbers[middleIndex + 1]]
    }
}

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

// For a given array of input numbers, calculate the median of this dataset.
// Median is the middle number of a sorted array.
// median(numbers: [1.0, 2.0, 3.0, 4.0]) == 2.5
func median(numbers: [Double]) -> Double {
    let sortedNumbers = numbers.sorted()
    let middleIndex = sortedNumbers.count / 2
    if sortedNumbers.count % 2 == 0 {
        return (sortedNumbers[middleIndex - 1] + sortedNumbers[middleIndex]) / 2
    } else {
        return sortedNumbers[middleIndex]
    }
}

// For a given array of input numbers, calculate the mode of this dataset.
// Mode is the number that appears most often in a sorted array.
// mode(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func mode(numbers: [Double]) -> Double {
    let sortedNumbers = numbers.sorted()
    var mode = sortedNumbers[0]
    var modeCount = 1
    var currentCount = 1
    for i in 1..<sortedNumbers.count {
        if sortedNumbers[i] == sortedNumbers[i - 1] {
            currentCount += 1
        } else {
            if currentCount > modeCount {
                mode = sortedNumbers[i - 1]
                modeCount = currentCount
            }
            currentCount = 1
        }
    }
    if currentCount > modeCount {
        mode = sortedNumbers[sortedNumbers.count - 1]
    }
    return mode
}

// For a given array of input numbers, calculate the range of this dataset.
// Range is the difference between the highest and lowest number in a sorted array.
// range(numbers: [1.0, 2.0, 3.0, 4.0]) == 3.0
func range(numbers: [Double]) -> Double {
    let sortedNumbers = numbers.sorted()
    return sortedNumbers[sortedNumbers.count - 1] - sortedNumbers[0]
}

// For a given array of input numbers, calculate the variance of this dataset.
// Variance is the average of the squared differences between each element and a centerpoint (mean in this case).
// variance(numbers: [1.0, 2.0, 3.0, 4.0]) == 0.25
func variance(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { pow($0 - mean, 2) }.reduce(0, +) / Double(numbers.count)
}

// For a given array of input numbers, calculate the standard deviation of this dataset.
// Standard deviation is the square root of the variance.
// standardDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 0.816496580927736
func standardDeviation(numbers: [Double]) -> Double {
    return sqrt(variance(numbers: numbers))
}

// For a given array of input numbers, calculate the quartiles of this dataset.
// Quartile is the median of the lower half of the sorted array.
// quartiles(numbers: [1.0, 2.0, 3.0, 4.0]) == [1.0, 2.5, 3.0]
func quartiles(numbers: [Double]) -> [Double] {
    let sortedNumbers = numbers.sorted()
    let middleIndex = sortedNumbers.count / 2
    if sortedNumbers.count % 2 == 0 {
        return [sortedNumbers[middleIndex - 1], sortedNumbers[middleIndex], sortedNumbers[middleIndex + 1]]
    } else {
        return [sortedNumbers[middleIndex], sortedNumbers[middleIndex + 1]]
    }
}

// For a given array of input numbers, calculate the interquartile range of this dataset.
// Interquartile range is the difference between the upper quartile and the lower quartile.
// interquartileRange(numbers: [1.0, 2.0, 3.0, 

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

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

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

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

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

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

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

// For a given array of input numbers, calculate the Median Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the median of the absolute difference between
// each element and a centerpoint (median in this case):
// MAD = median | 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.map { abs($0 - median) }.sorted()[numbers.count / 2]
}

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

// For a given array of input numbers, calculate the Median Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the median of the absolute difference between
// each element and a centerpoint (median in this case):
// MAD = median | 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.map { abs($0 - median) }.sorted()[numbers.count / 2]
}

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

// For a given array of input numbers, calculate the Median Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the median of the absolute difference between
// each element and a centerpoint (median in this case):
// MAD = median | 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.map { abs($0 - median) }.sorted()[numbers.count / 2]
}

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

// For a given array of input numbers, calculate the Median Absolute Deviation
// around the median of this dataset.
// Median Absolute Deviation is the median of the absolute difference between
// each element and a centerpoint (median in this case):
// MAD = median |

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

print(parseNestedParens(parenString: "(()()) ((())) () ((())()())"))
<|file_separator|>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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) }
}
<|file_separator|>

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) }
}
<|file_separator|>

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) }
}
<|file_separator|>

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

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

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

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

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)
}
<|file_separator|>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)
}
<|file_separator|>

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)
}
<|file_separator|>

func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for i in numbers {
        sum += i
        product *= i
    }
    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 i in numbers {
        sum += i
        product *= i
    }
    return (sum, product)
}

// 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 i in numbers {
        sum += i
        product *= i
    }
    return (sum, product)
}

// 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 i in numbers {
        sum += i
        product *= i
    }
    return (sum, product)
}

// 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 i in numbers {
        sum += i
        product *= i
    }
    return (sum, product)
}

// 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 i in numbers {
        sum += i
        product *= i
    }
    return (sum, product)
}

// 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 i in numbers {
        sum += i
        product *= i
    }
    return (sum, product)
}

// 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 i in numbers {
        sum += i
        product *= i
    }
    return (sum, product)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func rollingMedian(numbers: [Int]) -> [Double] {
    var rollingMedian: [Double] = []
    var sortedNumbers = numbers.sorted()
    for number in numbers {
        var median: Double = 0
        var count = 0
        for i in 0..<sortedNumbers.count {
            if sortedNumbers[i] == number {
                count += 1
            }
            if count == 2 {
                median = Double(sortedNumbers[i - 1] + sortedNumbers[i]) / 2
                break
            }
        }
        rollingMedian.append(median)
    }
    return rollingMedian
}

func rollingMode(numbers: [Int]) -> [Int] {
    var rollingMode: [Int] = []
    var mode = numbers[0]
    var count = 0
    for number in numbers {
        if number == mode {
            count += 1
        } else {
            if count > 0 {
                rollingMode.append(mode)
            }
            mode = number
            count = 1
        }
    }
    rollingMode.append(mode)
    return rollingMode
}

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

// 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, 1, 2, 2, 2, 2]
func rollingMin(numbers: [Int]) -> [Int] {
    var rollingMin: [Int] = []
    var min = numbers[0]
    for number in numbers {
        if number < min {
            min = number
        }
        rollingMin.append(min)
    }
    return rollingMin
}

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

// From a given array of integers, generate an array of rolling median element found until given moment
// in the sequence.
// rollingMedian(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 2.5, 3, 3, 3.5, 4]
func rollingMedian(numbers: [Int]) -> [Double] {
    var rollingMedian: [Double] = []
    var sortedNumbers = numbers.sorted()
    for number in numbers {
        var median: Double = 0
        var count = 0
        for i in 0..<sortedNumbers.count {
            if sortedNumbers[i] == number {
                count += 1
            }
            if count == 2 {
                median = Double(sortedNumbers[i - 1] + sortedNumbers[i]) / 2
                break
            }
        }
        rollingMedian.append(median)
    }
    return rollingMedian
}

// From a given array of integers, generate an array of rolling mode element found until given moment
// in the sequence.
// rollingMode(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 2, 3, 3, 4, 4]
func rollingMode(numbers: [Int]) -> [Int] {
    var rollingMode: [Int] = []
    var mode = numbers[0]
    var count = 0
    for number in numbers {
        if number == mode {
            count += 1
        } else {
            if count > 0 {
                rollingMode.append(mode)
            }
            mode = number
            count = 1
        }
    }
    rollingMode.append(mode)
    return rollingMode
}

// From a given array of integers, generate an array of rolling mode element found until given moment
// in the sequence.
// rollingMode(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 2, 3, 3, 4, 4]
func rollingMode(numbers: [Int]) -> [Int] {
    var rollingMode: [Int] = []
    var mode = numbers[0]
    var count = 0
    for number in numbers {
        if number == mode {
            count += 1
        } else {
            if count > 0 {
                rollingMode.append(mode)
            }
            mode = number
            count = 1
        }
    }
    rollingMode.append(mode)
    return rollingMode
}

// From a given array of integers, generate an array of rolling mode element found until given moment
//

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

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

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

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

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

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

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

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

// From a given array of integers, generate an array of rolling sum of elements found until given moment
// in the sequence.
// rollingSum(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 3, 6, 9, 12, 15, 18]
func rollingSum(numbers: [Int]) -> [Int] {
  var result = [Int]()
  var sum = 0
  for number in numbers {
    sum += number
    result.append(sum)
  }
  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.5, 3, 3.5, 4]
func rollingAvg(numbers: [Int]) -> [Double] {
  var result = [Double]()
  var sum = 0
  for number in numbers {
    sum += number
  }
  for number in numbers {
    result.append(Double(sum) / Double(number))
  }
  return result
}
<|file_separator|>

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

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

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

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

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

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

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

// 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, 1, 2, 2, 2, 2]
func rollingMin(numbers: [Int]) -> [Int] {
    var rollingMin: [Int] = []
    var min = numbers[0]
    for number in numbers {
        if number < min {
            min = number
        }
        rollingMin.append(min)
    }
    return rollingMin
}

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

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

// From a given array of integers, generate an array of rolling standard deviation element found until given moment
// in the sequence.
// rollingStdDev(numbers: [1, 2, 3, 2, 3, 4, 2]) == [0, 0.816496580927726, 1.154700538379251, 1.309011240711411, 1.397804940635183, 1.4211547005383793, 1.4211547005383793]
func rollingStdDev(numbers: [Int]) -> [Double] {
    var rollingStdDev: [Double] = []
    var sum = 0
    var count = 0
    for number in numbers {
        sum += number
        count += 1
        rollingStdDev.append(Double(sum) / Double(count))
    }
    return rollingStdDev
}

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

// From a given array of integers, generate an array of rolling standard deviation element found until given moment
// in the sequence.
// rollingStdDev

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

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

func rollingMin(numbers: [Int]) -> [Int] {
    var rollingMin = [Int]()
    var min = 0
    for number in numbers {
        if number < min {
            min = number
            rollingMin.append(min)
        } else {
            rollingMin.append(min)
        }
    }
    return rollingMin
}

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

func rollingMedian(numbers: [Int]) -> [Double] {
    var rollingMedian = [Double]()
    var sortedNumbers = numbers
    sortedNumbers.sort()
    for number in numbers {
        let index = sortedNumbers.index(of: number)!
        let left = sortedNumbers[0..<index].count
        let right = sortedNumbers[index+1..<sortedNumbers.count].count
        let median = Double(number)
        if left == right {
            rollingMedian.append(median)
        } else {
            rollingMedian.append((Double(number) + Double(sortedNumbers[index-1])) / 2)
        }
    }
    return rollingMedian
}

func rollingSum(numbers: [Int]) -> [Int] {
    var rollingSum = [Int]()
    var sum = 0
    for number in numbers {
        sum += number
        rollingSum.append(sum)
    }
    return rollingSum
}

func rollingProduct(numbers: [Int]) -> [Int] {
    var rollingProduct = [Int]()
    var product = 1
    for number in numbers {
        product *= number
        rollingProduct.append(product)
    }
    return rollingProduct
}

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

// 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, 1, 2, 2, 2, 2]
func rollingMin(numbers: [Int]) -> [Int] {
    var rollingMin = [Int]()
    var min = 0
    for number in numbers {
        if number < min {
            min = number
            rollingMin.append(min)
        } else {
            rollingMin.append(min)
        }
    }
    return rollingMin
}

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

// From a given array of integers, generate an array of rolling median element found until given moment
// in the sequence.
// rollingMedian(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 2, 2, 2, 3, 3]
func rollingMedian(numbers: [Int]) -> [Double] {
    var rollingMedian = [Double]()
    var sortedNumbers = numbers
    sortedNumbers.sort()
    for number in numbers {
        let index = sortedNumbers.index(of: number)!
        let left = sortedNumbers[0..<index].count
        let right = sortedNumbers[index+1..<sortedNumbers.count].count
        let median = Double(number)
        if left == right {
            rollingMedian.append(median)
        } else {
            rollingMedian.append((Double(number) + Double(sortedNumbers[index-1])) / 2)
        }
    }
    return rollingMedian
}

// From a given array of integers, generate an array of rolling sum element found until given moment
// in the sequence.
// rollingSum(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 3, 6, 9, 12, 15, 18]
func rollingSum(numbers: [Int]) -> [Int] {
    var rollingSum = [Int]()
    var sum = 0
    for number in numbers {
        sum += number
        rollingSum.append(sum)
    }
    return rollingSum
}

// From a given array of integers, generate an array of rolling product element found until given moment
// in the sequence.
// rollingProduct(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 6, 24, 12, 8, 4]
func rollingProduct(numbers: [Int]) -> [Int] {
    var rollingProduct = [Int]()
    var product = 1
    for number in numbers {
        product *= number
        rollingProduct.append(product)
    }
    return rollingProduct
}

// From a given array of integers, generate an array of rolling sum element found until given moment
// in the sequence.
// rollingSum(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 3, 6, 9, 12, 15, 18]
func rollingSum(numbers: [Int]) -> [Int] {
    var rollingSum = [Int]()
    var sum = 0
    for number

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

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

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

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

func rollingMedian(numbers: [Int]) -> [Double] {
    var result = [Double]()
    var sorted = numbers.sorted()
    for number in numbers {
        let index = sorted.index(of: number)!
        let left = sorted[0..<index]
        let right = sorted[index+1..<sorted.count]
        let median = (left.count + right.count) % 2 == 0 ? (left.count + right.count) / 2.0 : left.count / 2.0
        result.append(median)
    }
    return result
}

func rollingMode(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var mode = Int.min
    var count = 0
    for number in numbers {
        if number == mode {
            count += 1
        } else {
            if count > 0 {
                result.append(mode)
                count = 0
            }
            mode = number
        }
    }
    if count > 0 {
        result.append(mode)
    }
    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
}

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

// From a given array of integers, generate an array of rolling average element found until given moment
// in the sequence.
// rollingAvg(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 1.5, 2, 2.5, 3, 3.5, 4]
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 sum element found until given moment
// in the sequence.
// rollingSum(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 3, 6, 9, 12, 15, 18]
func rollingSum(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var sum = 0
    for number in numbers {
        sum += number
        result.append(sum)
    }
    return result
}

// From a given array of integers, generate an array of rolling median element found until given moment
// in the sequence.
// rollingMedian(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 2, 2, 3, 3, 3]
func rollingMedian(numbers: [Int]) -> [Double] {
    var result = [Double]()
    var sorted = numbers.sorted()
    for number in numbers {
        let index = sorted.index(of: number)!
        let left = sorted[0..<index]
        let right = sorted[index+1..<sorted.count]
        let median = (left.count + right.count) % 2 == 0 ? (left.count + right.count) / 2.0 : left.count / 2.0
        result.append(median)
    }
    return result
}

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

// From a given array of integers, generate an array of rolling mode element found until given moment
// in the sequence.
// rollingMode(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMode(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var mode = Int.min
    var count = 0
    for number in numbers

func makePalindrome(string: String) -> String {
    if string.isEmpty {
        return ""
    }
    let reversedString = string.reversed()
    let reversedStringPrefix = reversedString.prefix(string.count)
    let reversedStringSuffix = reversedString.suffix(string.count)
    let reversedStringPrefixPalindrome = isPalindrome(string: reversedStringPrefix.description)
    let reversedStringSuffixPalindrome = isPalindrome(string: reversedStringSuffix.description)
    if reversedStringPrefixPalindrome {
        return string + reversedStringSuffixPalindrome
    } else if reversedStringSuffixPalindrome {
        return reversedStringPrefixPalindrome + string
    } else {
        return makePalindrome(string: string.prefix(string.count - 1).description)
    }
}

func isPalindrome(string: String) -> Bool {
    if string.isEmpty {
        return true
    }
    let reversedString = string.reversed()
    if string == reversedString {
        return true
    }
    return false
}

```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 {
    if string.isEmpty {
        return ""
    }
    let reversedString = string.reversed()
    let reversedStringPrefix = reversedString.prefix(string.count)
    let reversedStringSuffix = reversedString.suffix(string.count)
    let reversedStringPrefixPalindrome = isPalindrome(string: reversedStringPrefix.description)
    let reversedStringSuffixPalindrome = isPalindrome(string: reversedStringSuffix.description)
    if reversedStringPrefixPalindrome {
        return string + reversedStringSuffixPalindrome
    } else if reversedStringSuffixPalindrome {
        return reversedStringPrefixPalindrome + string
    } else {
        return makePalindrome(string: string.prefix(string.count - 1).description)
    }
}

func isPalindrome(string: String) -> Bool {
    if string.isEmpty {
        return true
    }
    let reversedString = string.reversed()
    if string == reversedString {
        return true
    }
    return false
}

print(makePalindrome(string: "cat"))
print(makePalindrome(string: "cata"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(makePalindrome(string: "catac"))
print(make

func makePalindrome(string: String) -> String {
    let stringLength = string.count
    if stringLength == 0 {
        return ""
    }
    let stringPrefix = string.prefix(stringLength / 2)
    let stringSuffix = string.suffix(stringLength / 2)
    let stringPrefixReversed = stringPrefix.reversed()
    let stringSuffixReversed = stringSuffix.reversed()
    let stringPrefixPalindrome = stringPrefixReversed.joined()
    let stringSuffixPalindrome = stringSuffixReversed.joined()
    if stringPrefixPalindrome == stringSuffixPalindrome {
        return stringPrefixPalindrome
    }
    return stringPrefixPalindrome + stringSuffixPalindrome
}

```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 stringLength = string.count
    if stringLength == 0 {
        return ""
    }
    let stringPrefix = string.prefix(stringLength / 2)
    let stringSuffix = string.suffix(stringLength / 2)
    let stringPrefixReversed = stringPrefix.reversed()
    let stringSuffixReversed = stringSuffix.reversed()
    let stringPrefixPalindrome = stringPrefixReversed.joined()
    let stringSuffixPalindrome = stringSuffixReversed.joined()
    if stringPrefixPalindrome == stringSuffixPalindrome {
        return stringPrefixPalindrome
    }
    return stringPrefixPalindrome + stringSuffixPalindrome
}
<|file_separator|>

func makePalindrome(string: String) -> String {
    if string.isEmpty {
        return string
    }
    let reversed = string.reversed()
    let prefix = string.prefix(string.count / 2)
    let postfix = reversed.prefix(reversed.count / 2)
    let palindrome = prefix + postfix
    return palindrome
}

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

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

func longestPalindrome(string: String) -> String {
    var longestPalindrome = ""
    for i in 0..<string.count {
        let palindrome = longestPalindrome(string: string, start: i, end: i)
        if palindrome.count > longestPalindrome.count {
            longestPalindrome = palindrome
        }
    }
    return longestPalindrome
}

func longestPalindrome(string: String, start: Int, end: Int) -> String {
    var start = start
    var end = end
    while start >= 0 && end < string.count && string[start] == string[end] {
        start -= 1
        end += 1
    }
    return string[start + 1..<end]
}

```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 palindrome = longestPalindrome(string: string)
    let palindromePrefix = palindrome.prefix(palindrome.count / 2)
    let palindromeSuffix = palindrome.suffix(palindrome.count / 2)
    return palindromePrefix + string.reversed() + palindromeSuffix
}

func longestPalindrome(string: String) -> String {
    var longestPalindrome = ""
    for i in 0..<string.count {
        let palindrome = longestPalindrome(string: string, start: i, end: i)
        if palindrome.count > longestPalindrome.count {
            longestPalindrome = palindrome
        }
    }
    return longestPalindrome
}

func longestPalindrome(string: String, start: Int, end: Int) -> String {
    var start = start
    var end = end
    while start >= 0 && end < string.count && string[start] == string[end] {
        start -= 1
        end += 1
    }
    return string[start + 1..<end]
}

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

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

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

func makePalindrome(string: String) -> String {
    if string.isEmpty {
        return string
    }
    let reversed = string.reversed()
    let prefix = string.prefix(upTo: string.index(before: string.endIndex))
    let postfix = string.suffix(from: string.index(after: string.startIndex))
    let reversedPrefix = reversed.prefix(upTo: reversed.index(before: reversed.endIndex))
    let reversedPostfix = reversed.suffix(from: reversed.index(after: reversed.startIndex))
    let palindrome = prefix + reversedPostfix
    let palindromePrefix = reversedPrefix + string
    return palindrome.isEmpty ? palindromePrefix : palindrome
}

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

// 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 {
    if string.isEmpty {
        return string
    }
    let reversed = string.reversed()
    let prefix = string.prefix(upTo: string.index(before: string.endIndex))
    let postfix = string.suffix(from: string.index(after: string.startIndex))
    let reversedPrefix = reversed.prefix(upTo: reversed.index(before: reversed.endIndex))
    let reversedPostfix = reversed.suffix(from: reversed.index(after: reversed.startIndex))
    let palindrome = prefix + reversedPostfix
    let palindromePrefix = reversedPrefix + string
    return palindrome.isEmpty ? palindromePrefix : palindrome
}

// 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 {
    if string.isEmpty {
        return string
    }
    let reversed = string.reversed()
    let prefix = string.prefix(upTo: string.index(before: string.endIndex))
    let postfix = string.suffix(from: string.index(after: string.startIndex))
    let reversedPrefix = reversed.prefix(upTo: reversed.index(before: reversed.endIndex))
    let reversedPostfix = reversed.suffix(from: reversed.index(after: reversed.startIndex))
    let palindrome = prefix + reversedPostfix
    let palindromePrefix = reversedPrefix + string
    return palindrome.isEmpty ? palindromePrefix : palindrome
}

// 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 {
    if string.isEmpty {
        return string
    }
    let reversed = string.reversed()
    let prefix = string.prefix(upTo: string.index(before: string.endIndex))
    let postfix = string.suffix(from: string.index(after: string.startIndex))
    let reversedPrefix = reversed.prefix(upTo: reversed.index(before: reversed.endIndex))
    let reversedPostfix = reversed.suffix(from: reversed.index(after: reversed.startIndex))
    let palindrome = prefix + reversedPostfix
    let palindromePrefix = reversedPrefix + string
    return palindrome.isEmpty ? palindromePrefix : palindrome
}

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

func makePalindrome(string: String) -> String {
    var palindrome = string
    var i = 0
    var j = string.count - 1
    while i < j {
        if string[i] != string[j] {
            break
        }
        palindrome.append(string[j])
        i += 1
        j -= 1
    }
    return palindrome
}

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

func makePalindrome(string: String) -> String {
    if string.isEmpty {
        return string
    }
    
    let reversedString = string.reversed()
    let reversedStringPrefix = string.prefix(string.count / 2)
    let reversedStringSuffix = reversedString.suffix(reversedString.count / 2)
    
    let palindrome = reversedStringPrefix.appending(reversedStringSuffix)
    
    return palindrome
}

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

func makePalindrome(string: String) -> String {
    if string.isEmpty {
        return ""
    }
    let reversed = string.reversed()
    let longestPalindrome = longestPalindrome(string: string)
    return string + String(reversed.dropFirst(longestPalindrome.count))
}

func longestPalindrome(string: String) -> String {
    if string.isEmpty {
        return ""
    }
    var longestPalindrome = ""
    for i in 0..<string.count {
        let palindrome = palindrome(string: string, start: i, end: i)
        if palindrome.count > longestPalindrome.count {
            longestPalindrome = palindrome
        }
        let palindrome2 = palindrome(string: string, start: i, end: i + 1)
        if palindrome2.count > longestPalindrome.count {
            longestPalindrome = palindrome2
        }
    }
    return longestPalindrome
}

func palindrome(string: String, start: Int, end: Int) -> String {
    if start < 0 || end >= string.count || string[start] != string[end] {
        return ""
    }
    return palindrome(string: string, start: start - 1, end: end + 1) + string[start..<end]
}

```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 {
    if string.isEmpty {
        return ""
    }
    let reversed = string.reversed()
    let longestPalindrome = longestPalindrome(string: string)
    return string + String(reversed.dropFirst(longestPalindrome.count))
}

func longestPalindrome(string: String) -> String {
    if string.isEmpty {
        return ""
    }
    var longestPalindrome = ""
    for i in 0..<string.count {
        let palindrome = palindrome(string: string, start: i, end: i)
        if palindrome.count > longestPalindrome.count {
            longestPalindrome = palindrome
        }
        let palindrome2 = palindrome(string: string, start: i, end: i + 1)
        if palindrome2.count > longestPalindrome.count {
            longestPalindrome = palindrome2
        }
    }
    return longestPalindrome
}

func palindrome(string: String, start: Int, end: Int) -> String {
    if start < 0 || end >= string.count || string[start] != string[end] {
        return ""
    }
    return palindrome(string: string, start: start - 1, end: end + 1) + string[start..<end]
}

// 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 {
    if string.isEmpty {
        return ""
    }
    let reversed = string.reversed()
    let longestPalindrome = longestPalindrome(string: string)
    return string + String(reversed.dropFirst(longestPalindrome.count))
}

func longestPalindrome(string: String) -> String {
    if string.isEmpty {
        return ""
    }
    var longestPalindrome = ""
    for i in 0..<string.count {
        let palindrome = palindrome(string: string, start: i, end: i)
        if palindrome.count > longestPalindrome.count {
            longestPalindrome = palindrome
        }
        let palindrome2 = palindrome(string: string, start: i, end: i + 1)
        if palindrome2.count > longestPalindrome.count {
            longestPalindrome = palindrome2
        }
    }
    return longestPalindrome
}

func palindrome(string: String, start: Int, end: Int) -> String {
    if start < 0 || end >= string.count || string[start] != string[end] {
        return ""
    }
    return palindrome(string: string, start: start - 1, end: end + 1) + string[start..<end]
}

// 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 {
    if string.isEmpty {
        return ""
    }
    let reversed = string.reversed()
    let longestPalindrome = longestPalindrome(string: string)
    return string + String(reversed.dropFirst(longestPalindrome.count))
}

func longestPalindrome(string: String) -> String {
    if string.isEmpty {
        return ""
    }
    var longestPalindrome = ""
    for i in 0..<string.count {
        let palindrome = palindrome(string: string, start: i, end: i)
        if palindrome.count > longestPalindrome.count {
            longestPalindrome = palindrome
        }
        let palindrome2 = palindrome(string: string, start: i, end: i + 1)
        if palindrome2.count > longestPalindrome.count {
            longestPalindrome = palindrome2
        }
    }
    return longestPalindrome
}

func palindrome(string: String, start: Int, end: Int) -> String {
    if start < 0 || end >= string.count || string[start] != string[end] {
        return ""
    }

func makePalindrome(string: String) -> String {
    if string.isEmpty {
        return ""
    }
    let reversed = string.reversed()
    let prefix = string.prefix(upTo: string.index(before: string.endIndex))
    let suffix = string.suffix(from: string.index(after: string.startIndex))
    let palindrome = String(suffix) + String(reversed)
    return String(prefix) + palindrome
}

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

// 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 {
    if string.isEmpty {
        return ""
    }
    let reversed = string.reversed()
    let prefix = string.prefix(upTo: string.index(before: string.endIndex))
    let suffix = string.suffix(from: string.index(after: string.startIndex))
    let palindrome = String(suffix) + String(reversed)
    return String(prefix) + palindrome
}

// 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 {
    if string.isEmpty {
        return ""
    }
    let reversed = string.reversed()
    let prefix = string.prefix(upTo: string.index(before: string.endIndex))
    let suffix = string.suffix(from: string.index(after: string.startIndex))
    let palindrome = String(suffix) + String(reversed)
    return String(prefix) + palindrome
}

// 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 {
    if string.isEmpty {
        return ""
    }
    let reversed = string.reversed()
    let prefix = string.prefix(upTo: string.index(before: string.endIndex))
    let suffix = string.suffix(from: string.index(after: string.startIndex))
    let palindrome = String(suffix) + String(reversed)
    return String(prefix) + palindrome
}

// 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 {
    if string.isEmpty {
        return ""
    }
    let reversed = string.reversed()
    let prefix = string.prefix(upTo: string.index(before: string.endIndex))
    let suffix = string.suffix(from: string.index(after: string.startIndex))
    let palindrome = String(suffix) + String(reversed)
    return String(prefix) + palindrome
}

// 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 {
    if string.isEmpty {
        return ""
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func stringToInteger(input: String) -> Int {
    var result = 0
    for i in 0..<input.count {
        result = result * 10 + Int(input[input.index(input.startIndex, offsetBy: i)]) - 48
    }
    return result
}

func integerToString(input: Int) -> String {
    var result = ""
    var input = input
    while input > 0 {
        result = String(input % 10) + result
        input /= 10
    }
    return result
}

func sumArray(input: [Int]) -> Int {
    var result = 0
    for i in 0..<input.count {
        result += input[i]
    }
    return result
}

func productArray(input: [Int]) -> Int {
    var result = 1
    for i in 0..<input.count {
        result *= input[i]
    }
    return result
}

func averageArray(input: [Int]) -> Double {
    var result = 0.0
    for i in 0..<input.count {
        result += Double(input[i])
    }
    return result / Double(input.count)
}

func medianArray(input: [Int]) -> Double {
    var result = 0.0
    for i in 0..<input.count {
        result += Double(input[i])
    }
    return result / Double(input.count)
}

func modeArray(input: [Int]) -> Int {
    var result = 0
    for i in 0..<input.count {
        if input[i] > result {
            result = input[i]
        }
    }
    return result
}

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

// Input is a string of digits that represent a number.
// Return the number as an integer.
// stringToInteger(input: "123") == 123
func stringToInteger(input: String) -> Int {
    var result = 0
    for i in 0..<input.count {
        result = result * 10 + Int(input[input.index(input.startIndex, offsetBy: i)]) - 48
    }
    return result
}

// Input is a string of digits that represent a number.
// Return the number as an integer.
// integerToString(input: 123) == "123"
func integerToString(input: Int) -> String {
    var result = ""
    var input = input
    while input > 0 {
        result = String(input % 10) + result
        input /= 10
    }
    return result
}

// Input is an array of integers.
// Return the sum of all the integers in the array.
// sumArray(input: [1, 2, 3, 4]) == 10
func sumArray(input: [Int]) -> Int {
    var result = 0
    for i in 0..<input.count {
        result += input[i]
    }
    return result
}

// Input is an array of integers.
// Return the product of all the integers in the array.
// productArray(input: [1, 2, 3, 4]) == 24
func productArray(input: [Int]) -> Int {
    var result = 1
    for i in 0..<input.count {
        result *= input[i]
    }
    return result
}

// Input is an array of integers.
// Return the average of all the integers in the array.
// averageArray(input: [1, 2, 3, 4]) == 2.5
func averageArray(input: [Int]) -> Double {
    var result = 0.0
    for i in 0..<input.count {
        result += Double(input[i])
    }
    return result / Double(input.count)
}

// Input is an array of integers.
// Return the median of all the integers in the array.
// medianArray(input: [1, 2, 3, 4]) == 2.5
func medianArray(input: [Int]) -> Double {
    var result = 0.0
    for i in 0..<input.count {
        result += Double(input[i])
    }
    return result / Double(input.count)
}

// Input is an array of integers.
// Return the mode of all the integers in the array.
// modeArray(input: [1, 2, 3, 4]) == 1
func modeArray(input: [Int]) -> Int {
    var result = 0
    for i in 0..<input.count {
        if input[i] > result {
            result = input[i]
        }
    }
    return result
}

// Input is an array of integers.
// Return the mode of all the integers in the array.
// modeArray(input: [1, 2, 3, 4]) == 1
func modeArray(input: [Int]) -> Int {
    var result = 0
    for i in 0..<input.count {
        if input[i] > result {
            result = input[i]
        }
    }
    return result
}

// Input is an array of integers.
// Return the mode of all the integers in the array.
// modeArray(input: [1, 2, 3, 4]) == 1
func modeArray(input: [Int]) -> Int {
    var result = 0
    for i in 0..<input.count {
        if input[i] > result {
            result = input[i]
        }
    }
    return result
}

// Input is an array of integers

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

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

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

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

func shortestByLength(strings: [String]) -> String? {
    if strings.isEmpty {
        return nil
    }
    
    var shortest = strings[0]
    for string in strings {
        if string.count < shortest.count {
            shortest = string
        }
    }
    
    return shortest
}

```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? {
    if strings.isEmpty {
        return nil
    }
    
    var longest = strings[0]
    for string in strings {
        if string.count > longest.count {
            longest = string
        }
    }
    
    return longest
}

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

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

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

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

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

// Out of array of strings, return the one with the longest length. Return the first one in case of
// multiple strings of the same length. Return nil in case the input array is empty.
// longest_by_length(strings: [] as [String]) == nil
// longest_by_length(strings:

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

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

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

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

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

func sum(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        sum += integers[i]
    }
    return sum
}

func sumEven(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        if integers[i] % 2 == 0 {
            sum += integers[i]
        }
    }
    return sum
}

func sumOdd(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        if integers[i] % 2 != 0 {
            sum += integers[i]
        }
    }
    return sum
}

func sumModulo3(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        sum += integers[i] % 3
    }
    return sum
}

func sumModulo5(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        sum += integers[i] % 5
    }
    return sum
}

func sumModulo7(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        sum += integers[i] % 7
    }
    return sum
}

func sumModulo11(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        sum += integers[i] % 11
    }
    return sum
}

```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? {
    if strings.count == 0 {
        return nil
    }
    var longest = strings[0]
    for i in 1..<strings.count {
        if strings[i].count > longest.count {
            longest = strings[i]
        }
    }
    return longest
}

// Given an array of integers, return the sum of all the integers.
// sum(integers: []) == 0
// sum(integers: [1, 2, 3]) == 6
func sum(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        sum += integers[i]
    }
    return sum
}

// Given an array of integers, return the sum of all the even integers.
// sumEven(integers: []) == 0
// sumEven(integers: [1, 2, 3]) == 2
// sumEven(integers: [1, 2, 3, 4]) == 6
func sumEven(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        if integers[i] % 2 == 0 {
            sum += integers[i]
        }
    }
    return sum
}

// Given an array of integers, return the sum of all the odd integers.
// sumOdd(integers: []) == 0
// sumOdd(integers: [1, 2, 3]) == 0
// sumOdd(integers: [1, 2, 3, 4]) == 4
func sumOdd(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        if integers[i] % 2 != 0 {
            sum += integers[i]
        }
    }
    return sum
}

// Given an array of integers, return the sum of all the integers modulo 3.
// sumModulo3(integers: []) == 0
// sumModulo3(integers: [1, 2, 3]) == 1
// sumModulo3(integers: [1, 2, 3, 4]) == 2
func sumModulo3(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        sum += integers[i] % 3
    }
    return sum
}

// Given an array of integers, return the sum of all the integers modulo 5.
// sumModulo5(integers: []) == 0
// sumModulo5(integers: [1, 2, 3]) == 1
// sumModulo5(integers: [1, 2, 3, 4]) == 0
func sumModulo5(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        sum += integers[i] % 5
    }
    return sum
}

// Given an array of integers, return the sum of all the integers modulo 7.
// sumModulo7(integers: []) == 0
// sumModulo7(integers: [1, 2, 3]) == 2
// sumModulo7(integers: [1, 2, 3, 4]) == 3
func sumModulo7(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        sum += integers[i] % 7
    }
    return sum
}

// Given an array of integers, return the sum of all the integers modulo 11.
// sumModulo11(integers: []) == 0
// sumModulo11(integers: [1, 2, 3]) == 2
// sumModulo11(integers: [1, 2, 3, 4]) == 4
func sumModulo11(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        sum += integers[i] % 11
    }
    return sum
}

// Given an array of integers, return the sum of all the integers modulo 13.
// sumModulo13(integers: []) == 0
// sumModulo13(integers: [1, 2, 3]) == 3
// sumModulo13(integers: [1, 2, 3, 4]) == 

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

func sum(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        sum += integers[i]
    }
    return sum
}

func sumEven(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        if integers[i] % 2 == 0 {
            sum += integers[i]
        }
    }
    return sum
}

func sumOdd(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        if integers[i] % 2 != 0 {
            sum += integers[i]
        }
    }
    return sum
}

func sumAllButFirst(integers: [Int]) -> Int {
    var sum = 0
    for i in 1..<integers.count {
        sum += integers[i]
    }
    return sum
}

func sumAllButLast(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count-1 {
        sum += integers[i]
    }
    return sum
}

```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? {
    if strings.count == 0 {
        return nil
    }
    var longest = strings[0]
    for i in 1..<strings.count {
        if strings[i].count > longest.count {
            longest = strings[i]
        }
    }
    return longest
}

// Given an array of integers, return the sum of all the integers. Return 0 in case the input array is empty.
// sum(integers: [] as [Int]) == 0
// sum(integers: [1, 2, 3]) == 6
func sum(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        sum += integers[i]
    }
    return sum
}

// Given an array of integers, return the sum of all the even integers. Return 0 in case the input array is empty.
// sumEven(integers: [] as [Int]) == 0
// sumEven(integers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 30
func sumEven(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        if integers[i] % 2 == 0 {
            sum += integers[i]
        }
    }
    return sum
}

// Given an array of integers, return the sum of all the odd integers. Return 0 in case the input array is empty.
// sumOdd(integers: [] as [Int]) == 0
// sumOdd(integers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 25
func sumOdd(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count {
        if integers[i] % 2 != 0 {
            sum += integers[i]
        }
    }
    return sum
}

// Given an array of integers, return the sum of all the integers except for the first one. Return 0 in case the input array is empty.
// sumAllButFirst(integers: [] as [Int]) == 0
// sumAllButFirst(integers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 55
func sumAllButFirst(integers: [Int]) -> Int {
    var sum = 0
    for i in 1..<integers.count {
        sum += integers[i]
    }
    return sum
}

// Given an array of integers, return the sum of all the integers except for the last one. Return 0 in case the input array is empty.
// sumAllButLast(integers: [] as [Int]) == 0
// sumAllButLast(integers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 55
func sumAllButLast(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count-1 {
        sum += integers[i]
    }
    return sum
}

// Given an array of integers, return the sum of all the integers except for the last one. Return 0 in case the input array is empty.
// sumAllButLast(integers: [] as [Int]) == 0
// sumAllButLast(integers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 55
func sumAllButLast(integers: [Int]) -> Int {
    var sum = 0
    for i in 0..<integers.count-1 {
        sum += integers[i]
    }
    return sum
}

// Given an array of integers, return the sum of all the integers except for the last one. Return 0 in case the input array is empty.
// sumAllButLast(integers: [] as [Int]) == 0
// sumAllButLast(integers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 55
func sumAllButLast(integers: [Int]) -> Int {

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

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

func productExceptSelf(nums: [Int]) -> [Int] {
    var result = [Int](repeating: 1, count: nums.count)
    var left = 1
    for i in 0..<nums.count {
        result[i] = left
        left *= nums[i]
    }
    var right = 1
    for i in (0..<nums.count).reversed() {
        result[i] *= right
        right *= nums[i]
    }
    return result
}

func swapEnds(str: String) -> String {
    if str.count == 2 {
        return str
    }
    return String(str[str.index(str.startIndex, offsetBy: 1)]) + String(str[str.index(str.endIndex, offsetBy: -2)]) + String(str[str.index(str.startIndex, offsetBy: 1)])
}

func stringBits(str: String) -> String {
    var result = ""
    for i in 0..<str.count {
        if i % 2 == 0 {
            result += String(str[str.index(str.startIndex, offsetBy: i)])
        }
    }
    return result
}

func last2(str: String) -> Int {
    if str.count < 2 {
        return 0
    }
    var count = 0
    var last2 = str[str.index(str.endIndex, offsetBy: -2)..<str.endIndex]
    for i in 0..<str.count - 2 {
        if str[str.index(str.startIndex, offsetBy: i)] == str[str.index(str.startIndex, offsetBy: i + 1)] {
            if String(str[str.index(str.startIndex, offsetBy: i)]) + String(str[str.index(str.startIndex, offsetBy: i + 1)]) == last2 {
                count += 1
            }
        }
    }
    return 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? {
    if strings.count == 0 {
        return nil
    }
    var longest = strings[0]
    for i in 1..<strings.count {
        if strings[i].count > longest.count {
            longest = strings[i]
        }
    }
    return longest
}

// Given an array of integers, return an array of the same length, where each element is the product of all the elements in the original array except for the one at that index.
// productExceptSelf(nums: [1, 2, 3, 4]) == [24, 12, 8, 6]
// productExceptSelf(nums: [1, 2, 3, 0]) == [0, 0, 6, 0]
// productExceptSelf(nums: [1, 2, 3, 4, 5]) == [120, 60, 40, 30, 24]
func productExceptSelf(nums: [Int]) -> [Int] {
    var result = [Int](repeating: 1, count: nums.count)
    var left = 1
    for i in 0..<nums.count {
        result[i] = left
        left *= nums[i]
    }
    var right = 1
    for i in (0..<nums.count).reversed() {
        result[i] *= right
        right *= nums[i]
    }
    return result
}

// Given a string, return a new string with the first and last chars swapped, except keep the first and last chars if they appear at the beginning or end of the string. You may assume that the string has at least two chars.
// swapEnds("Hello") == "oellH"
// swapEnds("ab") == "ba"
// swapEnds("Hi") == "Hi"
func swapEnds(str: String) -> String {
    if str.count == 2 {
        return str
    }
    return String(str[str.index(str.startIndex, offsetBy: 1)]) + String(str[str.index(str.endIndex, offsetBy: -2)]) + String(str[str.index(str.startIndex, offsetBy: 1)])
}

// Given a string, return a new string made of every other char starting with the first, so "Hello" yields "Hlo".
// stringBits("Hello") == "Hlo"
// stringBits("Hi") == "H"
// stringBits("Heeololeo") == "Hello"
func stringBits(str: String) -> String {
    var result = ""
    for i in 0..<str.count {
        if i % 2 == 0 {
            result += String(str[str.index(str.startIndex, offsetBy: i)])
        }
    }
    return result
}

// Given a string, return the count of the number of times that a substring length 2 appears in the string and also as the last 2 chars of the string, so "hixxxhi" yields 1 (we won't count the end substring).
// last2("hixxhi") == 1
// last2("xaxxaxaxx") == 1
// last2("axxxaaxx") == 2
func last2(str: String) -> Int {
    if str.count < 2 {
        return 0
    }
    var count = 0
    var last2 = str[str.index(str.endIndex, offsetBy: -2)..<str.endIndex]
    for i in 0..<str.count - 2 {
        if str[str.index(str.startIndex, offsetBy: i)] == str[str.index(str.startIndex, offsetBy: i + 1)] {
            if String(str[str.index(str.startIndex, offsetBy: i)]) + String(str[str.index(str.startIndex, offsetBy: i + 1)]) == last2 {
                count += 1
            }
        }
    }
    return count
}

// Given an array of ints, return the number of times that two 6's are next to each other in the array. Also count instances where the second "6" is actually a 7.
// sixes9([6, 6, 2]) == 1
// sixes9([6, 6, 2, 6]) == 1
// sixes9([6, 7, 

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

func leastCommonMultiple(a: Int, b: Int) -> Int {
    return a * b / greatestCommonDivisor(a: a, b: b)
}

func divisorsSum(number: Int) -> Int {
    var sum = 0
    for divisor in 1...number {
        if number % divisor == 0 {
            sum += divisor
        }
    }
    return sum
}

func primeNumbersSum(number: Int) -> Int {
    var sum = 0
    for number in 2...number {
        if isPrime(number: number) {
            sum += number
        }
    }
    return sum
}

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

// Return a least common multiple of two integers a and b
// leastCommonMultiple(a: 3, b: 5) == 15
// leastCommonMultiple(a: 25, b: 15) == 75
func leastCommonMultiple(a: Int, b: Int) -> Int {
    return a * b / greatestCommonDivisor(a: a, b: b)
}

// Return a sum of all divisors of a given number
// divisorsSum(12) == 16
// divisorsSum(24) == 30
func divisorsSum(number: Int) -> Int {
    var sum = 0
    for divisor in 1...number {
        if number % divisor == 0 {
            sum += divisor
        }
    }
    return sum
}

// Return a sum of all prime numbers less than a given number
// primeNumbersSum(100) == 1060
// primeNumbersSum(1000) == 11039
func primeNumbersSum(number: Int) -> Int {
    var sum = 0
    for number in 2...number {
        if isPrime(number: number) {
            sum += number
        }
    }
    return sum
}

// Return a sum of all prime numbers less than a given number
// primeNumbersSum(100) == 1060
// primeNumbersSum(1000) == 11039
func primeNumbersSum(number: Int) -> Int {
    var sum = 0
    for number in 2...number {
        if isPrime(number: number) {
            sum += number
        }
    }
    return sum
}

// Return a sum of all prime numbers less than a given number
// primeNumbersSum(100) == 1060
// primeNumbersSum(1000) == 11039
func primeNumbersSum(number: Int) -> Int {
    var sum = 0
    for number in 2...number {
        if isPrime(number: number) {
            sum += number
        }
    }
    return sum
}

// Return a sum of all prime numbers less than a given number
// primeNumbersSum(100) == 1060
// primeNumbersSum(1000) == 11039
func primeNumbersSum(number: Int) -> Int {
    var sum = 0
    for number in 2...number {
        if isPrime(number: number) {
            sum += number
        }
    }
    return sum
}

// Return a sum of all prime numbers less than a given number
// primeNumbersSum(100) == 1060
// primeNumbersSum(1000) == 11039
func primeNumbersSum(number: Int) -> Int {
    var sum = 0
    for number in 2...number {
        if isPrime(number: number) {
            sum += number
        }
    }
    return sum
}

// Return a sum of all prime numbers less than a given number
// primeNumbersSum(100) == 1060
// primeNumbersSum(1000) == 11039
func primeNumbersSum(number: Int) -> Int {
    var sum = 0
    for number in 2...number {
        if isPrime(number: number) {
            sum += number
        }
    }
    return sum
}

// Return a sum of all prime numbers less than a given number
// primeNumbersSum(100) == 1060
// primeNumbersSum(1000) == 11039
func primeNumbersSum(number: Int) -> Int {
    var sum = 0
    for number in 2...number {
        if isPrime(number: number) {
            sum += number
        }
    }
    return sum
}

// Return a sum of all prime numbers less than a given number
// primeNumbersSum(100) == 1060
// primeNumbersSum(1000) == 110

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 leastCommonMultiple(a: Int, b: Int) -> Int {
  return a * b / greatestCommonDivisor(a: a, b: b)
}

func primeNumbers(from: Int, to: Int) -> [Int] {
  var primes = [Int]()
  for i in from...to {
    var isPrime = true
    for j in 2..<i {
      if i % j == 0 {
        isPrime = false
        break
      }
    }
    if isPrime {
      primes.append(i)
    }
  }
  return primes
}

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

```swift
// Return 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
}

// Return a least common multiple of two integers a and b
// leastCommonMultiple(a: 3, b: 5) == 15
// leastCommonMultiple(a: 25, b: 15) == 60
func leastCommonMultiple(a: Int, b: Int) -> Int {
  return a * b / greatestCommonDivisor(a: a, b: b)
}

// Return a list of all prime numbers in a given range
// primeNumbers(from: 1, to: 10) == [2, 3, 5, 7]
func primeNumbers(from: Int, to: Int) -> [Int] {
  var primes = [Int]()
  for i in from...to {
    var isPrime = true
    for j in 2..<i {
      if i % j == 0 {
        isPrime = false
        break
      }
    }
    if isPrime {
      primes.append(i)
    }
  }
  return primes
}

// Return a list of all prime factors of a given number
// primeFactors(of: 30) == [2, 3, 5]
func primeFactors(of: Int) -> [Int] {
  var factors = [Int]()
  var number = of
  var i = 2
  while i * i <= number {
    if number % i == 0 {
      factors.append(i)
      number /= i
    } else {
      i += 1
    }
  }
  if number > 1 {
    factors.append(number)
  }
  return factors
}

// Return a list of all prime numbers in a given range
// primeNumbers(from: 1, to: 10) == [2, 3, 5, 7]
func primeNumbers(from: Int, to: Int) -> [Int] {
  var primes = [Int]()
  for i in from...to {
    var isPrime = true
    for j in 2..<i {
      if i % j == 0 {
        isPrime = false
        break
      }
    }
    if isPrime {
      primes.append(i)
    }
  }
  return primes
}

// Return a list of all prime factors of a given number
// primeFactors(of: 30) == [2, 3, 5]
func primeFactors(of: Int) -> [Int] {
  var factors = [Int]()
  var number = of
  var i = 2
  while i * i <= number {
    if number % i == 0 {
      factors.append(i)
      number /= i
    } else {
      i += 1
    }
  }
  if number > 1 {
    factors.append(number)
  }
  return factors
}

// Return a list of all prime numbers in a given range
// primeNumbers(from: 1, to: 10) == [2, 3, 5, 7]
func primeNumbers(from: Int, to: Int) -> [Int] {
  var primes = [Int]()
  for i in from...to {
    var isPrime = true
    for j in 2..<i {
      if i % j == 0 {
        isPrime = false
        break
      }
    }
    if isPrime {
      primes.append(i)
    }
  }
  return primes
}

// Return a list of all prime factors of a given number
// primeFactors(of: 30) == [2, 3, 5]
func primeFactors(of: Int) -> [Int] {
  var factors = [Int]()
  var number = of
  var i = 2
  while i * i <= number {
    if number % i == 0 {
      factors.append(i)
      number /= i
    } else {
      i += 1
    }
  }
  if number > 1 {
    factors.append(number)
  }
  return factors
}

// Return a list of all prime numbers in a given range
// primeNumbers(from: 1

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 leastCommonMultiple(a: Int, b: Int) -> Int {
    return a * b / greatestCommonDivisor(a: a, b: b)
}

func sum(a: Int, b: Int) -> Int {
    return a + b
}

func difference(a: Int, b: Int) -> Int {
    return a - b
}

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

func quotient(a: Int, b: Int) -> Int {
    return a / b
}

func remainder(a: Int, b: Int) -> Int {
    return a % b
}

func power(a: Int, b: Int) -> Int {
    var result = 1
    for _ in 1...b {
        result *= a
    }
    return result
}

func factorial(a: Int) -> Int {
    var result = 1
    for i in 1...a {
        result *= i
    }
    return result
}

func sumOfDigits(a: Int) -> Int {
    var result = 0
    var temp = a
    while temp > 0 {
        result += temp % 10
        temp /= 10
    }
    return result
}

func productOfDigits(a: Int) -> Int {
    var result = 1
    var temp = a
    while temp > 0 {
        result *= temp % 10
        temp /= 10
    }
    return result
}

func reverse(a: Int) -> Int {
    var result = 0
    var temp = a
    while temp > 0 {
        result = result * 10 + temp % 10
        temp /= 10
    }
    return result
}

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

// Return a least common multiple of two integers a and b
// leastCommonMultiple(a: 3, b: 5) == 15
// leastCommonMultiple(a: 25, b: 15) == 75
func leastCommonMultiple(a: Int, b: Int) -> Int {
    return a * b / greatestCommonDivisor(a: a, b: b)
}

// Return a sum of two integers a and b
// sum(a: 3, b: 5) == 8
func sum(a: Int, b: Int) -> Int {
    return a + b
}

// Return a difference of two integers a and b
// difference(a: 3, b: 5) == -2
func difference(a: Int, b: Int) -> Int {
    return a - b
}

// Return a product of two integers a and b
// product(a: 3, b: 5) == 15
func product(a: Int, b: Int) -> Int {
    return a * b
}

// Return a quotient of two integers a and b
// quotient(a: 3, b: 5) == 0
// quotient(a: 25, b: 15) == 1
func quotient(a: Int, b: Int) -> Int {
    return a / b
}

// Return a remainder of two integers a and b
// remainder(a: 3, b: 5) == 3
// remainder(a: 25, b: 15) == 0
func remainder(a: Int, b: Int) -> Int {
    return a % b
}

// Return a power of two integers a and b
// power(a: 3, b: 5) == 243
// power(a: 25, b: 15) == 15625
func power(a: Int, b: Int) -> Int {
    var result = 1
    for _ in 1...b {
        result *= a
    }
    return result
}

// Return a factorial of an integer a
// factorial(a: 3) == 6
// factorial(a: 5) == 120
func factorial(a: Int) -> Int {
    var result = 1
    for i in 1...a {
        result *= i
    }
    return result
}

// Return a sum of digits of an integer a
// sumOfDigits(a: 3) == 3
// sumOfDigits(a: 123) == 6
func sumOfDigits(a: Int) -> Int {
    var result = 0
    var temp = a
    while temp > 0 {
        result += temp % 10
        temp /= 10
    }
    return result
}

// Return a product of digits of an integer a
// productOfDigits(a: 3) == 3
// productOfDigits(a: 123) == 6
func productOfDigits(a: Int) -> Int {
    var result = 1
    var temp = a
    while temp > 0 {
        result *= temp % 10
        temp /= 10
    }
    return result
}

// Return a reverse of an integer a
// reverse(a: 3) == 3
// reverse(a: 123) == 321
func reverse(a: Int) -> Int {
    var result = 0
    var temp = a
    while temp > 0 {
        result = result * 10 + temp % 10
        temp /= 10
    }
    return result
}

// Return a sum of digits of an integer a
// sumOfDigits(a: 3) == 3
// sumOfDigits(a: 123) == 6
func sumOfDigits(a: Int) -> Int {
    var result = 0
    var temp = a
    while temp > 0 {
        result += temp % 10
        temp /= 10
    }
    return result
}

// Return a product of digits of an integer 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
}

func leastCommonMultiple(a: Int, b: Int) -> Int {
    return a * b / greatestCommonDivisor(a: a, b: b)
}

func primeNumbers(n: Int) -> [Int] {
    var primes = [Int]()
    for i in 2...n {
        var isPrime = true
        for j in 2..<i {
            if i % j == 0 {
                isPrime = false
                break
            }
        }
        if isPrime {
            primes.append(i)
        }
    }
    return primes
}

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

// Return a least common multiple of two integers a and b
// leastCommonMultiple(a: 3, b: 5) == 15
// leastCommonMultiple(a: 25, b: 15) == 75
func leastCommonMultiple(a: Int, b: Int) -> Int {
    return a * b / greatestCommonDivisor(a: a, b: b)
}

// Return a list of all prime numbers in the range from 2 to n
// primeNumbers(n: 10) == [2, 3, 5, 7]
func primeNumbers(n: Int) -> [Int] {
    var primes = [Int]()
    for i in 2...n {
        var isPrime = true
        for j in 2..<i {
            if i % j == 0 {
                isPrime = false
                break
            }
        }
        if isPrime {
            primes.append(i)
        }
    }
    return primes
}

// Return a list of all prime numbers in the range from 2 to n
// primeNumbers(n: 10) == [2, 3, 5, 7]
func primeNumbers(n: Int) -> [Int] {
    var primes = [Int]()
    for i in 2...n {
        var isPrime = true
        for j in 2..<i {
            if i % j == 0 {
                isPrime = false
                break
            }
        }
        if isPrime {
            primes.append(i)
        }
    }
    return primes
}

// Return a list of all prime numbers in the range from 2 to n
// primeNumbers(n: 10) == [2, 3, 5, 7]
func primeNumbers(n: Int) -> [Int] {
    var primes = [Int]()
    for i in 2...n {
        var isPrime = true
        for j in 2..<i {
            if i % j == 0 {
                isPrime = false
                break
            }
        }
        if isPrime {
            primes.append(i)
        }
    }
    return primes
}

// Return a list of all prime numbers in the range from 2 to n
// primeNumbers(n: 10) == [2, 3, 5, 7]
func primeNumbers(n: Int) -> [Int] {
    var primes = [Int]()
    for i in 2...n {
        var isPrime = true
        for j in 2..<i {
            if i % j == 0 {
                isPrime = false
                break
            }
        }
        if isPrime {
            primes.append(i)
        }
    }
    return primes
}

// Return a list of all prime numbers in the range from 2 to n
// primeNumbers(n: 10) == [2, 3, 5, 7]
func primeNumbers(n: Int) -> [Int] {
    var primes = [Int]()
    for i in 2...n {
        var isPrime = true
        for j in 2..<i {
            if i % j == 0 {
                isPrime = false
                break
            }
        }
        if isPrime {
            primes.append(i)
        }
    }
    return primes
}

// Return a list of all prime numbers in the range from 2 to n
// primeNumbers(n: 10) == [2, 3, 5, 7]
func primeNumbers(n: Int) -> [Int] {
    var primes = [Int]()
    for i in 2...n {
        var isPrime = true
        for j in 2..<i {
            if i % j == 0 {
                isPrime = false
                break
            }
        }
        if isPrime {
            primes.append(i)
        }
    }
    return primes
}

// Return a list of all prime numbers in the range from 2 to n
// primeNumbers(n: 10) == [2, 3, 5, 7]
func

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

func leastCommonMultiple(a: Int, b: Int) -> Int {
    return a * b / greatestCommonDivisor(a: a, b: b)
}

func sum(a: Int, b: Int) -> Int {
    return a + b
}

func difference(a: Int, b: Int) -> Int {
    return a - b
}

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

func quotient(a: Int, b: Int) -> Int {
    return a / b
}

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

// Return a least common multiple of two integers a and b
// leastCommonMultiple(a: 3, b: 5) == 15
// leastCommonMultiple(a: 25, b: 15) == 60
func leastCommonMultiple(a: Int, b: Int) -> Int {
    return a * b / greatestCommonDivisor(a: a, b: b)
}

// Return a sum of two integers a and b
// sum(a: 3, b: 5) == 8
func sum(a: Int, b: Int) -> Int {
    return a + b
}

// Return a difference of two integers a and b
// difference(a: 3, b: 5) == -2
func difference(a: Int, b: Int) -> Int {
    return a - b
}

// Return a product of two integers a and b
// product(a: 3, b: 5) == 15
func product(a: Int, b: Int) -> Int {
    return a * b
}

// Return a quotient of two integers a and b
// quotient(a: 3, b: 5) == 0
// quotient(a: 25, b: 15) == 1
func quotient(a: Int, b: Int) -> Int {
    return a / b
}

// Return a remainder of two integers a and b
// remainder(a: 3, b: 5) == 3
// remainder(a: 25, b: 15) == 0
func remainder(a: Int, b: Int) -> Int {
    return a % b
}

// Return a sum of two integers a and b
// sum(a: 3, b: 5) == 8
func sum(a: Int, b: Int) -> Int {
    return a + b
}

// Return a difference of two integers a and b
// difference(a: 3, b: 5) == -2
func difference(a: Int, b: Int) -> Int {
    return a - b
}

// Return a product of two integers a and b
// product(a: 3, b: 5) == 15
func product(a: Int, b: Int) -> Int {
    return a * b
}

// Return a quotient of two integers a and b
// quotient(a: 3, b: 5) == 0
// quotient(a: 25, b: 15) == 1
func quotient(a: Int, b: Int) -> Int {
    return a / b
}

// Return a remainder of two integers a and b
// remainder(a: 3, b: 5) == 3
// remainder(a: 25, b: 15) == 0
func remainder(a: Int, b: Int) -> Int {
    return a % b
}

// Return a sum of two integers a and b
// sum(a: 3, b: 5) == 8
func sum(a: Int, b: Int) -> Int {
    return a + b
}

// Return a difference of two integers a and b
// difference(a: 3, b: 5) == -2
func difference(a: Int, b: Int) -> Int {
    return a - b
}

// Return a product of two integers a and b
// product(a: 3, b: 5) == 15
func product(a: Int, b: Int) -> Int {
    return a * b
}

// Return a quotient of two integers a and b
// quotient(a: 3, b: 5) == 0
// quotient(a: 25, b: 15) == 1
func quotient(a: Int, b: Int) -> Int {
    return a / b
}

// Return a remainder of two integers a and b
// remainder(a: 3, b: 5) == 3
// remainder(a: 25, b: 15) == 0
func remainder(a: Int, b: Int) -> Int {
    return 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
}

func leastCommonMultiple(a: Int, b: Int) -> Int {
    return a * b / greatestCommonDivisor(a: a, b: b)
}

func sum(a: Int, b: Int) -> Int {
    return a + b
}

func difference(a: Int, b: Int) -> Int {
    return a - b
}

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

func quotient(a: Int, b: Int) -> Int {
    return a / b
}

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

// Return a least common multiple of two integers a and b
// leastCommonMultiple(a: 3, b: 5) == 15
// leastCommonMultiple(a: 25, b: 15) == 75
func leastCommonMultiple(a: Int, b: Int) -> Int {
    return a * b / greatestCommonDivisor(a: a, b: b)
}

// Return a sum of two integers a and b
// sum(a: 3, b: 5) == 8
func sum(a: Int, b: Int) -> Int {
    return a + b
}

// Return a difference of two integers a and b
// difference(a: 3, b: 5) == -2
func difference(a: Int, b: Int) -> Int {
    return a - b
}

// Return a product of two integers a and b
// product(a: 3, b: 5) == 15
func product(a: Int, b: Int) -> Int {
    return a * b
}

// Return a quotient of two integers a and b
// quotient(a: 3, b: 5) == 0
// quotient(a: 25, b: 15) == 1
func quotient(a: Int, b: Int) -> Int {
    return a / b
}

// Return a remainder of two integers a and b
// remainder(a: 3, b: 5) == 3
// remainder(a: 25, b: 15) == 0
func remainder(a: Int, b: Int) -> Int {
    return a % b
}

// Return a sum of two integers a and b
// sum(a: 3, b: 5) == 8
func sum(a: Int, b: Int) -> Int {
    return a + b
}

// Return a difference of two integers a and b
// difference(a: 3, b: 5) == -2
func difference(a: Int, b: Int) -> Int {
    return a - b
}

// Return a product of two integers a and b
// product(a: 3, b: 5) == 15
func product(a: Int, b: Int) -> Int {
    return a * b
}

// Return a quotient of two integers a and b
// quotient(a: 3, b: 5) == 0
// quotient(a: 25, b: 15) == 1
func quotient(a: Int, b: Int) -> Int {
    return a / b
}

// Return a remainder of two integers a and b
// remainder(a: 3, b: 5) == 3
// remainder(a: 25, b: 15) == 0
func remainder(a: Int, b: Int) -> Int {
    return a % b
}

// Return a sum of two integers a and b
// sum(a: 3, b: 5) == 8
func sum(a: Int, b: Int) -> Int {
    return a + b
}

// Return a difference of two integers a and b
// difference(a: 3, b: 5) == -2
func difference(a: Int, b: Int) -> Int {
    return a - b
}

// Return a product of two integers a and b
// product(a: 3, b: 5) == 15
func product(a: Int, b: Int) -> Int {
    return a * b
}

// Return a quotient of two integers a and b
// quotient(a: 3, b: 5) == 0
// quotient(a: 25, b: 15) == 1
func quotient(a: Int, b: Int) -> Int {
    return a / b
}

// Return a remainder of two integers a and b
// remainder(a: 3, b: 5) == 3
// remainder(a: 25, b: 15) == 0
func remainder(a: Int, b: Int) -> Int {
    return a % b
}

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

func leastCommonMultiple(a: Int, b: Int) -> Int {
    return a * b / greatestCommonDivisor(a: a, b: b)
}

func sum(a: Int, b: Int) -> Int {
    return a + b
}

func difference(a: Int, b: Int) -> Int {
    return a - b
}

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

func quotient(a: Int, b: Int) -> Int {
    return a / b
}

func remainder(a: Int, b: Int) -> Int {
    return a % b
}

func sum(a: Int, b: Int) -> Int {
    var sum = 0
    for i in a...b {
        sum += i
    }
    return sum
}

func difference(a: Int, b: Int) -> Int {
    var difference = 0
    for i in a...b {
        difference -= i
    }
    return difference
}

func product(a: Int, b: Int) -> Int {
    var product = 1
    for i in a...b {
        product *= i
    }
    return product
}

func quotient(a: Int, b: Int) -> Int {
    var quotient = 0
    for i in a...b {
        quotient += i
    }
    return quotient
}

func remainder(a: Int, b: Int) -> Int {
    var remainder = 0
    for i in a...b {
        remainder += i
    }
    return remainder
}

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

// Return a least common multiple of two integers a and b
// leastCommonMultiple(a: 3, b: 5) == 15
// leastCommonMultiple(a: 25, b: 15) == 75
func leastCommonMultiple(a: Int, b: Int) -> Int {
    return a * b / greatestCommonDivisor(a: a, b: b)
}

// Return a sum of two integers a and b
// sum(a: 3, b: 5) == 8
func sum(a: Int, b: Int) -> Int {
    return a + b
}

// Return a difference of two integers a and b
// difference(a: 3, b: 5) == -2
func difference(a: Int, b: Int) -> Int {
    return a - b
}

// Return a product of two integers a and b
// product(a: 3, b: 5) == 15
func product(a: Int, b: Int) -> Int {
    return a * b
}

// Return a quotient of two integers a and b
// quotient(a: 3, b: 5) == 0
// quotient(a: 25, b: 15) == 1
func quotient(a: Int, b: Int) -> Int {
    return a / b
}

// Return a remainder of two integers a and b
// remainder(a: 3, b: 5) == 3
// remainder(a: 25, b: 15) == 0
func remainder(a: Int, b: Int) -> Int {
    return a % b
}

// Return a sum of all integers from a to b
// sum(a: 3, b: 5) == 12
// sum(a: 25, b: 15) == 105
func sum(a: Int, b: Int) -> Int {
    var sum = 0
    for i in a...b {
        sum += i
    }
    return sum
}

// Return a difference of all integers from a to b
// difference(a: 3, b: 5) == -6
// difference(a: 25, b: 15) == 100
func difference(a: Int, b: Int) -> Int {
    var difference = 0
    for i in a...b {
        difference -= i
    }
    return difference
}

// Return a product of all integers from a to b
// product(a: 3, b: 5) == 60
// product(a: 25, b: 15) == 1500
func product(a: Int, b: Int) -> Int {
    var product = 1
    for i in a...b {
        product *= i
    }
    return product
}

// Return a quotient of all integers from a to b
// quotient(a: 3, b: 5) == 3
// quotient(a: 25, b: 15) == 3
func quotient(a: Int, b: Int) -> Int {
    var quotient = 0
    for i in a...b {
        quotient += i
    }
    return quotient
}

// Return a remainder of all integers from a to b
// remainder(a: 3, b: 5) == 3
// remainder(a: 25, b: 15) == 0
func remainder(a: Int, b: Int) -> Int {
    var remainder = 0
    for i in a...b {
        remainder += i
    }
    return remainder
}

// Return a sum of all even integers from a to b
// sum(a: 3, b: 5) == 6
// sum(a: 25, b: 15) == 105
func sum(a: Int, b: Int) -> Int {
    var sum = 0
    for i in

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

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

func sumOfDigits(number: Int) -> Int {
    var number = number
    var sum = 0
    while number > 0 {
        sum += number % 10
        number /= 10
    }
    return sum
}

```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 t = b
        b = a % b
        a = t
    }
    return a
}

// Return the sum of the digits of a positive integer
// sumOfDigits(1234) == 10
// sumOfDigits(999) == 27
func sumOfDigits(number: Int) -> Int {
    var number = number
    var sum = 0
    while number > 0 {
        sum += number % 10
        number /= 10
    }
    return sum
}

// Return the sum of the digits of a positive integer
// sumOfDigits(1234) == 10
// sumOfDigits(999) == 27
func sumOfDigits(number: Int) -> Int {
    var number = number
    var sum = 0
    while number > 0 {
        sum += number % 10
        number /= 10
    }
    return sum
}

// Return the sum of the digits of a positive integer
// sumOfDigits(1234) == 10
// sumOfDigits(999) == 27
func sumOfDigits(number: Int) -> Int {
    var number = number
    var sum = 0
    while number > 0 {
        sum += number % 10
        number /= 10
    }
    return sum
}

// Return the sum of the digits of a positive integer
// sumOfDigits(1234) == 10
// sumOfDigits(999) == 27
func sumOfDigits(number: Int) -> Int {
    var number = number
    var sum = 0
    while number > 0 {
        sum += number % 10
        number /= 10
    }
    return sum
}

// Return the sum of the digits of a positive integer
// sumOfDigits(1234) == 10
// sumOfDigits(999) == 27
func sumOfDigits(number: Int) -> Int {
    var number = number
    var sum = 0
    while number > 0 {
        sum += number % 10
        number /= 10
    }
    return sum
}

// Return the sum of the digits of a positive integer
// sumOfDigits(1234) == 10
// sumOfDigits(999) == 27
func sumOfDigits(number: Int) -> Int {
    var number = number
    var sum = 0
    while number > 0 {
        sum += number % 10
        number /= 10
    }
    return sum
}

// Return the sum of the digits of a positive integer
// sumOfDigits(1234) == 10
// sumOfDigits(999) == 27
func sumOfDigits(number: Int) -> Int {
    var number = number
    var sum = 0
    while number > 0 {
        sum += number % 10
        number /= 10
    }
    return sum
}

// Return the sum of the digits of a positive integer
// sumOfDigits(1234) == 10
// sumOfDigits(999) == 27
func sumOfDigits(number: Int) -> Int {
    var number = number
    var sum = 0
    while number > 0 {
        sum += number % 10
        number /= 10
    }
    return sum
}

// Return the sum of the digits of a positive integer
// sumOfDigits(1234) == 10
// sumOfDigits(999) == 27
func sumOfDigits(number: Int) -> Int {
    var number = number
    var sum = 0
    while number > 0 {
        sum += number % 10
        number /= 10
    }
    return sum
}

// Return the sum of the digits of a positive integer
// sumOfDigits(1234) == 10
// sumOfDigits(999) == 27
func sumOfDigits(number: Int) -> Int {
    var number = number
    var sum = 0
    while number > 0 {
        

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 leastCommonMultiple(a: Int, b: Int) -> Int {
    return a * b / greatestCommonDivisor(a: a, b: b)
}

func primeNumbers(n: Int) -> [Int] {
    var primes = [2]
    var i = 3
    while i <= n {
        var isPrime = true
        for j in 0..<primes.count {
            if i % primes[j] == 0 {
                isPrime = false
                break
            }
        }
        if isPrime {
            primes.append(i)
        }
        i += 2
    }
    return primes
}

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

func perfectNumbers(n: Int) -> [Int] {
    var perfectNumbers = [Int]()
    for i in 1..<n {
        var sum = 0
        for j in 1..<i {
            if i % j == 0 {
                sum += j
            }
        }
        if sum == i {
            perfectNumbers.append(i)
        }
    }
    return perfectNumbers
}

func perfectSquares(n: Int) -> [Int] {
    var perfectSquares = [Int]()
    for i in 1..<n {
        var j = 1
        while j * j <= i {
            if j * j == i {
                perfectSquares.append(i)
                break
            }
            j += 1
        }
    }
    return perfectSquares
}

func perfectCubes(n: Int) -> [Int] {
    var perfectCubes = [Int]()
    for i in 1..<n {
        var j = 1
        while j * j * j <= i {
            if j * j * j == i {
                perfectCubes.append(i)
                break
            }
            j += 1
        }
    }
    return perfectCubes
}

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

// Return a least common multiple of two integers a and b
// leastCommonMultiple(a: 3, b: 5) == 15
// leastCommonMultiple(a: 25, b: 15) == 75
func leastCommonMultiple(a: Int, b: Int) -> Int {
    return a * b / greatestCommonDivisor(a: a, b: b)
}

// Return a list of all prime numbers in the range [1, n]
// primeNumbers(n: 10) == [2, 3, 5, 7]
func primeNumbers(n: Int) -> [Int] {
    var primes = [2]
    var i = 3
    while i <= n {
        var isPrime = true
        for j in 0..<primes.count {
            if i % primes[j] == 0 {
                isPrime = false
                break
            }
        }
        if isPrime {
            primes.append(i)
        }
        i += 2
    }
    return primes
}

// Return a list of all prime factors of a given number n
// primeFactors(n: 315) == [3, 3, 5, 7]
// primeFactors(n: 100) == [2, 2, 5, 5]
func primeFactors(n: Int) -> [Int] {
    var factors = [Int]()
    var num = n
    var i = 2
    while i * i <= num {
        while num % i == 0 {
            factors.append(i)
            num /= i
        }
        i += 1
    }
    if num > 1 {
        factors.append(num)
    }
    return factors
}

// Return a list of all perfect numbers in the range [1, n]
// perfectNumbers(n: 100) == [6, 28, 496]
func perfectNumbers(n: Int) -> [Int] {
    var perfectNumbers = [Int]()
    for i in 1..<n {
        var sum = 0
        for j in 1..<i {
            if i % j == 0 {
                sum += j
            }
        }
        if sum == i {
            perfectNumbers.append(i)
        }
    }
    return perfectNumbers
}

// Return a list of all perfect squares in the range [1, n]
// perfectSquares(n: 100) == [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
func perfectSquares(n: Int) -> [Int] {
    var perfectSquares = [Int]()
    for i in 1..<n {
        var j = 1
        while j * j <= i {
            if j * j == i {
                perfectSquares.append(i)
                break
            }
            j += 1
        }
    }
    return perfectSquares
}

// Return a list of all perfect cubes in the range [1, n]
// perfectCubes(n: 100) == [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
func perfectCubes(n: Int) -> [Int] {
    var perfectCubes = [Int]()
    for i in 1..<n {
        var j = 1
        while j * j * j <= i {
            if j * j * j == i {
                perfectCubes.append(i)
                break
            }
            j += 1
        }
    }
    return perfectCubes
}

// Return a list of all perfect numbers in the range [1, n] that are also perfect squares
// perfectNumbers(n: 100) == [6, 28, 496]
func perfectNumbers(n: Int) -> [Int] {
    var perfectNumbers = [Int]()
    for i in 1..<n {
        

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

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

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

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

func permutations(string: String) -> [String] {
  var permutations = [String]()
  for i in 0..<string.count {
    for j in 0..<string.count {
      if i != j {
        permutations.append(string.substring(from: i).substring(to: j) + string.substring(from: j))
      }
    }
  }
  return permutations
}

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

// 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.substring(from: i))
  }
  return suffixes
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
  var permutations = [String]()
  for i in 0..<string.count {
    for j in 0..<string.count {
      if i != j {
        permutations.append(string.substring(from: i).substring(to: j) + string.substring(from: j))
      }
    }
  }
  return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
  var permutations = [String]()
  for i in 0..<string.count {
    for j in 0..<string.count {
      if i != j {
        permutations.append(string.substring(from: i).substring(to: j) + string.substring(from: j))
      }
    }
  }
  return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
  var permutations = [String]()
  for i in 0..<string.count {
    for j in 0..<string.count {
      if i != j {
        permutations.append(string.substring(from: i).substring(to: j) + string.substring(from: j))
      }
    }
  }
  return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
  var permutations = [String]()
  for i in 0..<string.count {
    for j in 0..<string.count {
      if i != j {
        permutations.append(string.substring(from: i).substring(to: j) + string.substring(from: j))
      }
    }
  }
  return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
  var permutations = [String]()
  for i in 0..<string.count {
    for j in 0..<string.count {
      if i != j {
        permutations.append(string.substring(from: i).substring(to: j) + string.substring(from: j))
      }
    }
  }
  return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
  var permutations = [String]()
  for i in 0..<string.count {
    for j in 0..<string.count {
      if i != j {
        permutations.append(string.substring(from: i).substring(to: j) + string.substring(from: j))
      }
    }
  }
  return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
  var permutations = [String]()
  for i in 0..<string.

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

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

func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

```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.substring(to: i)
        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.substring(from: i)
        suffixes.append(suffix)
    }
    return suffixes
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) ->

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

func allSuffixes(string: String) -> [String] {
    var result = [String]()
    for i in 1...string.count {
        result.append(string.substring(from: i))
    }
    return result
}

func permutations(string: String) -> [String] {
    var result = [String]()
    for i in 0..<string.count {
        let prefix = string.substring(to: i)
        let suffix = string.substring(from: i)
        for permutation in permutations(string: suffix) {
            result.append(prefix + permutation)
        }
    }
    return result
}

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

// Return array of all suffixes from shortest to longest of the input string
// allSuffixes(string: "abc") == ["a", "ab", "abc"]
func allSuffixes(string: String) -> [String] {
    var result = [String]()
    for i in 1...string.count {
        result.append(string.substring(from: i))
    }
    return result
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var result = [String]()
    for i in 0..<string.count {
        let prefix = string.substring(to: i)
        let suffix = string.substring(from: i)
        for permutation in permutations(string: suffix) {
            result.append(prefix + permutation)
        }
    }
    return result
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var result = [String]()
    for i in 0..<string.count {
        let prefix = string.substring(to: i)
        let suffix = string.substring(from: i)
        for permutation in permutations(string: suffix) {
            result.append(prefix + permutation)
        }
    }
    return result
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var result = [String]()
    for i in 0..<string.count {
        let prefix = string.substring(to: i)
        let suffix = string.substring(from: i)
        for permutation in permutations(string: suffix) {
            result.append(prefix + permutation)
        }
    }
    return result
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var result = [String]()
    for i in 0..<string.count {
        let prefix = string.substring(to: i)
        let suffix = string.substring(from: i)
        for permutation in permutations(string: suffix) {
            result.append(prefix + permutation)
        }
    }
    return result
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var result = [String]()
    for i in 0..<string.count {
        let prefix = string.substring(to: i)
        let suffix = string.substring(from: i)
        for permutation in permutations(string: suffix) {
            result.append(prefix + permutation)
        }
    }
    return result
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var result = [String]()
    for i in 0..<string.count {
        let prefix = string.substring(to: i)
        let suffix = string.substring(from: i)
        for permutation in permutations(string: suffix) {
            result.append(prefix + permutation)
        }
    }
    return result
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var result = [String]()
    for i in 0..<string.count {
        let prefix = string.substring(to: i)
        let suffix = string.substring(from

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

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

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

func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0...string.count {
        suffixes.append(string.substring(with: NSMakeRange(i, string.count - i)))
    }
    return suffixes
}

func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0...string.count {
        for j in 0...string.count {
            if i != j {
                permutations.append(string.substring(with: NSMakeRange(i, j)))
            }
        }
    }
    return permutations
}

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

// Return array of all suffixes from shortest to longest of the input string
// allSuffixes(string: "abc") == ["a", "ab", "abc"]
func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0...string.count {
        suffixes.append(string.substring(with: NSMakeRange(i, string.count - i)))
    }
    return suffixes
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0...string.count {
        for j in 0...string.count {
            if i != j {
                permutations.append(string.substring(with: NSMakeRange(i, j)))
            }
        }
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0...string.count {
        for j in 0...string.count {
            if i != j {
                permutations.append(string.substring(with: NSMakeRange(i, j)))
            }
        }
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0...string.count {
        for j in 0...string.count {
            if i != j {
                permutations.append(string.substring(with: NSMakeRange(i, j)))
            }
        }
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0...string.count {
        for j in 0...string.count {
            if i != j {
                permutations.append(string.substring(with: NSMakeRange(i, j)))
            }
        }
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0...string.count {
        for j in 0...string.count {
            if i != j {
                permutations.append(string.substring(with: NSMakeRange(i, j)))
            }
        }
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0...string.count {
        for j in 0...string.count {
            if i != j {
                permutations.append(string.substring(with: NSMakeRange(i, j)))
            }
        }
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0...string.count {
        for j in 0...string.count {
            if i != j {
                permutations.append(string.substring(with: NSMakeRange(

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

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

func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

```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.substring(to: i)
        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.substring(from: i)
        suffixes.append(suffix)
    }
    return suffixes
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        let permutation = string.substring(from: i)
        permutations.append(permutation)
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) ->

func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            if i <= j {
                prefixes.append(string.substring(with: Range(start: i, end: j+1)))
            }
        }
    }
    return prefixes
}

func allPermutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            if i <= j {
                let permutation = string.substring(with: Range(start: i, end: j+1))
                permutations.append(permutation)
            }
        }
    }
    return permutations
}

```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 {
        for j in 0..<string.count {
            if i <= j {
                prefixes.append(string.substring(with: Range(start: i, end: j+1)))
            }
        }
    }
    return prefixes
}

// Return array of all permutations of the input string
// allPermutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func allPermutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            if i <= j {
                let permutation = string.substring(with: Range(start: i, end: j+1))
                permutations.append(permutation)
            }
        }
    }
    return permutations
}

// Return array of all permutations of the input string
// allPermutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func allPermutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            if i <= j {
                let permutation = string.substring(with: Range(start: i, end: j+1))
                permutations.append(permutation)
            }
        }
    }
    return permutations
}

// Return array of all permutations of the input string
// allPermutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func allPermutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            if i <= j {
                let permutation = string.substring(with: Range(start: i, end: j+1))
                permutations.append(permutation)
            }
        }
    }
    return permutations
}

// Return array of all permutations of the input string
// allPermutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func allPermutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            if i <= j {
                let permutation = string.substring(with: Range(start: i, end: j+1))
                permutations.append(permutation)
            }
        }
    }
    return permutations
}

// Return array of all permutations of the input string
// allPermutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func allPermutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            if i <= j {
                let permutation = string.substring(with: Range(start: i, end: j+1))
                permutations.append(permutation)
            }
        }
    }
    return permutations
}

// Return array of all permutations of the input string
// allPermutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func allPermutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            if i <= j {
                let permutation = string.substring(with: Range(start: i, end: j+1))
                permutations.append(permutation)
            }
        }
    }
    return permutations
}

// Return array of all permutations of the input string
// allPermutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func allPermutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            if i <= j

func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    for i in 0...string.count {
        prefixes.append(string.substring(with: NSRange(location: 0, length: i)))
    }
    return prefixes
}

func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0...string.count {
        suffixes.append(string.substring(with: NSRange(location: i, length: string.count - i)))
    }
    return suffixes
}

func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0...string.count {
        for j in 0...string.count {
            if i != j {
                permutations.append(string.substring(with: NSRange(location: i, length: 1)) + string.substring(with: NSRange(location: j, length: 1)))
            }
        }
    }
    return permutations
}

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

// Return array of all suffixes from shortest to longest of the input string
// allSuffixes(string: "abc") == ["a", "ab", "abc"]
func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0...string.count {
        suffixes.append(string.substring(with: NSRange(location: i, length: string.count - i)))
    }
    return suffixes
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0...string.count {
        for j in 0...string.count {
            if i != j {
                permutations.append(string.substring(with: NSRange(location: i, length: 1)) + string.substring(with: NSRange(location: j, length: 1)))
            }
        }
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0...string.count {
        for j in 0...string.count {
            if i != j {
                permutations.append(string.substring(with: NSRange(location: i, length: 1)) + string.substring(with: NSRange(location: j, length: 1)))
            }
        }
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0...string.count {
        for j in 0...string.count {
            if i != j {
                permutations.append(string.substring(with: NSRange(location: i, length: 1)) + string.substring(with: NSRange(location: j, length: 1)))
            }
        }
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0...string.count {
        for j in 0...string.count {
            if i != j {
                permutations.append(string.substring(with: NSRange(location: i, length: 1)) + string.substring(with: NSRange(location: j, length: 1)))
            }
        }
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0...string.count {
        for j in 0...string.count {
            if i != j {
                permutations.append(string.substring(with: NSRange(location: i, length: 1)) + string.substring(with: NSRange(location: j, length: 1)))
            }
        }
    }
    return permutations
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var permutations = [String]()
    for i in 0...string.count {
        for j in 0...string.count {
            if i != j {
                permutations.append(string.substring

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

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

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

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

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

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var result = [String]()
    for i in 1...string.count {
        for j in 0...string.count - i {
            result.append(string.prefix(j) + string.suffix(i - j))
        }
    }
    return result
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var result = [String]()
    for i in 1...string.count {
        for j in 0...string.count - i {
            result.append(string.prefix(j) + string.suffix(i - j))
        }
    }
    return result
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var result = [String]()
    for i in 1...string.count {
        for j in 0...string.count - i {
            result.append(string.prefix(j) + string.suffix(i - j))
        }
    }
    return result
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var result = [String]()
    for i in 1...string.count {
        for j in 0...string.count - i {
            result.append(string.prefix(j) + string.suffix(i - j))
        }
    }
    return result
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var result = [String]()
    for i in 1...string.count {
        for j in 0...string.count - i {
            result.append(string.prefix(j) + string.suffix(i - j))
        }
    }
    return result
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var result = [String]()
    for i in 1...string.count {
        for j in 0...string.count - i {
            result.append(string.prefix(j) + string.suffix(i - j))
        }
    }
    return result
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {
    var result = [String]()
    for i in 1...string.count {
        for j in 0...string.count - i {
            result.append(string.prefix(j) + string.suffix(i - j))
        }
    }
    return result
}

// Return array of all permutations of the input string
// permutations(string: "abc") == ["abc", "acb", "bac", "bca", "cab", "cba"]
func permutations(string: String) -> [String] {

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
}

stringSequence(n: 5)
<|file_separator|>

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

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

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

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
}

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

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

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

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

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

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

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

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

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

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

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

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

func sum(n: Int) -> Int {
    var result = 0
    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
}

// Return the sum of all numbers from 0 to n inclusive.
// sum(n: 0) == 0
// sum(n: 5) == 15
func sum(n: Int) -> Int {
    var result = 0
    for i in 0...n {
        result += i
    }
    return result
}

// Return the sum of all numbers from 0 to n inclusive.
// sum(n: 0) == 0
// sum(n: 5) == 15
func sum(n: Int) -> Int {
    var result = 0
    for i in 0...n {
        result += i
    }
    return result
}

// Return the sum of all numbers from 0 to n inclusive.
// sum(n: 0) == 0
// sum(n: 5) == 15
func sum(n: Int) -> Int {
    var result = 0
    for i in 0...n {
        result += i
    }
    return result
}

// Return the sum of all numbers from 0 to n inclusive.
// sum(n: 0) == 0
// sum(n: 5) == 15
func sum(n: Int) -> Int {
    var result = 0
    for i in 0...n {
        result += i
    }
    return result
}

// Return the sum of all numbers from 0 to n inclusive.
// sum(n: 0) == 0
// sum(n: 5) == 15
func sum(n: Int) -> Int {
    var result = 0
    for i in 0...n {
        result += i
    }
    return result
}

// Return the sum of all numbers from 0 to n inclusive.
// sum(n: 0) == 0
// sum(n: 5) == 15
func sum(n: Int) -> Int {
    var result = 0
    for i in 0...n {
        result += i
    }
    return result
}

// Return the sum of all numbers from 0 to n inclusive.
// sum(n: 0) == 0
// sum(n: 5) == 15
func sum(n: Int) -> Int {
    var result = 0
    for i in 0...n {
        result += i
    }
    return result
}

// Return the sum of all numbers from 0 to n inclusive.
// sum(n: 0) == 0
// sum(n: 5) == 15
func sum(n: Int) -> Int {
    var result = 0
    for i in 0...n {
        result += i
    }
    return result
}

// Return the sum of all numbers from 0 to n inclusive.
// sum(n: 0) == 0
// sum(n: 5) == 15
func sum(n: Int) -> Int {
    var result = 0
    for i in 0...n {
        result += i
    }
    return result
}

// Return the sum of all numbers from 0 to n inclusive.
// sum(n: 0) == 0
// sum(n: 5) == 15
func sum(n: Int) -> Int {
    var result = 0
    for i in 0...n {
        result += i
    }
    return result
}

// Return the sum of all numbers from 0 to n inclusive.
// sum(n: 0) == 0
// sum(n: 5) == 15
func sum(n: Int) -> Int {
    var result = 0
    for i in 0...n {
        result += i
    }
    return result
}

// Return the sum of all numbers from 0 to n inclusive.
// sum(n: 0) == 0
// sum(n: 5) == 15
func sum(n: Int) -> Int {
    var result = 0
    for i in 0...n {
        result += i
    }
    return result
}

// Return the sum of all

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
}

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

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

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
}

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

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

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

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

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

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

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

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

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

// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5)

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

func countWords(string: String) -> Int {
    var words = 0
    var currentWord = ""
    for character in string {
        if character == " " {
            words += 1
            currentWord = ""
        } else {
            currentWord += character
        }
    }
    words += 1
    return words
}

func countWordsAndCharacters(string: String) -> (Int, Int) {
    var words = 0
    var characters = 0
    var currentWord = ""
    for character in string {
        if character == " " {
            words += 1
            currentWord = ""
        } else {
            currentWord += character
            characters += 1
        }
    }
    words += 1
    return (words, characters)
}

func countWordsAndCharactersAndDistinctCharacters(string: String) -> (Int, Int, Int) {
    var words = 0
    var characters = 0
    var distinctCharacters = Set<Character>()
    var currentWord = ""
    for character in string {
        if character == " " {
            words += 1
            currentWord = ""
        } else {
            currentWord += character
            characters += 1
            distinctCharacters.insert(character)
        }
    }
    words += 1
    return (words, characters, distinctCharacters.count)
}

func countWordsAndCharactersAndDistinctCharactersAndDistinctWords(string: String) -> (Int, Int, Int, Int) {
    var words = 0
    var characters = 0
    var distinctCharacters = Set<Character>()
    var distinctWords = Set<String>()
    var currentWord = ""
    for character in string {
        if character == " " {
            words += 1
            currentWord = ""
        } else {
            currentWord += character
            characters += 1
            distinctCharacters.insert(character)
            distinctWords.insert(currentWord)
        }
    }
    words += 1
    return (words, characters, distinctCharacters.count, distinctWords.count)
}

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

// Given a string, find out how many words are in it
// countWords(string: "xyzXYZ") == 1
// countWords(string: "Jerry") == 2
func countWords(string: String) -> Int {
    var words = 0
    var currentWord = ""
    for character in string {
        if character == " " {
            words += 1
            currentWord = ""
        } else {
            currentWord += character
        }
    }
    words += 1
    return words
}

// Given a string, find out how many words are in it, and how many characters are in it
// countWordsAndCharacters(string: "xyzXYZ") == (3, 6)
// countWordsAndCharacters(string: "Jerry") == (2, 7)
func countWordsAndCharacters(string: String) -> (Int, Int) {
    var words = 0
    var characters = 0
    var currentWord = ""
    for character in string {
        if character == " " {
            words += 1
            currentWord = ""
        } else {
            currentWord += character
            characters += 1
        }
    }
    words += 1
    return (words, characters)
}

// Given a string, find out how many words are in it, and how many characters are in it, and how many distinct characters are in it
// countWordsAndCharactersAndDistinctCharacters(string: "xyzXYZ") == (3, 6, 3)
// countWordsAndCharactersAndDistinctCharacters(string: "Jerry") == (2, 7, 4)
func countWordsAndCharactersAndDistinctCharacters(string: String) -> (Int, Int, Int) {
    var words = 0
    var characters = 0
    var distinctCharacters = Set<Character>()
    var currentWord = ""
    for character in string {
        if character == " " {
            words += 1
            currentWord = ""
        } else {
            currentWord += character
            characters += 1
            distinctCharacters.insert(character)
        }
    }
    words += 1
    return (words, characters, distinctCharacters.count)
}

// Given a string, find out how many words are in it, and how many characters are in it, and how many distinct characters are in it, and how many distinct words are in it
// countWordsAndCharactersAndDistinctCharactersAndDistinctWords(string: "xyzXYZ") == (3, 6, 3, 1)
// countWordsAndCharactersAndDistinctCharactersAndDistinctWords(string: "Jerry") == (2, 7, 4, 2)
func countWordsAndCharactersAndDistinctCharactersAndDistinctWords(string: String) -> (Int, Int, Int, Int) {
    var words = 0
    var characters = 0
    var distinctCharacters = Set<Character>()
    var distinctWords = Set<String>()
    var currentWord = ""
    for character in string {
        if character == " " {
            words += 1
            currentWord = ""
        } else {
            currentWord += character
            characters += 1
            distinctCharacters.insert(character)
            distinctWords.insert(currentWord)
        }
    }
    words += 1
    return (words, characters, distinctCharacters.count, distinctWords.count)
}

// Given a string, find out how many words are in it, and how many characters are in it, and how many distinct characters are in it, and how many distinct words are in it, and how many distinct characters in each word are in it
// countWordsAndCharactersAndDistinctCharactersAndDistinctWordsAndCharactersInWords(string: "xyzXYZ") == (3, 6, 3, 1, [3])
// countWordsAndCharactersAndDistinctCharactersAndDistinctWordsAndCharactersInWords(string: "Jerry") == (2, 7, 4, 2, [4])
func countWordsAndCharactersAndDistinctCharactersAndDistinctWordsAndCharactersInWords(string: String) -> (Int, Int, Int, Int, [Int]) {
    var words = 0
    var characters = 0
    var distinctCharacters = Set<Character>()
    var distinctWords = Set<String>()
    var charactersInWords = [Int]()
    var currentWord =

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

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

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

func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

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

// Given a string, find out how many words are in it
// countWords(string: "Hello, my name is Jerry") == 3
// countWords(string: "Jerry") == 1
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words are in it
// countWords(string: "Hello, my name is Jerry") == 3
// countWords(string: "Jerry") == 1
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words are in it
// countWords(string: "Hello, my name is Jerry") == 3
// countWords(string: "Jerry") == 1
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words are in it
// countWords(string: "Hello, my name is Jerry") == 3
// countWords(string: "Jerry") == 1
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words are in it
// countWords(string: "Hello, my name is Jerry") == 3
// countWords(string: "Jerry") == 1
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words are in it
// countWords(string: "Hello, my name is Jerry") == 3
// countWords(string: "Jerry") == 1
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words are in it
// countWords(string: "Hello, my name is Jerry") == 3
// countWords(string: "Jerry") == 1
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words are in it
// countWords(string: "Hello, my name is Jerry") == 3
// countWords(string: "Jerry") == 1
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words are in it
// countWords(string: "Hello, my name is Jerry") == 3
// countWords(string: "Jerry") == 1
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words are in it
// countWords(string: "Hello, my name is Jerry") == 3
// countWords(string: "Jerry") == 1
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words are in it
// countWords(string: "Hello, my name is Jerry") == 3
// countWords(string: "Jerry") == 1
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words are in it
// countWords(string: "Hello, my name is Jerry") == 3
// countWords(string: "Jerry") == 1
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words are in it
// countWords(string: "Hello, my name is Jerry") == 3
// countWords(string

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

func countVowels(string: String) -> Int {
  var vowels = 0
  for character in string {
    if character == "a" || character == "e" || character == "i" || character == "o" || character == "u" {
      vowels += 1
    }
  }
  return vowels
}

func countConsonants(string: String) -> Int {
  var consonants = 0
  for character in string {
    if character != "a" && character != "e" && character != "i" && character != "o" && character != "u" {
      consonants += 1
    }
  }
  return consonants
}

func countWords(string: String) -> Int {
  var words = 0
  var word = ""
  for character in string {
    if character == " " {
      words += 1
    } else {
      word += character
    }
  }
  words += 1
  return words
}

func countSentences(string: String) -> Int {
  var sentences = 0
  var sentence = ""
  for character in string {
    if character == "." || character == "?" || character == "!" {
      sentences += 1
    } else {
      sentence += character
    }
  }
  sentences += 1
  return sentences
}

func countWordsLongerThan(string: String, length: Int) -> Int {
  var words = 0
  var word = ""
  for character in string {
    if character == " " {
      if word.count > length {
        words += 1
      }
      word = ""
    } else {
      word += character
    }
  }
  if word.count > length {
    words += 1
  }
  return words
}

func countWordsShorterThan(string: String, length: Int) -> Int {
  var words = 0
  var word = ""
  for character in string {
    if character == " " {
      if word.count < length {
        words += 1
      }
      word = ""
    } else {
      word += character
    }
  }
  if word.count < length {
    words += 1
  }
  return words
}

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

// Given a string, find out how many vowels (a, e, i, o, u) does it consist of
// countVowels(string: "xyzXYZ") == 0
// countVowels(string: "Jerry") == 3
func countVowels(string: String) -> Int {
  var vowels = 0
  for character in string {
    if character == "a" || character == "e" || character == "i" || character == "o" || character == "u" {
      vowels += 1
    }
  }
  return vowels
}

// Given a string, find out how many consonants (all other characters) does it consist of
// countConsonants(string: "xyzXYZ") == 3
// countConsonants(string: "Jerry") == 3
func countConsonants(string: String) -> Int {
  var consonants = 0
  for character in string {
    if character != "a" && character != "e" && character != "i" && character != "o" && character != "u" {
      consonants += 1
    }
  }
  return consonants
}

// Given a string, find out how many words does it consist of
// countWords(string: "xyzXYZ") == 1
// countWords(string: "Jerry") == 1
func countWords(string: String) -> Int {
  var words = 0
  var word = ""
  for character in string {
    if character == " " {
      words += 1
    } else {
      word += character
    }
  }
  words += 1
  return words
}

// Given a string, find out how many sentences does it consist of
// countSentences(string: "xyzXYZ") == 1
// countSentences(string: "Jerry") == 1
func countSentences(string: String) -> Int {
  var sentences = 0
  var sentence = ""
  for character in string {
    if character == "." || character == "?" || character == "!" {
      sentences += 1
    } else {
      sentence += character
    }
  }
  sentences += 1
  return sentences
}

// Given a string, find out how many words are longer than a given length
// countWordsLongerThan(string: "xyzXYZ", length: 3) == 1
// countWordsLongerThan(string: "Jerry", length: 3) == 1
func countWordsLongerThan(string: String, length: Int) -> Int {
  var words = 0
  var word = ""
  for character in string {
    if character == " " {
      if word.count > length {
        words += 1
      }
      word = ""
    } else {
      word += character
    }
  }
  if word.count > length {
    words += 1
  }
  return words
}

// Given a string, find out how many words are shorter than a given length
// countWordsShorterThan(string: "xyzXYZ", length: 3) == 1
// countWordsShorterThan(string: "Jerry", length: 3) == 1
func countWordsShorterThan(string: String, length: Int) -> Int {
  var words = 0
  var word = ""
  for character in string {
    if character == " " {
      if word.count < length {
        words += 1
      }
      word = ""
    } else {
      word += character
    }
  }
  if word.count < length {
    words += 1
  }
  return words
}

// Given a string, find out how many words are longer than a given length
// countWordsLongerThan(string: "xyzXYZ", length: 3) == 1
// countWordsLongerThan(string: "Jerry", length: 3) == 1
func countWordsLongerThan(string: String, length: Int) -> Int {
  var words = 0
  var word = ""
  for character in string {
    if character == " " {
      if word.count > length {
        words += 1
      }
      word = ""
    } else {
      word += character
    }

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

func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

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

// Given a string, find out how many words it consists of
// countWords(string: "xyzXYZ") == 1
// countWords(string: "Jerry") == 2
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words it consists of
// countWords(string: "xyzXYZ") == 1
// countWords(string: "Jerry") == 2
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words it consists of
// countWords(string: "xyzXYZ") == 1
// countWords(string: "Jerry") == 2
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words it consists of
// countWords(string: "xyzXYZ") == 1
// countWords(string: "Jerry") == 2
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words it consists of
// countWords(string: "xyzXYZ") == 1
// countWords(string: "Jerry") == 2
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words it consists of
// countWords(string: "xyzXYZ") == 1
// countWords(string: "Jerry") == 2
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words it consists of
// countWords(string: "xyzXYZ") == 1
// countWords(string: "Jerry") == 2
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words it consists of
// countWords(string: "xyzXYZ") == 1
// countWords(string: "Jerry") == 2
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words it consists of
// countWords(string: "xyzXYZ") == 1
// countWords(string: "Jerry") == 2
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words it consists of
// countWords(string: "xyzXYZ") == 1
// countWords(string: "Jerry") == 2
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words it consists of
// countWords(string: "xyzXYZ") == 1
// countWords(string: "Jerry") == 2
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words it consists of
// countWords(string: "xyzXYZ") == 1
// countWords(string: "Jerry") == 2
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words it consists of
// countWords(string: "xyzXYZ") == 1
// countWords(string: "Jerry") == 2
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many words

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

func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

func countVowels(string: String) -> Int {
    let vowels = "aeiou"
    var vowelCount = 0
    for character in string {
        if vowels.contains(character) {
            vowelCount += 1
        }
    }
    return vowelCount
}

func countConsonants(string: String) -> Int {
    let consonants = "bcdfghjklmnpqrstvwxyz"
    var consonantCount = 0
    for character in string {
        if consonants.contains(character) {
            consonantCount += 1
        }
    }
    return consonantCount
}

func countDigits(string: String) -> Int {
    let digits = "0123456789"
    var digitCount = 0
    for character in string {
        if digits.contains(character) {
            digitCount += 1
        }
    }
    return digitCount
}

func countSpaces(string: String) -> Int {
    var spaceCount = 0
    for character in string {
        if character == " " {
            spaceCount += 1
        }
    }
    return spaceCount
}

func countSpecialCharacters(string: String) -> Int {
    let specialCharacters = "!@#$%^&*()_+-=[]{}|;':\",./<>?"
    var specialCharacterCount = 0
    for character in string {
        if specialCharacters.contains(character) {
            specialCharacterCount += 1
        }
    }
    return specialCharacterCount
}

func countUppercaseLetters(string: String) -> Int {
    let uppercaseLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var uppercaseLetterCount = 0
    for character in string {
        if uppercaseLetters.contains(character) {
            uppercaseLetterCount += 1
        }
    }
    return uppercaseLetterCount
}

func countLowercaseLetters(string: String) -> Int {
    let lowercaseLetters = "abcdefghijklmnopqrstuvwxyz"
    var lowercaseLetterCount = 0
    for character in string {
        if lowercaseLetters.contains(character) {
            lowercaseLetterCount += 1
        }
    }
    return lowercaseLetterCount
}

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

// Given a string, find out how many words are in it
// countWords(string: "Hello, my name is Jerry") == 3
// countWords(string: "Jerry") == 1
func countWords(string: String) -> Int {
    let words = string.components(separatedBy: " ")
    return words.count
}

// Given a string, find out how many vowels are in it
// countVowels(string: "Hello, my name is Jerry") == 4
// countVowels(string: "Jerry") == 0
func countVowels(string: String) -> Int {
    let vowels = "aeiou"
    var vowelCount = 0
    for character in string {
        if vowels.contains(character) {
            vowelCount += 1
        }
    }
    return vowelCount
}

// Given a string, find out how many consonants are in it
// countConsonants(string: "Hello, my name is Jerry") == 11
// countConsonants(string: "Jerry") == 0
func countConsonants(string: String) -> Int {
    let consonants = "bcdfghjklmnpqrstvwxyz"
    var consonantCount = 0
    for character in string {
        if consonants.contains(character) {
            consonantCount += 1
        }
    }
    return consonantCount
}

// Given a string, find out how many digits are in it
// countDigits(string: "Hello, my name is Jerry") == 0
// countDigits(string: "Jerry") == 0
func countDigits(string: String) -> Int {
    let digits = "0123456789"
    var digitCount = 0
    for character in string {
        if digits.contains(character) {
            digitCount += 1
        }
    }
    return digitCount
}

// Given a string, find out how many spaces are in it
// countSpaces(string: "Hello, my name is Jerry") == 1
// countSpaces(string: "Jerry") == 0
func countSpaces(string: String) -> Int {
    var spaceCount = 0
    for character in string {
        if character == " " {
            spaceCount += 1
        }
    }
    return spaceCount
}

// Given a string, find out how many special characters are in it
// countSpecialCharacters(string: "Hello, my name is Jerry") == 0
// countSpecialCharacters(string: "Jerry") == 0
func countSpecialCharacters(string: String) -> Int {
    let specialCharacters = "!@#$%^&*()_+-=[]{}|;':\",./<>?"
    var specialCharacterCount = 0
    for character in string {
        if specialCharacters.contains(character) {
            specialCharacterCount += 1
        }
    }
    return specialCharacterCount
}

// Given a string, find out how many uppercase letters are in it
// countUppercaseLetters(string: "Hello, my name is Jerry") == 0
// countUppercaseLetters(string: "Jerry") == 0
func countUppercaseLetters(string: String) -> Int {
    let uppercaseLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var uppercaseLetterCount = 0
    for character in string {
        if uppercaseLetters.contains(character) {
            uppercaseLetterCount += 1
        }
    }
    return uppercaseLetterCount
}

// Given a string, find out how many lowercase letters are in it
// countLowercaseLetters(string: "Hello, my name is Jerry") == 11
// countLowercaseLetters(string: "Jerry") == 0
func countLowercaseLetters(string: String) -> Int {
    let lowercaseLetters = "abcdefghijklmnopqrstuvwxyz"
    var lowercaseLetterCount = 0
    for character in string {
        if lowercaseLetters.contains(character) {
            lowercaseLetterCount += 1
        }
    }
    return lowercaseLetterCount
}

// Given a string, find out how many uppercase and lowercase letters are in it
// countLetters(string: "Hello, my name is Jerry") == 11
// countLetters(string: "Jerry") == 0
func countLetters(string: String) -> Int {
    let letters =

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

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

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

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

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

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

func countDistinctCharacters(string: String) -> Int {
    var distinctCharacters = [Character]()
    for character in string {
        if !distinctCharacters.contains(character) {
            distinctCharacters.append(character)
        }
    }
    return distinctCharacters.count
}

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

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

func parseNote(note: String) -> Int {
    switch note {
    case "o":
        return 4
    case "o|":
        return 2
    case ".":
        return 1
    case ".|":
        return 1
    default:
        return 0
    }
}

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

func parseNote(note: String) -> Int {
    switch note {
    case "o":
        return 4
    case "o|":
        return 2
    case ".":
        return 1
    case ".|":
        return 1
    default:
        return 0
    }
}
<|file_separator|>

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

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

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

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

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

func parseNote(note: String) -> Int {
    switch note {
    case "o":
        return 4
    case "o|":
        return 2
    case ".|":
        return 1
    default:
        return 0
    }
}

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

func parseNote(note: String) -> Int {
    switch note {
    case "o":
        return 4
    case "o|":
        return 2
    case ".|":
        return 1
    default:
        return 0
    }
}
<|file_separator|>

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

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

func parseMusic(musicString: String) -> [Int] {
    var result = [Int]()
    var currentNote = ""
    var currentNoteLength = 0
    for char in musicString {
        if char == "o" || char == "o|" {
            currentNoteLength += 4
        } else if char == "." || char == ".|" {
            currentNoteLength += 2
        } else if char == " " {
            result.append(currentNoteLength)
            currentNote = ""
            currentNoteLength = 0
        } else {
            currentNote += char
        }
    }
    result.append(currentNoteLength)
    return result
}

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

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

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

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

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

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

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

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

func howManyTimes(string: String, substring: String) -> Int {
    var count = 0
    var index = 0
    while index < string.count {
        let substringIndex = string.index(string.startIndex, offsetBy: index)
        let substringEndIndex = string.index(string.startIndex, offsetBy: index + substring.count)
        let substringRange = substringIndex..<substringEndIndex
        if string.substring(with: substringRange) == substring {
            count += 1
        }
        index += 1
    }
    return count
}

func longestSubstring(string: String) -> String {
    var longestSubstring = ""
    var substring = ""
    for char in string {
        if substring.contains(char) {
            if substring.count > longestSubstring.count {
                longestSubstring = substring
            }
            substring = ""
        }
        substring += String(char)
    }
    if substring.count > longestSubstring.count {
        longestSubstring = substring
    }
    return longestSubstring
}

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

// Find the longest substring that can be found in the original string.
// longestSubstring(string: "abcabcbb") == "abc"
// longestSubstring(string: "bbbbb") == "b"
// longestSubstring(string: "pwwkew") == "wke"
func longestSubstring(string: String) -> String {
    var longestSubstring = ""
    var substring = ""
    for char in string {
        if substring.contains(char) {
            if substring.count > longestSubstring.count {
                longestSubstring = substring
            }
            substring = ""
        }
        substring += String(char)
    }
    if substring.count > longestSubstring.count {
        longestSubstring = substring
    }
    return longestSubstring
}

// Find the longest substring that can be found in the original string.
// longestSubstring(string: "abcabcbb") == "abc"
// longestSubstring(string: "bbbbb") == "b"
// longestSubstring(string: "pwwkew") == "wke"
func longestSubstring(string: String) -> String {
    var longestSubstring = ""
    var substring = ""
    for char in string {
        if substring.contains(char) {
            if substring.count > longestSubstring.count {
                longestSubstring = substring
            }
            substring = ""
        }
        substring += String(char)
    }
    if substring.count > longestSubstring.count {
        longestSubstring = substring
    }
    return longestSubstring
}

// Find the longest substring that can be found in the original string.
// longestSubstring(string: "abcabcbb") == "abc"
// longestSubstring(string: "bbbbb") == "b"
// longestSubstring(string: "pwwkew") == "wke"
func longestSubstring(string: String) -> String {
    var longestSubstring = ""
    var substring = ""
    for char in string {
        if substring.contains(char) {
            if substring.count > longestSubstring.count {
                longestSubstring = substring
            }
            substring = ""
        }
        substring += String(char)
    }
    if substring.count > longestSubstring.count {
        longestSubstring = substring
    }
    return longestSubstring
}

// Find the longest substring that can be found in the original string.
// longestSubstring(string: "abcabcbb") == "abc"
// longestSubstring(string: "bbbbb") == "b"
// longestSubstring(string: "pwwkew") == "wke"
func longestSubstring(string: String) -> String {
    var longestSubstring = ""
    var substring = ""
    for char in string {
        if substring.contains(char) {
            if substring.count > longestSubstring.count {
                longestSubstring = substring
            }
            substring = ""
        }
        substring += String(char)
    }
    if substring.count > longestSubstring.count {
        longestSubstring = substring
    }
    return longestSubstring
}

// Find the longest substring that can be found in the original string.
// longestSubstring(string: "abcabcbb") == "abc"
// longestSubstring(string: "bbbbb") == "b"
// longestSubstring(string: "pwwkew") == "wke"
func longestSubstring(string: String) -> String {
    var longestSubstring = ""
    var substring = ""
    for char in string {
        if substring.contains(char) {
            if substring.count > longestSubstring.count {
                longestSubstring = substring
            }
            substring = ""
        }
        substring += String(char)
    }
    if substring.count > longestSubstring.count {
        longestSubstring = substring
    }
    return longestSubstring
}

// Find the longest substring that can be found in the original string.
// longestSubstring(string: "abcabcbb") == "abc"
// longestSubstring(

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

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

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

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

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

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

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

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

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

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

func howManyTimes(string: String, substring: String) -> Int {
    let substringCount = string.components(separatedBy: substring).count - 1
    return substringCount
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    let substringCount = string.components(separatedBy: substring).count - 1
    return substringCount
}
<|file_separator|>```

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

func longestCommonSubstring(string1: String, string2: String) -> String {
    let string1 = string1.lowercased()
    let string2 = string2.lowercased()
    var longest = ""
    for i in 0..<string1.count {
        for j in 0..<string2.count {
            let substring = string1.substring(with: string1.index(string1.startIndex, offsetBy: i)..<string1.index(string1.startIndex, offsetBy: i + 1))
            if string2.contains(substring) {
                if substring.count > longest.count {
                    longest = substring
                }
            }
        }
    }
    return longest
}

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

// Find the longest common substring between two strings.
// longestCommonSubstring(string1: "abcde", string2: "abfde") == "ab"
// longestCommonSubstring(string1: "abcde", string2: "abfde") == "ab"
// longestCommonSubstring(string1: "abcde", string2: "abfde") == "ab"
func longestCommonSubstring(string1: String, string2: String) -> String {
    let string1 = string1.lowercased()
    let string2 = string2.lowercased()
    var longest = ""
    for i in 0..<string1.count {
        for j in 0..<string2.count {
            let substring = string1.substring(with: string1.index(string1.startIndex, offsetBy: i)..<string1.index(string1.startIndex, offsetBy: i + 1))
            if string2.contains(substring) {
                if substring.count > longest.count {
                    longest = substring
                }
            }
        }
    }
    return longest
}

// Find the longest common substring between two strings.
// longestCommonSubstring(string1: "abcde", string2: "abfde") == "ab"
// longestCommonSubstring(string1: "abcde", string2: "abfde") == "ab"
// longestCommonSubstring(string1: "abcde", string2: "abfde") == "ab"
func longestCommonSubstring(string1: String, string2: String) -> String {
    let string1 = string1.lowercased()
    let string2 = string2.lowercased()
    var longest = ""
    for i in 0..<string1.count {
        for j in 0..<string2.count {
            let substring = string1.substring(with: string1.index(string1.startIndex, offsetBy: i)..<string1.index(string1.startIndex, offsetBy: i + 1))
            if string2.contains(substring) {
                if substring.count > longest.count {
                    longest = substring
                }
            }
        }
    }
    return longest
}

// Find the longest common substring between two strings.
// longestCommonSubstring(string1: "abcde", string2: "abfde") == "ab"
// longestCommonSubstring(string1: "abcde", string2: "abfde") == "ab"
// longestCommonSubstring(string1: "abcde", string2: "abfde") == "ab"
func longestCommonSubstring(string1: String, string2: String) -> String {
    let string1 = string1.lowercased()
    let string2 = string2.lowercased()
    var longest = ""
    for i in 0..<string1.count {
        for j in 0..<string2.count {
            let substring = string1.substring(with: string1.index(string1.startIndex, offsetBy: i)..<string1.index(string1.startIndex, offsetBy: i + 1))
            if string2.contains(substring) {
                if substring.count > longest.count {
                    longest = substring
                }
            }
        }
    }
    return longest
}

// Find the longest common substring between two strings.
// longestCommonSubstring(string1: "abcde", string2: "abfde") == "ab"
// longestCommonSubstring(string1: "abcde", string2: "abfde") == "ab"
// longestCommonSubstring(string1: "abcde", string2: "abfde") == "ab"
func longestCommonSubstring(string1: String, string2: String) -> String {
    let string1 = string1.lowercased()
    let string2 = string2.lowercased()

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

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

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

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

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

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

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

// 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 largest to smallest
// sortNumbers(numbers: "three one five") == "nine seven five three one"
func sortNumbers(numbers: String) -> String {
    let numbers = numbers.split(separator: " ").map { Int($0)! }
    return numbers.sorted(by: >).map { String($0) }.joined(separator: " ")
}
<|file_separator|>

func sortNumbers(numbers: String) -> String {
    let numbersArray = numbers.components(separatedBy: " ")
    var numbersArraySorted = numbersArray
    for i in 0..<numbersArraySorted.count {
        for j in 0..<numbersArraySorted.count {
            if numbersArraySorted[i] < numbersArraySorted[j] {
                let temp = numbersArraySorted[i]
                numbersArraySorted[i] = numbersArraySorted[j]
                numbersArraySorted[j] = temp
            }
        }
    }
    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
    for i in 0..<numbersArraySorted.count {
        for j in 0..<numbersArraySorted.count {
            if numbersArraySorted[i] < numbersArraySorted[j] {
                let temp = numbersArraySorted[i]
                numbersArraySorted[i] = numbersArraySorted[j]
                numbersArraySorted[j] = temp
            }
        }
    }
    return numbersArraySorted.joined(separator: " ")
}
<|file_separator|>

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

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

// Input is a string of numbers separated by spaces.
// Return the string with the numbers sorted from smallest to largest.
// sortNumbers(numbers: "1 2 3 4 5 6 7 8 9") == "1 2 3 4 5 6 7 8 9"
func sortNumbers(numbers: String) -> String {
    let numbers = numbers.split(separator: " ")
    let sortedNumbers = numbers.sorted()
    return sortedNumbers.joined(separator: " ")
}

// Input is a string of numbers separated by spaces.
// Return the string with the numbers sorted from smallest to largest.
// sortNumbers(numbers: "1 2 3 4 5 6 7 8 9") == "1 2 3 4 5 6 7 8 9"
func sortNumbers(numbers: String) -> String {
    let numbers = numbers.split(separator: " ")
    let sortedNumbers = numbers.sorted()
    return sortedNumbers.joined(separator: " ")
}
<|file_separator|>

func sortNumbers(numbers: String) -> String {
    let numbersArray = numbers.split(separator: " ")
    var sortedNumbersArray = numbersArray.sorted()
    var sortedNumbersString = ""
    for number in sortedNumbersArray {
        sortedNumbersString += number + " "
    }
    return sortedNumbersString.trimmingCharacters(in: .whitespaces)
}

```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.split(separator: " ")
    var sortedNumbersArray = numbersArray.sorted()
    var sortedNumbersString = ""
    for number in sortedNumbersArray {
        sortedNumbersString += number + " "
    }
    return sortedNumbersString.trimmingCharacters(in: .whitespaces)
}

print(sortNumbers(numbers: "three one five"))
<|file_separator|>

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

func sortWords(words: String) -> String {
    let wordsArray = words.components(separatedBy: " ")
    let sortedWordsArray = wordsArray.sorted(by: { $0 < $1 })
    return sortedWordsArray.joined(separator: " ")
}

func sortWordsByLength(words: String) -> String {
    let wordsArray = words.components(separatedBy: " ")
    let sortedWordsArray = wordsArray.sorted(by: { $0.count < $1.count })
    return sortedWordsArray.joined(separator: " ")
}

func sortWordsByLengthAndAlphabetically(words: String) -> String {
    let wordsArray = words.components(separatedBy: " ")
    let sortedWordsArray = wordsArray.sorted(by: { $0.count < $1.count || $0 < $1 })
    return sortedWordsArray.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 sortedNumbersArray = numbersArray.sorted(by: { $0 < $1 })
    return sortedNumbersArray.joined(separator: " ")
}

// Input is a string of words separated by spaces.
// Return the string with words sorted alphabetically.
// sortWords(words: "hello world") == "hello world"
func sortWords(words: String) -> String {
    let wordsArray = words.components(separatedBy: " ")
    let sortedWordsArray = wordsArray.sorted(by: { $0 < $1 })
    return sortedWordsArray.joined(separator: " ")
}

// Input is a string of words separated by spaces.
// Return the string with words sorted by length.
// sortWordsByLength(words: "hello world") == "hello world"
func sortWordsByLength(words: String) -> String {
    let wordsArray = words.components(separatedBy: " ")
    let sortedWordsArray = wordsArray.sorted(by: { $0.count < $1.count })
    return sortedWordsArray.joined(separator: " ")
}

// Input is a string of words separated by spaces.
// Return the string with words sorted by length and then alphabetically.
// sortWordsByLengthAndAlphabetically(words: "hello world") == "hello world"
func sortWordsByLengthAndAlphabetically(words: String) -> String {
    let wordsArray = words.components(separatedBy: " ")
    let sortedWordsArray = wordsArray.sorted(by: { $0.count < $1.count || $0 < $1 })
    return sortedWordsArray.joined(separator: " ")
}

// Input is a string of words separated by spaces.
// Return the string with words sorted by length and then alphabetically, but only if the length is greater than 5.
// sortWordsByLengthAndAlphabetically(words: "hello world") == "hello world"
func sortWordsByLengthAndAlphabetically(words: String) -> String {
    let wordsArray = words.components(separatedBy: " ")
    let sortedWordsArray = wordsArray.sorted(by: { $0.count < $1.count || $0 < $1 })
    return sortedWordsArray.joined(separator: " ")
}

// Input is a string of words separated by spaces.
// Return the string with words sorted by length and then alphabetically, but only if the length is greater than 5.
// sortWordsByLengthAndAlphabetically(words: "hello world") == "hello world"
func sortWordsByLengthAndAlphabetically(words: String) -> String {
    let wordsArray = words.components(separatedBy: " ")
    let sortedWordsArray = wordsArray.sorted(by: { $0.count < $1.count || $0 < $1 })
    return sortedWordsArray.joined(separator: " ")
}

// Input is a string of words separated by spaces.
// Return the string with words sorted by length and then alphabetically, but only if the length is greater than 5.
// sortWordsByLengthAndAlphabetically(words: "hello world") == "hello world"
func sortWordsByLengthAndAlphabetically(words: String) -> String {
    let wordsArray = words.components(separatedBy: " ")
    let sortedWordsArray = wordsArray.sorted(by: { $0.count < $1.count || $0 < $1 })
    return sortedWordsArray.joined(separator: " ")
}

// Input is a string of words separated by spaces.
// Return the string with words sorted by length and then alphabetically, but only if the length is greater than 5.
// sortWordsByLengthAndAlphabetically(words: "hello world") == "hello world"
func sortWordsByLengthAndAlphabetically(words: String) -> String {
    let wordsArray = words.components(separatedBy: " ")
    let sortedWordsArray = wordsArray.sorted(by: { $0.count < $1.count || $0 < $1 })
    return sortedWordsArray.joined(separator: " ")
}

// Input is a string of words separated by spaces.
// Return the string with words sorted by length and then alphabetically, but only if the length is greater than 5.
// sortWordsByLengthAndAlphabetically(words: "hello world") == "hello world"
func sortWordsByLengthAndAlphabetically(words: String) -> String {
    let wordsArray =

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

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

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

func sumOfNumbers(numbers: String) -> String {
    let numberals = numbers.components(separatedBy: " ")
    let sum = numberals.reduce(0) { $0 + Int($1)! }
    return String(sum)
}

```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 numberals = numbers.components(separatedBy: " ")
    let sorted = numberals.sorted()
    return sorted.joined(separator: " ")
}

// Input is a string of numbers separated by spaces.
// Return the sum of the numbers as a string.
// sumOfNumbers("1 2 3 4 5") == "15"
func sumOfNumbers(numbers: String) -> String {
    let numberals = numbers.components(separatedBy: " ")
    let sum = numberals.reduce(0) { $0 + Int($1)! }
    return String(sum)
}

// Input is a string of numbers separated by spaces.
// Return the sum of the numbers as a string.
// sumOfNumbers("1 2 3 4 5") == "15"
func sumOfNumbers(numbers: String) -> String {
    let numberals = numbers.components(separatedBy: " ")
    let sum = numberals.reduce(0) { $0 + Int($1)! }
    return String(sum)
}

// Input is a string of numbers separated by spaces.
// Return the sum of the numbers as a string.
// sumOfNumbers("1 2 3 4 5") == "15"
func sumOfNumbers(numbers: String) -> String {
    let numberals = numbers.components(separatedBy: " ")
    let sum = numberals.reduce(0) { $0 + Int($1)! }
    return String(sum)
}

// Input is a string of numbers separated by spaces.
// Return the sum of the numbers as a string.
// sumOfNumbers("1 2 3 4 5") == "15"
func sumOfNumbers(numbers: String) -> String {
    let numberals = numbers.components(separatedBy: " ")
    let sum = numberals.reduce(0) { $0 + Int($1)! }
    return String(sum)
}

// Input is a string of numbers separated by spaces.
// Return the sum of the numbers as a string.
// sumOfNumbers("1 2 3 4 5") == "15"
func sumOfNumbers(numbers: String) -> String {
    let numberals = numbers.components(separatedBy: " ")
    let sum = numberals.reduce(0) { $0 + Int($1)! }
    return String(sum)
}

// Input is a string of numbers separated by spaces.
// Return the sum of the numbers as a string.
// sumOfNumbers("1 2 3 4 5") == "15"
func sumOfNumbers(numbers: String) -> String {
    let numberals = numbers.components(separatedBy: " ")
    let sum = numberals.reduce(0) { $0 + Int($1)! }
    return String(sum)
}

// Input is a string of numbers separated by spaces.
// Return the sum of the numbers as a string.
// sumOfNumbers("1 2 3 4 5") == "15"
func sumOfNumbers(numbers: String) -> String {
    let numberals = numbers.components(separatedBy: " ")
    let sum = numberals.reduce(0) { $0 + Int($1)! }
    return String(sum)
}

// Input is a string of numbers separated by spaces.
// Return the sum of the numbers as a string.
// sumOfNumbers("1 2 3 4 5") == "15"
func sumOfNumbers(numbers: String) -> String {
    let numberals = numbers.components(separatedBy: " ")
    let sum = numberals.reduce(0) { $0 + Int($1)! }
    return String(sum)
}

// Input is a string of numbers separated by spaces.
// Return the sum of the numbers as a string.
// sumOfNumbers("1 2 3 4 5") == "15"
func sumOfNumbers(numbers: String) -> String {
    let numberals = numbers.components(separatedBy: " ")
    let sum = numberals.reduce(0) { $0 + Int($1)! }
    return String(sum)
}

// Input is a string of numbers separated by spaces.
// Return the sum of the numbers as a string.
// sumOfNumbers("1 2 3 4 5") == "15"
func sumOfNumbers(numbers: String) -> String {

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

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

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

func sumNumbers(numbers: String) -> Int {
    return numbers.split(separator: " ").map { Int($0)! }.reduce(0, +)
}

func productNumbers(numbers: String) -> Int {
    return numbers.split(separator: " ").map { Int($0)! }.reduce(1, *)
}

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

// Input is a string of numbers separated by spaces.
// Return the sum of the numbers.
// sumNumbers(numbers: "1 2 3") == 6
func sumNumbers(numbers: String) -> Int {
    return numbers.split(separator: " ").map { Int($0)! }.reduce(0, +)
}

// Input is a string of numbers separated by spaces.
// Return the product of the numbers.
// productNumbers(numbers: "1 2 3") == 6
func productNumbers(numbers: String) -> Int {
    return numbers.split(separator: " ").map { Int($0)! }.reduce(1, *)
}

// Input is a string of numbers separated by spaces.
// Return the sum of the numbers.
// sumNumbers(numbers: "1 2 3") == 6
func sumNumbers(numbers: String) -> Int {
    return numbers.split(separator: " ").map { Int($0)! }.reduce(0, +)
}

// Input is a string of numbers separated by spaces.
// Return the product of the numbers.
// productNumbers(numbers: "1 2 3") == 6
func productNumbers(numbers: String) -> Int {
    return numbers.split(separator: " ").map { Int($0)! }.reduce(1, *)
}

// Input is a string of numbers separated by spaces.
// Return the sum of the numbers.
// sumNumbers(numbers: "1 2 3") == 6
func sumNumbers(numbers: String) -> Int {
    return numbers.split(separator: " ").map { Int($0)! }.reduce(0, +)
}

// Input is a string of numbers separated by spaces.
// Return the product of the numbers.
// productNumbers(numbers: "1 2 3") == 6
func productNumbers(numbers: String) -> Int {
    return numbers.split(separator: " ").map { Int($0)! }.reduce(1, *)
}

// Input is a string of numbers separated by spaces.
// Return the sum of the numbers.
// sumNumbers(numbers: "1 2 3") == 6
func sumNumbers(numbers: String) -> Int {
    return numbers.split(separator: " ").map { Int($0)! }.reduce(0, +)
}

// Input is a string of numbers separated by spaces.
// Return the product of the numbers.
// productNumbers(numbers: "1 2 3") == 6
func productNumbers(numbers: String) -> Int {
    return numbers.split(separator: " ").map { Int($0)! }.reduce(1, *)
}

// Input is a string of numbers separated by spaces.
// Return the sum of the numbers.
// sumNumbers(numbers: "1 2 3") == 6
func sumNumbers(numbers: String) -> Int {
    return numbers.split(separator: " ").map { Int($0)! }.reduce(0, +)
}

// Input is a string of numbers separated by spaces.
// Return the product of the numbers.
// productNumbers(numbers: "1 2 3") == 6
func productNumbers(numbers: String) -> Int {
    return numbers.split(separator: " ").map { Int($0)! }.reduce(1, *)
}

// Input is a string of numbers separated by spaces.
// Return the sum of the numbers.
// sumNumbers(numbers: "1 2 3") == 6
func sumNumbers(numbers: String) -> Int {
    return numbers.split(separator: " ").map { Int($0)! }.reduce(0, +)
}

// Input is a string of numbers separated by spaces.
// Return the product of the numbers.
// productNumbers(numbers: "1 2 3") == 6
func productNumbers(numbers: String) -> Int {
    return numbers.split(separator: " ").map { Int($0)! }.reduce(1, *)
}

// Input is a string of numbers separated by spaces.
// Return the sum of the numbers.
// sumNumbers(numbers: "1 2 3") == 6
func sumNumbers(numbers: String) -> Int {
    return numbers.split(separator: " ").map { Int($0)! }.reduce(0, +)
}

func sortNumbers(numbers: String) -> String {
    let numbersArray = numbers.components(separatedBy: " ")
    let sortedNumbersArray = numbersArray.sorted()
    return sortedNumbersArray.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 sortedNumbersArray = numbersArray.sorted()
    return sortedNumbersArray.joined(separator: " ")
}
<|file_separator|>

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

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

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

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

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

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

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

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

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

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

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    var minDiff = Double.infinity
    var minDiffIndex = 0
    var minDiffIndex2 = 1
    var minDiffIndex3 = 2
    var minDiffIndex4 = 3
    var minDiffIndex5 = 4
    var minDiffIndex6 = 5
    var minDiffIndex7 = 6
    var minDiffIndex8 = 7
    var minDiffIndex9 = 8
    var minDiffIndex10 = 9
    var minDiffIndex11 = 10
    var minDiffIndex12 = 11
    var minDiffIndex13 = 12
    var minDiffIndex14 = 13
    var minDiffIndex15 = 14
    var minDiffIndex16 = 15
    var minDiffIndex17 = 16
    var minDiffIndex18 = 17
    var minDiffIndex19 = 18
    var minDiffIndex20 = 19
    var minDiffIndex21 = 20
    var minDiffIndex22 = 21
    var minDiffIndex23 = 22
    var minDiffIndex24 = 23
    var minDiffIndex25 = 24
    var minDiffIndex26 = 25
    var minDiffIndex27 = 26
    var minDiffIndex28 = 27
    var minDiffIndex29 = 28
    var minDiffIndex30 = 29
    var minDiffIndex31 = 30
    var minDiffIndex32 = 31
    var minDiffIndex33 = 32
    var minDiffIndex34 = 33
    var minDiffIndex35 = 34
    var minDiffIndex36 = 35
    var minDiffIndex37 = 36
    var minDiffIndex38 = 37
    var minDiffIndex39 = 38
    var minDiffIndex40 = 39
    var minDiffIndex41 = 40
    var minDiffIndex42 = 41
    var minDiffIndex43 = 42
    var minDiffIndex44 = 43
    var minDiffIndex45 = 44
    var minDiffIndex46 = 45
    var minDiffIndex47 = 46
    var minDiffIndex48 = 47
    var minDiffIndex49 = 48
    var minDiffIndex50 = 49
    var minDiffIndex51 = 50
    var minDiffIndex52 = 51
    var minDiffIndex53 = 52
    var minDiffIndex54 = 53
    var minDiffIndex55 = 54
    var minDiffIndex56 = 55
    var minDiffIndex57 = 56
    var minDiffIndex58 = 57
    var minDiffIndex59 = 58
    var minDiffIndex60 = 59
    var minDiffIndex61 = 60
    var minDiffIndex62 = 61
    var minDiffIndex63 = 62
    var minDiffIndex64 = 63
    var minDiffIndex65 = 64
    var minDiffIndex66 = 65
    var minDiffIndex67 = 66
    var minDiffIndex68 = 67
    var minDiffIndex69 = 68
    var minDiffIndex70 = 69
    var minDiffIndex71 = 70
    var minDiffIndex72 = 71
    var minDiffIndex73 = 72
    var minDiffIndex74 = 73
    var minDiffIndex75 = 74
    var minDiffIndex76 = 75
    var minDiffIndex77 = 76
    var minDiffIndex78 = 77
    var minDiffIndex79 = 78
    var minDiffIndex80 = 79
    var minDiffIndex81 = 80
    var minDiffIndex82 = 81
    var minDiffIndex83 = 82
    var minDiffIndex84 = 83
    var minDiffIndex85 = 84
    var minDiffIndex86 = 85
    var

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

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

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

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

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

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

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

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

// 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 min = numbers[0]
    var max = numbers[0]
    for i in 1..<numbers.count {
        if numbers[i] < min {
            min = numbers[i]
        }
        if numbers[i] > max {
            max = numbers[i]
        }
    }
    return (min, max)
}

// 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 min = numbers[0]
    var max = numbers[0]
    for i in 1..<numbers.count {
        if numbers[i] < min {
            min = numbers[i]
        }
        if numbers[i] > max {
            max = numbers[i]
        }
    }
    return (min, max)
}

// 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 min = numbers[0]
    var max = numbers[0]
    for i in 1..<numbers.count {
        if numbers[i] < min {
            min = numbers[i]
        }
        if numbers[i] > max {
            max = numbers[i]
        }
    }
    return (min, max)
}

// 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 min = numbers[0]
    var max = numbers[0]
    for i in 1..<numbers.count {
        if numbers[i] < min {
            min = numbers[i]
        }
        if numbers[i] > max

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

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

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

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

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

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

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

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

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

func repeatString(str: String) -> String {
  return str.map { (c: Character) -> String in
    return String(c) + String(c)
  }.reduce("", combine: { (acc: String, str: String) -> String in
    return acc + str
  })
}

```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 { (n: Double) -> Double in
    return (n - min) / range
  }
}

// Given a string, return a new string where each character is repeated once
// repeatString("hello") == "hheelllloo"
func repeatString(str: String) -> String {
  return str.map { (c: Character) -> String in
    return String(c) + String(c)
  }.reduce("", combine: { (acc: String, str: String) -> String in
    return acc + str
  })
}

// Given a string, return a new string where each character is repeated once
// repeatString("hello") == "hheelllloo"
func repeatString(str: String) -> String {
  return str.map { (c: Character) -> String in
    return String(c) + String(c)
  }.reduce("", combine: { (acc: String, str: String) -> String in
    return acc + str
  })
}

// Given a string, return a new string where each character is repeated once
// repeatString("hello") == "hheelllloo"
func repeatString(str: String) -> String {
  return str.map { (c: Character) -> String in
    return String(c) + String(c)
  }.reduce("", combine: { (acc: String, str: String) -> String in
    return acc + str
  })
}

// Given a string, return a new string where each character is repeated once
// repeatString("hello") == "hheelllloo"
func repeatString(str: String) -> String {
  return str.map { (c: Character) -> String in
    return String(c) + String(c)
  }.reduce("", combine: { (acc: String, str: String) -> String in
    return acc + str
  })
}

// Given a string, return a new string where each character is repeated once
// repeatString("hello") == "hheelllloo"
func repeatString(str: String) -> String {
  return str.map { (c: Character) -> String in
    return String(c) + String(c)
  }.reduce("", combine: { (acc: String, str: String) -> String in
    return acc + str
  })
}

// Given a string, return a new string where each character is repeated once
// repeatString("hello") == "hheelllloo"
func repeatString(str: String) -> String {
  return str.map { (c: Character) -> String in
    return String(c) + String(c)
  }.reduce("", combine: { (acc: String, str: String) -> String in
    return acc + str
  })
}

// Given a string, return a new string where each character is repeated once
// repeatString("hello") == "hheelllloo"
func repeatString(str: String) -> String {
  return str.map { (c: Character) -> String in
    return String(c) + String(c)
  }.reduce("", combine: { (acc: String, str: String) -> String in
    return acc + str
  })
}

// Given a string, return a new string where each character is repeated once
// repeatString("hello") == "hheelllloo"
func repeatString(str: String) -> String {
  return str.map { (c: Character) -> String in
    return String(c) + String(c)
  }.reduce("", combine: { (acc: String, str: String) -> String in
    return acc + str
  })
}

// Given a string, return a new string where each character is repeated once
// repeatString("hello") == "hheelllloo"
func repeatString(str: String) -> String {
  return str.map { (c: Character) -> String in
    return String(c) + String(c)
  }.reduce("", combine: { (acc: String, str: String) -> String in
    return acc + str
  })
}

// Given a string, return a new string where each character is repeated once
// repeatString("hello") == "hheelllloo"
func repeatString(str: String) -> String {
  return str.map { (c: Character) -> String in
    return String(c) + String

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

func repeatString(string: String) -> String {
    return string.map { (character: Character) -> Character in
        return character
    }.reduce("", combine: { (string: String, character: Character) -> String in
        return string + String(character)
    })
}

func countIS(string: String) -> Int {
    return string.componentsSeparatedByString("is").count - 1
}

func sum(numbers: [Int]) -> Int {
    return numbers.reduce(0, combine: { (sum: Int, number: Int) -> Int in
        return sum + number
    })
}

func product(numbers: [Int]) -> Int {
    return numbers.reduce(1, combine: { (product: Int, number: Int) -> Int in
        return product * number
    })
}

func average(numbers: [Int]) -> Int {
    return sum(numbers) / numbers.count
}

func median(numbers: [Int]) -> Int {
    return numbers[numbers.count / 2]
}

func mode(numbers: [Int]) -> Int {
    let frequency = numbers.reduce(Dictionary<Int, Int>(), combine: { (frequency: Dictionary<Int, Int>, number: Int) -> Dictionary<Int, Int> in
        if let count = frequency[number] {
            frequency[number] = count + 1
        } else {
            frequency[number] = 1
        }
        return frequency
    })
    let max = frequency.maxElement()
    return max!.key
}

func range(numbers: [Int]) -> Int {
    return numbers.max()! - numbers.min()!
}

func sumOfSquares(numbers: [Int]) -> Int {
    return numbers.reduce(0, combine: { (sum: Int, number: Int) -> Int in
        return sum + number * number
    })
}

func sumOfCubes(numbers: [Int]) -> Int {
    return numbers.reduce(0, combine: { (sum: Int, number: Int) -> Int in
        return sum + number * number * number
    })
}

```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()!
    return numbers.map { (number: Double) -> Double in
        return (number - min) / (max - min)
    }
}

// Given a string, return a new string where each character is repeated once
// repeatString("hello") == "hheelllloo"
func repeatString(string: String) -> String {
    return string.map { (character: Character) -> Character in
        return character
    }.reduce("", combine: { (string: String, character: Character) -> String in
        return string + String(character)
    })
}

// Given a string, return the number of times the string "is" appears in the string
// countIS("This is is") == 2
func countIS(string: String) -> Int {
    return string.componentsSeparatedByString("is").count - 1
}

// Given an array of numbers, return the sum of the numbers
// sum([1, 2, 3, 4, 5]) == 15
func sum(numbers: [Int]) -> Int {
    return numbers.reduce(0, combine: { (sum: Int, number: Int) -> Int in
        return sum + number
    })
}

// Given an array of numbers, return the product of the numbers
// product([1, 2, 3, 4, 5]) == 120
func product(numbers: [Int]) -> Int {
    return numbers.reduce(1, combine: { (product: Int, number: Int) -> Int in
        return product * number
    })
}

// Given an array of numbers, return the average of the numbers
// average([1, 2, 3, 4, 5]) == 3
func average(numbers: [Int]) -> Int {
    return sum(numbers) / numbers.count
}

// Given an array of numbers, return the median of the numbers
// median([1, 2, 3, 4, 5]) == 3
func median(numbers: [Int]) -> Int {
    return numbers[numbers.count / 2]
}

// Given an array of numbers, return the mode of the numbers
// mode([1, 2, 3, 4, 5]) == 1
// mode([1, 2, 3, 4, 5, 1, 2, 3, 4, 5]) == 1
func mode(numbers: [Int]) -> Int {
    let frequency = numbers.reduce(Dictionary<Int, Int>(), combine: { (frequency: Dictionary<Int, Int>, number: Int) -> Dictionary<Int, Int> in
        if let count = frequency[number] {
            frequency[number] = count + 1
        } else {
            frequency[number] = 1
        }
        return frequency
    })
    let max = frequency.maxElement()
    return max!.key
}

// Given an array of numbers, return the range of the numbers
// range([1, 2, 3, 4, 5]) == 4
func range(numbers: [Int]) -> Int {
    return numbers.max()! - numbers.min()!
}

// Given an array of numbers, return the sum of the squares of the numbers
// sumOfSquares([1, 2, 3, 4, 5]) == 55
func sumOfSquares(numbers: [Int]) -> Int {
    return numbers.reduce(0, combine: { (sum: Int, number: Int) -> Int in
        return sum + number * number
    })
}

// Given an array of numbers, return the sum of the cubes of the numbers
// sumOfCubes([1, 2, 3, 4, 5]) == 225
func sumOfCubes(numbers: [Int]) -> Int {
    return numbers.reduce(0, combine: { (sum: Int, number: Int) -> Int in
        return sum + number * number * number
    })
}

// Given an array of numbers, return the sum of the powers of the numbers
// sumOfPowers([1, 2, 3, 4, 5]) == 338350
func sumOfPowers(numbers: [Int]) -> Int {
    return numbers.reduce(0, combine: { (sum: Int, number: Int) -> Int in
        return sum

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

func alphabetize(string: String) -> String {
  return String(string.characters.sort())
}

func alphabetize(string: String) -> String {
  return String(string.characters.sort())
    .characters
    .map { $0.uppercased() }
    .joinWithSeparator("")
}

```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()!
  return numbers.map { $0 - min }
}

// Given a string, return a string with the letters in alphabetical order
// alphabetize("hello") == "ehllo"
func alphabetize(string: String) -> String {
  return String(string.characters.sort())
}

// Given a string, return a string with the letters in alphabetical order, but with the first letter in upper case
// alphabetize("hello") == "Ehllo"
func alphabetize(string: String) -> String {
  return String(string.characters.sort())
    .characters
    .map { $0.uppercased() }
    .joinWithSeparator("")
}

// Given a string, return a string with the letters in alphabetical order, but with the first letter in upper case
// alphabetize("hello") == "Ehllo"
func alphabetize(string: String) -> String {
  return String(string.characters.sort())
    .characters
    .map { $0.uppercased() }
    .joinWithSeparator("")
}

// Given a string, return a string with the letters in alphabetical order, but with the first letter in upper case
// alphabetize("hello") == "Ehllo"
func alphabetize(string: String) -> String {
  return String(string.characters.sort())
    .characters
    .map { $0.uppercased() }
    .joinWithSeparator("")
}

// Given a string, return a string with the letters in alphabetical order, but with the first letter in upper case
// alphabetize("hello") == "Ehllo"
func alphabetize(string: String) -> String {
  return String(string.characters.sort())
    .characters
    .map { $0.uppercased() }
    .joinWithSeparator("")
}

// Given a string, return a string with the letters in alphabetical order, but with the first letter in upper case
// alphabetize("hello") == "Ehllo"
func alphabetize(string: String) -> String {
  return String(string.characters.sort())
    .characters
    .map { $0.uppercased() }
    .joinWithSeparator("")
}

// Given a string, return a string with the letters in alphabetical order, but with the first letter in upper case
// alphabetize("hello") == "Ehllo"
func alphabetize(string: String) -> String {
  return String(string.characters.sort())
    .characters
    .map { $0.uppercased() }
    .joinWithSeparator("")
}

// Given a string, return a string with the letters in alphabetical order, but with the first letter in upper case
// alphabetize("hello") == "Ehllo"
func alphabetize(string: String) -> String {
  return String(string.characters.sort())
    .characters
    .map { $0.uppercased() }
    .joinWithSeparator("")
}

// Given a string, return a string with the letters in alphabetical order, but with the first letter in upper case
// alphabetize("hello") == "Ehllo"
func alphabetize(string: String) -> String {
  return String(string.characters.sort())
    .characters
    .map { $0.uppercased() }
    .joinWithSeparator("")
}

// Given a string, return a string with the letters in alphabetical order, but with the first letter in upper case
// alphabetize("hello") == "Ehllo"
func alphabetize(string: String) -> String {
  return String(string.characters.sort())
    .characters
    .map { $0.uppercased() }
    .joinWithSeparator("")
}

// Given a string, return a string with the letters in alphabetical order, but with the first letter in upper case
// alphabetize("hello") == "Ehllo"
func alphabetize(string: String) -> String {
  return String(string.characters.sort())
    .characters
    .map { $0.uppercased() }
    .joinWithSeparator("")
}

// Given a string, return a string with the letters in alphabetical order, but with the first letter in upper case
// alphabetize("hello") == "Ehllo"
func alphabetize(string: String) -> String {
  return String(string.characters.sort())
    .characters
    .map { $0.uppercased() }
    .joinWithSeparator("")
}

// Given a string, return a string with the letters in alphabetical

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

func swapFirstLast(str: String) -> String {
    return str.substring(from: 1) + str.substring(to: 1)
}

```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()!
    return numbers.map {
        return ($0 - min) / (max - min)
    }
}

// Given a string, return a new string with the first and last characters swapped
// swapFirstLast("hello") == "oellh"
func swapFirstLast(str: String) -> String {
    return str.substring(from: 1) + str.substring(to: 1)
}

// Given a string, return a new string with the first and last characters swapped
// swapFirstLast("hello") == "oellh"
func swapFirstLast(str: String) -> String {
    return str.substring(from: 1) + str.substring(to: 1)
}

// Given a string, return a new string with the first and last characters swapped
// swapFirstLast("hello") == "oellh"
func swapFirstLast(str: String) -> String {
    return str.substring(from: 1) + str.substring(to: 1)
}

// Given a string, return a new string with the first and last characters swapped
// swapFirstLast("hello") == "oellh"
func swapFirstLast(str: String) -> String {
    return str.substring(from: 1) + str.substring(to: 1)
}

// Given a string, return a new string with the first and last characters swapped
// swapFirstLast("hello") == "oellh"
func swapFirstLast(str: String) -> String {
    return str.substring(from: 1) + str.substring(to: 1)
}

// Given a string, return a new string with the first and last characters swapped
// swapFirstLast("hello") == "oellh"
func swapFirstLast(str: String) -> String {
    return str.substring(from: 1) + str.substring(to: 1)
}

// Given a string, return a new string with the first and last characters swapped
// swapFirstLast("hello") == "oellh"
func swapFirstLast(str: String) -> String {
    return str.substring(from: 1) + str.substring(to: 1)
}

// Given a string, return a new string with the first and last characters swapped
// swapFirstLast("hello") == "oellh"
func swapFirstLast(str: String) -> String {
    return str.substring(from: 1) + str.substring(to: 1)
}

// Given a string, return a new string with the first and last characters swapped
// swapFirstLast("hello") == "oellh"
func swapFirstLast(str: String) -> String {
    return str.substring(from: 1) + str.substring(to: 1)
}

// Given a string, return a new string with the first and last characters swapped
// swapFirstLast("hello") == "oellh"
func swapFirstLast(str: String) -> String {
    return str.substring(from: 1) + str.substring(to: 1)
}

// Given a string, return a new string with the first and last characters swapped
// swapFirstLast("hello") == "oellh"
func swapFirstLast(str: String) -> String {
    return str.substring(from: 1) + str.substring(to: 1)
}

// Given a string, return a new string with the first and last characters swapped
// swapFirstLast("hello") == "oellh"
func swapFirstLast(str: String) -> String {
    return str.substring(from: 1) + str.substring(to: 1)
}

// Given a string, return a new string with the first and last characters swapped
// swapFirstLast("hello") == "oellh"
func swapFirstLast(str: String) -> String {
    return str.substring(from: 1) + str.substring(to: 1)
}

// Given a string, return a new string with the first and last characters swapped
// swapFirstLast("hello") == "oellh"
func swapFirstLast(str: String) -> String {
    return str.substring(from: 1) + str.substring(to: 1)
}

// Given a string, return a new string with the first and last characters swapped
// swapFirstLast("hello") ==

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

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

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

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

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

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

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

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

```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()!
    return numbers.map { $0 / (max - min) }
}

// Given array of numbers, return the sum of the squares of the numbers
// sumOfSquares([1, 2, 3, 4, 5]) == 55
func sumOfSquares(numbers: [Int]) -> Int {
    return numbers.reduce(0, { $0 + $1 * $1 })
}

// Given array of numbers, return the sum of the cubes of the numbers
// sumOfCubes([1, 2, 3, 4, 5]) == 225
func sumOfCubes(numbers: [Int]) -> Int {
    return numbers.reduce(0, { $0 + $1 * $1 * $1 })
}

// Given array of numbers, return the sum of the powers of the numbers
// sumOfPowers([1, 2, 3, 4, 5]) == 343
func sumOfPowers(numbers: [Int]) -> Int {
    return numbers.reduce(0, { $0 + $1 * $1 * $1 * $1 })
}

// Given array of numbers, return the sum of the squares of the numbers
// sumOfSquares([1, 2, 3, 4, 5]) == 55
func sumOfSquares(numbers: [Int]) -> Int {
    return numbers.reduce(0, { $0 + $1 * $1 })
}

// Given array of numbers, return the sum of the cubes of the numbers
// sumOfCubes([1, 2, 3, 4, 5]) == 225
func sumOfCubes(numbers: [Int]) -> Int {
    return numbers.reduce(0, { $0 + $1 * $1 * $1 })
}

// Given array of numbers, return the sum of the powers of the numbers
// sumOfPowers([1, 2, 3, 4, 5]) == 343
func sumOfPowers(numbers: [Int]) -> Int {
    return numbers.reduce(0, { $0 + $1 * $1 * $1 * $1 })
}

// Given array of numbers, return the sum of the squares of the numbers
// sumOfSquares([1, 2, 3, 4, 5]) == 55
func sumOfSquares(numbers: [Int]) -> Int {
    return numbers.reduce(0, { $0 + $1 * $1 })
}

// Given array of numbers, return the sum of the cubes of the numbers
// sumOfCubes([1, 2, 3, 4, 5]) == 225
func sumOfCubes(numbers: [Int]) -> Int {
    return numbers.reduce(0, { $0 + $1 * $1 * $1 })
}

// Given array of numbers, return the sum of the powers of the numbers
// sumOfPowers([1, 2, 3, 4, 5]) == 343
func sumOfPowers(numbers: [Int]) -> Int {
    return numbers.reduce(0, { $0 + $1 * $1 * $1 * $1 })
}

// Given array of numbers, return the sum of the squares of the numbers
// sumOfSquares([1, 2, 3, 4, 5]) == 55
func sumOfSquares(numbers: [Int]) -> Int {
    return numbers.reduce(0, { $0 + $1 * $1 })
}

// Given array of numbers, return the sum of the cubes of the numbers
// sumOfCubes([1, 2, 3, 4, 5]) == 225
func sumOfCubes(numbers: [Int]) -> Int {
    return numbers.reduce(0, { $0 + $1 * $1 * $1 })
}

// Given array of numbers, return the sum of the powers of the numbers
// sumOfPowers([1, 2, 3, 4, 5]) == 343
func sumOfPowers(numbers: [Int]) -> Int {
    return numbers.reduce(0, { $0 + $1 * $1 * $1 * $1 })
}

// Given array of numbers, return the sum of the squares of the numbers
// sumOfSquares([1, 2, 3, 4, 

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

func sumOfSquares(numbers: [Int]) -> Int {
    return numbers.reduce(0) { (sum, number) -> Int in
        return sum + number * number
    }
}

func sumOfCubes(numbers: [Int]) -> Int {
    return numbers.reduce(0) { (sum, number) -> Int in
        return sum + number * number * number
    }
}

func sumOfPowers(numbers: [Int]) -> Int {
    return numbers.reduce(0) { (sum, number) -> Int in
        return sum + number * number
    }
}

```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()!
    return numbers.map { (number) -> Double in
        return (number - min) / (max - min)
    }
}

// Given array of numbers, return the sum of the squares of the numbers
// sumOfSquares([1, 2, 3, 4, 5]) == 55
func sumOfSquares(numbers: [Int]) -> Int {
    return numbers.reduce(0) { (sum, number) -> Int in
        return sum + number * number
    }
}

// Given array of numbers, return the sum of the cubes of the numbers
// sumOfCubes([1, 2, 3, 4, 5]) == 225
func sumOfCubes(numbers: [Int]) -> Int {
    return numbers.reduce(0) { (sum, number) -> Int in
        return sum + number * number * number
    }
}

// Given array of numbers, return the sum of the powers of the numbers
// sumOfPowers([1, 2, 3, 4, 5]) == 341
func sumOfPowers(numbers: [Int]) -> Int {
    return numbers.reduce(0) { (sum, number) -> Int in
        return sum + number * number
    }
}

// Given array of numbers, return the sum of the squares of the numbers
// sumOfSquares([1, 2, 3, 4, 5]) == 55
func sumOfSquares(numbers: [Int]) -> Int {
    return numbers.reduce(0) { (sum, number) -> Int in
        return sum + number * number
    }
}

// Given array of numbers, return the sum of the cubes of the numbers
// sumOfCubes([1, 2, 3, 4, 5]) == 225
func sumOfCubes(numbers: [Int]) -> Int {
    return numbers.reduce(0) { (sum, number) -> Int in
        return sum + number * number * number
    }
}

// Given array of numbers, return the sum of the powers of the numbers
// sumOfPowers([1, 2, 3, 4, 5]) == 341
func sumOfPowers(numbers: [Int]) -> Int {
    return numbers.reduce(0) { (sum, number) -> Int in
        return sum + number * number
    }
}

// Given array of numbers, return the sum of the squares of the numbers
// sumOfSquares([1, 2, 3, 4, 5]) == 55
func sumOfSquares(numbers: [Int]) -> Int {
    return numbers.reduce(0) { (sum, number) -> Int in
        return sum + number * number
    }
}

// Given array of numbers, return the sum of the cubes of the numbers
// sumOfCubes([1, 2, 3, 4, 5]) == 225
func sumOfCubes(numbers: [Int]) -> Int {
    return numbers.reduce(0) { (sum, number) -> Int in
        return sum + number * number * number
    }
}

// Given array of numbers, return the sum of the powers of the numbers
// sumOfPowers([1, 2, 3, 4, 5]) == 341
func sumOfPowers(numbers: [Int]) -> Int {
    return numbers.reduce(0) { (sum, number) -> Int in
        return sum + number * number
    }
}

// Given array of numbers, return the sum of the squares of the numbers
// sumOfSquares([1, 2, 3, 4, 5]) == 55
func sumOfSquares(numbers: [Int]) -> Int {
    return numbers.reduce(0) { (sum, number) -> Int in
        return sum + number * number
    }
}

// Given array of numbers, return the sum of the cubes of the numbers
// sumOfCubes([1, 2, 3, 4, 5]) == 225
func sumOfCubes(numbers: [Int]) -> Int {
    return numbers.reduce(0) { (sum, number) -> Int in
        return sum + number * number * number
    }
}

// Given array of numbers, return the sum of the powers of

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

func square(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n
    }
}

func cube(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n * n
    }
}

func power(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n
    }
}

func power3(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n * n
    }
}

func power4(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n * n * n
    }
}

func power5(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n * n * n * n
    }
}

func power6(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n * n * n * n * n
    }
}

func power7(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n * n * n * n * n * n
    }
}

func power8(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n * n * n * n * n * n * n
    }
}

```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()!
    return numbers.map { (n) -> Double in
        return (n - min) / (max - min)
    }
}

// Given array of numbers, return an array of the same length with each number squared
// square(numbers: [1, 2, 3, 4, 5]) == [1, 4, 9, 16, 25]
func square(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n
    }
}

// Given array of numbers, return an array of the same length with each number cubed
// cube(numbers: [1, 2, 3, 4, 5]) == [1, 8, 27, 64, 125]
func cube(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n * n
    }
}

// Given array of numbers, return an array of the same length with each number raised to the power of 2
// power(numbers: [1, 2, 3, 4, 5]) == [1, 4, 9, 16, 25]
func power(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n
    }
}

// Given array of numbers, return an array of the same length with each number raised to the power of 3
// power3(numbers: [1, 2, 3, 4, 5]) == [1, 8, 27, 64, 125]
func power3(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n * n
    }
}

// Given array of numbers, return an array of the same length with each number raised to the power of 4
// power4(numbers: [1, 2, 3, 4, 5]) == [1, 4, 9, 16, 25]
func power4(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n * n * n
    }
}

// Given array of numbers, return an array of the same length with each number raised to the power of 5
// power5(numbers: [1, 2, 3, 4, 5]) == [1, 4, 9, 16, 25]
func power5(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n * n * n * n
    }
}

// Given array of numbers, return an array of the same length with each number raised to the power of 6
// power6(numbers: [1, 2, 3, 4, 5]) == [1, 4, 9, 16, 25]
func power6(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n * n * n * n * n
    }
}

// Given array of numbers, return an array of the same length with each number raised to the power of 7
// power7(numbers: [1, 2, 3, 4, 5]) == [1, 4, 9, 16, 25]
func power7(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n * n * n * n * n * n
    }
}

// Given array of numbers, return an array of the same length with each number raised to the power of 8
// power8(numbers: [1, 2, 3, 4, 5]) == [1, 4, 9, 16, 25]
func power8(numbers: [Int]) -> [Int] {
    return numbers.map { (n) -> Int in
        return n * n * n * n * n * n * n * n
    }
}

// Given array of numbers, return an array of the same length with

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

func swapEnds(str: String) -> String {
    if str.count == 2 {
        return str
    }
    return str.substring(from: 1) + str.substring(to: str.count - 1) + str.substring(from: 0, length: 1)
}

func stringBits(str: String) -> String {
    return str.characters.enumerated().map { (i, c) -> String in
        if i % 2 == 0 {
            return String(c)
        }
        return ""
    }.reduce("", combine: +)
}

func last2(str: String) -> Int {
    var count = 0
    for i in 0 ..< str.count - 2 {
        if str.substring(from: i, length: 2) == str.substring(from: str.count - 2) {
            count += 1
        }
    }
    return count
}

func arrayCount9(numbers: [Int]) -> Int {
    return numbers.filter { (n) -> Bool in
        return n == 9
    }.count
}

func arrayFront9(numbers: [Int]) -> Bool {
    return numbers.take(4).contains { (n) -> Bool in
        return n == 9
    }
}

func array123(numbers: [Int]) -> Bool {
    return numbers.contains { (n) -> Bool in
        return n == 1 && numbers.contains { (n) -> Bool in
            return n == 2 && numbers.contains { (n) -> Bool in
                return n == 3
            }
        }
    }
}

```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()!
    return numbers.map { (n) -> Double in
        return (n - min) / (max - min)
    }
}

// Given a string, return a new string with the first and last chars swapped,
// except keep the first and last chars if the string length is 2
// swapEnds("code") == "eodc"
// swapEnds("a") == "a"
// swapEnds("ab") == "ba"
func swapEnds(str: String) -> String {
    if str.count == 2 {
        return str
    }
    return str.substring(from: 1) + str.substring(to: str.count - 1) + str.substring(from: 0, length: 1)
}

// Given a string, return a new string made of every other char starting with the first,
// so "Hello" yields "Hlo".
// stringBits("Hello") == "Hlo"
// stringBits("Hi") == "H"
// stringBits("Heeololeo") == "Hello"
func stringBits(str: String) -> String {
    return str.characters.enumerated().map { (i, c) -> String in
        if i % 2 == 0 {
            return String(c)
        }
        return ""
    }.reduce("", combine: +)
}

// Given a string, return the count of the number of times that a substring length 2 appears
// in the string and also as the last 2 chars of the string, so "hixxxhi" yields 1 (we won't count the end substring).
// last2("hixxhi") == 1
// last2("xaxxaxaxx") == 1
// last2("axxxaaxx") == 2
func last2(str: String) -> Int {
    var count = 0
    for i in 0 ..< str.count - 2 {
        if str.substring(from: i, length: 2) == str.substring(from: str.count - 2) {
            count += 1
        }
    }
    return count
}

// Given an array of ints, return the number of 9's in the array.
// arrayCount9([1, 2, 9]) == 1
// arrayCount9([1, 9, 9]) == 2
// arrayCount9([1, 9, 9, 3, 9]) == 3
func arrayCount9(numbers: [Int]) -> Int {
    return numbers.filter { (n) -> Bool in
        return n == 9
    }.count
}

// Given an array of ints, return true if one of the first 4 elements in the array is a 9.
// The array length may be less than 4.
// arrayFront9([1, 2, 9, 3, 4]) == true
// arrayFront9([1, 2, 3, 4, 9]) == false
// arrayFront9([1, 2, 3, 4, 5]) == false
func arrayFront9(numbers: [Int]) -> Bool {
    return numbers.take(4).contains { (n) -> Bool in
        return n == 9
    }
}

// Given an array of ints, return true if the sequence of numbers 1, 2, 3 appears in the array somewhere.
// array123([1, 1, 2, 3, 1]) == true
// array123([1, 1, 2, 4, 1]) == false
// array123([1, 1, 2, 1, 2, 3]) == true
func array123(numbers: [Int]) -> Bool {
    return numbers.contains { (n) -> Bool in
        return n == 1 && numbers.contains { (n) -> Bool in
            return n == 2 && numbers.contains { (n) -> Bool in
                return n == 3
            }
        }
    }
}

// Given 2 strings, a and b, return the number of the positions where they contain the same length 2 substring.
// So "xxcaazz" and "xxbaaz" yields 3, since the "xx", "aa", and "az" substrings appear in the same place in both strings.
// string

func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.filter {
        if let value = $0 as? Int {
            return true
        } else {
            return false
        }
    }
}

func filterStrings(values: [AnyHashable]) -> [String] {
    return values.filter {
        if let value = $0 as? String {
            return true
        } else {
            return false
        }
    }
}

func filterArrays(values: [AnyHashable]) -> [[AnyHashable]] {
    return values.filter {
        if let value = $0 as? [AnyHashable] {
            return true
        } else {
            return false
        }
    }
}

func filterDictionaries(values: [AnyHashable]) -> [[AnyHashable : AnyHashable]] {
    return values.filter {
        if let value = $0 as? [AnyHashable : AnyHashable] {
            return true
        } else {
            return false
        }
    }
}

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

// Filter given array of any swiftthon values only for strings
// filterStrings(values: ["a", 3.14, 5]) == []
// filterStrings(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == ["abc"]
func filterStrings(values: [AnyHashable]) -> [String] {
    return values.filter {
        if let value = $0 as? String {
            return true
        } else {
            return false
        }
    }
}

// Filter given array of any swiftthon values only for arrays
// filterArrays(values: ["a", 3.14, 5]) == []
// filterArrays(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [[], []]
func filterArrays(values: [AnyHashable]) -> [[AnyHashable]] {
    return values.filter {
        if let value = $0 as? [AnyHashable] {
            return true
        } else {
            return false
        }
    }
}

// Filter given array of any swiftthon values only for dictionaries
// filterDictionaries(values: ["a", 3.14, 5]) == []
// filterDictionaries(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [[:]]
func filterDictionaries(values: [AnyHashable]) -> [[AnyHashable : AnyHashable]] {
    return values.filter {
        if let value = $0 as? [AnyHashable : AnyHashable] {
            return true
        } else {
            return false
        }
    }
}

// Filter given array of any swiftthon values only for dictionaries
// filterDictionaries(values: ["a", 3.14, 5]) == []
// filterDictionaries(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [[:]]
func filterDictionaries(values: [AnyHashable]) -> [[AnyHashable : AnyHashable]] {
    return values.filter {
        if let value = $0 as? [AnyHashable : AnyHashable] {
            return true
        } else {
            return false
        }
    }
}

// Filter given array of any swiftthon values only for dictionaries
// filterDictionaries(values: ["a", 3.14, 5]) == []
// filterDictionaries(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [[:]]
func filterDictionaries(values: [AnyHashable]) -> [[AnyHashable : AnyHashable]] {
    return values.filter {
        if let value = $0 as? [AnyHashable : AnyHashable] {
            return true
        } else {
            return false
        }
    }
}

// Filter given array of any swiftthon values only for dictionaries
// filterDictionaries(values: ["a", 3.14, 5]) == []
// filterDictionaries(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [[:]]
func filterDictionaries(values: [AnyHashable]) -> [[AnyHashable : AnyHashable]] {
    return values.filter {
        if let value = $0 as? [AnyHashable : AnyHashable] {
            return true
        } else {
            return false
        }
    }
}

// Filter given array of any swiftthon values only for dictionaries
// filterDictionaries(values: ["a", 3.14, 5]) == []
// filterDictionaries(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [[:]]
func filterDictionaries(values: [AnyHashable]) -> [[AnyHashable : AnyHashable]] {
    return values.filter {
        

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

func filterStrings(values: [AnyHashable]) -> [String] {
    return values.compactMap {
        if let value = $0 as? String {
            return value
        }
        return nil
    }
}

func filterArrays(values: [AnyHashable]) -> [[AnyHashable]] {
    return values.compactMap {
        if let value = $0 as? [AnyHashable] {
            return value
        }
        return nil
    }
}

func filterDictionaries(values: [AnyHashable]) -> [AnyHashable: AnyHashable] {
    return values.compactMap {
        if let value = $0 as? [AnyHashable: AnyHashable] {
            return value
        }
        return nil
    }
}

func filterTuples(values: [AnyHashable]) -> [(AnyHashable, AnyHashable)] {
    return values.compactMap {
        if let value = $0 as? (AnyHashable, AnyHashable) {
            return value
        }
        return nil
    }
}

func filterSets(values: [AnyHashable]) -> [AnyHashable] {
    return values.compactMap {
        if let value = $0 as? Set<AnyHashable> {
            return value
        }
        return nil
    }
}

```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 {
        if let value = $0 as? Int {
            return value
        }
        return nil
    }
}

// Filter given array of any swiftthon values only for strings
// filterStrings(values: ["a", 3.14, 5]) == []
// filterStrings(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == ["abc"]
func filterStrings(values: [AnyHashable]) -> [String] {
    return values.compactMap {
        if let value = $0 as? String {
            return value
        }
        return nil
    }
}

// Filter given array of any swiftthon values only for arrays
// filterArrays(values: ["a", 3.14, 5]) == []
// filterArrays(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [[], []]
func filterArrays(values: [AnyHashable]) -> [[AnyHashable]] {
    return values.compactMap {
        if let value = $0 as? [AnyHashable] {
            return value
        }
        return nil
    }
}

// Filter given array of any swiftthon values only for dictionaries
// filterDictionaries(values: ["a", 3.14, 5]) == []
// filterDictionaries(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [:] as [AnyHashable : AnyHashable]
func filterDictionaries(values: [AnyHashable]) -> [AnyHashable: AnyHashable] {
    return values.compactMap {
        if let value = $0 as? [AnyHashable: AnyHashable] {
            return value
        }
        return nil
    }
}

// Filter given array of any swiftthon values only for tuples
// filterTuples(values: ["a", 3.14, 5]) == []
// filterTuples(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == []
func filterTuples(values: [AnyHashable]) -> [(AnyHashable, AnyHashable)] {
    return values.compactMap {
        if let value = $0 as? (AnyHashable, AnyHashable) {
            return value
        }
        return nil
    }
}

// Filter given array of any swiftthon values only for sets
// filterSets(values: ["a", 3.14, 5]) == []
// filterSets(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == []
func filterSets(values: [AnyHashable]) -> [AnyHashable] {
    return values.compactMap {
        if let value = $0 as? Set<AnyHashable> {
            return value
        }
        return nil
    }
}

// Filter given array of any swiftthon values only for dictionaries
// filterDictionaries(values: ["a", 3.14, 5]) == []
// filterDictionaries(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == []
func filterDictionaries(values: [AnyHashable]) -> [AnyHashable: AnyHashable] {
    return values.compactMap {
        if let value = $0 as? [AnyHashable: AnyHashable] {
            return value
        }
        return nil
    }
}

// Filter given array of any swiftthon values only for dictionaries
// filterDictionaries(values: ["a", 3.14, 5]) == []
// filterDictionaries(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == []
func filterDictionaries(values: [AnyHashable]) -> [AnyHashable: AnyHashable] {
    return values.compactMap {
        if let value = $0 as? [AnyHashable: AnyHashable] {
            return value
        }
        return nil
    }
}

//

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

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

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

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

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

func filterSets(values: [AnyHashable]) -> [[AnyHashable]] {
    return values.compactMap { $0 as? Set<AnyHashable> }
}

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

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

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

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

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

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

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

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

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

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

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

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

// Filter given array of any swiftthon values only for protocols
// filterProtocols(values: ["a", 3.14, 5]) == [[], [], []

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

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

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

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

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

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

func filterSets(values: [AnyHashable]) -> [Set<AnyHashable>] {
    return values.compactMap { $0 as? Set<AnyHashable> }
}

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

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

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

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

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

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

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

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

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

// Filter given array of any swiftthon values only for dictionaries
// filterDictionaries(values: ["a", 3.14, 5]) ==

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

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

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

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

func filterDictionaries(values: [AnyHashable]) -> [Dictionary<AnyHashable, AnyHashable>] {
    return values.compactMap { $0 as? [AnyHashable : AnyHashable] }
}

func filterSets(values: [AnyHashable]) -> [Set<AnyHashable>] {
    return values.compactMap { $0 as? Set<AnyHashable> }
}

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

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

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

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

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

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

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

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

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

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

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

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

// Filter given array of any swiftthon values only for protocols
// filterProtocols(values: ["a", 3.14, 5]) == []
// filterProtocols(values: [1, 2, 3, "abc", [:] as [AnyHashable

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

```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 {
        if let value = $0 as? Int {
            return value
        }
        return nil
    }
}
<|file_separator|>

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

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

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

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

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

func filterSets(values: [AnyHashable]) -> [Set<AnyHashable>] {
    return values.compactMap { $0 as? Set<AnyHashable> }
}

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

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

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

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

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

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

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

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

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

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

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

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

// Filter given array of any swiftthon values only for doubles
// filterDoubles(values: ["a", 3.14, 5]) == [[], []]
// filterDoubles(values: [1, 2,

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

```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 {
        if let value = $0 as? Int {
            return value
        }
        return nil
    }
}
<|file_separator|>

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

```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 {
        if let value = $0 as? Int {
            return value
        }
        return nil
    }
}
<|file_separator|>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Return length of given string

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Return length of given string

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Return length of given string
// strlen(string: "") ==

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Return length of given string
// strlength(string: "") == 0
// strlength(string: "abc") == 3
func strlength(string: String) -> Int {
  return string

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Return length of given string

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Return length of given string

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Return length of given string

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Return length of given string

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Return length of given string

func largestDivisor(n: Int) -> Int {
    // TODO: Write your code here
    var divisor = n - 1
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 0
}

func smallestDivisor(n: Int) -> Int {
    // TODO: Write your code here
    var divisor = 2
    while divisor <= n {
        if n % divisor == 0 {
            return divisor
        }
        divisor += 1
    }
    return 0
}

func sum(n: Int) -> Int {
    // TODO: Write your code here
    var sum = 0
    for i in 1...n {
        sum += i
    }
    return sum
}

func sum(n: Int) -> Int {
    // TODO: Write your code here
    var sum = 0
    for i in 1...n {
        if i % 3 != 0 && i % 5 != 0 {
            sum += i
        }
    }
    return sum
}

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

// For a given number n, find the smallest number that is divisible by all numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
    // TODO: Write your code here
    var divisor = 2
    while divisor <= n {
        if n % divisor == 0 {
            return divisor
        }
        divisor += 1
    }
    return 0
}

// For a given number n, find the sum of all numbers from 1 to n
// sum(n: 15) == 120
func sum(n: Int) -> Int {
    // TODO: Write your code here
    var sum = 0
    for i in 1...n {
        sum += i
    }
    return sum
}

// For a given number n, find the sum of all numbers from 1 to n, but ignore numbers divisible by 3 and 5
// sum(n: 15) == 120
func sum(n: Int) -> Int {
    // TODO: Write your code here
    var sum = 0
    for i in 1...n {
        if i % 3 != 0 && i % 5 != 0 {
            sum += i
        }
    }
    return sum
}

// For a given number n, find the sum of all numbers from 1 to n, but ignore numbers divisible by 3 and 5
// sum(n: 15) == 120
func sum(n: Int) -> Int {
    // TODO: Write your code here
    var sum = 0
    for i in 1...n {
        if i % 3 != 0 && i % 5 != 0 {
            sum += i
        }
    }
    return sum
}

// For a given number n, find the sum of all numbers from 1 to n, but ignore numbers divisible by 3 and 5
// sum(n: 15) == 120
func sum(n: Int) -> Int {
    // TODO: Write your code here
    var sum = 0
    for i in 1...n {
        if i % 3 != 0 && i % 5 != 0 {
            sum += i
        }
    }
    return sum
}

// For a given number n, find the sum of all numbers from 1 to n, but ignore numbers divisible by 3 and 5
// sum(n: 15) == 120
func sum(n: Int) -> Int {
    // TODO: Write your code here
    var sum = 0
    for i in 1...n {
        if i % 3 != 0 && i % 5 != 0 {
            sum += i
        }
    }
    return sum
}

// For a given number n, find the sum of all numbers from 1 to n, but ignore numbers divisible by 3 and 5
// sum(n: 15) == 120
func sum(n: Int) -> Int {
    // TODO: Write your code here
    var sum = 0
    for i in 1...n {
        if i % 3 != 0 && i % 5 != 0 {
            sum += i
        }
    }
    return sum
}

// For a given number n, find the sum of all numbers from 1 to n, but ignore numbers divisible by 3 and 5
// sum(n: 15) == 120
func sum(n: Int) -> Int {
    // TODO: Write your code here
    var sum = 0
    for i in 1...n {
        if i % 3 != 0 && i % 5 != 0 {
            sum += i
        }
    }
    return sum
}

// For a given number n, find the sum of all numbers from 1 to n, but ignore numbers divisible by 3 and 5
// sum(n: 15) == 120
func sum(n: Int) -> Int {
    // TODO: Write your code

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

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

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

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

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

// For a given number n, find the smallest number that is divisible by all the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
    var divisor = 1
    while divisor < n {
        if n % divisor == 0 {
            return divisor
        }
        divisor += 1
    }
    return 0
}

// For a given number n, find the largest number that is divisible by all the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 0
}

// For a given number n, find the smallest number that is divisible by all the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 0
}

// For a given number n, find the largest number that is divisible by all the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
    var divisor = 1
    while divisor < n {
        if n % divisor == 0 {
            return divisor
        }
        divisor += 1
    }
    return 0
}

// For a given number n, find the smallest number that is divisible by all the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
    var divisor = 1
    while divisor < n {
        if n % divisor == 0 {
            return divisor
        }
        divisor += 1
    }
    return 0
}

// For a given number n, find the largest number that is divisible by all the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 0
}

// For a given number n, find the smallest number that is divisible by all the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 0 {
        if n % divisor == 0 {
            return divisor
        }
        divisor -= 1
    }
    return 0
}

// For a given number n, find the largest number that is divisible by all the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
    var divisor = 1
    while divisor < n {
        if n % divisor == 0 {
            return divisor
        }
        divisor += 1
    }
    return 0
}

// For a given number n, find the smallest number that is divisible by all the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
    var divisor = 1
    while divisor < n {
        if n % divisor == 0 {
            return divisor
        }
        divisor += 1
    }
    return 0
}

// For a given number n, find the largest number that is divisible by all the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
    var divisor = n
    while divisor > 0 {
        if n % divisor == 0 {

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

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

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

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

// For a given number n, find the smallest number that is divisible by all of the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
  var divisor = 1
  while divisor <= n {
    if n % divisor == 0 {
      return divisor
    }
    divisor += 1
  }
  return 1
}

// For a given number n, find the largest number that is divisible by all of the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
  var divisor = n
  while divisor > 0 {
    if n % divisor == 0 {
      return divisor
    }
    divisor -= 1
  }
  return 1
}

// For a given number n, find the smallest number that is divisible by all of the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
  var divisor = 1
  while divisor <= n {
    if n % divisor == 0 {
      return divisor
    }
    divisor += 1
  }
  return 1
}

// For a given number n, find the largest number that is divisible by all of the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
  var divisor = n
  while divisor > 0 {
    if n % divisor == 0 {
      return divisor
    }
    divisor -= 1
  }
  return 1
}

// For a given number n, find the smallest number that is divisible by all of the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
  var divisor = 1
  while divisor <= n {
    if n % divisor == 0 {
      return divisor
    }
    divisor += 1
  }
  return 1
}

// For a given number n, find the largest number that is divisible by all of the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
  var divisor = n
  while divisor > 0 {
    if n % divisor == 0 {
      return divisor
    }
    divisor -= 1
  }
  return 1
}

// For a given number n, find the smallest number that is divisible by all of the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
  var divisor = 1
  while divisor <= n {
    if n % divisor == 0 {
      return divisor
    }
    divisor += 1
  }
  return 1
}

// For a given number n, find the largest number that is divisible by all of the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
  var divisor = n
  while divisor > 0 {
    if n % divisor == 0 {
      return divisor
    }
    divisor -= 1
  }
  return 1
}

// For a given number n, find the smallest number that is divisible by all of the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
  var divisor = 1
  while divisor <= n {
    if n % divisor == 0 {
      return divisor
    }
    divisor += 1
  }
  return 1
}

// For a given number n, find the largest number that is divisible by all of the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
  var divisor = n
  while divisor >

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

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

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

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

// For a given number n, find the smallest number that is divisible by all of the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
  var divisor = 1
  while divisor < n {
    if n % divisor == 0 {
      return divisor
    }
    divisor += 1
  }
  return 0
}

// For a given number n, find the largest number that is divisible by all of the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
  var divisor = n
  while divisor > 0 {
    if n % divisor == 0 {
      return divisor
    }
    divisor -= 1
  }
  return 0
}

// For a given number n, find the smallest number that is divisible by all of the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
  var divisor = 1
  while divisor < n {
    if n % divisor == 0 {
      return divisor
    }
    divisor += 1
  }
  return 0
}

// For a given number n, find the largest number that is divisible by all of the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
  var divisor = n
  while divisor > 0 {
    if n % divisor == 0 {
      return divisor
    }
    divisor -= 1
  }
  return 0
}

// For a given number n, find the smallest number that is divisible by all of the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
  var divisor = 1
  while divisor < n {
    if n % divisor == 0 {
      return divisor
    }
    divisor += 1
  }
  return 0
}

// For a given number n, find the largest number that is divisible by all of the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
  var divisor = n
  while divisor > 0 {
    if n % divisor == 0 {
      return divisor
    }
    divisor -= 1
  }
  return 0
}

// For a given number n, find the smallest number that is divisible by all of the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
  var divisor = 1
  while divisor < n {
    if n % divisor == 0 {
      return divisor
    }
    divisor += 1
  }
  return 0
}

// For a given number n, find the largest number that is divisible by all of the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
  var divisor = n
  while divisor > 0 {
    if n % divisor == 0 {
      return divisor
    }
    divisor -= 1
  }
  return 0
}

// For a given number n, find the smallest number that is divisible by all of the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
  var divisor = 1
  while divisor < n {
    if n % divisor == 0 {
      return divisor
    }
    divisor += 1
  }
  return 0
}

// For a given number n, find the largest number that is divisible by all of the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
  var divisor = n
  while divisor >

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

func smallestMultiple(n: Int) -> Int {
  var smallest = 1
  for i in 1...n {
    smallest *= i
    for j in 1...n {
      if smallest % j != 0 {
        smallest /= i
        break
      }
    }
  }
  return smallest
}

func sumMultiples(n: Int) -> Int {
  var sum = 0
  for i in 1...n {
    if i % 3 == 0 || i % 5 == 0 {
      sum += i
    }
  }
  return sum
}

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

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

func sumMultiplesOf3And5(n: Int) -> Int {
  var sum = 0
  for i in 1...n {
    if i % 3 == 0 || i % 5 == 0 {
      sum += i
    }
  }
  return sum
}

func sumMultiplesOf3And5(n: Int) -> Int {
  var sum = 0
  for i in 1...n {
    if i % 3 == 0 || i % 5 == 0 {
      if i % 3 != 0 && i % 5 != 0 {
        sum += i
      }
    }
  }
  return sum
}

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

// For a given number n, find the smallest number that is divisible by all of the numbers from 1 to n
// smallestMultiple(n: 10) == 2520
func smallestMultiple(n: Int) -> Int {
  var smallest = 1
  for i in 1...n {
    smallest *= i
    for j in 1...n {
      if smallest % j != 0 {
        smallest /= i
        break
      }
    }
  }
  return smallest
}

// For a given number n, find the sum of all the multiples of 3 or 5 below n
// sumMultiples(n: 10) == 23
func sumMultiples(n: Int) -> Int {
  var sum = 0
  for i in 1...n {
    if i % 3 == 0 || i % 5 == 0 {
      sum += i
    }
  }
  return sum
}

// For a given number n, find the sum of all the even numbers below n
// sumEvenNumbers(n: 10) == 2 + 8
func sumEvenNumbers(n: Int) -> Int {
  var sum = 0
  for i in 1...n {
    if i % 2 == 0 {
      sum += i
    }
  }
  return sum
}

// For a given number n, find the sum of all the odd numbers below n
// sumOddNumbers(n: 10) == 1 + 3 + 5 + 7 + 9
func sumOddNumbers(n: Int) -> Int {
  var sum = 0
  for i in 1...n {
    if i % 2 != 0 {
      sum += i
    }
  }
  return sum
}

// For a given number n, find the sum of all the numbers from 1 to n that are divisible by 3 or 5
// sumMultiplesOf3And5(n: 10) == 3 + 5 + 6 + 9
func sumMultiplesOf3And5(n: Int) -> Int {
  var sum = 0
  for i in 1...n {
    if i % 3 == 0 || i % 5 == 0 {
      sum += i
    }
  }
  return sum
}

// For a given number n, find the sum of all the numbers from 1 to n that are divisible by 3 or 5, but not both
// sumMultiplesOf3And5(n: 10) == 3 + 5 + 6 + 9
func sumMultiplesOf3And5(n: Int) -> Int {
  var sum = 0
  for i in 1...n {
    if i % 3 == 0 || i % 5 == 0 {
      if i % 3 != 0 && i % 5 != 0 {
        sum += i
      }
    }
  }
  return sum
}

// For a given number n, find the sum of all the numbers from 1 to n that are divisible by 3 or 5, but not both
// sumMultiplesOf3And5(n: 10) == 3 + 5 + 6 + 9
func sumMultiplesOf3And5(n: Int) -> Int {
  var sum = 0
  for i in 1...n {
    if i % 3 == 0 || i % 5 == 0 {
      if i % 3 != 0 && i % 5 != 0 {
        sum += i
      }
    }
  }
  return sum
}

// For a given number n, find the sum of all the numbers from 1 to n that are divisible by 3 or 5, but not both
// sumMultiplesOf3And5(n: 10) == 3 + 5 + 6 + 9
func sumMultiplesOf3And5(n: Int) -> Int {
  var sum = 0
  for i in 1...n {
    if i % 3 == 0 || i % 5 == 0 {
      if i % 3 != 0 && i

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

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

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

func smallestDivisor(n: Int) -> Int {
  var divisor = 2
  while divisor <= n {
    if n % divisor == 0 {
      return divisor
    }
    divisor += 1
  }
  return 0
}

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

// For a given number n, find the smallest number that is divisible by all the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
  var divisor = 2
  while divisor <= n {
    if n % divisor == 0 {
      return divisor
    }
    divisor += 1
  }
  return 0
}

// For a given number n, find the largest number that is divisible by all the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
  var divisor = n - 1
  while divisor > 0 {
    if n % divisor == 0 {
      return divisor
    }
    divisor -= 1
  }
  return 0
}

// For a given number n, find the smallest number that is divisible by all the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
  var divisor = 2
  while divisor <= n {
    if n % divisor == 0 {
      return divisor
    }
    divisor += 1
  }
  return 0
}

// For a given number n, find the largest number that is divisible by all the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
  var divisor = n - 1
  while divisor > 0 {
    if n % divisor == 0 {
      return divisor
    }
    divisor -= 1
  }
  return 0
}

// For a given number n, find the smallest number that is divisible by all the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
  var divisor = 2
  while divisor <= n {
    if n % divisor == 0 {
      return divisor
    }
    divisor += 1
  }
  return 0
}

// For a given number n, find the largest number that is divisible by all the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
  var divisor = n - 1
  while divisor > 0 {
    if n % divisor == 0 {
      return divisor
    }
    divisor -= 1
  }
  return 0
}

// For a given number n, find the smallest number that is divisible by all the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
  var divisor = 2
  while divisor <= n {
    if n % divisor == 0 {
      return divisor
    }
    divisor += 1
  }
  return 0
}

// For a given number n, find the largest number that is divisible by all the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
  var divisor = n - 1
  while divisor > 0 {
    if n % divisor == 0 {
      return divisor
    }
    divisor -= 1
  }
  return 0
}

// For a given number n, find the smallest number that is divisible by all the numbers from 1 to n
// smallestDivisor(n: 15) == 15
func smallestDivisor(n: Int) -> Int {
  var divisor = 2
  while divisor <= n {
    if n % divisor == 0 {
      return divisor
    }
    divisor += 1
  }
  return 0
}

// For a given number n, find the largest number that is divisible by all the numbers from 1 to n
// largestDivisor(n: 15) == 15
func largestDivisor(n: Int) -> Int {
  var divisor = n - 1

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

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

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

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

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

func smallestDivisible(n: Int) -> Int {
    var smallest = 1
    for i in 1...n {
        smallest *= i
        while smallest % i != 0 {
            smallest += 1
        }
    }
    return smallest
}

func largestDivisible(n: Int) -> Int {
    var largest = 1
    for i in 1...n {
        largest *= i
        while largest % i != 0 {
            largest += 1
        }
    }
    return largest
}

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

// For a given number n, find the smallest number that is divisible by all the numbers from 1 to n
// smallestDivisible(n: 15) == 60
func smallestDivisible(n: Int) -> Int {
    var smallest = 1
    for i in 1...n {
        smallest *= i
        while smallest % i != 0 {
            smallest += 1
        }
    }
    return smallest
}

// For a given number n, find the largest number that is divisible by all the numbers from 1 to n
// largestDivisible(n: 15) == 120
func largestDivisible(n: Int) -> Int {
    var largest = 1
    for i in 1...n {
        largest *= i
        while largest % i != 0 {
            largest += 1
        }
    }
    return largest
}

// For a given number n, find the smallest number that is divisible by all the numbers from 1 to n
// smallestDivisible(n: 15) == 60
func smallestDivisible(n: Int) -> Int {
    var smallest = 1
    for i in 1...n {
        smallest *= i
        while smallest % i != 0 {
            smallest += 1
        }
    }
    return smallest
}

// For a given number n, find the largest number that is divisible by all the numbers from 1 to n
// largestDivisible(n: 15) == 120
func largestDivisible(n: Int) -> Int {
    var largest = 1
    for i in 1...n {
        largest *= i
        while largest % i != 0 {
            largest += 1
        }
    }
    return largest
}

// For a given number n, find the smallest number that is divisible by all the numbers from 1 to n
// smallestDivisible(n: 15) == 60
func smallestDivisible(n: Int) -> Int {
    var smallest = 1
    for i in 1...n {
        smallest *= i
        while smallest % i != 0 {
            smallest += 1
        }
    }
    return smallest
}

// For a given number n, find the largest number that is divisible by all the numbers from 1 to n
// largestDivisible(n: 15) == 120
func largestDivisible(n: Int) -> Int {
    var largest = 1
    for i in 1...n {
        largest *= i
        while largest % i != 0 {
            largest += 1
        }
    }
    return largest
}

// For a given number n, find the smallest number that is divisible by all the numbers from 1 to n
// smallestDivisible(n: 15) == 60
func smallestDivisible(n: Int) -> Int {
    var smallest = 1
    for i in 1...n {
        smallest *= i
        while smallest % i != 0 {
            smallest += 1
        }
    }
    return smallest
}

// For a given number n, find the largest number that is divisible by all the numbers from 1 to n
// largestDivisible(n: 15) == 120
func largestDivisible(n: Int) -> Int {
    var largest = 1
    for i in 1...n {
        largest *= i
        while largest % i != 0 {
            largest += 1
        }
    }
    return largest
}

// For a given number n, find the smallest number that is divisible by all the numbers from 1 to n
// smallestDivisible(n: 15) == 60
func smallestDivisible(n: Int) -> Int {
    var smallest = 1
    for i in 1...n {
        smallest *= i
        while smallest % i != 0 {
            smallest += 1
        }
    }
    return smallest
}

// For a given number n, find the largest number that is divisible by all the numbers from 1 to n
// largestDivisible(n: 15)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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) == [

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

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

// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
  var factors = [Int]()
  var n = n
  var i = 2
  while i * i <= n {
    if n % i == 0 {
      factors.append(i)
      n = n / i
    } else {
      i += 1
    }
  }
  if n > 1 {
    factors.append(n)
  }
  return factors
}

// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
  var factors = [Int]()
  var n = n
  var i = 2
  while i * i <= n {
    if n % i == 0 {
      factors.append(i)
      n = n / i
    } else {
      i += 1
    }
  }
  if n > 1 {
    factors.append(n)
  }
  return factors
}

// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
  var factors = [Int]()
  var n = n
  var i = 2
  while i * i <= n {
    if n % i == 0 {
      factors.append(i)
      n = n / i
    } else {
      i += 1
    }
  }
  if n > 1 {
    factors.append(n)
  }
  return factors
}

// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
  var factors = [Int]()
  var n = n
  var i = 2
  while i * i <= n {
    if n % i == 0 {
      factors.append(i)
      n = n / i
    } else {
      i += 1
    }
  }
  if n > 1 {
    factors.append(n)
  }
  return factors
}

// 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

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if seen.contains(number) {
            continue
        }
        seen.insert(number)
        result.append(number)
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if seen.contains(number) {
            continue
        }
        seen.insert(number)
        result.append(number)
    }
    return result
}
<|file_separator|>

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = [Int]()
    for number in numbers {
        if seen.contains(number) {
            continue
        } else {
            seen.append(number)
            result.append(number)
        }
    }
    return result
}

func longestUniqueSubstring(string: String) -> String {
    var result = ""
    var seen = [Character]()
    for char in string {
        if seen.contains(char) {
            result = String(seen)
            seen = [char]
        } else {
            seen.append(char)
        }
    }
    result = String(seen)
    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]()
    for number in numbers {
        if seen.contains(number) {
            continue
        } else {
            seen.append(number)
            result.append(number)
        }
    }
    return result
}

// From a string, return the longest substring that contains only unique characters.
// longestUniqueSubstring(string: "abcabcbb") == "abc"
// longestUniqueSubstring(string: "bbbbb") == "b"
// longestUniqueSubstring(string: "pwwkew") == "wke"
func longestUniqueSubstring(string: String) -> String {
    var result = ""
    var seen = [Character]()
    for char in string {
        if seen.contains(char) {
            result = String(seen)
            seen = [char]
        } else {
            seen.append(char)
        }
    }
    result = String(seen)
    return result
}

// Given a string, return the longest substring that contains only unique characters.
// longestUniqueSubstring(string: "abcabcbb") == "abc"
// longestUniqueSubstring(string: "bbbbb") == "b"
// longestUniqueSubstring(string: "pwwkew") == "wke"
func longestUniqueSubstring(string: String) -> String {
    var result = ""
    var seen = [Character]()
    for char in string {
        if seen.contains(char) {
            result = String(seen)
            seen = [char]
        } else {
            seen.append(char)
        }
    }
    result = String(seen)
    return result
}

// Given a string, return the longest substring that contains only unique characters.
// longestUniqueSubstring(string: "abcabcbb") == "abc"
// longestUniqueSubstring(string: "bbbbb") == "b"
// longestUniqueSubstring(string: "pwwkew") == "wke"
func longestUniqueSubstring(string: String) -> String {
    var result = ""
    var seen = [Character]()
    for char in string {
        if seen.contains(char) {
            result = String(seen)
            seen = [char]
        } else {
            seen.append(char)
        }
    }
    result = String(seen)
    return result
}

// Given a string, return the longest substring that contains only unique characters.
// longestUniqueSubstring(string: "abcabcbb") == "abc"
// longestUniqueSubstring(string: "bbbbb") == "b"
// longestUniqueSubstring(string: "pwwkew") == "wke"
func longestUniqueSubstring(string: String) -> String {
    var result = ""
    var seen = [Character]()
    for char in string {
        if seen.contains(char) {
            result = String(seen)
            seen = [char]
        } else {
            seen.append(char)
        }
    }
    result = String(seen)
    return result
}

// Given a string, return the longest substring that contains only unique characters.
// longestUniqueSubstring(string: "abcabcbb") == "abc"
// longestUniqueSubstring(string: "bbbbb") == "b"
// longestUniqueSubstring(string: "pwwkew") == "wke"
func longestUniqueSubstring(string: String) -> String {
    var result = ""
    var seen = [Character]()
    for char in string {
        if seen.contains(char) {
            result = String(seen)
            seen = [char]
        } else {
            seen.append(char)
        }
    }
    result = String(seen)
    return result
}

// Given a string, return the longest substring that contains only unique characters.
// longestUniqueSubstring(string: "abcabcbb") == "abc"
// longestUniqueSubstring(string: "bbbbb") == "b"
// longestUniqueSubstring(string: "pwwkew") == "wke"
func longestUniqueSubstring(string: String) -> String {
    var result = ""
    var seen = [Character]()
    for char in string {
        if seen.contains(char) {
            result = String(seen)
            seen = [char]
        } else {
            seen.append(char)
        }
    }
    result = String(seen)

func removeDuplicates(numbers: [Int]) -> [Int] {
  var result = [Int]()
  var seen = [Int: Int]()
  for number in numbers {
    if seen[number] == nil {
      seen[number] = 1
      result.append(number)
    } else {
      seen[number]! += 1
    }
  }
  return result
}

func maxDiff(numbers: [Int]) -> Int {
  var max = Int.min
  for i in 0..<numbers.count {
    for j in i+1..<numbers.count {
      if numbers[j] - numbers[i] > max {
        max = numbers[j] - numbers[i]
      }
    }
  }
  return max
}

func maxProduct(numbers: [Int]) -> Int {
  var max = Int.min
  for i in 0..<numbers.count {
    for j in i+1..<numbers.count {
      if numbers[j] * numbers[i] > max {
        max = numbers[j] * numbers[i]
      }
    }
  }
  return max
}

func maxSum(numbers: [Int]) -> Int {
  var max = Int.min
  for i in 0..<numbers.count {
    for j in i+1..<numbers.count {
      if numbers[j] + numbers[i] > max {
        max = numbers[j] + numbers[i]
      }
    }
  }
  return max
}

func maxSum(numbers: [Int]) -> Int {
  var max = Int.min
  for i in 0..<numbers.count {
    for j in i+1..<numbers.count {
      for k in j+1..<numbers.count {
        if numbers[j] + numbers[i] + numbers[k] > max {
          max = numbers[j] + numbers[i] + numbers[k]
        }
      }
    }
  }
  return max
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
  var result = [Int]()
  var seen = [Int: Int]()
  for number in numbers {
    if seen[number] == nil {
      seen[number] = 1
      result.append(number)
    } else {
      seen[number]! += 1
    }
  }
  return result
}

// From an array of integers, find the maximum difference between two elements.
// maxDiff(numbers: [1, 2, 3, 4]) == 3
func maxDiff(numbers: [Int]) -> Int {
  var max = Int.min
  for i in 0..<numbers.count {
    for j in i+1..<numbers.count {
      if numbers[j] - numbers[i] > max {
        max = numbers[j] - numbers[i]
      }
    }
  }
  return max
}

// From an array of integers, find the maximum product of two elements.
// maxProduct(numbers: [1, 2, 3, 4]) == 8
func maxProduct(numbers: [Int]) -> Int {
  var max = Int.min
  for i in 0..<numbers.count {
    for j in i+1..<numbers.count {
      if numbers[j] * numbers[i] > max {
        max = numbers[j] * numbers[i]
      }
    }
  }
  return max
}

// From an array of integers, find the maximum sum of two elements.
// maxSum(numbers: [1, 2, 3, 4]) == 7
func maxSum(numbers: [Int]) -> Int {
  var max = Int.min
  for i in 0..<numbers.count {
    for j in i+1..<numbers.count {
      if numbers[j] + numbers[i] > max {
        max = numbers[j] + numbers[i]
      }
    }
  }
  return max
}

// From an array of integers, find the maximum sum of three elements.
// maxSum(numbers: [1, 2, 3, 4]) == 10
func maxSum(numbers: [Int]) -> Int {
  var max = Int.min
  for i in 0..<numbers.count {
    for j in i+1..<numbers.count {
      for k in j+1..<numbers.count {
        if numbers[j] + numbers[i] + numbers[k] > max {
          max = numbers[j] + numbers[i] + numbers[k]
        }
      }
    }
  }
  return max
}

// From an array of integers, find the maximum sum of three elements.
// maxSum(numbers: [1, 2, 3, 4]) == 10
func maxSum(numbers: [Int]) -> Int {
  var max = Int.min
  for i in 0..<numbers.count {
    for j in i+1..<numbers.count {
      for k in j+1..<numbers.count {
        if numbers[j] + numbers[i] + numbers[k] > max {
          max = numbers[j] + numbers[i] + numbers[k]
        }
      }
    }
  }
  return max
}

// From an array of integers, find the maximum sum of three elements.
// maxSum(numbers: [1, 2, 3, 4]) == 10
func maxSum(numbers: [Int]) -> Int {
  var max = Int.min
  for i in 0..<numbers.count {
    for j in i+1..<numbers.count {
      for k in j+1..<numbers.count {
        if numbers[j] + numbers[i] + numbers[k] > max {
          max = numbers[j] + numbers[i] + numbers[k]
        }
      }
    }
  }
  return max
}

// From an array of integers, find the maximum sum of three elements.
// maxSum(numbers: [1, 2, 3, 4]) == 10
func maxSum(numbers: [Int]) -> Int {
  var max = Int.min
  for i in 0..<numbers.count {
    for j in i+1..<numbers.count {
      for k in j+1..<numbers.count {
        if numbers[

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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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) {
            

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = [Int]()
    for number in numbers {
        if seen.contains(number) {
            continue
        }
        seen.append(number)
        result.append(number)
    }
    return result
}

func longestSubstring(string: String) -> String {
    var longest = ""
    var current = ""
    for character in string {
        if current.contains(character) {
            if current.count > longest.count {
                longest = current
            }
            current = ""
        }
        current.append(character)
    }
    if current.count > longest.count {
        longest = current
    }
    return longest
}

```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]()
    for number in numbers {
        if seen.contains(number) {
            continue
        }
        seen.append(number)
        result.append(number)
    }
    return result
}

// Given a string, return the longest substring without repeating characters.
// longestSubstring("abcabcbb") == "abc"
// longestSubstring("bbbbb") == "b"
// longestSubstring("pwwkew") == "wke"
func longestSubstring(string: String) -> String {
    var longest = ""
    var current = ""
    for character in string {
        if current.contains(character) {
            if current.count > longest.count {
                longest = current
            }
            current = ""
        }
        current.append(character)
    }
    if current.count > longest.count {
        longest = current
    }
    return longest
}

// Given a string, return the longest substring without repeating characters.
// longestSubstring("abcabcbb") == "abc"
// longestSubstring("bbbbb") == "b"
// longestSubstring("pwwkew") == "wke"
func longestSubstring(string: String) -> String {
    var longest = ""
    var current = ""
    for character in string {
        if current.contains(character) {
            if current.count > longest.count {
                longest = current
            }
            current = ""
        }
        current.append(character)
    }
    if current.count > longest.count {
        longest = current
    }
    return longest
}

// Given a string, return the longest substring without repeating characters.
// longestSubstring("abcabcbb") == "abc"
// longestSubstring("bbbbb") == "b"
// longestSubstring("pwwkew") == "wke"
func longestSubstring(string: String) -> String {
    var longest = ""
    var current = ""
    for character in string {
        if current.contains(character) {
            if current.count > longest.count {
                longest = current
            }
            current = ""
        }
        current.append(character)
    }
    if current.count > longest.count {
        longest = current
    }
    return longest
}

// Given a string, return the longest substring without repeating characters.
// longestSubstring("abcabcbb") == "abc"
// longestSubstring("bbbbb") == "b"
// longestSubstring("pwwkew") == "wke"
func longestSubstring(string: String) -> String {
    var longest = ""
    var current = ""
    for character in string {
        if current.contains(character) {
            if current.count > longest.count {
                longest = current
            }
            current = ""
        }
        current.append(character)
    }
    if current.count > longest.count {
        longest = current
    }
    return longest
}

// Given a string, return the longest substring without repeating characters.
// longestSubstring("abcabcbb") == "abc"
// longestSubstring("bbbbb") == "b"
// longestSubstring("pwwkew") == "wke"
func longestSubstring(string: String) -> String {
    var longest = ""
    var current = ""
    for character in string {
        if current.contains(character) {
            if current.count > longest.count {
                longest = current
            }
            current = ""
        }
        current.append(character)
    }
    if current.count > longest.count {
        longest = current
    }
    return longest
}

// Given a string, return the longest substring without repeating characters.
// longestSubstring("abcabcbb") == "abc"
// longestSubstring("bbbbb") == "b"
// longestSubstring("pwwkew") == "wke"
func longestSubstring(string: String) -> String {
    var longest = ""
    var current = ""
    for character in string {
        if current.contains(character) {
            if current.count > longest.count {
                longest = current
            }
            current = ""
        }
        current.append(character)
    }
    if current.count > longest.count {
        longest = current
    }
    return longest
}

// Given a string, return the longest substring without repeating

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if seen.contains(number) {
            continue
        }
        seen.insert(number)
        result.append(number)
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if seen.contains(number) {
            continue
        }
        seen.insert(number)
        result.append(number)
    }
    return result
}

// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if seen.contains(number) {
            continue
        }
        seen.insert(number)
        result.append(number)
    }
    return result
}

// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if seen.contains(number) {
            continue
        }
        seen.insert(number)
        result.append(number)
    }
    return result
}

// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if seen.contains(number) {
            continue
        }
        seen.insert(number)
        result.append(number)
    }
    return result
}

// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if seen.contains(number) {
            continue
        }
        seen.insert(number)
        result.append(number)
    }
    return result
}

// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if seen.contains(number) {
            continue
        }
        seen.insert(number)
        result.append(number)
    }
    return result
}

// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if seen.contains(number) {
            continue
        }
        seen.insert(number)
        result.append(number)
    }
    return result
}

// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = [Int]()
    for number in numbers {
        if !seen.contains(number) {
            result.append(number)
            seen.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]()
    for number in numbers {
        if !seen.contains(number) {
            result.append(number)
            seen.append(number)
        }
    }
    return result
}
<|file_separator|>

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = [Int]()
    for number in numbers {
        if !seen.contains(number) {
            seen.append(number)
            result.append(number)
        }
    }
    return result
}

func removeDuplicates(string: String) -> String {
    var result = ""
    var seen = [Character]()
    for char in string {
        if !seen.contains(char) {
            seen.append(char)
            result.append(char)
        }
    }
    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]()
    for number in numbers {
        if !seen.contains(number) {
            seen.append(number)
            result.append(number)
        }
    }
    return result
}

// Given a string, return a new string with all duplicate characters removed.
// removeDuplicates(string: "hello") == "helo"
func removeDuplicates(string: String) -> String {
    var result = ""
    var seen = [Character]()
    for char in string {
        if !seen.contains(char) {
            seen.append(char)
            result.append(char)
        }
    }
    return result
}

// Given a string, return a new string with all duplicate characters removed.
// removeDuplicates(string: "hello") == "helo"
func removeDuplicates(string: String) -> String {
    var result = ""
    var seen = [Character]()
    for char in string {
        if !seen.contains(char) {
            seen.append(char)
            result.append(char)
        }
    }
    return result
}

// Given a string, return a new string with all duplicate characters removed.
// removeDuplicates(string: "hello") == "helo"
func removeDuplicates(string: String) -> String {
    var result = ""
    var seen = [Character]()
    for char in string {
        if !seen.contains(char) {
            seen.append(char)
            result.append(char)
        }
    }
    return result
}

// Given a string, return a new string with all duplicate characters removed.
// removeDuplicates(string: "hello") == "helo"
func removeDuplicates(string: String) -> String {
    var result = ""
    var seen = [Character]()
    for char in string {
        if !seen.contains(char) {
            seen.append(char)
            result.append(char)
        }
    }
    return result
}

// Given a string, return a new string with all duplicate characters removed.
// removeDuplicates(string: "hello") == "helo"
func removeDuplicates(string: String) -> String {
    var result = ""
    var seen = [Character]()
    for char in string {
        if !seen.contains(char) {
            seen.append(char)
            result.append(char)
        }
    }
    return result
}

// Given a string, return a new string with all duplicate characters removed.
// removeDuplicates(string: "hello") == "helo"
func removeDuplicates(string: String) -> String {
    var result = ""
    var seen = [Character]()
    for char in string {
        if !seen.contains(char) {
            seen.append(char)
            result.append(char)
        }
    }
    return result
}

// Given a string, return a new string with all duplicate characters removed.
// removeDuplicates(string: "hello") == "helo"
func removeDuplicates(string: String) -> String {
    var result = ""
    var seen = [Character]()
    for char in string {
        if !seen.contains(char) {
            seen.append(char)
            result.append(char)
        }
    }
    return result
}

// Given a string, return a new string with all duplicate characters removed.
// removeDuplicates(string: "hello") == "helo"
func removeDuplicates(string: String) -> String {
    var result = ""
    var seen = [Character]()
    for char in string {
        if !seen.contains(char) {
            seen.append(char)
            result.append(char)
        }
    }
    return result
}

// Given a string, return a new string with all duplicate characters removed.
// removeDuplicates(string: "hello") == "helo"
func removeDuplicates(string: String) -> String {
    var result = ""
    var seen = [Character]()
    for char in string {
        if !seen.contains(char) {
            seen.append(char)
            result.append(char)
        }
    }
    return result
}

// Given a string, return a new string with all duplicate characters removed.
// removeDuplicates(string: "hello") == "helo"
func removeDuplicates(string: String) -> String {
    

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = [Int]()
    for number in numbers {
        if seen.contains(number) {
            continue
        }
        seen.append(number)
        result.append(number)
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = [Int]()
    for number in numbers {
        if seen.contains(number) {
            continue
        }
        seen.append(number)
        result.append(number)
    }
    return result
}
<|file_separator|>```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if !seen.contains(number) {
            seen.insert(number)
            result.append(number)
        }
    }
    return result
}

func longestSubstring(string: String) -> String {
    var result = ""
    var seen = Set<Character>()
    var start = 0
    for end in 0..<string.count {
        let char = string[string.index(string.startIndex, offsetBy: end)]
        if seen.contains(char) {
            while string[string.index(string.startIndex, offsetBy: start)] != char {
                seen.remove(string[string.index(string.startIndex, offsetBy: start)])
                start += 1
            }
            start += 1
        } else {
            seen.insert(char)
        }
        if end - start + 1 > result.count {
            result = String(string[string.index(string.startIndex, offsetBy: start)..<string.index(string.startIndex, offsetBy: end + 1)])
        }
    }
    return result
}

func longestPalindrome(string: String) -> String {
    var result = ""
    for i in 0..<string.count {
        var left = i
        var right = i
        while left >= 0 && right < string.count && string[string.index(string.startIndex, offsetBy: left)] == string[string.index(string.startIndex, offsetBy: right)] {
            left -= 1
            right += 1
        }
        if right - left - 1 > result.count {
            result = String(string[string.index(string.startIndex, offsetBy: left + 1)..<string.index(string.startIndex, offsetBy: right)])
        }
    }
    for i in 0..<string.count {
        var left = i
        var right = i + 1
        while left >= 0 && right < string.count && string[string.index(string.startIndex, offsetBy: left)] == string[string.index(string.startIndex, offsetBy: right)] {
            left -= 1
            right += 1
        }
        if right - left - 1 > result.count {
            result = String(string[string.index(string.startIndex, offsetBy: left + 1)..<string.index(string.startIndex, offsetBy: right)])
        }
    }
    return result
}

func longestPalindromePermutation(string: String) -> String {
    var result = ""
    var seen = Set<Character>()
    var oddCount = 0
    for char in string {
        if seen.contains(char) {
            seen.remove(char)
            oddCount -= 1
        } else {
            seen.insert(char)
            oddCount += 1
        }
    }
    if oddCount > 1 {
        return ""
    }
    for char in string {
        if seen.contains(char) {
            result += String(char)
            seen.remove(char)
        }
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if !seen.contains(number) {
            seen.insert(number)
            result.append(number)
        }
    }
    return result
}

// Given a string, return the longest substring without repeating characters.
// longestSubstring(string: "abcabcbb") == "abc"
func longestSubstring(string: String) -> String {
    var result = ""
    var seen = Set<Character>()
    var start = 0
    for end in 0..<string.count {
        let char = string[string.index(string.startIndex, offsetBy: end)]
        if seen.contains(char) {
            while string[string.index(string.startIndex, offsetBy: start)] != char {
                seen.remove(string[string.index(string.startIndex, offsetBy: start)])
                start += 1
            }
            start += 1
        } else {
            seen.insert(char)
        }
        if end - start + 1 > result.count {
            result = String(string[string.index(string.startIndex, offsetBy: start)..<string.index(string.startIndex, offsetBy: end + 1)])
        }
    }
    return result
}

// Given a string, return the longest substring that is a palindrome.
// longestPalindrome(string: "abccba") == "abccba"
func longestPalindrome(string: String) -> String {
    var result = ""
    for i in 0..<string.count {
        var left = i
        var right = i
        while left >= 0 && right < string.count && string[string.index(string.startIndex, offsetBy: left)] == string[string.index(string.startIndex, offsetBy: right)] {
            left -= 1
            right += 1
        }
        if right - left - 1 > result.count {
            result = String(string[string.index(string.startIndex, offsetBy: left + 1)..<string.index(string.startIndex, offsetBy: right)])
        }
    }
    for i in 0..<string.count {
        var left = i
        var right = i + 1
        while left >= 0 && right < string.count && string[string.index(string.startIndex, offsetBy: left)] == string[string.index(string.startIndex, offsetBy: right)] {
            left -= 1
            right += 1
        }
        if right - left - 1 > result.count {
            result = String(string[string.index(string.startIndex, offsetBy: left + 1)..<string.index(string.startIndex, offsetBy: right)])
        }
    }
    return result
}

// Given a string, return the longest substring that is a permutation of a palindrome.
// longestPalindromePermutation(string: "abccba") == "abccba"
// longestPalindromePermutation(string: "abccba") == "abccba"
func longestPalindromePermutation(string: String) -> String {
    var result = ""
    var seen = Set<Character>()
    var oddCount = 0
    for char in string {
        if seen.contains(char) {
            seen.remove(char)
            oddCount -= 1
        } else {
            seen.insert(char)
            oddCount += 1
        }
    }
    if oddCount > 1 {
        return ""
    }
    for char in string {
        if seen.contains(char) {
            result += String(char)
            seen.remove(char)
        }
    }
    return result
}

// Given a string, return the longest substring that is a permutation of a palindrome.
// longestPalindromePermutation(string: "abccba") == "abccba"
// longestPalindromePermutation(string: "abccba") == "abccba"
func longestPalindromePermutation(string: String) -> String {
    var result = ""
    var seen = Set<Character>()
    var oddCount = 0
    for char in string {
        if seen.contains(char) {
            seen.remove(char)
            oddCount -= 1
        } else {
            seen.insert(char)
            oddCount += 1
        }
    }
    if oddCount > 1 {

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char
        }
    }
    return result
}
<|file_separator|>

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char
        }
    }
    return result
}
<|file_separator|>

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char
        }
    }
    return result
}
<|file_separator|>

func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isUppercase {
            result += c.lowercased()
        } else {
            result += c.uppercased()
        }
    }
    return result
}

func countIS(string: String) -> Int {
    var result = 0
    var index = 0
    while index < string.count {
        if string.substring(with: index..<index+2) == "is" {
            result += 1
            index += 2
        } else {
            index += 1
        }
    }
    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 c in string {
        if c.isUppercase {
            result += c.lowercased()
        } else {
            result += c.uppercased()
        }
    }
    return result
}

// For a given string, return the number of times the string "is" appears in the string.
// countIS(string: "This is a test") == 1
// countIS(string: "This is is a test") == 2
func countIS(string: String) -> Int {
    var result = 0
    var index = 0
    while index < string.count {
        if string.substring(with: index..<index+2) == "is" {
            result += 1
            index += 2
        } else {
            index += 1
        }
    }
    return result
}

// For a given string, return the number of times the string "is" appears in the string.
// countIS(string: "This is a test") == 1
// countIS(string: "This is is a test") == 2
func countIS(string: String) -> Int {
    var result = 0
    var index = 0
    while index < string.count {
        if string.substring(with: index..<index+2) == "is" {
            result += 1
            index += 2
        } else {
            index += 1
        }
    }
    return result
}

// For a given string, return the number of times the string "is" appears in the string.
// countIS(string: "This is a test") == 1
// countIS(string: "This is is a test") == 2
func countIS(string: String) -> Int {
    var result = 0
    var index = 0
    while index < string.count {
        if string.substring(with: index..<index+2) == "is" {
            result += 1
            index += 2
        } else {
            index += 1
        }
    }
    return result
}

// For a given string, return the number of times the string "is" appears in the string.
// countIS(string: "This is a test") == 1
// countIS(string: "This is is a test") == 2
func countIS(string: String) -> Int {
    var result = 0
    var index = 0
    while index < string.count {
        if string.substring(with: index..<index+2) == "is" {
            result += 1
            index += 2
        } else {
            index += 1
        }
    }
    return result
}

// For a given string, return the number of times the string "is" appears in the string.
// countIS(string: "This is a test") == 1
// countIS(string: "This is is a test") == 2
func countIS(string: String) -> Int {
    var result = 0
    var index = 0
    while index < string.count {
        if string.substring(with: index..<index+2) == "is" {
            result += 1
            index += 2
        } else {
            index += 1
        }
    }
    return result
}

// For a given string, return the number of times the string "is" appears in the string.
// countIS(string: "This is a test") == 1
// countIS(string: "This is is a test") == 2
func countIS(string: String) -> Int {
    var result = 0
    var index = 0
    while index < string.count {
        if string.substring(with: index..<index+2) == "is" {
            result += 1
            index += 2
        } else {
            index += 1
        }
    }
    return result
}

// For a given string, return the number of times the string "is" appears in the string.
// countIS(string: "This is a test") == 1
// countIS(string: "This is is a test") == 2
func countIS(string: String) -> Int {
    var result = 0
    var index = 0
    while index < string.count {
        if string.substring(

func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isLowercase {
            result += c.uppercased()
        } else if c.isUppercase {
            result += c.lowercased()
        } else {
            result += c
        }
    }
    return result
}

func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    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 c in string {
        if c.isLowercase {
            result += c.uppercased()
        } else if c.isUppercase {
            result += c.lowercased()
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "hello world") == "Hello World"
func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "hello world") == "Hello World"
func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "hello world") == "Hello World"
func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "hello world") == "Hello World"
func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "hello world") == "Hello World"
func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "hello world") == "Hello World"
func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "hello world") == "Hello World"
func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "hello world") == "Hello World"
func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char
        }
    }
    return result
}
<|file_separator|>

func flipCase(string: String) -> String {
  return string.map {
    if $0.isUppercase {
      return $0.lowercased()
    } else {
      return $0.uppercased()
    }
  }.joined()
}

func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
  return string.map {
    if $0.isUppercase {
      return $0.lowercased()
    } else {
      return $0.uppercased()
    }
  }.joined()
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is William") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is William") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello

func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isUppercase {
            result += c.lowercased()
        } else {
            result += c.uppercased()
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isUppercase {
            result += c.lowercased()
        } else {
            result += c.uppercased()
        }
    }
    return result
}
<|file_separator|>

func flipCase(string: String) -> String {
    return string.uppercased()
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.uppercased()
}
<|file_separator|>

func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isLowercase {
            result += c.uppercased()
        } else {
            result += c.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 c in string {
        if c.isLowercase {
            result += c.uppercased()
        } else {
            result += c.lowercased()
        }
    }
    return result
}
<|file_separator|>

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
}
<|file_separator|>

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}

func concatenate(strings: [String], separator: String) -> String {
    var result = ""
    for string in strings {
        result += string + separator
    }
    return result
}

func concatenate(strings: [String], separator: String, prefix: String, postfix: String) -> String {
    var result = prefix
    for string in strings {
        result += string + separator
    }
    return result + postfix
}

```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: ["a", "b", "c"], separator: ", ") == "a, b, c"
func concatenate(strings: [String], separator: String) -> String {
    var result = ""
    for string in strings {
        result += string + separator
    }
    return result
}

// Concatenate array of strings into a single string
// concatenate(strings: ["a", "b", "c"], separator: ", ", prefix: "(", postfix: ")") == "(a, b, c)"
func concatenate(strings: [String], separator: String, prefix: String, postfix: String) -> String {
    var result = prefix
    for string in strings {
        result += string + separator
    }
    return result + postfix
}

// Concatenate array of strings into a single string
// concatenate(strings: ["a", "b", "c"], separator: ", ", prefix: "(", postfix: ")") == "(a, b, c)"
func concatenate(strings: [String], separator: String, prefix: String, postfix: String) -> String {
    var result = prefix
    for string in strings {
        result += string + separator
    }
    return result + postfix
}

// Concatenate array of strings into a single string
// concatenate(strings: ["a", "b", "c"], separator: ", ", prefix: "(", postfix: ")") == "(a, b, c)"
func concatenate(strings: [String], separator: String, prefix: String, postfix: String) -> String {
    var result = prefix
    for string in strings {
        result += string + separator
    }
    return result + postfix
}

// Concatenate array of strings into a single string
// concatenate(strings: ["a", "b", "c"], separator: ", ", prefix: "(", postfix: ")") == "(a, b, c)"
func concatenate(strings: [String], separator: String, prefix: String, postfix: String) -> String {
    var result = prefix
    for string in strings {
        result += string + separator
    }
    return result + postfix
}

// Concatenate array of strings into a single string
// concatenate(strings: ["a", "b", "c"], separator: ", ", prefix: "(", postfix: ")") == "(a, b, c)"
func concatenate(strings: [String], separator: String, prefix: String, postfix: String) -> String {
    var result = prefix
    for string in strings {
        result += string + separator
    }
    return result + postfix
}

// Concatenate array of strings into a single string
// concatenate(strings: ["a", "b", "c"], separator: ", ", prefix: "(", postfix: ")") == "(a, b, c)"
func concatenate(strings: [String], separator: String, prefix: String, postfix: String) -> String {
    var result = prefix
    for string in strings {
        result += string + separator
    }
    return result + postfix
}

// Concatenate array of strings into a single string
// concatenate(strings: ["a", "b", "c"], separator: ", ", prefix: "(", postfix: ")") == "(a, b, c)"
func concatenate(strings: [String], separator: String, prefix: String, postfix: String) -> String {
    var result = prefix
    for string in strings {
        result += string + separator
    }
    return result + postfix
}

// Concatenate array of strings into a single string
// concatenate(strings: ["a", "b", "c"], separator: ", ", prefix: "(", postfix: ")") == "(a, b, c)"
func concatenate(strings: [String], separator: String, prefix: String, postfix: String) -> String {
    var result = prefix
    for string in strings {
        result += string + separator
    }
    return result + postfix
}

// Concatenate array of strings into a single string
// concatenate(strings: ["a", "b", "c"], separator: ", ", prefix: "(", postfix: ")") == "(a, b, c)"
func concatenate(strings: [String], separator: String, prefix: String, postfix: String) -> String {
    var result = prefix
    for string in strings {
        result += string + separator
    }
    return

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
}
<|file_separator|>

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: ["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: ["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: ["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: ["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: ["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: ["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: ["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: ["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: ["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: ["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: ["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: ["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: ["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: ["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

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}

func concatenate(strings: [String], separator: String) -> String {
    var result = ""
    for string in strings {
        result += string + separator
    }
    return result
}

func concatenate(strings: [String], separator: String, prefix: String, postfix: String) -> String {
    var result = prefix
    for string in strings {
        result += string + separator
    }
    return result + postfix
}

```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: ["a", "b", "c"], separator: ", ") == "a, b, c"
func concatenate(strings: [String], separator: String) -> String {
    var result = ""
    for string in strings {
        result += string + separator
    }
    return result
}

// Concatenate array of strings into a single string
// concatenate(strings: ["a", "b", "c"], separator: ", ", prefix: "(", postfix: ")") == "(a, b, c)"
func concatenate(strings: [String], separator: String, prefix: String, postfix: String) -> String {
    var result = prefix
    for string in strings {
        result += string + separator
    }
    return result + postfix
}

// Concatenate array of strings into a single string
// concatenate(strings: ["a", "b", "c"], separator: ", ", prefix: "(", postfix: ")") == "(a, b, c)"
func concatenate(strings: [String], separator: String, prefix: String, postfix: String) -> String {
    var result = prefix
    for string in strings {
        result += string + separator
    }
    return result + postfix
}
<|file_separator|>

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
}
<|file_separator|>

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
}
<|file_separator|>

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
}
<|file_separator|>

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
}
<|file_separator|>

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
}
<|file_separator|>

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    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) }
}
<|file_separator|>

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }

func filterByPrefix(strings: [String], prefix: String) -> [String] {
  return strings.filter { $0.hasPrefix(prefix) }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
  return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
  return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
  return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
  return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
  return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
  return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
  return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
  return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
  return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
  return strings.filter { $0.hasPrefix(prefix) }

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    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) }
}
<|file_separator|>

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }

func 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2,

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
}
<|file_separator|>

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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2,

func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}

func getNegative(l: [Int]) -> [Int] {
    return l.filter { $0 < 0 }
}

func getDivisibleBy3(l: [Int]) -> [Int] {
    return l.filter { $0 % 3 == 0 }
}

func getDivisibleBy5(l: [Int]) -> [Int] {
    return l.filter { $0 % 5 == 0 }
}

func getDivisibleBy3And5(l: [Int]) -> [Int] {
    return l.filter { $0 % 3 == 0 && $0 % 5 == 0 }
}

func getDivisibleBy3Or5(l: [Int]) -> [Int] {
    return l.filter { $0 % 3 == 0 || $0 % 5 == 0 }
}

func getDivisibleBy3Or5ButNotBoth(l: [Int]) -> [Int] {
    return l.filter { $0 % 3 == 0 || $0 % 5 == 0 && $0 % 3 != $0 % 5 }
}

```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 }
}

// Return only negative numbers in the array.
// getNegative(l: [-1, 2, -4, 5, 6]) == [-1, -4]
// getNegative(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [-5, -3, -10]
func getNegative(l: [Int]) -> [Int] {
    return l.filter { $0 < 0 }
}

// Return only numbers that are divisible by 3.
// getDivisibleBy3(l: [-1, 2, -4, 5, 6]) == [2, 5]
// getDivisibleBy3(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [3, 9, 0, 123, -10]
func getDivisibleBy3(l: [Int]) -> [Int] {
    return l.filter { $0 % 3 == 0 }
}

// Return only numbers that are divisible by 5.
// getDivisibleBy5(l: [-1, 2, -4, 5, 6]) == [5]
// getDivisibleBy5(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5]
func getDivisibleBy5(l: [Int]) -> [Int] {
    return l.filter { $0 % 5 == 0 }
}

// Return only numbers that are divisible by 3 and 5.
// getDivisibleBy3And5(l: [-1, 2, -4, 5, 6]) == [5]
// getDivisibleBy3And5(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5]
func getDivisibleBy3And5(l: [Int]) -> [Int] {
    return l.filter { $0 % 3 == 0 && $0 % 5 == 0 }
}

// Return only numbers that are divisible by 3 or 5.
// getDivisibleBy3Or5(l: [-1, 2, -4, 5, 6]) == [2, 5]
// getDivisibleBy3Or5(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [2, 5, 3, 9, 123, 1]
func getDivisibleBy3Or5(l: [Int]) -> [Int] {
    return l.filter { $0 % 3 == 0 || $0 % 5 == 0 }
}

// Return only numbers that are divisible by 3 or 5, but not both.
// getDivisibleBy3Or5ButNotBoth(l: [-1, 2, -4, 5, 6]) == [2, 5]
// getDivisibleBy3Or5ButNotBoth(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 9, 123, 1]
func getDivisibleBy3Or5ButNotBoth(l: [Int]) -> [Int] {
    return l.filter { $0 % 3 == 0 || $0 % 5 == 0 && $0 % 3 != $0 % 5 }
}

// Return only numbers that are divisible by 3 or 5, but not both, and are greater than 10.
// getDivisibleBy3Or5ButNotBothAndGreaterThan10(l: [-1, 2, -4, 5, 6]) == [2, 5]
// getDivisibleBy3Or5ButNotBothAndGreaterThan10(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 

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
}
<|file_separator|>

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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2,

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}
}

// 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}
}

// 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}
}

// 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}
}

// 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}
}

// 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}
}

// 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}
}

// 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}
}

// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
//

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 }
}

// 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 }
}
<|file_separator|>

func getPositive(l: [Int]) -> [Int] {
  return l.filter { $0 > 0 }
}

func getSum(l: [Int]) -> Int {
  return l.reduce(0, +)
}

func getAverage(l: [Int]) -> Double {
  return Double(getSum(l: l)) / Double(l.count)
}

func getProduct(l: [Int]) -> Int {
  return l.reduce(1, *)
}

func getMin(l: [Int]) -> Int {
  return l.reduce(l[0], { $0 < $1 ? $0 : $1 })
}

func getMax(l: [Int]) -> Int {
  return l.reduce(l[0], { $0 > $1 ? $0 : $1 })
}

func getEvenCount(l: [Int]) -> Int {
  return l.filter { $0 % 2 == 0 }.count
}

func getOddCount(l: [Int]) -> Int {
  return l.filter { $0 % 2 != 0 }.count
}

func getPositiveCount(l: [Int]) -> Int {
  return l.filter { $0 > 0 }.count
}

```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 }
}

// Return the sum of all numbers in the array.
// getSum(l: [-1, 2, -4, 5, 6]) == 12
// getSum(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 165
func getSum(l: [Int]) -> Int {
  return l.reduce(0, +)
}

// Return the average of all numbers in the array.
// getAverage(l: [-1, 2, -4, 5, 6]) == 3.2
// getAverage(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 2.1
func getAverage(l: [Int]) -> Double {
  return Double(getSum(l: l)) / Double(l.count)
}

// Return the product of all numbers in the array.
// getProduct(l: [-1, 2, -4, 5, 6]) == -120
// getProduct(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == -360
func getProduct(l: [Int]) -> Int {
  return l.reduce(1, *)
}

// Return the smallest number in the array.
// getMin(l: [-1, 2, -4, 5, 6]) == -4
// getMin(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == -10
func getMin(l: [Int]) -> Int {
  return l.reduce(l[0], { $0 < $1 ? $0 : $1 })
}

// Return the largest number in the array.
// getMax(l: [-1, 2, -4, 5, 6]) == 6
// getMax(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func getMax(l: [Int]) -> Int {
  return l.reduce(l[0], { $0 > $1 ? $0 : $1 })
}

// Return the number of even numbers in the array.
// getEvenCount(l: [-1, 2, -4, 5, 6]) == 3
// getEvenCount(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 5
func getEvenCount(l: [Int]) -> Int {
  return l.filter { $0 % 2 == 0 }.count
}

// Return the number of odd numbers in the array.
// getOddCount(l: [-1, 2, -4, 5, 6]) == 2
// getOddCount(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 5
func getOddCount(l: [Int]) -> Int {
  return l.filter { $0 % 2 != 0 }.count
}

// Return the number of positive numbers in the array.
// getPositiveCount(l: [-1, 2, -4, 5, 6]) == 3
// getPositiveCount(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 5
func getPositiveCount(l: [Int]) -> Int {
  return l.filter { $0 > 0 }.count
}

// Return the number of negative numbers in the array.
// getNegativeCount(l: [-1, 2, -4, 5, 6]) == 2
// getNegativeCount(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -

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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2,

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
}
<|file_separator|>

func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    for i in 3...n {
        if n % i == 0 {
            return false
        }
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    for i in 3...n {
        if n % i == 0 {
            return false
        }
    }
    return true
}
<|file_separator|>

func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    if n == 2 {
        return true
    }
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    return true
}

func sum(n: Int) -> Int {
    var sum = 0
    for i in 1...n {
        sum += i
    }
    return sum
}

func sum(n: Int) -> Int {
    if n == 0 {
        return 0
    }
    return n + sum(n: n - 1)
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    if n == 2 {
        return true
    }
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    return true
}

// Return the sum of the first n positive integers.
// sum(n: 6) == 21
// sum(n: 10) == 55
// sum(n: 1) == 1
// sum(n: 0) == 0
func sum(n: Int) -> Int {
    var sum = 0
    for i in 1...n {
        sum += i
    }
    return sum
}

// Return the sum of the first n positive integers.
// sum(n: 6) == 21
// sum(n: 10) == 55
// sum(n: 1) == 1
// sum(n: 0) == 0
func sum(n: Int) -> Int {
    if n == 0 {
        return 0
    }
    return n + sum(n: n - 1)
}

// Return the sum of the first n positive integers.
// sum(n: 6) == 21
// sum(n: 10) == 55
// sum(n: 1) == 1
// sum(n: 0) == 0
func sum(n: Int) -> Int {
    if n == 0 {
        return 0
    }
    return n + sum(n: n - 1)
}

// Return the sum of the first n positive integers.
// sum(n: 6) == 21
// sum(n: 10) == 55
// sum(n: 1) == 1
// sum(n: 0) == 0
func sum(n: Int) -> Int {
    if n == 0 {
        return 0
    }
    return n + sum(n: n - 1)
}

// Return the sum of the first n positive integers.
// sum(n: 6) == 21
// sum(n: 10) == 55
// sum(n: 1) == 1
// sum(n: 0) == 0
func sum(n: Int) -> Int {
    if n == 0 {
        return 0
    }
    return n + sum(n: n - 1)
}

// Return the sum of the first n positive integers.
// sum(n: 6) == 21
// sum(n: 10) == 55
// sum(n: 1) == 1
// sum(n: 0) == 0
func sum(n: Int) -> Int {
    if n == 0 {
        return 0
    }
    return n + sum(n: n - 1)
}

// Return the sum of the first n positive integers.
// sum(n: 6) == 21
// sum(n: 10) == 55
// sum(n: 1) == 1
// sum(n: 0) == 0
func sum(n: Int) -> Int {
    if n == 0 {
        return 0
    }
    return n + sum(n: n - 1)
}

// Return the sum of the first n positive integers.
// sum(n: 6) == 21
// sum(n: 10) == 55
// sum(n: 1) == 1
// sum(n: 0) == 0
func sum(n: Int) -> Int {
    if n == 0 {
        return 0
    }
    return n + sum(n: n - 1)
}

// Return the sum of the first n positive integers.
// sum(n: 6) == 21
// sum(n: 10) == 55
// sum(n: 1) == 1
// sum(n: 0) == 0
func sum(n: Int) -> Int {
    if n == 0 {
        return 0
    }
    return n + sum(n: n - 1)
}

// Return the sum

func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    for i in 2...n/2 {
        if n % i == 0 {
            return false
        }
    }
    return true
}

func sumOf(numbers: [Int]) -> Int {
    var sum = 0
    for i in numbers {
        sum += i
    }
    return sum
}

func sumOf(numbers: [Int], ignore: [Int]) -> Int {
    var sum = 0
    for i in numbers {
        if !ignore.contains(i) {
            sum += i
        }
    }
    return sum
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    for i in 2...n/2 {
        if n % i == 0 {
            return false
        }
    }
    return true
}

// Return the sum of all the numbers in a given array.
// sumOf(numbers: [1, 2, 3, 4, 5]) == 15
// sumOf(numbers: [1, 1, 1, 1, 1]) == 5
// sumOf(numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 55
// sumOf(numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]) == 210
// sumOf(numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]) == 555
func sumOf(numbers: [Int]) -> Int {
    var sum = 0
    for i in numbers {
        sum += i
    }
    return sum
}

// Return the sum of all the numbers in a given array, except ignore any numbers that come in a second array.
// sumOf(numbers: [1, 2, 3, 4, 5], ignore: [3, 4]) == 10
// sumOf(numbers: [1, 1, 1, 1, 1], ignore: [1]) == 5
// sumOf(numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], ignore: [6, 7, 8, 9, 10]) == 55
// sumOf(numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], ignore: [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]) == 210
// sumOf(numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30], ignore: [11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]) == 555
func sumOf(numbers: [Int], ignore: [Int]) -> Int {
    var sum = 0
    for i in numbers {
        if !ignore.contains(i) {
            sum += i
        }
    }
    return sum
}

// Return the sum of all the numbers in a given array, except ignore any numbers that come in a second array.
// sumOf(numbers: [1, 2, 3, 4, 5], ignore: [3, 4]) == 10
// sumOf(numbers: [1, 1, 1, 1,

func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    if n == 2 {
        return true
    }
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    return true
}

func sumOfPrimes(n: Int) -> Int {
    var sum = 0
    for i in 2...n {
        if isPrime(n: i) {
            sum += i
        }
    }
    return sum
}

func sumOfEvens(n: Int) -> Int {
    var sum = 0
    for i in 2...n {
        if i % 2 == 0 {
            sum += i
        }
    }
    return sum
}

func sumOfOdds(n: Int) -> Int {
    var sum = 0
    for i in 1...n {
        if i % 2 != 0 {
            sum += i
        }
    }
    return sum
}

func sum(n: Int) -> Int {
    var sum = 0
    for i in 1...n {
        sum += i
    }
    return sum
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    if n == 2 {
        return true
    }
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    return true
}

// Return the sum of all prime numbers up to and including the given number.
// sumOfPrimes(n: 10) == 17
// sumOfPrimes(n: 11) == 17
// sumOfPrimes(n: 13441) == 41758
// sumOfPrimes(n: 61) == 13441
// sumOfPrimes(n: 4) == 5
// sumOfPrimes(n: 1) == 0
func sumOfPrimes(n: Int) -> Int {
    var sum = 0
    for i in 2...n {
        if isPrime(n: i) {
            sum += i
        }
    }
    return sum
}

// Return the sum of all even numbers up to and including the given number.
// sumOfEvens(n: 10) == 30
// sumOfEvens(n: 11) == 30
// sumOfEvens(n: 13441) == 41758
// sumOfEvens(n: 61) == 13441
// sumOfEvens(n: 4) == 6
// sumOfEvens(n: 1) == 0
func sumOfEvens(n: Int) -> Int {
    var sum = 0
    for i in 2...n {
        if i % 2 == 0 {
            sum += i
        }
    }
    return sum
}

// Return the sum of all odd numbers up to and including the given number.
// sumOfOdds(n: 10) == 25
// sumOfOdds(n: 11) == 25
// sumOfOdds(n: 13441) == 41758
// sumOfOdds(n: 61) == 13441
// sumOfOdds(n: 4) == 6
// sumOfOdds(n: 1) == 0
func sumOfOdds(n: Int) -> Int {
    var sum = 0
    for i in 1...n {
        if i % 2 != 0 {
            sum += i
        }
    }
    return sum
}

// Return the sum of all numbers up to and including the given number.
// sum(n: 10) == 55
// sum(n: 11) == 66
// sum(n: 13441) == 613441
// sum(n: 61) == 61
// sum(n: 4) == 10
// sum(n: 1) == 1
func sum(n: Int) -> Int {
    var sum = 0
    for i in 1...n {
        sum += i
    }
    return sum
}

// Return the sum of all numbers up to and including the given number.
// sum(n: 10) == 55
// sum(n: 11) == 66
// sum(n: 13441) == 613441
// sum(n: 61) == 61
// sum(n: 4) == 10
// sum(n: 1) == 1
func sum(n: Int) -> Int {
    var sum = 0
    for i in 1...n {
        sum += i
    }
    return sum
}

// Return the sum of all numbers up to and including the given number.
// sum(n: 10) == 55
// sum(n: 11) == 66
// sum(n: 13441) == 613441
// sum(n: 61) == 61
// sum(n: 4) == 10
// sum(n: 1) == 1
func sum(n: Int) -> Int {
    var sum = 0
    for i in 1...n

func isPrime(n: Int) -> Bool {
    if n <= 1 {
        return false
    }
    
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    
    return true
}

func sumPrimes(n: Int) -> Int {
    var sum = 0
    for i in 2...n {
        if isPrime(n: i) {
            sum += i
        }
    }
    return sum
}

```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
}

// Return the sum of all prime numbers less than or equal to n.
// sumPrimes(n: 10) == 17
// sumPrimes(n: 100) == 1060
// sumPrimes(n: 1000) == 10909
// sumPrimes(n: 10000) == 110906
// sumPrimes(n: 100000) == 1109061
// sumPrimes(n: 1000000) == 11090612
// sumPrimes(n: 10000000) == 110906122
// sumPrimes(n: 100000000) == 110906122
// sumPrimes(n: 1000000000) == 110906122
func sumPrimes(n: Int) -> Int {
    var sum = 0
    for i in 2...n {
        if isPrime(n: i) {
            sum += i
        }
    }
    return sum
}

// Return the nth number in the Fibonacci sequence.
// fibonacci(n: 0) == 0
// fibonacci(n: 1) == 1
// fibonacci(n: 2) == 1
// fibonacci(n: 3) == 2
// fibonacci(n: 4) == 3
// fibonacci(n: 5) == 5
// fibonacci(n: 6) == 8
// fibonacci(n: 7) == 13
// fibonacci(n: 8) == 21
// fibonacci(n: 9) == 34
// fibonacci(n: 10) == 55
// fibonacci(n: 11) == 89
// fibonacci(n: 12) == 144
// fibonacci(n: 13) == 233
// fibonacci(n: 14) == 377
// fibonacci(n: 15) == 610
// fibonacci(n: 16) == 987
// fibonacci(n: 17) == 1597
// fibonacci(n: 18) == 2584
// fibonacci(n: 19) == 4181
// fibonacci(n: 20) == 6765
// fibonacci(n: 21) == 10946
// fibonacci(n: 22) == 17711
// fibonacci(n: 23) == 28657
// fibonacci(n: 24) == 46368
// fibonacci(n: 25) == 75025
// fibonacci(n: 26) == 121393
// fibonacci(n: 27) == 196418
// fibonacci(n: 28) == 317811
// fibonacci(n: 29) == 514229
// fibonacci(n: 30) == 832040
// fibonacci(n: 31) == 1346269
// fibonacci(n: 32) == 2178309
// fibonacci(n: 33) == 3524578
// fibonacci(n: 34) == 5702887
// fibonacci(n: 35) == 9227465
// fibonacci(n: 36) == 14930352
// fibonacci(n: 37) == 24157817
// fibonacci(n: 38) == 39088169
// fibonacci(n: 39) == 63245986
// fibonacci(n: 40) == 102334155
// fibonacci(n: 41) == 

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
}
<|file_separator|>

func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    if n == 2 {
        return true
    }
    for i in 2...n-1 {
        if n % i == 0 {
            return false
        }
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    if n == 2 {
        return true
    }
    for i in 2...n-1 {
        if n % i == 0 {
            return false
        }
    }
    return true
}
<|file_separator|>

func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    if n == 2 {
        return true
    }
    for i in 2...n/2 {
        if n % i == 0 {
            return false
        }
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    if n == 2 {
        return true
    }
    for i in 2...n/2 {
        if n % i == 0 {
            return false
        }
    }
    return true
}
<|file_separator|>

func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    for i in 3...n {
        if n % i == 0 {
            return false
        }
    }
    return true
}

func sumOfArray(arr: [Int]) -> Int {
    var sum = 0
    for i in arr {
        sum += i
    }
    return sum
}

func sumOfArray(arr: [Int], threshold: Int) -> Int {
    var sum = 0
    for i in arr {
        if i >= threshold {
            sum += i
        }
    }
    return sum
}

func sumOfArray(arr: [Int], threshold: Int, max: Int) -> Int {
    var sum = 0
    for i in arr {
        if i >= threshold && i <= max {
            sum += i
        }
    }
    return sum
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    for i in 3...n {
        if n % i == 0 {
            return false
        }
    }
    return true
}

// Return the sum of all the numbers in the given array.
// sumOfArray(arr: [1, 2, 3, 4, 5]) == 15
// sumOfArray(arr: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 55
// sumOfArray(arr: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]) == 210
func sumOfArray(arr: [Int]) -> Int {
    var sum = 0
    for i in arr {
        sum += i
    }
    return sum
}

// Return the sum of all the numbers in the given array, except ignore any where the value is less than the given threshold.
// sumOfArray(arr: [1, 2, 3, 4, 5], threshold: 3) == 12
// sumOfArray(arr: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], threshold: 3) == 21
// sumOfArray(arr: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], threshold: 3) == 54
func sumOfArray(arr: [Int], threshold: Int) -> Int {
    var sum = 0
    for i in arr {
        if i >= threshold {
            sum += i
        }
    }
    return sum
}

// Return the sum of all the numbers in the given array, except ignore any where the value is less than the given threshold, and ignore any where the value is greater than the given max.
// sumOfArray(arr: [1, 2, 3, 4, 5], threshold: 3, max: 10) == 12
// sumOfArray(arr: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], threshold: 3, max: 10) == 21
// sumOfArray(arr: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], threshold: 3, max: 10) == 54
func sumOfArray(arr: [Int], threshold: Int, max: Int) -> Int {
    var sum = 0
    for i in arr {
        if i >= threshold && i <= max {
            sum += i
        }
    }
    return sum
}

// Return the sum of all the numbers in the given array, except ignore any where the value is less than the given threshold, and ignore any where the value is greater than the given max.
// sumOfArray(arr: [1, 2, 3, 4, 5], threshold: 3, max: 10) == 12
// sumOfArray(arr: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], threshold: 3, max: 10) == 21
// sumOfArray(arr: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 1

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
        }
        i += 1
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
        }
        i += 1
    }
    return l
}
<|file_separator|>

func sortThird(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
        }
    }
    return l
}
<|file_separator|>

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
        }
        i += 1
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
        }
        i += 1
    }
    return l
}
<|file_separator|>

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
            l.remove(at: i)
        }
        i += 1
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
            l.remove(at: i)
        }
        i += 1
    }
    return l
}
<|file_separator|>

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
            l.remove(at: i)
            i -= 1
        }
        i += 1
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
            l.remove(at: i)
            i -= 1
        }
        i += 1
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
            l.remove(at: i)
            i -= 1
        }
        i += 1
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
            l.remove(at: i)
            i -= 1
        }
        i += 1
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
            l.remove(at: i)
            i -= 1
        }
        i += 1
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
            l.remove(at: i)
            l.insert(l[i], at: i)
        }
        i += 1
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
            l.remove(at: i)
            l.insert(l[i], at: i)
        }
        i += 1
    }
    return l
}
<|file_separator|>

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var l_sorted = l
    var l_sorted_index = 0
    var l_sorted_index_last = l_sorted_index
    var l_index = 0
    var l_index_last = l_index
    var l_index_last_last = l_index_last
    var l_index_last_last_last = l_index_last_last
    var l_index_last_last_last_last = l_index_last_last_last
    var l_index_last_last_last_last_last = l_index_last_last_last_last
    while l_index < l.count {
        if l_index % 3 == 0 {
            l_sorted[l_sorted_index] = l[l_index]
            l_sorted_index += 1
        }
        l_index += 1
    }
    l_index = 0
    while l_index < l.count {
        if l_index % 3 != 0 {
            l_sorted[l_sorted_index] = l[l_index]
            l_sorted_index += 1
        }
        l_index += 1
    }
    l_index = 0
    while l_index < l.count {
        if l_index % 3 == 0 {
            l_sorted[l_sorted_index] = l[l_index]
            l_sorted_index += 1
        }
        l_index += 1
    }
    return l_sorted
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var l_sorted = l
    var l_sorted_index = 0
    var l_sorted_index_last = l_sorted_index
    var l_index = 0
    var l_index_last = l_index
    var l_index_last_last = l_index_last
    var l_index_last_last_last = l_index_last_last
    var l_index_last_last_last_last = l_index_last_last_last
    var l_index_last_last_last_last_last = l_index_last_last_last_last
    while l_index < l.count {
        if l_index % 3 == 0 {
            l_sorted[l_sorted_index] = l[l_index]
            l_sorted_index += 1
        }
        l_index += 1
    }
    l_index = 0
    while l_index < l.count {
        if l_index % 3 != 0 {
            l_sorted[l_sorted_index] = l[l_index]
            l_sorted_index += 1
        }
        l_index += 1
    }
    l_index = 0
    while l_index < l.count {
        if l_index % 3 == 0 {
            l_sorted[l_sorted_index] = l[l_index]
            l_sorted_index += 1
        }
        l_index += 1
    }
    return l_sorted
}
<|file_separator|>

func sortThird(l: [Int]) -> [Int] {
  var l = l
  var i = 0
  while i < l.count {
    if i % 3 == 0 {
      l[i] = l[i]
    } else {
      l.remove(at: i)
    }
    i += 1
  }
  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
  var i = 0
  while i < l.count {
    if i % 3 == 0 {
      l[i] = l[i]
    } else {
      l.remove(at: i)
    }
    i += 1
  }
  l.sort()
  return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
  var l = l
  var i = 0
  while i < l.count {
    if i % 3 == 0 {
      l[i] = l[i]
    } else {
      l.remove(at: i)
    }
    i += 1
  }
  l.sort()
  return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
  var l = l
  var i = 0
  while i < l.count {
    if i % 3 == 0 {
      l[i] = l[i]
    } else {
      l.remove(at: i)
    }
    i += 1
  }
  l.sort()
  return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
  var l = l
  var i = 0
  while i < l.count {
    if i % 3 == 0 {
      l[i] = l[i]
    } else {
      l.remove(at: i)
    }
    i += 1
  }
  l.sort()
  return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
  var l = l
  var i = 0
  while i < l.count {
    if i % 3 == 0 {
      l[i] = l[i]
    } else {
      l.remove(at: i)
    }
    i += 1

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
            l.remove(at: i)
            i -= 1
        }
        i += 1
    }
    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
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
            l.remove(at: i)
            i -= 1
        }
        i += 1
    }
    l.sort()
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
            l.remove(at: i)
            i -= 1
        }
        i += 1
    }
    l.sort()
    return l
}
<|file_separator|>

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
            l.remove(at: i)
            l.insert(l[i], at: i)
        }
        i += 1
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    while i < l.count {
        if i % 3 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
            l.remove(at: i)
            l.insert(l[i], at: i)
        }
        i += 1
    }
    return l
}
<|file_separator|>

func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if !unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}

func count(l: [Int], e: Int) -> Int {
    var count = 0
    for i in l {
        if i == e {
            count += 1
        }
    }
    return count
}

func count(l: [Int], e: Int) -> Int {
    return l.filter { $0 == e }.count
}

func count(l: [Int], e: Int) -> Int {
    return l.reduce(0) { (count, i) -> Int in
        if i == e {
            return count + 1
        }
        return count
    }
}

func count(l: [Int], e: Int) -> Int {
    return l.reduce(0) { count, i in
        if i == e {
            return 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
}

// Return the number of times a given element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], e: 3) == 3
func count(l: [Int], e: Int) -> Int {
    var count = 0
    for i in l {
        if i == e {
            count += 1
        }
    }
    return count
}

// Return the number of times a given element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], e: 3) == 3
func count(l: [Int], e: Int) -> Int {
    return l.filter { $0 == e }.count
}

// Return the number of times a given element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], e: 3) == 3
func count(l: [Int], e: Int) -> Int {
    return l.reduce(0) { (count, i) -> Int in
        if i == e {
            return count + 1
        }
        return count
    }
}

// Return the number of times a given element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], e: 3) == 3
func count(l: [Int], e: Int) -> Int {
    return l.reduce(0) { count, i in
        if i == e {
            return count + 1
        }
        return count
    }
}

// Return the number of times a given element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], e: 3) == 3
func count(l: [Int], e: Int) -> Int {
    return l.reduce(0) { count, i in
        if i == e {
            return count + 1
        }
        return count
    }
}

// Return the number of times a given element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], e: 3) == 3
func count(l: [Int], e: Int) -> Int {
    return l.reduce(0) { count, i in
        if i == e {
            return count + 1
        }
        return count
    }
}

// Return the number of times a given element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], e: 3) == 3
func count(l: [Int], e: Int) -> Int {
    return l.reduce(0) { count, i in
        if i == e {
            return count + 1
        }
        return count
    }
}

// Return the number of times a given element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], e: 3) == 3
func count(l: [Int], e: Int) -> Int {
    return l.reduce(0) { count, i in
        if i == e {
            return count + 1
        }
        return count
    }
}

// Return the number of times a given element appears in an array
// count(l: [5, 3, 5, 2, 3, 3, 9, 0, 123], e: 3) == 3
func count(l: [Int], e: Int) -> Int {
    return l.reduce(0) { count, i in
        if i == e {
            

func unique(l: [Int]) -> [Int] {
  var result = [Int]()
  var seen = [Int: Bool]()
  for i in l {
    if seen[i] == nil {
      seen[i] = true
      result.append(i)
    }
  }
  return result
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
  var result = [Int]()
  var seen = [Int: Bool]()
  for i in l {
    if seen[i] == nil {
      seen[i] = true
      result.append(i)
    }
  }
  return result
}
<|file_separator|>

func unique(l: [Int]) -> [Int] {
  var result = [Int]()
  var seen = [Int: Bool]()
  for i in l {
    if !seen[i] {
      result.append(i)
      seen[i] = true
    }
  }
  return result
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
  var result = [Int]()
  var seen = [Int: Bool]()
  for i in l {
    if !seen[i] {
      result.append(i)
      seen[i] = true
    }
  }
  return result
}

// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
  var result = [Int]()
  var seen = [Int: Bool]()
  for i in l {
    if !seen[i] {
      result.append(i)
      seen[i] = true
    }
  }
  return result
}

// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
  var result = [Int]()
  var seen = [Int: Bool]()
  for i in l {
    if !seen[i] {
      result.append(i)
      seen[i] = true
    }
  }
  return result
}

// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
  var result = [Int]()
  var seen = [Int: Bool]()
  for i in l {
    if !seen[i] {
      result.append(i)
      seen[i] = true
    }
  }
  return result
}

// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
  var result = [Int]()
  var seen = [Int: Bool]()
  for i in l {
    if !seen[i] {
      result.append(i)
      seen[i] = true
    }
  }
  return result
}

// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
  var result = [Int]()
  var seen = [Int: Bool]()
  for i in l {
    if !seen[i] {
      result.append(i)
      seen[i] = true
    }
  }
  return result
}

// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
  var result = [Int]()
  var seen = [Int: Bool]()
  for i in l {
    if !seen[i] {
      result.append(i)
      seen[i] = true
    }
  }
  return result
}

// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
  var result = [Int]()
  var seen = [Int: Bool]()
  for i in l {
    if !seen[i] {
      result

func unique(l: [Int]) -> [Int] {
    var unique = [Int]()
    for i in l {
        if !unique.contains(i) {
            unique.append(i)
        }
    }
    return unique
}

func sum(l: [Int]) -> Int {
    var sum = 0
    for i in l {
        sum += i
    }
    return sum
}

func sum(l: [Int]) -> Int {
    return l.reduce(0, +)
}

```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 the sum of all elements in an array
// sum(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == 142
func sum(l: [Int]) -> Int {
    var sum = 0
    for i in l {
        sum += i
    }
    return sum
}

// Return the sum of all elements in an array
// sum(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == 142
func sum(l: [Int]) -> Int {
    return l.reduce(0, +)
}

// Return the sum of all elements in an array
// sum(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == 142
func sum(l: [Int]) -> Int {
    var sum = 0
    for i in l {
        sum += i
    }
    return sum
}

// Return the sum of all elements in an array
// sum(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == 142
func sum(l: [Int]) -> Int {
    return l.reduce(0, +)
}

// Return the sum of all elements in an array
// sum(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == 142
func sum(l: [Int]) -> Int {
    return l.reduce(0, +)
}

// Return the sum of all elements in an array
// sum(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == 142
func sum(l: [Int]) -> Int {
    return l.reduce(0, +)
}

// Return the sum of all elements in an array
// sum(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == 142
func sum(l: [Int]) -> Int {
    return l.reduce(0, +)
}

// Return the sum of all elements in an array
// sum(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == 142
func sum(l: [Int]) -> Int {
    return l.reduce(0, +)
}

// Return the sum of all elements in an array
// sum(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == 142
func sum(l: [Int]) -> Int {
    return l.reduce(0, +)
}

// Return the sum of all elements in an array
// sum(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == 142
func sum(l: [Int]) -> Int {
    return l.reduce(0, +)
}

// Return the sum of all elements in an array
// sum(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == 142
func sum(l: [Int]) -> Int {
    return l.reduce(0, +)
}

// Return the sum of all elements in an array
// sum(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == 142
func sum(l: [Int]) -> Int {
    return l.reduce(0, +)
}

// Return the sum of all elements in an array
// sum(l: [5, 3, 5, 2, 3, 3, 

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
}

```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
}

```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 result = [Int]()
  var seen = [Int: Bool]()
  for i in l {
    if seen[i] == nil {
      result.append(i)
      seen[i] = true
    }
  }
  return result
}

func sum(l: [Int]) -> Int {
  var result = 0
  for i in l {
    result += i
  }
  return result
}

func sumLessThan100(l: [Int]) -> Int {
  var result = 0
  for i in l {
    result += i
    if result > 100 {
      return result
    }
  }
  return result
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
  var result = [Int]()
  var seen = [Int: Bool]()
  for i in l {
    if seen[i] == nil {
      result.append(i)
      seen[i] = true
    }
  }
  return result
}

// Return the sum of all elements in an array
// sum([1, 2, 3, 4, 5]) == 15
func sum(l: [Int]) -> Int {
  var result = 0
  for i in l {
    result += i
  }
  return result
}

// Return the sum of all elements in an array, but only if the sum is less than 100
// sumLessThan100([1, 2, 3, 4, 5]) == 15
// sumLessThan100([1, 2, 3, 4, 5, 50]) == 15
// sumLessThan100([10, 20, 30]) == 60
func sumLessThan100(l: [Int]) -> Int {
  var result = 0
  for i in l {
    result += i
    if result > 100 {
      return result
    }
  }
  return result
}

// Return the sum of all elements in an array, but only if the sum is less than 100
// sumLessThan100([1, 2, 3, 4, 5]) == 15
// sumLessThan100([1, 2, 3, 4, 5, 50]) == 15
// sumLessThan100([10, 20, 30]) == 60
func sumLessThan100(l: [Int]) -> Int {
  var result = 0
  for i in l {
    result += i
    if result > 100 {
      return result
    }
  }
  return result
}

// Return the sum of all elements in an array, but only if the sum is less than 100
// sumLessThan100([1, 2, 3, 4, 5]) == 15
// sumLessThan100([1, 2, 3, 4, 5, 50]) == 15
// sumLessThan100([10, 20, 30]) == 60
func sumLessThan100(l: [Int]) -> Int {
  var result = 0
  for i in l {
    result += i
    if result > 100 {
      return result
    }
  }
  return result
}

// Return the sum of all elements in an array, but only if the sum is less than 100
// sumLessThan100([1, 2, 3, 4, 5]) == 15
// sumLessThan100([1, 2, 3, 4, 5, 50]) == 15
// sumLessThan100([10, 20, 30]) == 60
func sumLessThan100(l: [Int]) -> Int {
  var result = 0
  for i in l {
    result += i
    if result > 100 {
      return result
    }
  }
  return result
}

// Return the sum of all elements in an array, but only if the sum is less than 100
// sumLessThan100([1, 2, 3, 4, 5]) == 15
// sumLessThan100([1, 2, 3, 4, 5, 50]) == 15
// sumLessThan100([10, 20, 30]) == 60
func sumLessThan100(l: [Int]) -> Int {
  var result = 0
  for i in l {
    result += i
    if result > 100 {
      return result
    }
  }
  return result
}

// Return the sum of all elements in an array, but only if the sum is less than 100
// sumLessThan100([1, 2, 3, 4, 5]) == 15
// sumLessThan100([1, 2, 3, 4

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
}

```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 maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}
<|file_separator|>

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

func minElement(l: [Int]) -> Int {
    var min = l[0]
    for i in 1..<l.count {
        if l[i] < min {
            min = l[i]
        }
    }
    return min
}

func sumElements(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum
}

func averageElements(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum / l.count
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

// 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 1..<l.count {
        if l[i] < min {
            min = l[i]
        }
    }
    return min
}

// Return the sum of all elements in the array.
// sumElements(l: [1, 2, 3]) == 6
// sumElements(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 122
func sumElements(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum
}

// Return the average of all elements in the array.
// averageElements(l: [1, 2, 3]) == 2
// averageElements(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 1
func averageElements(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum / l.count
}

// Return the sum of all elements in the array.
// sumElements(l: [1, 2, 3]) == 6
// sumElements(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 122
func sumElements(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum
}

// Return the average of all elements in the array.
// averageElements(l: [1, 2, 3]) == 2
// averageElements(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 1
func averageElements(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum / l.count
}

// Return the sum of all elements in the array.
// sumElements(l: [1, 2, 3]) == 6
// sumElements(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 122
func sumElements(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum
}

// Return the average of all elements in the array.
// averageElements(l: [1, 2, 3]) == 2
// averageElements(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 1
func averageElements(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum / l.count
}

// Return the sum of all elements in the array.
// sumElements(l: [1, 2, 3]) == 6
// sumElements(l: [5, 3, -5, 2, -3, 3, 9, 

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

func minElement(l: [Int]) -> Int {
    var min = l[0]
    for i in 1..<l.count {
        if l[i] < min {
            min = l[i]
        }
    }
    return min
}

func sum(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum
}

func average(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum / l.count
}

func count(l: [Int]) -> Int {
    return l.count
}

func countGreaterThan(l: [Int], value: Int) -> Int {
    var count = 0
    for i in 0..<l.count {
        if l[i] > value {
            count += 1
        }
    }
    return count
}

func countLessThan(l: [Int], value: Int) -> Int {
    var count = 0
    for i in 0..<l.count {
        if l[i] < value {
            count += 1
        }
    }
    return count
}

func countEqualTo(l: [Int], value: Int) -> Int {
    var count = 0
    for i in 0..<l.count {
        if l[i] == value {
            count += 1
        }
    }
    return count
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

// 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 1..<l.count {
        if l[i] < min {
            min = l[i]
        }
    }
    return min
}

// Return 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]) == 128
func sum(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum
}

// Return 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]) == 1
func average(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum / l.count
}

// 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 {
    return l.count
}

// Return the number of elements in the array that are greater than the given value.
// countGreaterThan(l: [1, 2, 3], value: 2) == 2
// countGreaterThan(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10], value: 2) == 4
func countGreaterThan(l: [Int], value: Int) -> Int {
    var count = 0
    for i in 0..<l.count {
        if l[i] > value {
            count += 1
        }
    }
    return count
}

// Return the number of elements in the array that are less than the given value.
// countLessThan(l: [1, 2, 3], value: 2) == 1
// countLessThan(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10], value: 2) == 3
func countLessThan(l: [Int], value: Int) -> Int {
    var count = 0
    for i in 0..<l.count {
        if l[i] < value {
            count += 1
        }
    }
    return count
}

// Return the number of elements in the array that are equal to the given value.
// countEqualTo(l: [1, 2, 3], value: 2) == 1
// countEqualTo(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10], value: 2) == 2
func countEqualTo(l: [Int], value: Int) -> Int {
    var count = 0
    for i in 0..<l.count {
        if l[i] == value {
            count += 1
        }
    }
    return count
}

// Return the number of elements in the array that are not equal to the given value

func maxElement(l: [Int]) -> Int {
  var max = l[0]
  for i in 1..<l.count {
    if l[i] > max {
      max = l[i]
    }
  }
  return max
}

func 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 sumOfEvens(l: [Int]) -> Int {
  var sum = 0
  for i in l {
    if i % 2 == 0 {
      sum += i
    }
  }
  return sum
}

func sumOfOdds(l: [Int]) -> Int {
  var sum = 0
  for i in l {
    if i % 2 != 0 {
      sum += i
    }
  }
  return sum
}

func sumOfAllButFirstAndLast(l: [Int]) -> Int {
  var sum = 0
  for i in 1..<l.count-1 {
    sum += l[i]
  }
  return sum
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
  var max = l[0]
  for i in 1..<l.count {
    if l[i] > max {
      max = l[i]
    }
  }
  return max
}

// 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]) == 144
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]) == 3.6
func average(l: [Int]) -> Double {
  var sum = 0
  for i in l {
    sum += i
  }
  return Double(sum) / Double(l.count)
}

// Return the sum of all even elements in the array.
// sumOfEvens(l: [1, 2, 3]) == 2
// sumOfEvens(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 10
func sumOfEvens(l: [Int]) -> Int {
  var sum = 0
  for i in l {
    if i % 2 == 0 {
      sum += i
    }
  }
  return sum
}

// Return the sum of all odd elements in the array.
// sumOfOdds(l: [1, 2, 3]) == 2
// sumOfOdds(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 10
func sumOfOdds(l: [Int]) -> Int {
  var sum = 0
  for i in l {
    if i % 2 != 0 {
      sum += i
    }
  }
  return sum
}

// Return the sum of all elements in the array, except for the first and last elements,
// which must both be odd. Do not use a counter to keep track of the index.
// sumOfAllButFirstAndLast(l: [1, 2, 3]) == 2
// sumOfAllButFirstAndLast(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 144
func sumOfAllButFirstAndLast(l: [Int]) -> Int {
  var sum = 0
  for i in 1..<l.count-1 {
    sum += l[i]
  }
  return sum
}

// Return the sum of all elements in the array, except for the first and last elements,
// which must both be odd. Do not use a counter to keep track of the index.
// sumOfAllButFirstAndLast(l: [1, 2, 3]) == 2
// sumOfAllButFirstAndLast(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 144
func sumOfAllButFirstAndLast(l: [Int]) -> Int {
  var sum = 0
  for i in 1..<l.count-1 {
    sum += l[i]
  }
  return sum
}

// Return the sum of all elements in the array, except for the first and last elements,
// which must both be odd. Do not use a counter to keep track of the index.
// sumOfAllButFirstAndLast(l: [1, 2, 3]) == 2
// sumOfAllButFirstAndLast(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 

func maxElement(l: [Int]) -> Int {
    return l.max()!
}

func sum(l: [Int]) -> Int {
    return l.reduce(0, +)
}

func sumLessThan100(l: [Int]) -> Int {
    return l.reduce(0, +) < 100 ? l.reduce(0, +) : 0
}

func sumGreaterThan100(l: [Int]) -> Int {
    return l.reduce(0, +) > 100 ? l.reduce(0, +) : 0
}

func sumBetween100And200(l: [Int]) -> Int {
    return l.reduce(0, +) > 100 && l.reduce(0, +) < 200 ? l.reduce(0, +) : 0
}

func sumBetween100And200GreaterThan100(l: [Int]) -> Int {
    return l.reduce(0, +) > 100 && l.reduce(0, +) < 200 ? l.reduce(0, +) : 0
}

func sumBetween100And200LessThan100(l: [Int]) -> Int {
    return l.reduce(0, +) > 100 && l.reduce(0, +) < 200 ? l.reduce(0, +) : 0
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    return l.max()!
}

// Return the sum of the elements in the array.
// sum(l: [1, 2, 3]) == 6
// sum(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 132
func sum(l: [Int]) -> Int {
    return l.reduce(0, +)
}

// Return the sum of the elements in the array, but only if the sum is less than 100.
// sumLessThan100(l: [1, 2, 3]) == 6
// sumLessThan100(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 132
func sumLessThan100(l: [Int]) -> Int {
    return l.reduce(0, +) < 100 ? l.reduce(0, +) : 0
}

// Return the sum of the elements in the array, but only if the sum is greater than 100.
// sumGreaterThan100(l: [1, 2, 3]) == 0
// sumGreaterThan100(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 132
func sumGreaterThan100(l: [Int]) -> Int {
    return l.reduce(0, +) > 100 ? l.reduce(0, +) : 0
}

// Return the sum of the elements in the array, but only if the sum is between 100 and 200.
// sumBetween100And200(l: [1, 2, 3]) == 6
// sumBetween100And200(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 132
func sumBetween100And200(l: [Int]) -> Int {
    return l.reduce(0, +) > 100 && l.reduce(0, +) < 200 ? l.reduce(0, +) : 0
}

// Return the sum of the elements in the array, but only if the sum is between 100 and 200, but only if the sum is greater than 100.
// sumBetween100And200GreaterThan100(l: [1, 2, 3]) == 0
// sumBetween100And200GreaterThan100(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 132
func sumBetween100And200GreaterThan100(l: [Int]) -> Int {
    return l.reduce(0, +) > 100 && l.reduce(0, +) < 200 ? l.reduce(0, +) : 0
}

// Return the sum of the elements in the array, but only if the sum is between 100 and 200, but only if the sum is less than 100.
// sumBetween100And200LessThan100(l: [1, 2, 3]) == 0
// sumBetween100And200LessThan100(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 132
func sumBetween100And200LessThan100(l: [Int]) -> Int {
    return l.reduce(0, +) > 100 && l.reduce(0, +) < 200 ? l.reduce(0, +) : 0
}

// Return the sum of the elements in the array, but only if the sum is between 100 and 200, but only if the sum is between 100 and 200.
// sumBetween10

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

func minElement(l: [Int]) -> Int {
    var min = l[0]
    for i in 1..<l.count {
        if l[i] < min {
            min = l[i]
        }
    }
    return min
}

func sum(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum
}

func average(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum / l.count
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

// 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 1..<l.count {
        if l[i] < min {
            min = l[i]
        }
    }
    return min
}

// Return 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]) == 108
func sum(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum
}

// Return 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]) == 2
func average(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum / l.count
}

// Return 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]) == 108
func sum(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum
}

// Return 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]) == 2
func average(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum / l.count
}

// Return 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]) == 108
func sum(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum
}

// Return 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]) == 2
func average(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum / l.count
}

// Return 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]) == 108
func sum(l: [Int

func maxElement(l: [Int]) -> Int {
    return l.max()!
}

func minElement(l: [Int]) -> Int {
    return l.min()!
}

func sum(l: [Int]) -> Int {
    return l.reduce(0, +)
}

func average(l: [Int]) -> Double {
    return Double(sum(l: l)) / Double(l.count)
}

func sumOfEven(l: [Int]) -> Int {
    return l.filter { $0 % 2 == 0 }.reduce(0, +)
}

func sumOfOdd(l: [Int]) -> Int {
    return l.filter { $0 % 2 != 0 }.reduce(0, +)
}

func sumOfAllButFirstAndLast(l: [Int]) -> Int {
    return l.dropFirst().dropLast().reduce(0, +)
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    return l.max()!
}

// 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 {
    return l.min()!
}

// 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]) == 144
func sum(l: [Int]) -> Int {
    return l.reduce(0, +)
}

// 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]) == 1
func average(l: [Int]) -> Double {
    return Double(sum(l: l)) / Double(l.count)
}

// Return the sum of all even elements in the array.
// sumOfEven(l: [1, 2, 3]) == 2
// sumOfEven(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 10
func sumOfEven(l: [Int]) -> Int {
    return l.filter { $0 % 2 == 0 }.reduce(0, +)
}

// Return the sum of all odd elements in the array.
// sumOfOdd(l: [1, 2, 3]) == 2
// sumOfOdd(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 12
func sumOfOdd(l: [Int]) -> Int {
    return l.filter { $0 % 2 != 0 }.reduce(0, +)
}

// Return the sum of all elements in the array, except for the first and last elements.
// sumOfAllButFirstAndLast(l: [1, 2, 3]) == 4
// sumOfAllButFirstAndLast(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 144
func sumOfAllButFirstAndLast(l: [Int]) -> Int {
    return l.dropFirst().dropLast().reduce(0, +)
}

// Return the sum of all elements in the array, except for the first and last elements.
// sumOfAllButFirstAndLast(l: [1, 2, 3]) == 4
// sumOfAllButFirstAndLast(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 144
func sumOfAllButFirstAndLast(l: [Int]) -> Int {
    return l.dropFirst().dropLast().reduce(0, +)
}

// Return the sum of all elements in the array, except for the first and last elements.
// sumOfAllButFirstAndLast(l: [1, 2, 3]) == 4
// sumOfAllButFirstAndLast(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 144
func sumOfAllButFirstAndLast(l: [Int]) -> Int {
    return l.dropFirst().dropLast().reduce(0, +)
}

// Return the sum of all elements in the array, except for the first and last elements.
// sumOfAllButFirstAndLast(l: [1, 2, 3]) == 4
// sumOfAllButFirstAndLast(l: [5, 3, -5, 2

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

func minElement(l: [Int]) -> Int {
    var min = l[0]
    for i in 1..<l.count {
        if l[i] < min {
            min = l[i]
        }
    }
    return min
}

func sum(l: [Int]) -> Int {
    var sum = 0
    for i in l {
        sum += i
    }
    return sum
}

func average(l: [Int]) -> Int {
    var sum = 0
    for i in l {
        sum += i
    }
    return sum / l.count
}

func count(l: [Int]) -> Int {
    return l.count
}

func countGreaterThan(l: [Int], value: Int) -> Int {
    var count = 0
    for i in l {
        if i > value {
            count += 1
        }
    }
    return count
}

func countLessThan(l: [Int], value: Int) -> Int {
    var count = 0
    for i in l {
        if i < value {
            count += 1
        }
    }
    return count
}

func countEqualTo(l: [Int], value: Int) -> Int {
    var count = 0
    for i in l {
        if i == value {
            count += 1
        }
    }
    return count
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

// 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 1..<l.count {
        if l[i] < min {
            min = l[i]
        }
    }
    return min
}

// 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]) == 144
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]) == 1
func average(l: [Int]) -> Int {
    var sum = 0
    for i in l {
        sum += i
    }
    return sum / l.count
}

// 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 {
    return l.count
}

// Return the number of elements in the array that are greater than the given value.
// countGreaterThan(l: [1, 2, 3], value: 2) == 2
// countGreaterThan(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10], value: 2) == 6
func countGreaterThan(l: [Int], value: Int) -> Int {
    var count = 0
    for i in l {
        if i > value {
            count += 1
        }
    }
    return count
}

// Return the number of elements in the array that are less than the given value.
// countLessThan(l: [1, 2, 3], value: 2) == 1
// countLessThan(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10], value: 2) == 5
func countLessThan(l: [Int], value: Int) -> Int {
    var count = 0
    for i in l {
        if i < value {
            count += 1
        }
    }
    return count
}

// Return the number of elements in the array that are equal to the given value.
// countEqualTo(l: [1, 2, 3], value: 2) == 1
// countEqualTo(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10], value: 2) == 2
func countEqualTo(l: [Int], value: Int) -> Int {
    var count = 0
    for i in l {
        if i == value {
            count += 1
        }
    }
    return count
}

// Return the number of elements in the array that are not equal to the given value.
// countNotEqualTo(l: [1, 2, 3], value: 2) == 2
// countNotEqualTo(l: [5, 3,

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

func minElement(l: [Int]) -> Int {
    var min = l[0]
    for i in 1..<l.count {
        if l[i] < min {
            min = l[i]
        }
    }
    return min
}

func sum(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum
}

func average(l: [Int]) -> Double {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return Double(sum) / Double(l.count)
}

func median(l: [Int]) -> Int {
    let sorted = l.sorted()
    if l.count % 2 == 0 {
        return (sorted[l.count / 2 - 1] + sorted[l.count / 2]) / 2
    } else {
        return sorted[l.count / 2]
    }
}

func mode(l: [Int]) -> Int {
    var mode = l[0]
    var count = 1
    var maxCount = 1
    for i in 1..<l.count {
        if l[i] == mode {
            count += 1
        } else {
            if count > maxCount {
                maxCount = count
                mode = l[i - 1]
            }
            count = 1
        }
    }
    if count > maxCount {
        mode = l[l.count - 1]
    }
    return mode
}

func range(l: [Int]) -> Int {
    return maxElement(l: l) - minElement(l: l)
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

// 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 1..<l.count {
        if l[i] < min {
            min = l[i]
        }
    }
    return min
}

// 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]) == 142
func sum(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[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]) == 2.6
func average(l: [Int]) -> Double {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return Double(sum) / Double(l.count)
}

// Return the median of all elements in the array.
// median(l: [1, 2, 3]) == 2
// median(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 3
func median(l: [Int]) -> Int {
    let sorted = l.sorted()
    if l.count % 2 == 0 {
        return (sorted[l.count / 2 - 1] + sorted[l.count / 2]) / 2
    } else {
        return sorted[l.count / 2]
    }
}

// Return the mode of all elements in the array.
// mode(l: [1, 2, 3]) == 1
// mode(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == -3
func mode(l: [Int]) -> Int {
    var mode = l[0]
    var count = 1
    var maxCount = 1
    for i in 1..<l.count {
        if l[i] == mode {
            count += 1
        } else {
            if count > maxCount {
                maxCount = count
                mode = l[i - 1]
            }
            count = 1
        }
    }
    if count > maxCount {
        mode = l[l.count - 1]
    }
    return mode
}

// Return the range of all elements in the array.
// range(l: [1, 2, 3]) == 2
// range(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func range(l: [Int]) -> Int {
    return maxElement(l: l) - minElement(l: l)
}

// Return the standard deviation of all elements in the array.
// standardDeviation(l: [1, 2, 3]) == 0
// standardDeviation(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 23.96202786885

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

func minElement(l: [Int]) -> Int {
    var min = l[0]
    for i in 1..<l.count {
        if l[i] < min {
            min = l[i]
        }
    }
    return min
}

func sum(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum
}

func product(l: [Int]) -> Int {
    var product = 1
    for i in 0..<l.count {
        product *= l[i]
    }
    return product
}

func average(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum / l.count
}

func median(l: [Int]) -> Int {
    var sorted = l
    sorted.sort()
    if l.count % 2 == 0 {
        return (sorted[l.count / 2 - 1] + sorted[l.count / 2]) / 2
    } else {
        return sorted[l.count / 2]
    }
}

func mode(l: [Int]) -> Int {
    var mode = l[0]
    var count = 1
    var maxCount = 1
    for i in 1..<l.count {
        if l[i] == l[i - 1] {
            count += 1
        } else {
            if count > maxCount {
                maxCount = count
                mode = l[i - 1]
            }
            count = 1
        }
    }
    if count > maxCount {
        mode = l[l.count - 1]
    }
    return mode
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

// 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 1..<l.count {
        if l[i] < min {
            min = l[i]
        }
    }
    return min
}

// 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]) == 128
func sum(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum
}

// Return the product of all elements in the array.
// product(l: [1, 2, 3]) == 6
// product(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == -360
func product(l: [Int]) -> Int {
    var product = 1
    for i in 0..<l.count {
        product *= l[i]
    }
    return product
}

// 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]) == 1
func average(l: [Int]) -> Int {
    var sum = 0
    for i in 0..<l.count {
        sum += l[i]
    }
    return sum / l.count
}

// Return the median of all elements in the array.
// median(l: [1, 2, 3]) == 2
// median(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 3
func median(l: [Int]) -> Int {
    var sorted = l
    sorted.sort()
    if l.count % 2 == 0 {
        return (sorted[l.count / 2 - 1] + sorted[l.count / 2]) / 2
    } else {
        return sorted[l.count / 2]
    }
}

// Return the mode of all elements in the array.
// mode(l: [1, 2, 3]) == 3
// mode(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 3
func mode(l: [Int]) -> Int {
    var mode = l[0]
    var count = 1
    var maxCount = 1
    for i in 1..<l.count {
        if l[i] == l[i - 1] {
            count += 1
        } else {
            if count > maxCount {
                maxCount = count
                mode = l[i - 1]
            }
            count = 1
        }
    }
    if count > maxCount {
        mode = l[l.count - 1]
    }
    return mode
}

// Return the variance of all elements in the array.
// variance(l: [1, 2, 3]) == 0
// variance(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
<|file_separator|>

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 0..<n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 0..<n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
<|file_separator|>

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 0..<n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

func fakeBin(x: String) -> String {
    var result = ""
    for i in x {
        if Int(String(i))! < 5 {
            result += "0"
        } else {
            result += "1"
        }
    }
    return result
}

func countBits(n: Int) -> Int {
    var count = 0
    var num = n
    while num > 0 {
        if num % 2 == 1 {
            count += 1
        }
        num /= 2
    }
    return count
}

func sumArray(array: [Double]) -> Double {
    var sum = 0.0
    for i in array {
        sum += i
    }
    return sum
}

```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 += 1
        }
    }
    return count
}

// Given a string of digits, you should replace any digit below 5 with '0' and any digit 5 and above with '1'. Return the resulting string.
//
// Note that you'll be given numbers as a string.
//
// Examples
//
// "56789" --> "11111"
// "1234" --> "1111"
// "11111" --> "11111"
func fakeBin(x: String) -> String {
    var result = ""
    for i in x {
        if Int(String(i))! < 5 {
            result += "0"
        } else {
            result += "1"
        }
    }
    return result
}

// Write a function that takes an integer as input, and returns the number of bits that are equal to one in the binary representation of that number. You can guarantee that input is non-negative.
//
// Example: The binary representation of 1234 is 10011010010, so the function should return 5 in this case
func countBits(n: Int) -> Int {
    var count = 0
    var num = n
    while num > 0 {
        if num % 2 == 1 {
            count += 1
        }
        num /= 2
    }
    return count
}

// Write a function that takes an array of numbers and returns the sum of the numbers. The numbers can be negative or non-integer. If the array does not contain any numbers then you should return 0.
//
// Examples
//
// Input: [1, 5.2, 4, 0, -1]
// Output: 9.2
// Input: []
// Output: 0
// Input: [-2.398]
// Output: -2.398
// Assumptions
// You can assume that you are only given numbers.
// You cannot assume the size of the array.
// You can assume that you do get an array and if the array is empty, return 0.
// What We're Testing
// We're testing basic loops and math operations. This is for beginners who are just learning loops and math operations.
// Advanced users may find this extremely easy and can easily write this in one line.
func sumArray(array: [Double]) -> Double {
    var sum = 0.0
    for i in array {
        sum += i
    }
    return sum
}

// Write a function that takes an array of numbers and returns the sum of the numbers. The numbers can be negative or non-integer. If the array does not contain any numbers then you should return 0.
//
// Examples
//
// Input: [1, 5.2, 4, 0, -1]
// Output: 9.2
// Input: []
// Output: 0
// Input: [-2.398]
// Output: -2.398
// Assumptions
// You can assume that you are only given numbers.
// You cannot assume the size of the array.
// You can assume that you do get an array and if the array is empty, return 0.
// What We're Testing
// We're testing basic loops and math operations. This is for beginners who are just learning loops and math operations.
// Advanced users may find this extremely easy and can easily write this in one line.
func sumArray(array: [Double]) -> Double {
    var sum = 0.0
    for i in array {
        sum += i
    }
    return sum
}

// Write a function that takes an array of numbers and returns the sum of the numbers. The numbers can be negative or non-integer. If the array does not contain any numbers then you should return 0.
//
// Examples
//
// Input: [1, 5.2, 4, 0, -1]
// Output: 9.2
// Input: []
// Output: 0
// Input: [-2.398]
// Output: -2.398
// Assumptions
// You can assume that you are only given numbers.
// You cannot assume the size of the

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
<|file_separator|>

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
<|file_separator|>

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
<|file_separator|>

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
<|file_separator|>

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 0...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 0...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
<|file_separator|>```

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 0...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 0...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
<|file_separator|>

func sortEven(l: [Int]) -> [Int] {
    var result = [Int]()
    var even = [Int]()
    for (i, v) in l.enumerate() {
        if i % 2 == 0 {
            even.append(v)
        } else {
            result.append(v)
        }
    }
    even.sort()
    for (i, v) in even.enumerate() {
        result[i] = v
    }
    return result
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var result = [Int]()
    var even = [Int]()
    for (i, v) in l.enumerate() {
        if i % 2 == 0 {
            even.append(v)
        } else {
            result.append(v)
        }
    }
    even.sort()
    for (i, v) in even.enumerate() {
        result[i] = v
    }
    return result
}
<|file_separator|>

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    return l
}

// 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 indic

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l[i+1] = l[i] - l[i+1]
            l[i] = l[i] - l[i+1]
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l[i+1] = l[i] - l[i+1]
            l[i] = l[i] - l[i+1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l[i+1] = l[i] - l[i+1]
            l[i] = l[i] - l[i+1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l[i+1] = l[i] - l[i+1]
            l[i] = l[i] - l[i+1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l[i+1] = l[i] - l[i+1]
            l[i] = l[i] - l[i+1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l[i+1] = l[i] - l[i+1]
            l[i] = l[i] - l[i+1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0...l.count - 1 {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    l.removeLast()
    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 odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0...l.count - 1 {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    l.removeLast()
    l.sort()
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0...l.count - 1 {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    l.removeLast()
    l.sort()
    return l
}
<|file_separator|>

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i + 1]
            l[i + 1] = l[i] - l[i + 1]
            l[i] = l[i] - l[i + 1]
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i + 1]
            l[i + 1] = l[i] - l[i + 1]
            l[i] = l[i] - l[i + 1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i + 1]
            l[i + 1] = l[i] - l[i + 1]
            l[i] = l[i] - l[i + 1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i + 1]
            l[i + 1] = l[i] - l[i + 1]
            l[i] = l[i] - l[i + 1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i + 1]
            l[i + 1] = l[i] - l[i + 1]
            l[i] = l[i] - l[i + 1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i + 1]
            l[i + 1] = l[i] - l[i + 1]
            l[i] = l[i] - l[i + 1]
        }
    }
    return l
}

// This

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    return l
}
<|file_separator|>

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i + 1]
        }
    }
    return l
}

// 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 indic

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0...l.count - 1 {
        if i % 2 == 1 {
            l[i] = l[i]
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0...l.count - 1 {
        if i % 2 == 1 {
            l[i] = l[i]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0...l.count - 1 {
        if i % 2 == 1 {
            l[i] = l[i]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0...l.count - 1 {
        if i % 2 == 1 {
            l[i] = l[i]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0...l.count - 1 {
        if i % 2 == 1 {
            l[i] = l[i]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0...l.count - 1 {
        if i % 2 == 1 {
            l[i] = l[i]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0...l.count - 1 {
        if i % 2 == 1 {
            l[i] = l[i]
        }
    }
    return l
}

// 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 indic

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
        }
    }
    return l
}

// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i]
        } else {
            l[i] = l[i]
        }
    }
    return l
}
<|file_separator|>

func primeFib(n: Int) -> Int {
    var a = 2
    var b = 3
    var c = 0
    var i = 1
    while i < n {
        c = a + b
        a = b
        b = c
        i += 1
    }
    return c
}

func primeFibList(n: Int) -> [Int] {
    var a = 2
    var b = 3
    var c = 0
    var i = 1
    var list = [2]
    while i < n {
        c = a + b
        a = b
        b = c
        if isPrime(c) {
            list.append(c)
        }
        i += 1
    }
    return list
}

func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 1
    }
    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 = 2
    var b = 3
    var c = 0
    var i = 1
    while i < n {
        c = a + b
        a = b
        b = c
        i += 1
    }
    return c
}

// prime_fib_list returns a list of n-th number that are Fibonacci numbers and they are also prime.
// primeFibList(n: 1) == [2]
// primeFibList(n: 2) == [2, 3]
// primeFibList(n: 3) == [2, 3, 5]
// primeFibList(n: 4) == [2, 3, 5, 13]
// primeFibList(n: 5) == [2, 3, 5, 13, 89]
func primeFibList(n: Int) -> [Int] {
    var a = 2
    var b = 3
    var c = 0
    var i = 1
    var list = [2]
    while i < n {
        c = a + b
        a = b
        b = c
        if isPrime(c) {
            list.append(c)
        }
        i += 1
    }
    return list
}

// is_prime returns true if n is a prime number.
// isPrime(n: 2) == true
// isPrime(n: 3) == true
// isPrime(n: 4) == false
// isPrime(n: 5) == true
// isPrime(n: 6) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 1
    }
    return true
}

// is_prime_list returns a list of prime numbers.
// primeFibList(n: 1) == [2]
// primeFibList(n: 2) == [2, 3]
// primeFibList(n: 3) == [2, 3, 5]
// primeFibList(n: 4) == [2, 3, 5, 13]
// primeFibList(n: 5) == [2, 3, 5, 13, 89]
func primeFibList(n: Int) -> [Int] {
    var a = 2
    var b = 3
    var c = 0
    var i = 1
    var list = [2]
    while i < n {
        c = a + b
        a = b
        b = c
        if isPrime(c) {
            list.append(c)
        }
        i += 1
    }
    return list
}

// is_prime_list returns a list of prime numbers.
// primeFibList(n: 1) == [2]
// primeFibList(n: 2) == [2, 3]
// primeFibList(n: 3) == [2, 3, 5]
// primeFibList(n: 4) == [2, 3, 5, 13]
// primeFibList(n: 5) == [2, 3, 5, 13, 89]
func primeFibList(n: Int) -> [Int] {
    var a = 2
    var b = 3
    var c = 0
    var i = 1
    var list = [2]
    while i < n {
        c = a + b
        a = b
        b = c
        if isPrime(c) {
            list.append(c)
        }
        i += 1
    }
    return list
}

// is_prime_list returns a list of prime numbers.
// primeFibList(n: 1) == [2]
// primeFibList(n: 2) == [2, 3]
// primeFibList(n: 3) == [2, 3, 5]
// primeFibList(n: 4) == [2, 3, 5, 13]
// primeFibList(n:

func primeFib(n: Int) -> Int {
    var a = 1
    var b = 1
    var c = 2
    while c < n {
        c = a + b
        a = b
        b = c
        if isPrime(c) {
            return c
        }
    }
    return c
}

func isPrime(n: Int) -> Bool {
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    return true
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var a = 1
    var b = 1
    var c = 2
    while c < n {
        c = a + b
        a = b
        b = c
        if isPrime(c) {
            return c
        }
    }
    return c
}

// isPrime returns true if n is a prime number
func isPrime(n: Int) -> Bool {
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    return true
}
<|file_separator|>

func primeFib(n: Int) -> Int {
    var a = 2
    var b = 3
    var c = 0
    var i = 2
    while i < n {
        c = a + b
        a = b
        b = c
        i += 1
    }
    return c
}

func primeFibList(n: Int) -> [Int] {
    var list = [2, 3]
    var a = 2
    var b = 3
    var c = 0
    var i = 2
    while i < n {
        c = a + b
        a = b
        b = c
        if isPrime(c) {
            list.append(c)
        }
        i += 1
    }
    return list
}

func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 1
    }
    return true
}

func primeFibListPrimePairs(n: Int) -> [[Int]] {
    var list = [[2, 2]]
    var a = 2
    var b = 3
    var c = 0
    var i = 2
    while i < n {
        c = a + b
        a = b
        b = c
        if isPrime(c) {
            list.append([c, c])
        }
        i += 1
    }
    return list
}

```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 = 2
    var b = 3
    var c = 0
    var i = 2
    while i < n {
        c = a + b
        a = b
        b = c
        i += 1
    }
    return c
}

// prime_fib_list returns a list of n Fibonacci numbers and their prime counterparts.
// primeFibList(n: 1) == [2, 3]
// primeFibList(n: 2) == [2, 3, 5]
// primeFibList(n: 3) == [2, 3, 5, 13]
// primeFibList(n: 4) == [2, 3, 5, 13, 89]
// primeFibList(n: 5) == [2, 3, 5, 13, 89, 233]
func primeFibList(n: Int) -> [Int] {
    var list = [2, 3]
    var a = 2
    var b = 3
    var c = 0
    var i = 2
    while i < n {
        c = a + b
        a = b
        b = c
        if isPrime(c) {
            list.append(c)
        }
        i += 1
    }
    return list
}

// is_prime returns true if n is a prime number, false otherwise.
// isPrime(n: 1) == false
// isPrime(n: 2) == true
// isPrime(n: 3) == true
// isPrime(n: 4) == false
// isPrime(n: 5) == true
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 1
    }
    return true
}

// prime_fib_list_prime_pairs returns a list of pairs of Fibonacci numbers and their prime counterparts.
// primeFibListPrimePairs(n: 1) == [[2, 2]]
// primeFibListPrimePairs(n: 2) == [[2, 2], [3, 3]]
// primeFibListPrimePairs(n: 3) == [[2, 2], [3, 3], [5, 5]]
// primeFibListPrimePairs(n: 4) == [[2, 2], [3, 3], [5, 5], [13, 13]]
// primeFibListPrimePairs(n: 5) == [[2, 2], [3, 3], [5, 5], [13, 13], [89, 89]]
func primeFibListPrimePairs(n: Int) -> [[Int]] {
    var list = [[2, 2]]
    var a = 2
    var b = 3
    var c = 0
    var i = 2
    while i < n {
        c = a + b
        a = b
        b = c
        if isPrime(c) {
            list.append([c, c])
        }
        i += 1
    }
    return list
}

// prime_fib_list_prime_pairs_sum returns a list of pairs of Fibonacci numbers and their prime counterparts and their sum.
// primeFibListPrimePairsSum(n: 1) == [[2, 2, 4]]
// primeFibListPrimePairsSum(n: 2) == [[2, 2, 4], [3, 3, 6]]
// primeFibListPrimePairsSum(n: 3) == [[2, 2, 4], [3, 3, 6], [5, 5, 10]]
// primeFibListPrimePairsSum(n: 4) == [[2, 2, 4], [3, 3, 6], [5, 5, 10], [13, 13, 26]]
// primeFibListPrimePairsSum(n: 5) == [[2, 2, 4], [3, 3, 6], [5, 5, 10], [13, 13, 26],

func primeFib(n: Int) -> Int {
    var a = 1
    var b = 1
    var c = 0
    var i = 0
    while i < n {
        c = a + b
        a = b
        b = c
        i += 1
    }
    return c
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var a = 1
    var b = 1
    var c = 0
    var i = 0
    while i < n {
        c = a + b
        a = b
        b = c
        i += 1
    }
    return c
}

// primeFib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var a = 1
    var b = 1
    var c = 0
    var i = 0
    while i < n {
        c = a + b
        a = b
        b = c
        i += 1
    }
    return c
}

// primeFib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var a = 1
    var b = 1
    var c = 0
    var i = 0
    while i < n {
        c = a + b
        a = b
        b = c
        i += 1
    }
    return c
}

// primeFib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var a = 1
    var b = 1
    var c = 0
    var i = 0
    while i < n {
        c = a + b
        a = b
        b = c
        i += 1
    }
    return c
}

// primeFib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var a = 1
    var b = 1
    var c = 0
    var i = 0
    while i < n {
        c = a + b
        a = b
        b = c
        i += 1
    }
    return c
}

// primeFib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var a = 1
    var b = 1
    var c = 0
    var i = 0
    while i < n {
        c = a + b
        a = b
        b = c
        i += 1
    }
    return c
}

// primeFib 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

func primeFib(n: Int) -> Int {
  var a = 1
  var b = 1
  var c = 0
  var i = 0
  while i < n {
    c = a + b
    a = b
    b = c
    i += 1
  }
  return c
}

func primeFibs(n: Int) -> [Int] {
  var a = 1
  var b = 1
  var c = 0
  var i = 0
  var result = [Int]()
  while i < n {
    c = a + b
    a = b
    b = c
    if isPrime(c) {
      result.append(c)
    }
    i += 1
  }
  return result
}

func isPrime(n: Int) -> Bool {
  if n < 2 {
    return false
  }
  if n == 2 {
    return true
  }
  if n % 2 == 0 {
    return false
  }
  var i = 3
  while i * i <= n {
    if n % i == 0 {
      return false
    }
    i += 2
  }
  return true
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
  var a = 1
  var b = 1
  var c = 0
  var i = 0
  while i < n {
    c = a + b
    a = b
    b = c
    i += 1
  }
  return c
}

// primeFibs returns an array of n Fibonacci numbers and their prime equivalents.
// primeFibs(n: 1) == [2, 3]
// primeFibs(n: 2) == [2, 3, 5]
// primeFibs(n: 3) == [2, 3, 5, 13]
// primeFibs(n: 4) == [2, 3, 5, 13, 89]
// primeFibs(n: 5) == [2, 3, 5, 13, 89, 233]
func primeFibs(n: Int) -> [Int] {
  var a = 1
  var b = 1
  var c = 0
  var i = 0
  var result = [Int]()
  while i < n {
    c = a + b
    a = b
    b = c
    if isPrime(c) {
      result.append(c)
    }
    i += 1
  }
  return result
}

// isPrime returns true if n is a prime number.
func isPrime(n: Int) -> Bool {
  if n < 2 {
    return false
  }
  if n == 2 {
    return true
  }
  if n % 2 == 0 {
    return false
  }
  var i = 3
  while i * i <= n {
    if n % i == 0 {
      return false
    }
    i += 2
  }
  return true
}
<|file_separator|>

func primeFib(n: Int) -> Int {
    var fib = [2, 3]
    var i = 0
    while fib.count < n {
        fib.append(fib[i] + fib[i + 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 = [2, 3]
    var i = 0
    while fib.count < n {
        fib.append(fib[i] + fib[i + 1])
        i += 1
    }
    return fib[n - 1]
}

// primeFib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [2, 3]
    var i = 0
    while fib.count < n {
        fib.append(fib[i] + fib[i + 1])
        i += 1
    }
    return fib[n - 1]
}

// primeFib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [2, 3]
    var i = 0
    while fib.count < n {
        fib.append(fib[i] + fib[i + 1])
        i += 1
    }
    return fib[n - 1]
}

// primeFib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [2, 3]
    var i = 0
    while fib.count < n {
        fib.append(fib[i] + fib[i + 1])
        i += 1
    }
    return fib[n - 1]
}

// primeFib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [2, 3]
    var i = 0
    while fib.count < n {
        fib.append(fib[i] + fib[i + 1])
        i += 1
    }
    return fib[n - 1]
}

// primeFib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [2, 3]
    var i = 0
    while fib.count < n {
        fib.append(fib[i] + fib[i + 1])
        i += 1
    }
    return fib[n - 1]
}

// primeFib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [2, 3]
    var i = 0
    while fib.count < n {

func primeFib(n: Int) -> Int {
    var a = 0
    var b = 1
    var c = 0
    var i = 0
    while i < n {
        c = a + b
        a = b
        b = c
        if isPrime(c) {
            i += 1
        }
    }
    return c
}

func isPrime(n: Int) -> Bool {
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    for i in 3...Int(sqrt(Double(n))) {
        if n % i == 0 {
            return false
        }
    }
    return true
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var a = 0
    var b = 1
    var c = 0
    var i = 0
    while i < n {
        c = a + b
        a = b
        b = c
        if isPrime(c) {
            i += 1
        }
    }
    return c
}

// isPrime returns true if n is prime
func isPrime(n: Int) -> Bool {
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    for i in 3...Int(sqrt(Double(n))) {
        if n % i == 0 {
            return false
        }
    }
    return true
}
<|file_separator|>

func primeFib(n: Int) -> Int {
    var a = 0
    var b = 1
    var c = 1
    var i = 0
    while i < n {
        c = a + b
        a = b
        b = c
        i += 1
    }
    return c
}

func primeFibPrimes(n: Int) -> Int {
    var a = 0
    var b = 1
    var c = 1
    var i = 0
    var primes = [2, 3]
    while i < n {
        c = a + b
        a = b
        b = c
        if c > 2 {
            var isPrime = true
            for j in 0..<primes.count {
                if c % primes[j] == 0 {
                    isPrime = false
                    break
                }
            }
            if isPrime {
                primes.append(c)
            }
        }
        i += 1
    }
    return c
}

func primeFibPrimesFast(n: Int) -> Int {
    var a = 0
    var b = 1
    var c = 1
    var i = 0
    var primes = [2, 3]
    while i < n {
        c = a + b
        a = b
        b = c
        if c > 2 {
            var isPrime = true
            for j in 0..<primes.count {
                if c % primes[j] == 0 {
                    isPrime = false
                    break
                }
            }
            if isPrime {
                primes.append(c)
            }
        }
        i += 1
    }
    return c
}

func primeFibPrimesFast2(n: Int) -> Int {
    var a = 0
    var b = 1
    var c = 1
    var i = 0
    var primes = [2, 3]
    while i < n {
        c = a + b
        a = b
        b = c
        if c > 2 {
            var isPrime = true
            for j in 0..<primes.count {
                if c % primes[j] == 0 {
                    isPrime = false
                    break
                }
            }
            if isPrime {
                primes.append(c)
            }
        }
        i += 1
    }
    return c
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var a = 0
    var b = 1
    var c = 1
    var i = 0
    while i < n {
        c = a + b
        a = b
        b = c
        i += 1
    }
    return c
}

// prime_fib_primes returns n-th number that is a Fibonacci number and it's also prime.
// primeFibPrimes(n: 1) == 2
// primeFibPrimes(n: 2) == 3
// primeFibPrimes(n: 3) == 5
// primeFibPrimes(n: 4) == 13
// primeFibPrimes(n: 5) == 89
func primeFibPrimes(n: Int) -> Int {
    var a = 0
    var b = 1
    var c = 1
    var i = 0
    var primes = [2, 3]
    while i < n {
        c = a + b
        a = b
        b = c
        if c > 2 {
            var isPrime = true
            for j in 0..<primes.count {
                if c % primes[j] == 0 {
                    isPrime = false
                    break
                }
            }
            if isPrime {
                primes.append(c)
            }
        }
        i += 1
    }
    return c
}

// prime_fib_primes_fast returns n-th number that is a Fibonacci number and it's also prime.
// primeFibPrimesFast(n: 1) == 2
// primeFibPrimesFast(n: 2) == 3
// primeFibPrimesFast(n: 3) == 5
// primeFibPrimesFast(n: 4) == 13
// primeFibPrimesFast(n: 5) == 89
func primeFibPrimesFast(n: Int) -> Int {
    var a = 0
    var b = 1
    var c = 1
    var i = 0
    var primes = [2, 3]
    while i < n {
        c = a + b
        a = b
        b = c
        if c > 2 {
            var isPrime = true
            for j in 0..<primes.count {
                if c % primes[j] == 0 {
                    isPrime = false
                    break
                }
            }
            if isPrime {
                primes.append(c)
            }
        }
        i += 1
    }
    return c
}

// prime_fib_primes_fast_2 returns n-th number that is a Fibonacci number and it's also prime.
// primeFibPrimesFast2(n: 1) == 2
// primeFibPrimesFast2(n: 2) == 3
// primeFibPrimesFast2(n: 3) == 5
// primeFibPrimesFast2(n: 4) == 13
// primeFibPrimesFast2(n: 5) == 89
func primeFibPrimesFast2(n: Int) -> Int {
    var a = 0
    var b = 1
    var c = 1
    var i = 0
    var primes = [2, 3]
    while i < n {
        c = a + b
        a = b
        b = c
        if c > 2 {
            var isPrime = true
            for j in 0..<primes.count {
                if c % primes[j] == 0 {
                    isPrime = false
                    break
                }
            }
            if isPrime {
                primes.append(c)
            }
        }
        i += 1
    }
    return c
}

// prime_fib_primes_fast_3 returns n-th number that is a Fibonacci number and it's also prime.
// primeFibPrimesFast3(n: 1) == 2
// primeFibPrimesFast3(n: 2) == 3
// primeFibPrimesFast3(n: 3) == 5
// primeFibPrimesFast3(n: 4) == 13
// primeFibPrimesFast3(n: 5) == 89
func primeFibPrimesFast3(n: Int) -> Int {
    var a = 0
    var b = 1
    var c = 1
    var i

func primeFib(n: Int) -> Int {
    var a = 2
    var b = 3
    var c = 5
    var i = 2
    while i < n {
        if isPrime(n: c) {
            i += 1
        }
        c += 2
    }
    return c
}

func isPrime(n: Int) -> Bool {
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    return true
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var a = 2
    var b = 3
    var c = 5
    var i = 2
    while i < n {
        if isPrime(n: c) {
            i += 1
        }
        c += 2
    }
    return c
}

func isPrime(n: Int) -> Bool {
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    return true
}
<|file_separator|>

func primeFib(n: Int) -> Int {
    var fib = [2, 3]
    var i = 2
    while fib.count < n {
        let last = fib[fib.count - 1]
        let secondLast = fib[fib.count - 2]
        fib.append(last + secondLast)
    }
    return fib[n - 1]
}

func primeFibPrime(n: Int) -> Int {
    var fib = [2, 3]
    var i = 2
    while fib.count < n {
        let last = fib[fib.count - 1]
        let secondLast = fib[fib.count - 2]
        fib.append(last + secondLast)
    }
    return fib[n - 1]
}

func primeFibPrimePrime(n: Int) -> Int {
    var fib = [2, 3]
    var i = 2
    while fib.count < n {
        let last = fib[fib.count - 1]
        let secondLast = fib[fib.count - 2]
        fib.append(last + secondLast)
    }
    return fib[n - 1]
}

func primeFibPrimePrimePrime(n: Int) -> Int {
    var fib = [2, 3]
    var i = 2
    while fib.count < n {
        let last = fib[fib.count - 1]
        let secondLast = fib[fib.count - 2]
        fib.append(last + secondLast)
    }
    return fib[n - 1]
}

func primeFibPrimePrimePrimePrime(n: Int) -> Int {
    var fib = [2, 3]
    var i = 2
    while fib.count < n {
        let last = fib[fib.count - 1]
        let secondLast = fib[fib.count - 2]
        fib.append(last + secondLast)
    }
    return fib[n - 1]
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [2, 3]
    var i = 2
    while fib.count < n {
        let last = fib[fib.count - 1]
        let secondLast = fib[fib.count - 2]
        fib.append(last + secondLast)
    }
    return fib[n - 1]
}

// prime_fib_prime returns n-th number that is a Fibonacci number and it's also prime.
// primeFibPrime(n: 1) == 2
// primeFibPrime(n: 2) == 3
// primeFibPrime(n: 3) == 5
// primeFibPrime(n: 4) == 13
// primeFibPrime(n: 5) == 89
func primeFibPrime(n: Int) -> Int {
    var fib = [2, 3]
    var i = 2
    while fib.count < n {
        let last = fib[fib.count - 1]
        let secondLast = fib[fib.count - 2]
        fib.append(last + secondLast)
    }
    return fib[n - 1]
}

// prime_fib_prime_prime returns n-th number that is a Fibonacci number and it's also prime.
// primeFibPrimePrime(n: 1) == 2
// primeFibPrimePrime(n: 2) == 3
// primeFibPrimePrime(n: 3) == 5
// primeFibPrimePrime(n: 4) == 13
// primeFibPrimePrime(n: 5) == 89
func primeFibPrimePrime(n: Int) -> Int {
    var fib = [2, 3]
    var i = 2
    while fib.count < n {
        let last = fib[fib.count - 1]
        let secondLast = fib[fib.count - 2]
        fib.append(last + secondLast)
    }
    return fib[n - 1]
}

// prime_fib_prime_prime_prime returns n-th number that is a Fibonacci number and it's also prime.
// primeFibPrimePrimePrime(n: 1) == 2
// primeFibPrimePrimePrime(n: 2) == 3
// primeFibPrimePrimePrime(n: 3) == 5
// primeFibPrimePrimePrime(n: 4) == 13
// primeFibPrimePrimePrime(n: 5) == 89
func primeFibPrimePrimePrime(n: Int) -> Int {
    var fib = [2, 3]
    var i = 2
    while fib.count < n {
        let last = fib[fib.count - 1]
        let secondLast = fib[fib.count - 2]
        fib.append(last + secondLast)
    }
    return fib[n - 1]
}

// prime_fib_prime_prime_prime_prime returns n-th number that is a Fibonacci number and it's also prime.
// primeFibPrimePrimePrimePrime(n: 1) == 2
// primeFibPrimePrimePrimePrime(n: 2) == 3
// primeFibPrimePrimePrimePrime(n: 3) == 5
// primeFibPrimePrimePrimePrime(n: 4) == 13
// primeFibPrimePrimePrimePrime(n: 5) == 89
func primeFibPrimePrimePrimePrime(n: Int) -> Int {
    var fib = [2, 3]
    var i = 2
    while fib.count < n {
        let last = fib[fib.count - 1]
        let secondLast = fib[fib.count - 2]
        fib.append(last + secondLast)
    }
    return fib[n - 1]
}

// prime_fib_prime_prime_prime_prime_prime returns n-th number that is a Fibonacci number and it's also prime.
// primeFibPrimePrimePrimePrimePrime(n: 1) == 2
// primeFibPrimePrimePrimePrimePrime(n: 2) == 3
// primeFibPrimePrimePrimePrimePrime(n: 3) == 5
// primeFibPrimePrimePrimePrimePrime(n: 4) == 13
// primeFibPrimePrimePrimePrimePrime(n: 5) == 89
func primeFibPrimePrime

func triplesSumToZero(l: [Int]) -> Bool {
    var l = l
    l.sort()
    for i in 0..<l.count-2 {
        var j = i+1
        var k = l.count-1
        while j < k {
            let sum = l[i] + l[j] + l[k]
            if sum == 0 {
                return true
            } else if sum < 0 {
                j += 1
            } else {
                k -= 1
            }
        }
    }
    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 l = l
    l.sort()
    for i in 0..<l.count-2 {
        var j = i+1
        var k = l.count-1
        while j < k {
            let sum = l[i] + l[j] + l[k]
            if sum == 0 {
                return true
            } else if sum < 0 {
                j += 1
            } else {
                k -= 1
            }
        }
    }
    return false
}
<|file_separator|>

func triplesSumToZero(l: [Int]) -> Bool {
    var l = l
    l.sort()
    var i = 0
    var j = l.count - 1
    while i < j {
        var sum = l[i] + l[j]
        if sum == 0 {
            return true
        } else if sum > 0 {
            j -= 1
        } else {
            i += 1
        }
    }
    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 l = l
    l.sort()
    var i = 0
    var j = l.count - 1
    while i < j {
        var sum = l[i] + l[j]
        if sum == 0 {
            return true
        } else if sum > 0 {
            j -= 1
        } else {
            i += 1
        }
    }
    return false
}
<|file_separator|>

func triplesSumToZero(l: [Int]) -> Bool {
    var l = l
    l.sort()
    for i in 0..<l.count {
        var j = i + 1
        var k = l.count - 1
        while j < k {
            if l[i] + l[j] + l[k] == 0 {
                return true
            } else if l[i] + l[j] + l[k] < 0 {
                j += 1
            } else {
                k -= 1
            }
        }
    }
    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 l = l
    l.sort()
    for i in 0..<l.count {
        var j = i + 1
        var k = l.count - 1
        while j < k {
            if l[i] + l[j] + l[k] == 0 {
                return true
            } else if l[i] + l[j] + l[k] < 0 {
                j += 1
            } else {
                k -= 1
            }
        }
    }
    return false
}

<|file_separator|>```

func triplesSumToZero(l: [Int]) -> Bool {
    var l = l
    var result = false
    l.sort()
    for i in 0..<l.count {
        var j = i + 1
        var k = l.count - 1
        while j < k {
            if l[i] + l[j] + l[k] == 0 {
                result = true
            }
            if l[i] + l[j] + l[k] < 0 {
                j += 1
            } else {
                k -= 1
            }
        }
    }
    return result
}

```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 l = l
    var result = false
    l.sort()
    for i in 0..<l.count {
        var j = i + 1
        var k = l.count - 1
        while j < k {
            if l[i] + l[j] + l[k] == 0 {
                result = true
            }
            if l[i] + l[j] + l[k] < 0 {
                j += 1
            } else {
                k -= 1
            }
        }
    }
    return result
}
<|file_separator|>

func triplesSumToZero(l: [Int]) -> Bool {
    var l = l
    l.sort()
    for i in 0..<l.count-2 {
        var j = i+1
        var k = l.count-1
        while j < k {
            if l[i] + l[j] + l[k] == 0 {
                return true
            } else if l[i] + l[j] + l[k] < 0 {
                j += 1
            } else {
                k -= 1
            }
        }
    }
    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 l = l
    l.sort()
    for i in 0..<l.count-2 {
        var j = i+1
        var k = l.count-1
        while j < k {
            if l[i] + l[j] + l[k] == 0 {
                return true
            } else if l[i] + l[j] + l[k] < 0 {
                j += 1
            } else {
                k -= 1
            }
        }
    }
    return false
}
<|file_separator|>

func triplesSumToZero(l: [Int]) -> Bool {
    var l = l
    var result = false
    var i = 0
    var j = 0
    var k = 0
    var sum = 0
    while i < l.count {
        j = i + 1
        while j < l.count {
            k = j + 1
            while k < l.count {
                sum = l[i] + l[j] + l[k]
                if sum == 0 {
                    result = true
                    break
                }
                k += 1
            }
            if result == true {
                break
            }
            j += 1
        }
        if result == true {
            break
        }
        i += 1
    }
    return result
}

```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 l = l
    var result = false
    var i = 0
    var j = 0
    var k = 0
    var sum = 0
    while i < l.count {
        j = i + 1
        while j < l.count {
            k = j + 1
            while k < l.count {
                sum = l[i] + l[j] + l[k]
                if sum == 0 {
                    result = true
                    break
                }
                k += 1
            }
            if result == true {
                break
            }
            j += 1
        }
        if result == true {
            break
        }
        i += 1
    }
    return result
}
<|file_separator|>

func triplesSumToZero(l: [Int]) -> Bool {
    var l = l
    var result = false
    
    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 {
                    result = true
                }
            }
        }
    }
    return result
}

```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 l = l
    var result = false
    
    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 {
                    result = true
                }
            }
        }
    }
    return result
}
<|file_separator|>

func triplesSumToZero(l: [Int]) -> Bool {
    var l = l
    var result = false
    l.sort()
    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 {
                    result = true
                }
            }
        }
    }
    return result
}

func triplesSumToZeroTwo(l: [Int]) -> Bool {
    var l = l
    var result = false
    l.sort()
    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 {
                    result = true
                }
            }
        }
    }
    return result
}

func triplesSumToZeroThree(l: [Int]) -> Bool {
    var l = l
    var result = false
    l.sort()
    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 {
                    result = true
                }
            }
        }
    }
    return result
}

func triplesSumToZeroFour(l: [Int]) -> Bool {
    var l = l
    var result = false
    l.sort()
    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 {
                    result = true
                }
            }
        }
    }
    return result
}

```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 l = l
    var result = false
    l.sort()
    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 {
                    result = true
                }
            }
        }
    }
    return result
}

// triples_sum_to_zero_two 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.
// triplesSumToZeroTwo(l: [1, 3, 5, 0]) == false
// triplesSumToZeroTwo(l: [1, 3, -2, 1]) == true
// triplesSumToZeroTwo(l: [1, 2, 3, 7]) == false
// triplesSumToZeroTwo(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZeroTwo(l: [1]) == false
func triplesSumToZeroTwo(l: [Int]) -> Bool {
    var l = l
    var result = false
    l.sort()
    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 {
                    result = true
                }
            }
        }
    }
    return result
}

// triples_sum_to_zero_three 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.
// triplesSumToZeroThree(l: [1, 3, 5, 0]) == false
// triplesSumToZeroThree(l: [1, 3, -2, 1]) == true
// triplesSumToZeroThree(l: [1, 2, 3, 7]) == false
// triplesSumToZeroThree(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZeroThree(l: [1]) == false
func triplesSumToZeroThree(l: [Int]) -> Bool {
    var l = l
    var result = false
    l.sort()
    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 {
                    result = true
                }
            }
        }
    }
    return result
}

// triples_sum_to_zero_four 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.
// triplesSumToZeroFour(l: [1, 3, 5, 0]) == false
// triplesSumToZeroFour(l: [1, 3, -2, 1]) == true
// triplesSumToZeroFour(l: [1, 2, 3, 7]) == false
// triplesSumToZeroFour(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZeroFour(l: [1]) == false
func triplesSumToZeroFour(l: [Int]) -> Bool {
    var l = l
    var result = false
    l.sort()
    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 {
                    result = true
                }
            }
        }
    }
    return result
}

// triples_sum_to_zero_five 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.
// triplesSumToZeroFive(l: [1, 3, 5, 0]) == false
// triplesSumToZeroFive(l: [1, 3, -2, 1

func triplesSumToZero(l: [Int]) -> Bool {
    var l = l
    l.sort()
    for i in 0..<l.count {
        var j = i + 1
        var k = l.count - 1
        while j < k {
            if l[i] + l[j] + l[k] == 0 {
                return true
            } else if l[i] + l[j] + l[k] < 0 {
                j += 1
            } else {
                k -= 1
            }
        }
    }
    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 l = l
    l.sort()
    for i in 0..<l.count {
        var j = i + 1
        var k = l.count - 1
        while j < k {
            if l[i] + l[j] + l[k] == 0 {
                return true
            } else if l[i] + l[j] + l[k] < 0 {
                j += 1
            } else {
                k -= 1
            }
        }
    }
    return false
}
<|file_separator|>```

func triplesSumToZero(l: [Int]) -> Bool {
    var l = l
    var result = false
    l.sort()
    for i in 0...l.count-3 {
        for j in i+1...l.count-2 {
            for k in j+1...l.count-1 {
                if l[i] + l[j] + l[k] == 0 {
                    result = true
                }
            }
        }
    }
    return result
}

```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 l = l
    var result = false
    l.sort()
    for i in 0...l.count-3 {
        for j in i+1...l.count-2 {
            for k in j+1...l.count-1 {
                if l[i] + l[j] + l[k] == 0 {
                    result = true
                }
            }
        }
    }
    return result
}
<|file_separator|>

func carRaceCollision(n: Int) -> Int {
  var collisions = 0
  var cars = [Int](count: n, repeatedValue: 0)
  var left = 0
  var right = n - 1
  while left < right {
    if cars[left] == 0 && cars[right] == 0 {
      cars[left] = 1
      cars[right] = 1
      left += 1
      right -= 1
    } else if cars[left] == 1 && cars[right] == 0 {
      cars[right] = 1
      right -= 1
    } else if cars[left] == 0 && cars[right] == 1 {
      cars[left] = 1
      left += 1
    } else {
      left += 1
      right -= 1
    }
    collisions += 1
  }
  return collisions
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
  var collisions = 0
  var cars = [Int](count: n, repeatedValue: 0)
  var left = 0
  var right = n - 1
  while left < right {
    if cars[left] == 0 && cars[right] == 0 {
      cars[left] = 1
      cars[right] = 1
      left += 1
      right -= 1
    } else if cars[left] == 1 && cars[right] == 0 {
      cars[right] = 1
      right -= 1
    } else if cars[left] == 0 && cars[right] == 1 {
      cars[left] = 1
      left += 1
    } else {
      left += 1
      right -= 1
    }
    collisions += 1
  }
  return collisions
}
<|file_separator|>

func carRaceCollision(n: Int) -> Int {
  var collisions = 0
  var cars = Array(repeating: 0, count: n)
  for i in 0..<n {
    cars[i] = i
  }
  for i in 0..<n {
    for j in 0..<n {
      if cars[i] < cars[j] {
        collisions += 1
      }
    }
  }
  return collisions
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
  var collisions = 0
  var cars = Array(repeating: 0, count: n)
  for i in 0..<n {
    cars[i] = i
  }
  for i in 0..<n {
    for j in 0..<n {
      if cars[i] < cars[j] {
        collisions += 1
      }
    }
  }
  return collisions
}
<|file_separator|>

func carRaceCollision(n: Int) -> Int {
  var leftCars = Array(repeating: 0, count: n)
  var rightCars = Array(repeating: 0, count: n)
  var collisions = 0
  for i in 0..<n {
    for j in 0..<n {
      if leftCars[i] < rightCars[j] {
        collisions += 1
      }
    }
  }
  return collisions
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
  var leftCars = Array(repeating: 0, count: n)
  var rightCars = Array(repeating: 0, count: n)
  var collisions = 0
  for i in 0..<n {
    for j in 0..<n {
      if leftCars[i] < rightCars[j] {
        collisions += 1
      }
    }
  }
  return collisions
}
<|file_separator|>

func carRaceCollision(n: Int) -> Int {
    // Write your code here
    var left = 0
    var right = 0
    var collision = 0
    for i in 0..<n {
        if left < right {
            left += 1
        } else if right < left {
            right += 1
        } else {
            collision += 1
            left += 1
            right += 1
        }
    }
    return collision
}

```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 {
    // Write your code here
    var left = 0
    var right = 0
    var collision = 0
    for i in 0..<n {
        if left < right {
            left += 1
        } else if right < left {
            right += 1
        } else {
            collision += 1
            left += 1
            right += 1
        }
    }
    return collision
}
<|file_separator|>

func carRaceCollision(n: Int) -> Int {
  var left = Array(repeating: 0, count: n)
  var right = Array(repeating: 0, count: n)
  var collisions = 0
  for i in 0..<n {
    if left[i] == 0 && right[i] == 0 {
      left[i] = 1
      right[i] = 1
      collisions += 1
    }
  }
  return collisions
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
  var left = Array(repeating: 0, count: n)
  var right = Array(repeating: 0, count: n)
  var collisions = 0
  for i in 0..<n {
    if left[i] == 0 && right[i] == 0 {
      left[i] = 1
      right[i] = 1
      collisions += 1
    }
  }
  return collisions
}
<|file_separator|>

func carRaceCollision(n: Int) -> Int {
  var leftCars = Array(repeating: 0, count: n)
  var rightCars = Array(repeating: 0, count: n)
  var collisions = 0
  for i in 0..<n {
    leftCars[i] = i
    rightCars[i] = n - i - 1
  }
  for i in 0..<n {
    for j in 0..<n {
      if leftCars[i] > rightCars[j] {
        collisions += 1
      }
    }
  }
  return collisions
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
  var leftCars = Array(repeating: 0, count: n)
  var rightCars = Array(repeating: 0, count: n)
  var collisions = 0
  for i in 0..<n {
    leftCars[i] = i
    rightCars[i] = n - i - 1
  }
  for i in 0..<n {
    for j in 0..<n {
      if leftCars[i] > rightCars[j] {
        collisions += 1
      }
    }
  }
  return collisions
}
<|file_separator|>

func carRaceCollision(n: Int) -> Int {
    var leftCars = Array(repeating: 0, count: n)
    var rightCars = Array(repeating: 0, count: n)
    var collisions = 0
    for i in 0..<n {
        leftCars[i] = i
        rightCars[i] = n - i - 1
    }
    for i in 0..<n {
        for j in 0..<n {
            if leftCars[i] < rightCars[j] {
                collisions += 1
            }
        }
    }
    return collisions
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var leftCars = Array(repeating: 0, count: n)
    var rightCars = Array(repeating: 0, count: n)
    var collisions = 0
    for i in 0..<n {
        leftCars[i] = i
        rightCars[i] = n - i - 1
    }
    for i in 0..<n {
        for j in 0..<n {
            if leftCars[i] < rightCars[j] {
                collisions += 1
            }
        }
    }
    return collisions
}
<|file_separator|>

func carRaceCollision(n: Int) -> Int {
    var collisions = 0
    for i in 0..<n {
        for j in i+1..<n {
            if i < j {
                if (j - i) % 2 == 0 {
                    collisions += 1
                }
            }
        }
    }
    return collisions
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var collisions = 0
    for i in 0..<n {
        for j in i+1..<n {
            if i < j {
                if (j - i) % 2 == 0 {
                    collisions += 1
                }
            }
        }
    }
    return collisions
}
<|file_separator|>

func carRaceCollision(n: Int) -> Int {
    var left = 0
    var right = 0
    for i in 0..<n {
        if left < right {
            left += 1
        } else {
            right += 1
        }
    }
    return left
}

```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 = 0
    for i in 0..<n {
        if left < right {
            left += 1
        } else {
            right += 1
        }
    }
    return left
}
<|file_separator|>

func carRaceCollision(n: Int) -> Int {
  var collisions = 0
  var cars = [Int]()
  for i in 1...n {
    cars.append(i)
  }
  for i in 0..<n {
    for j in i+1..<n {
      if cars[i] > cars[j] {
        collisions += 1
      }
    }
  }
  return collisions
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
  var collisions = 0
  var cars = [Int]()
  for i in 1...n {
    cars.append(i)
  }
  for i in 0..<n {
    for j in i+1..<n {
      if cars[i] > cars[j] {
        collisions += 1
      }
    }
  }
  return collisions
}
<|file_separator|>

func incrList(l: [Int]) -> [Int] {
    return l.map { $0 + 1 }
}

func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

func incrDoubleList(l: [Int]) -> [Int] {
    return doubleList(l: incrList(l: l))
}

func decrDoubleList(l: [Int]) -> [Int] {
    return doubleList(l: decrList(l: l))
}

func halfDoubleList(l: [Int]) -> [Double] {
    return doubleList(l: halfList(l: l))
}

```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 }
}

// Return array with elements decremented by 1.
// decrList(l: [1, 2, 3]) == [0, 1, 2]
// decrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [4, 2, 4, 1, 2, 2, 8, 0, 122]
func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

// Return array with elements multiplied by 2.
// doubleList(l: [1, 2, 3]) == [2, 4, 6]
// doubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [10, 6, 10, 4, 6, 6, 18, 0, 246]
func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

// Return array with elements divided by 2.
// halfList(l: [1, 2, 3]) == [0.5, 1, 1.5]
// halfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.5, 1.5, 1.5, 4.5, 0, 61.5]
func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

// Return array with elements multiplied by 2 and incremented by 1.
// incrDoubleList(l: [1, 2, 3]) == [3, 5, 7]
// incrDoubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [11, 7, 11, 4, 7, 7, 18, 0, 124]
func incrDoubleList(l: [Int]) -> [Int] {
    return doubleList(l: incrList(l: l))
}

// Return array with elements multiplied by 2 and decremented by 1.
// decrDoubleList(l: [1, 2, 3]) == [0, 1, 2]
// decrDoubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [10, 5, 5, 1, 3, 3, 8, 0, 122]
func decrDoubleList(l: [Int]) -> [Int] {
    return doubleList(l: decrList(l: l))
}

// Return array with elements multiplied by 2 and divided by 2.
// halfDoubleList(l: [1, 2, 3]) == [0.5, 1, 1.5]
// halfDoubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.5, 1.5, 1.5, 4.5, 0, 61.5]
func halfDoubleList(l: [Int]) -> [Double] {
    return doubleList(l: halfList(l: l))
}

// Return array with elements multiplied by 2 and incremented by 1 and divided by 2.
// halfDoubleList(l: [1, 2, 3]) == [0.5, 1, 1.5]
// halfDoubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.5, 1.5, 1.5, 4.

func incrList(l: [Int]) -> [Int] {
    return l.map { $0 + 1 }
}

func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

func incrDoubleList(l: [Int]) -> [Int] {
    return incrList(doubleList(l))
}

func decrDoubleList(l: [Int]) -> [Int] {
    return decrList(doubleList(l))
}

func halfDoubleList(l: [Int]) -> [Double] {
    return halfList(doubleList(l))
}

```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 }
}

// Return array with elements decremented by 1.
// decrList(l: [1, 2, 3]) == [0, 1, 2]
// decrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [4, 2, 4, 1, 2, 2, 8, 0, 122]
func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

// Return array with elements multiplied by 2.
// doubleList(l: [1, 2, 3]) == [2, 4, 6]
// doubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [10, 6, 10, 4, 6, 6, 18, 0, 246]
func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

// Return array with elements divided by 2.
// halfList(l: [1, 2, 3]) == [0.5, 1, 1.5]
// halfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.5, 1.5, 1.5, 4.5, 0, 61.5]
func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

// Return array with elements multiplied by 2 and incremented by 1.
// incrDoubleList(l: [1, 2, 3]) == [2, 3, 4]
// incrDoubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrDoubleList(l: [Int]) -> [Int] {
    return incrList(doubleList(l))
}

// Return array with elements multiplied by 2 and decremented by 1.
// decrDoubleList(l: [1, 2, 3]) == [0, 1, 2]
// decrDoubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [4, 2, 4, 1, 2, 2, 8, 0, 122]
func decrDoubleList(l: [Int]) -> [Int] {
    return decrList(doubleList(l))
}

// Return array with elements multiplied by 2 and divided by 2.
// halfDoubleList(l: [1, 2, 3]) == [0.5, 1, 1.5]
// halfDoubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.5, 1.5, 1.5, 4.5, 0, 61.5]
func halfDoubleList(l: [Int]) -> [Double] {
    return halfList(doubleList(l))
}

// Return array with elements multiplied by 2 and incremented by 1 and divided by 2.
// incrHalfDoubleList(l: [1, 2, 3]) == [2, 3, 4]
// incrHalfDoubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrHalfDoubleList(l: [Int]) -> [Int] {
    return

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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// 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 }
}

// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 

func incrList(l: [Int]) -> [Int] {
    return l.map { $0 + 1 }
}

func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

func doubleHalfList(l: [Int]) -> [Double] {
    return l.map { Double($0) * 2 }.map { $0 / 2 }
}

```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 }
}

// Return array with elements decremented by 1.
// decrList(l: [1, 2, 3]) == [0, 1, 2]
// decrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [4, 2, 4, 1, 2, 2, 8, 0, 122]
func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

// Return array with elements multiplied by 2.
// doubleList(l: [1, 2, 3]) == [2, 4, 6]
// doubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [10, 6, 10, 4, 6, 6, 18, 0, 246]
func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

// Return array with elements divided by 2.
// halfList(l: [1, 2, 3]) == [0.5, 1, 1.5]
// halfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.5, 1.5, 1.5, 4.5, 0, 61.5]
func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

// Return array with elements multiplied by 2 and then divided by 2.
// doubleHalfList(l: [1, 2, 3]) == [0.5, 1, 1.5]
// doubleHalfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.5, 1.5, 1.5, 4.5, 0, 61.5]
func doubleHalfList(l: [Int]) -> [Double] {
    return l.map { Double($0) * 2 }.map { $0 / 2 }
}

// Return array with elements multiplied by 2 and then divided by 2.
// doubleHalfList(l: [1, 2, 3]) == [0.5, 1, 1.5]
// doubleHalfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.5, 1.5, 1.5, 4.5, 0, 61.5]
func doubleHalfList(l: [Int]) -> [Double] {
    return l.map { Double($0) * 2 }.map { $0 / 2 }
}

// Return array with elements multiplied by 2 and then divided by 2.
// doubleHalfList(l: [1, 2, 3]) == [0.5, 1, 1.5]
// doubleHalfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.5, 1.5, 1.5, 4.5, 0, 61.5]
func doubleHalfList(l: [Int]) -> [Double] {
    return l.map { Double($0) * 2 }.map { $0 / 2 }
}

// Return array with elements multiplied by 2 and then divided by 2.
// doubleHalfList(l: [1, 2, 3]) == [0.5, 1, 1.5]
// doubleHalfList(l: [5, 3, 5, 2, 

func incrList(l: [Int]) -> [Int] {
    return l.map { $0 + 1 }
}

func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

func tripleHalfList(l: [Int]) -> [Double] {
    return l.map { Double($0) * 3 / 2 }
}

```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 }
}

// Return array with elements decremented by 1.
// decrList(l: [1, 2, 3]) == [0, 1, 2]
// decrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [4, 2, 4, 1, 2, 2, 8, 0, 122]
func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

// Return array with elements multiplied by 2.
// doubleList(l: [1, 2, 3]) == [2, 4, 6]
// doubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [10, 6, 10, 4, 6, 6, 18, 0, 246]
func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

// Return array with elements divided by 2.
// halfList(l: [1, 2, 3]) == [0.5, 1.0, 1.5]
// halfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.0, 1.5, 1.5, 4.5, 0.0, 61.5]
func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

// Return array with elements multiplied by 2 and then divided by 2.
// tripleHalfList(l: [1, 2, 3]) == [0.5, 1.0, 1.5]
// tripleHalfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.0, 1.5, 1.5, 4.5, 0.0, 61.5]
func tripleHalfList(l: [Int]) -> [Double] {
    return l.map { Double($0) * 3 / 2 }
}

// Return array with elements multiplied by 2 and then divided by 2.
// tripleHalfList(l: [1, 2, 3]) == [0.5, 1.0, 1.5]
// tripleHalfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.0, 1.5, 1.5, 4.5, 0.0, 61.5]
func tripleHalfList(l: [Int]) -> [Double] {
    return l.map { Double($0) * 3 / 2 }
}

// Return array with elements multiplied by 2 and then divided by 2.
// tripleHalfList(l: [1, 2, 3]) == [0.5, 1.0, 1.5]
// tripleHalfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.0, 1.5, 1.5, 4.5, 0.0, 61.5]
func tripleHalfList(l: [Int]) -> [Double] {
    return l.map { Double($0) * 3 / 2 }
}

// Return array with elements multiplied by 2 and then divided by 2.
// tripleHalfList(l: [1, 2, 3]) == [0.5, 1.0, 1.5]
// tripleHalfList(l: [5, 3, 5, 

func incrList(l: [Int]) -> [Int] {
    return l.map { $0 + 1 }
}

func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

func tripleList(l: [Int]) -> [Int] {
    return l.map { $0 * 3 }
}

func doubleIncrList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 + 1 }
}

func tripleDecrList(l: [Int]) -> [Int] {
    return l.map { $0 * 3 - 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 }
}

// Return array with elements decremented by 1.
// decrList(l: [1, 2, 3]) == [0, 1, 2]
// decrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [4, 2, 4, 1, 2, 2, 8, 0, 122]
func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

// Return array with elements multiplied by 2.
// doubleList(l: [1, 2, 3]) == [2, 4, 6]
// doubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [10, 6, 10, 4, 6, 6, 18, 0, 246]
func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

// Return array with elements divided by 2.
// halfList(l: [1, 2, 3]) == [0.5, 1, 1.5]
// halfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.5, 1.5, 1.5, 4.5, 0.5, 61.5]
func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

// Return array with elements multiplied by 3.
// tripleList(l: [1, 2, 3]) == [3, 6, 9]
// tripleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [15, 9, 15, 6, 9, 9, 27, 0, 369]
func tripleList(l: [Int]) -> [Int] {
    return l.map { $0 * 3 }
}

// Return array with elements multiplied by 2 and incremented by 1.
// doubleIncrList(l: [1, 2, 3]) == [3, 5, 7]
// doubleIncrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [7, 9, 11, 4, 6, 8, 18, 0, 246]
func doubleIncrList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 + 1 }
}

// Return array with elements multiplied by 3 and decremented by 1.
// tripleDecrList(l: [1, 2, 3]) == [0, 1, 2]
// tripleDecrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [15, 11, 9, 4, 2, 2, 6, 0, 122]
func tripleDecrList(l: [Int]) -> [Int] {
    return l.map { $0 * 3 - 1 }
}

// Return array with elements multiplied by 2 and decremented by 1.
// doubleDecrList(l: [1, 2, 3]) == [0, 1, 2]
// doubleDecrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [10, 8, 6, 4, 2, 2, 4, 0, 122]
func doubleDecrList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 -

func incrList(l: [Int]) -> [Int] {
    return l.map { $0 + 1 }
}

func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

func doubleHalfList(l: [Int]) -> [Double] {
    return doubleList(l: halfList(l: l))
}

```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 }
}

// Return array with elements decremented by 1.
// decrList(l: [1, 2, 3]) == [0, 1, 2]
// decrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [4, 2, 4, 1, 2, 2, 8, 0, 122]
func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

// Return array with elements multiplied by 2.
// doubleList(l: [1, 2, 3]) == [2, 4, 6]
// doubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [10, 6, 10, 4, 6, 6, 18, 0, 246]
func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

// Return array with elements divided by 2.
// halfList(l: [1, 2, 3]) == [0.5, 1.0, 1.5]
// halfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.0, 1.5, 1.5, 4.5, 0.0, 61.5]
func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

// Return array with elements multiplied by 2 and then divided by 2.
// doubleHalfList(l: [1, 2, 3]) == [0.5, 1.0, 1.5]
// doubleHalfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.0, 1.5, 1.5, 4.5, 0.0, 61.5]
func doubleHalfList(l: [Int]) -> [Double] {
    return doubleList(l: halfList(l: l))
}

// Return array with elements multiplied by 2 and then divided by 2.
// doubleHalfList(l: [1, 2, 3]) == [0.5, 1.0, 1.5]
// doubleHalfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.0, 1.5, 1.5, 4.5, 0.0, 61.5]
func doubleHalfList(l: [Int]) -> [Double] {
    return doubleList(l: halfList(l: l))
}

// Return array with elements multiplied by 2 and then divided by 2.
// doubleHalfList(l: [1, 2, 3]) == [0.5, 1.0, 1.5]
// doubleHalfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.0, 1.5, 1.5, 4.5, 0.0, 61.5]
func doubleHalfList(l: [Int]) -> [Double] {
    return doubleList(l: halfList(l: l))
}

// Return array with elements multiplied by 2 and then divided by 2.
// doubleHalfList(l: [1, 2, 3]) == [0.5, 1.0, 1.5]
// doubleHalfList(l: [5, 3, 5, 2, 3, 3, 

func incrList(l: [Int]) -> [Int] {
    return l.map { $0 + 1 }
}

func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

func tripleList(l: [Int]) -> [Int] {
    return l.map { $0 * 3 }
}

func quadrupleList(l: [Int]) -> [Int] {
    return l.map { $0 * 4 }
}

func quintupleList(l: [Int]) -> [Int] {
    return l.map { $0 * 5 }
}

func sextupleList(l: [Int]) -> [Int] {
    return l.map { $0 * 6 }
}

```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 }
}

// Return array with elements decremented by 1.
// decrList(l: [1, 2, 3]) == [0, 1, 2]
// decrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [4, 2, 4, 1, 2, 2, 8, 0, 122]
func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

// Return array with elements multiplied by 2.
// doubleList(l: [1, 2, 3]) == [2, 4, 6]
// doubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [10, 6, 10, 4, 6, 6, 18, 0, 246]
func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

// Return array with elements divided by 2.
// halfList(l: [1, 2, 3]) == [0.5, 1.0, 1.5]
// halfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.0, 1.5, 1.5, 4.5, 0.0, 61.5]
func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

// Return array with elements multiplied by 3.
// tripleList(l: [1, 2, 3]) == [3, 6, 9]
// tripleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [15, 9, 15, 6, 9, 9, 27, 0, 369]
func tripleList(l: [Int]) -> [Int] {
    return l.map { $0 * 3 }
}

// Return array with elements multiplied by 4.
// quadrupleList(l: [1, 2, 3]) == [4, 8, 12]
// quadrupleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [20, 16, 24, 8, 12, 12, 48, 0, 384]
func quadrupleList(l: [Int]) -> [Int] {
    return l.map { $0 * 4 }
}

// Return array with elements multiplied by 5.
// quintupleList(l: [1, 2, 3]) == [5, 10, 15]
// quintupleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [25, 15, 25, 10, 15, 15, 45, 0, 360]
func quintupleList(l: [Int]) -> [Int] {
    return l.map { $0 * 5 }
}

// Return array with elements multiplied by 6.
// sextupleList(l: [1, 2, 3]) == [6, 12, 18]
// sextupleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [30, 18, 30, 12, 18, 18, 54, 0, 366]
func sextupleList(l: [Int]) -> [Int] {
    return l.map { $0 * 6 }
}

// Return array with elements multiplied by 

func incrList(l: [Int]) -> [Int] {
    return l.map { $0 + 1 }
}

func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

func tripleList(l: [Int]) -> [Int] {
    return l.map { $0 * 3 }
}

func quarterList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 3 }
}

```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 }
}

// Return array with elements decremented by 1.
// decrList(l: [1, 2, 3]) == [0, 1, 2]
// decrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [4, 2, 4, 1, 2, 2, 8, 0, 122]
func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

// Return array with elements multiplied by 2.
// doubleList(l: [1, 2, 3]) == [2, 4, 6]
// doubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [10, 6, 10, 4, 6, 6, 18, 0, 246]
func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

// Return array with elements divided by 2.
// halfList(l: [1, 2, 3]) == [0.5, 1.0, 1.5]
// halfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.0, 1.5, 1.5, 4.5, 0.0, 61.5]
func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

// Return array with elements multiplied by 3.
// tripleList(l: [1, 2, 3]) == [3, 6, 9]
// tripleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [15, 9, 15, 6, 9, 9, 27, 0, 369]
func tripleList(l: [Int]) -> [Int] {
    return l.map { $0 * 3 }
}

// Return array with elements divided by 3.
// quarterList(l: [1, 2, 3]) == [0.3333333333333333, 0.6666666666666666, 0.9999999999999999]
// quarterList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [1.6666666666666667, 1.3333333333333333, 1.6666666666666667, 0.6666666666666666, 1.3333333333333333, 1.3333333333333333, 3.3333333333333335, 0.0, 39.333333333333334]
func quarterList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 3 }
}

// Return array with elements multiplied by 4.
// quadrupleList(l: [1, 2, 3]) == [4, 8, 12]
// quadrupleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [20, 16, 24, 8, 12, 12, 36, 0, 432]
func quadrupleList(l: [Int])

func incrList(l: [Int]) -> [Int] {
    return l.map { $0 + 1 }
}

func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

func incrDoubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 + 1 }
}

func decrDoubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 - 1 }
}

func halfDoubleList(l: [Int]) -> [Double] {
    return l.map { Double($0) * 2 / 2 }
}

```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 }
}

// Return array with elements decremented by 1.
// decrList(l: [1, 2, 3]) == [0, 1, 2]
// decrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [4, 2, 4, 1, 2, 2, 8, 0, 122]
func decrList(l: [Int]) -> [Int] {
    return l.map { $0 - 1 }
}

// Return array with elements multiplied by 2.
// doubleList(l: [1, 2, 3]) == [2, 4, 6]
// doubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [10, 6, 10, 4, 6, 6, 18, 0, 246]
func doubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 }
}

// Return array with elements divided by 2.
// halfList(l: [1, 2, 3]) == [0.5, 1, 1.5]
// halfList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.5, 1.5, 1.5, 4.5, 0, 61.5]
func halfList(l: [Int]) -> [Double] {
    return l.map { Double($0) / 2 }
}

// Return array with elements multiplied by 2 and incremented by 1.
// incrDoubleList(l: [1, 2, 3]) == [3, 5, 7]
// incrDoubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [11, 7, 11, 4, 7, 7, 18, 0, 124]
func incrDoubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 + 1 }
}

// Return array with elements multiplied by 2 and decremented by 1.
// decrDoubleList(l: [1, 2, 3]) == [0, 1, 2]
// decrDoubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [10, 3, 5, 1, 3, 3, 8, 0, 122]
func decrDoubleList(l: [Int]) -> [Int] {
    return l.map { $0 * 2 - 1 }
}

// Return array with elements multiplied by 2 and divided by 2.
// halfDoubleList(l: [1, 2, 3]) == [0.5, 1, 1.5]
// halfDoubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [2.5, 1.5, 2.5, 1.5, 1.5, 1.5, 4.5, 0, 61.5]
func halfDoubleList(l: [Int]) -> [Double] {
    return l.map { Double($0) * 2 / 2 }
}

// Return array with elements multiplied by 2 and incremented by 1.
// incrHalfDoubleList(l: [1, 2, 3]) == [3, 5, 7]
// incrHalfDoubleList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [11, 7, 11, 4, 7, 7, 18, 0, 124]
func incrHalf

func pairsSumToZero(l: [Int]) -> Bool {
    // TODO: implement me
    return false
}

func pairsSumToZero2(l: [Int]) -> Bool {
    // TODO: implement me
    return false
}

func pairsSumToZero3(l: [Int]) -> Bool {
    // TODO: implement me
    return false
}

func pairsSumToZero4(l: [Int]) -> Bool {
    // TODO: implement me
    return false
}

func pairsSumToZero5(l: [Int]) -> Bool {
    // TODO: implement me
    return false
}

func pairsSumToZero6(l: [Int]) -> Bool {
    // TODO: implement me
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    // TODO: implement me
    return false
}

// pairs_sum_to_zero_2 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: implement me
    return false
}

// pairs_sum_to_zero_3 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: implement me
    return false
}

// pairs_sum_to_zero_4 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: implement me
    return false
}

// pairs_sum_to_zero_5 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: implement me
    return false
}

// pairs_sum_to_zero_6 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: implement me
    return false
}

// pairs_sum_to_zero_7 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: [

func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}
<|file_separator|>```

func pairsSumToZero(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

func pairsSumToZeroTwo(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

func pairsSumToZeroThree(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

func pairsSumToZeroFour(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

func pairsSumToZeroFive(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            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 * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

// pairs_sum_to_zero_two 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.
// pairsSumToZeroTwo(l: [1, 3, 5, 0]) == false
// pairsSumToZeroTwo(l: [1, 3, -2, 1]) == false
// pairsSumToZeroTwo(l: [1, 2, 3, 7]) == false
// pairsSumToZeroTwo(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZeroTwo(l: [1]) == false
func pairsSumToZeroTwo(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

// pairs_sum_to_zero_three 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.
// pairsSumToZeroThree(l: [1, 3, 5, 0]) == false
// pairsSumToZeroThree(l: [1, 3, -2, 1]) == false
// pairsSumToZeroThree(l: [1, 2, 3, 7]) == false
// pairsSumToZeroThree(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZeroThree(l: [1]) == false
func pairsSumToZeroThree(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

// pairs_sum_to_zero_four 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.
// pairsSumToZeroFour(l: [1, 3, 5, 0]) == false
// pairsSumToZeroFour(l: [1, 3, -2, 1]) == false
// pairsSumToZeroFour(l: [1, 2, 3, 7]) == false
// pairsSumToZeroFour(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZeroFour(l: [1]) == false
func pairsSumToZeroFour(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

// pairs_sum_to_zero_five 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.
// pairsSumToZeroFive(l: [1, 3, 5, 0]) == false
// pairsSumToZeroFive(l: [1, 3, -2, 1]) == false
// pairsSumToZeroFive(l: [1, 2, 3, 7]) == false
// pairsSumToZeroFive(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZeroFive(l: [1]) == false
func pairsSumToZeroFive(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

// pairs_sum_to_zero_six 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.
//

func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(i * -1) {
            return true
        } else {
            set.insert(i)
        }
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(i * -1) {
            return true
        } else {
            set.insert(i)
        }
    }
    return false
}
<|file_separator|>

func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(i * -1) {
            return true
        } else {
            set.insert(i)
        }
    }
    return false
}

func pairsSumToZero2(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(i * -1) {
            return true
        } else {
            set.insert(i)
        }
    }
    return false
}

func pairsSumToZero3(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(i * -1) {
            return true
        } else {
            set.insert(i)
        }
    }
    return false
}

func pairsSumToZero4(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(i * -1) {
            return true
        } else {
            set.insert(i)
        }
    }
    return false
}

func pairsSumToZero5(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(i * -1) {
            return true
        } else {
            set.insert(i)
        }
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(i * -1) {
            return true
        } else {
            set.insert(i)
        }
    }
    return false
}

// pairs_sum_to_zero_2 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 {
    var set = Set<Int>()
    for i in l {
        if set.contains(i * -1) {
            return true
        } else {
            set.insert(i)
        }
    }
    return false
}

// pairs_sum_to_zero_3 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 {
    var set = Set<Int>()
    for i in l {
        if set.contains(i * -1) {
            return true
        } else {
            set.insert(i)
        }
    }
    return false
}

// pairs_sum_to_zero_4 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 {
    var set = Set<Int>()
    for i in l {
        if set.contains(i * -1) {
            return true
        } else {
            set.insert(i)
        }
    }
    return false
}

// pairs_sum_to_zero_5 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 {
    var set = Set<Int>()
    for i in l {
        if set.contains(i * -1) {
            return true
        } else {
            set.insert(i)
        }
    }
    return false
}

// pairs_sum_to_zero_6 takes an array of integers as an input.
//

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
}
<|file_separator|>

func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}

func pairsSumToZero2(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}

func pairsSumToZero3(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}

func pairsSumToZero4(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}

func pairsSumToZero5(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}

// pairs_sum_to_zero_2 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 {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}

// pairs_sum_to_zero_3 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 {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}

// pairs_sum_to_zero_4 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 {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}

// pairs_sum_to_zero_5 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 {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}

// pairs_sum_to_zero_6 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, 

func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(i * -1) {
            return true
        } else {
            set.insert(i)
        }
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(i * -1) {
            return true
        } else {
            set.insert(i)
        }
    }
    return false
}
<|file_separator|>

func pairsSumToZero(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

func pairsSumToZero2(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

func pairsSumToZero3(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

func pairsSumToZero4(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

func pairsSumToZero5(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            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 * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

// pairs_sum_to_zero_2 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]) == true
// 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 {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

// pairs_sum_to_zero_3 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]) == true
// 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 {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

// pairs_sum_to_zero_4 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]) == true
// 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 {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

// pairs_sum_to_zero_5 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]) == true
// 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 {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(i * -1) {
            return true
        }
        seen.insert(i)
    }
    return false
}

// pairs_sum_to_zero_6 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.
//

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 pairsSumToZero2(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}

func pairsSumToZero3(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}

func pairsSumToZero4(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}

func pairsSumToZero5(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
}

// pairs_sum_to_zero_2 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 {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}

// pairs_sum_to_zero_3 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 {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}

// pairs_sum_to_zero_4 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 {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}

// pairs_sum_to_zero_5 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 {
    var seen = Set<Int>()
    for i in l {
        if seen.contains(-i) {
            return true
        }
        seen.insert(i)
    }
    return false
}

// pairs_sum_to_zero_6 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, 

func changeBase(x: Int, base: Int) -> String {
    var x = x
    var base = base
    var result = ""
    while x > 0 {
        let remainder = x % base
        result = String(remainder) + result
        x /= base
    }
    return result
}

```swift
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var x = x
    var base = base
    var result = ""
    while x > 0 {
        let remainder = x % base
        result = String(remainder) + result
        x /= base
    }
    return result
}
<|file_separator|>

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var x = x
    while x > 0 {
        result = String(x % base) + result
        x /= base
    }
    return result
}

```swift
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var x = x
    while x > 0 {
        result = String(x % base) + result
        x /= base
    }
    return result
}
<|file_separator|>

func changeBase(x: Int, base: Int) -> String {
  var result = ""
  var x = x
  while x > 0 {
    result = String(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 = String(x % base) + result
    x = x / base
  }
  return result
}
<|file_separator|>```

func changeBase(x: Int, base: Int) -> String {
    var x = x
    var base = base
    var result = ""
    while x > 0 {
        let remainder = x % base
        result = String(remainder) + result
        x /= base
    }
    return result
}

```swift
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var x = x
    var base = base
    var result = ""
    while x > 0 {
        let remainder = x % base
        result = String(remainder) + result
        x /= base
    }
    return result
}
<|file_separator|>

func changeBase(x: Int, base: Int) -> String {
    var x = x
    var base = base
    var result = ""
    while x > 0 {
        result = String(x % base) + result
        x /= base
    }
    return result
}

```swift
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var x = x
    var base = base
    var result = ""
    while x > 0 {
        result = String(x % base) + result
        x /= base
    }
    return result
}
<|file_separator|>

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var x = x
    while x > 0 {
        let remainder = x % base
        result = String(remainder) + 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 {
        let remainder = x % base
        result = String(remainder) + result
        x = x / base
    }
    return result
}

// Change base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 8, base: 3) == "22"
// changeBase(x: 8, base: 2) == "1000"
// changeBase(x: 7, base: 2) == "111"
func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var x = x
    while x > 0 {
        let remainder = x % base
        result = String(remainder) + result
        x = x / base
    }
    return result
}
<|file_separator|>

func changeBase(x: Int, base: Int) -> String {
    var x = x
    var result = ""
    while x > 0 {
        result = String(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 x = x
    var result = ""
    while x > 0 {
        result = String(x % base) + result
        x = x / base
    }
    return result
}
<|file_separator|>

func changeBase(x: Int, base: Int) -> String {
    var x = x
    var result = ""
    while x > 0 {
        result = String(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 x = x
    var result = ""
    while x > 0 {
        result = String(x % base) + result
        x = x / base
    }
    return result
}
<|file_separator|>

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var x = x
    while x > 0 {
        let remainder = x % base
        result = String(remainder) + 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 {
        let remainder = x % base
        result = String(remainder) + result
        x = x / base
    }
    return result
}
<|file_separator|>```

func changeBase(x: Int, base: Int) -> String {
    var result = ""
    var number = x
    while number > 0 {
        let remainder = number % base
        result = "\(remainder)" + result
        number = number / base
    }
    return result
}

func changeBase(x: String, base: Int) -> Int {
    var result = 0
    var number = x
    for i in 0..<number.count {
        let digit = Int(number[number.index(number.startIndex, offsetBy: i)])!
        result += digit * pow(base, Double(number.count - i - 1))
    }
    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 {
        let remainder = number % base
        result = "\(remainder)" + result
        number = number / base
    }
    return result
}

// Change base of input number x to base.
// return integer representation after the conversion.
// base numbers are less than 10.
// changeBase(x: 22, base: 3) == 8
// changeBase(x: 1000, base: 2) == 8
// changeBase(x: 111, base: 2) == 7
func changeBase(x: String, base: Int) -> Int {
    var result = 0
    var number = x
    for i in 0..<number.count {
        let digit = Int(number[number.index(number.startIndex, offsetBy: i)])!
        result += digit * pow(base, Double(number.count - i - 1))
    }
    return result
}
<|file_separator|>

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

func factorial(n: Int) -> Int {
    var result = 1
    for i in 1...n {
        result *= i
    }
    return result
}

func factorial(n: Int) -> Int {
    if n == 1 {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

```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 a number return its factorial.
// factorial(5) == 120
func factorial(n: Int) -> Int {
    var result = 1
    for i in 1...n {
        result *= i
    }
    return result
}

// Given a number return its factorial.
// factorial(5) == 120
func factorial(n: Int) -> Int {
    if n == 1 {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

// Given a number return its factorial.
// factorial(5) == 120
func factorial(n: Int) -> Int {
    if n == 1 {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

// Given a number return its factorial.
// factorial(5) == 120
func factorial(n: Int) -> Int {
    if n == 1 {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

// Given a number return its factorial.
// factorial(5) == 120
func factorial(n: Int) -> Int {
    if n == 1 {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

// Given a number return its factorial.
// factorial(5) == 120
func factorial(n: Int) -> Int {
    if n == 1 {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

// Given a number return its factorial.
// factorial(5) == 120
func factorial(n: Int) -> Int {
    if n == 1 {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

// Given a number return its factorial.
// factorial(5) == 120
func factorial(n: Int) -> Int {
    if n == 1 {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

// Given a number return its factorial.
// factorial(5) == 120
func factorial(n: Int) -> Int {
    if n == 1 {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

// Given a number return its factorial.
// factorial(5) == 120
func factorial(n: Int) -> Int {
    if n == 1 {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

// Given a number return its factorial.
// factorial(5) == 120
func factorial(n: Int) -> Int {
    if n == 1 {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

// Given a number return its factorial.
// factorial(5) == 120
func factorial(n: Int) -> Int {
    if n == 1 {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

// Given a number return its factorial.
// factorial(5) == 120
func factorial(n: Int) -> Int {
    if n == 1 {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

// Given a number return its factorial.
// factorial(5) == 120
func factorial(n: Int) -> Int {
    if n == 1 {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

// Given a number return its factorial.
// factorial(5) == 120
func factorial(n: Int) -> Int {
    if n == 1 {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

// Given a number return its factorial.
// factorial(5) == 120
func factorial(

func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

func divisibleByThree(n: Int) -> Bool {
  return n % 3 == 0
}

func divisibleByFive(n: Int) -> Bool {
  return n % 5 == 0
}

func divisibleByThreeOrFive(n: Int) -> Bool {
  return divisibleByThree(n: n) || divisibleByFive(n: n)
}

func divisibleByThreeOrFive(n: Int) -> Bool {
  return divisibleByThree(n: n) && !divisibleByFive(n: n) || divisibleByFive(n: n) && !divisibleByThree(n: n)
}

```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 a number, return true if it's divisible by 3 and false if it's not.
// divisibleByThree(3) == true
// divisibleByThree(10) == false
func divisibleByThree(n: Int) -> Bool {
  return n % 3 == 0
}

// Given a number, return true if it's divisible by 5 and false if it's not.
// divisibleByFive(5) == true
// divisibleByFive(10) == false
func divisibleByFive(n: Int) -> Bool {
  return n % 5 == 0
}

// Given a number, return true if it's divisible by 3 or 5 and false if it's not.
// divisibleByThreeOrFive(15) == true
// divisibleByThreeOrFive(10) == false
func divisibleByThreeOrFive(n: Int) -> Bool {
  return divisibleByThree(n: n) || divisibleByFive(n: n)
}

// Given a number, return true if it's divisible by 3 or 5, but not both.
// divisibleByThreeOrFive(15) == true
// divisibleByThreeOrFive(30) == true
// divisibleByThreeOrFive(16) == false
func divisibleByThreeOrFive(n: Int) -> Bool {
  return divisibleByThree(n: n) && !divisibleByFive(n: n) || divisibleByFive(n: n) && !divisibleByThree(n: n)
}

// Given a number, return true if it's divisible by 3 or 5, but not both.
// divisibleByThreeOrFive(15) == true
// divisibleByThreeOrFive(30) == true
// divisibleByThreeOrFive(16) == false
func divisibleByThreeOrFive(n: Int) -> Bool {
  return divisibleByThree(n: n) && !divisibleByFive(n: n) || divisibleByFive(n: n) && !divisibleByThree(n: n)
}

// Given a number, return true if it's divisible by 3 or 5, but not both.
// divisibleByThreeOrFive(15) == true
// divisibleByThreeOrFive(30) == true
// divisibleByThreeOrFive(16) == false
func divisibleByThreeOrFive(n: Int) -> Bool {
  return divisibleByThree(n: n) && !divisibleByFive(n: n) || divisibleByFive(n: n) && !divisibleByThree(n: n)
}

// Given a number, return true if it's divisible by 3 or 5, but not both.
// divisibleByThreeOrFive(15) == true
// divisibleByThreeOrFive(30) == true
// divisibleByThreeOrFive(16) == false
func divisibleByThreeOrFive(n: Int) -> Bool {
  return divisibleByThree(n: n) && !divisibleByFive(n: n) || divisibleByFive(n: n) && !divisibleByThree(n: n)
}

// Given a number, return true if it's divisible by 3 or 5, but not both.
// divisibleByThreeOrFive(15) == true
// divisibleByThreeOrFive(30) == true
// divisibleByThreeOrFive(16) == false
func divisibleByThreeOrFive(n: Int) -> Bool {
  return divisibleByThree(n: n) && !divisibleByFive(n: n) || divisibleByFive(n: n) && !divisibleByThree(n: n)
}

// Given a number, return true if it's divisible by 3 or 5, but not both.
// divisibleByThreeOrFive(15) == true
// divisibleByThreeOrFive(30) == true
// divisibleByThreeOrFive(16) == false
func divisibleByThreeOrFive(n: Int) -> Bool {
  return divisibleByThree(n: n) && !divisibleByFive(n: n) || divisibleByFive(n: n) && !divisibleByThree(n: n)
}

// Given a number, return true if it's divisible by 3 or 5, but not both.
// divisibleByThreeOrFive(15) == true
// divisibleByThreeOrFive(30)

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

func vowelsCount(str: String) -> Int {
    let vowels = ["a", "e", "i", "o", "u"]
    var count = 0
    for char in str {
        if vowels.contains(String(char)) {
            count += 1
        }
    }
    return count
}

func consonantsCount(str: String) -> Int {
    let vowels = ["a", "e", "i", "o", "u"]
    var count = 0
    for char in str {
        if !vowels.contains(String(char)) {
            count += 1
        }
    }
    return count
}

func wordsCount(str: String) -> Int {
    let words = str.components(separatedBy: " ")
    return words.count
}

func wordsCountLongerThan3(str: String) -> Int {
    let words = str.components(separatedBy: " ")
    var count = 0
    for word in words {
        if word.count > 3 {
            count += 1
        }
    }
    return count
}

func wordsCountLongerThan3(str: String) -> Int {
    let words = str.components(separatedBy: " ")
    var count = 0
    for word in words {
        if word.count > 3 || word == "hello" {
            count += 1
        }
    }
    return count
}

```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 a string, return the number of vowels in the string.
// vowelsCount("hello") == 2
func vowelsCount(str: String) -> Int {
    let vowels = ["a", "e", "i", "o", "u"]
    var count = 0
    for char in str {
        if vowels.contains(String(char)) {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of consonants in the string.
// consonantsCount("hello") == 3
func consonantsCount(str: String) -> Int {
    let vowels = ["a", "e", "i", "o", "u"]
    var count = 0
    for char in str {
        if !vowels.contains(String(char)) {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of words in the string.
// wordsCount("hello world") == 2
func wordsCount(str: String) -> Int {
    let words = str.components(separatedBy: " ")
    return words.count
}

// Given a string, return the number of words in the string, but only if the word is longer than 3 characters.
// wordsCountLongerThan3("hello world") == 2
// wordsCountLongerThan3("hello") == 1
func wordsCountLongerThan3(str: String) -> Int {
    let words = str.components(separatedBy: " ")
    var count = 0
    for word in words {
        if word.count > 3 {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of words in the string, but only if the word is longer than 3 characters or the word is the string "hello".
// wordsCountLongerThan3("hello world") == 2
// wordsCountLongerThan3("hello") == 1
// wordsCountLongerThan3("hello world hello") == 3
func wordsCountLongerThan3(str: String) -> Int {
    let words = str.components(separatedBy: " ")
    var count = 0
    for word in words {
        if word.count > 3 || word == "hello" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of words in the string, but only if the word is longer than 3 characters or the word is the string "hello".
// wordsCountLongerThan3("hello world") == 2
// wordsCountLongerThan3("hello") == 1
// wordsCountLongerThan3("hello world hello") == 3
func wordsCountLongerThan3(str: String) -> Int {
    let words = str.components(separatedBy: " ")
    var count = 0
    for word in words {
        if word.count > 3 || word == "hello" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of words in the string, but only if the word is longer than 3 characters or the word is the string "hello".
// wordsCountLongerThan3("hello world") == 2
// wordsCountLongerThan3("hello") == 1
// wordsCountLongerThan3("hello world hello") == 3
func wordsCountLongerThan3(str: String) -> Int {
    let words = str.components(separatedBy: " ")
    var count = 0
    for word in words {
        if word.count > 3 || word == "hello" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of words in the string, but only if the word is longer than 3 characters or the word is the string "hello".
// wordsCountLongerThan3("hello world") == 2
// wordsCountLongerThan3("hello") == 1
// wordsCountLongerThan3("hello world hello") == 3
func wordsCountLongerThan3(str: String) -> Int {
    let words = str.components(separatedBy: " ")
    var count = 0
    for word in words {
        if word.count > 3 || word == "hello" {
            count += 1
        }
    }
    return count
}

// Given a string

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

func vowels(str: String) -> Int {
    var vowels = 0
    for char in str {
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            vowels += 1
        }
    }
    return vowels
}

func countHi(str: String) -> Int {
    var count = 0
    for i in 0...str.count - 2 {
        if str[i] == "h" && str[i + 1] == "i" {
            count += 1
        }
    }
    return count
}

func doubleChar(str: String) -> String {
    var result = ""
    for char in str {
        result += String(char) + String(char)
    }
    return result
}

func maxBlock(str: String) -> Int {
    var max = 0
    var current = 0
    for char in str {
        if char == str[str.index(str.startIndex, offsetBy: current + 1)] {
            current += 1
        } else {
            if current > max {
                max = current
            }
            current = 0
        }
    }
    if current > max {
        max = current
    }
    return max
}

func notNot(str: String) -> Int {
    var count = 0
    for i in 0...str.count - 3 {
        if str[i] == "n" && str[i + 1] == "o" && str[i + 2] == "t" {
            count += 1
        }
    }
    return count
}

func xCount(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "x" {
            count += 1
        }
    }
    return count
}

```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 a string, return the number of vowels in the string.
// vowels("hello") == 2
func vowels(str: String) -> Int {
    var vowels = 0
    for char in str {
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            vowels += 1
        }
    }
    return vowels
}

// Given a string, return the number of times the string "hi" appears in the string.
// countHi("hihi") == 2
func countHi(str: String) -> Int {
    var count = 0
    for i in 0...str.count - 2 {
        if str[i] == "h" && str[i + 1] == "i" {
            count += 1
        }
    }
    return count
}

// Given a string, return a string where for every char in the original, there are two chars.
// doubleChar("The") == "TThhee"
// doubleChar("AAbb") == "AAAAbbbb"
// doubleChar("Hi-There") == "HHii--TThheerree"
func doubleChar(str: String) -> String {
    var result = ""
    for char in str {
        result += String(char) + String(char)
    }
    return result
}

// Given a string, return the length of the largest "block" in the string.
// A block is a run of adjacent chars that are the same.
// maxBlock("hoopla") == 2
// maxBlock("abbCCCddBBBxx") == 3
// maxBlock("") == 0
func maxBlock(str: String) -> Int {
    var max = 0
    var current = 0
    for char in str {
        if char == str[str.index(str.startIndex, offsetBy: current + 1)] {
            current += 1
        } else {
            if current > max {
                max = current
            }
            current = 0
        }
    }
    if current > max {
        max = current
    }
    return max
}

// Given a string, return the number of times "not" appears in the string, but "not" must be
// considered in pair.
// notNot("not not") == 2
// notNot("not") == 0
// notNot("but not not this time") == 1
func notNot(str: String) -> Int {
    var count = 0
    for i in 0...str.count - 3 {
        if str[i] == "n" && str[i + 1] == "o" && str[i + 2] == "t" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times "x" appears in the string.
// xCount("xxHxix") == 3
// xCount("abxxxcd") == 2
// xCount("xabxxxcdx") == 4
func xCount(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "x" {
            count += 1
        }
    }
    return count
}

// Given a string, return a string where for every char in the original, there are two chars.
// doubleChar("The") == "TThhee"
// doubleChar("AAbb") == "AAAAbbbb"
// doubleChar("Hi-There") == "HHii--TThheerree"
func doubleChar(str: String) -> String {
    var result = ""
    for char in str {
        result += String(char) + String(char)
    }
    return result
}

// Given a string, return the number of times "the" appears in the string, but "the" must be
// considered in pair.
// the("the") == 1
// the("thethe") == 2
// the("hi") == 0
func the(str: String) -> Int {
    var count = 0
    for i in 0...str.count - 3 {
        if str[i] == "t" && str[i + 1] == "h" && str[i + 2] == "e

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

func vowelsCount(str: String) -> Int {
    var vowels = ["a", "e", "i", "o", "u"]
    var count = 0
    for char in str {
        if vowels.contains(String(char)) {
            count += 1
        }
    }
    return count
}

func hiCount(str: String) -> Int {
    var count = 0
    for i in 0..<str.count {
        if str[i] == "h" && str[i+1] == "i" {
            count += 1
        }
    }
    return count
}

func stringBits(str: String) -> String {
    var newStr = ""
    for i in 0..<str.count {
        if i % 2 == 0 {
            newStr += String(str[i])
        }
    }
    return newStr
}

func endOther(a: String, b: String) -> Bool {
    var aLower = a.lowercased()
    var bLower = b.lowercased()
    if aLower.hasSuffix(bLower) || bLower.hasSuffix(aLower) {
        return true
    }
    return false
}

func doubleChar(str: String) -> String {
    var newStr = ""
    for char in str {
        newStr += String(char) + String(char)
    }
    return newStr
}

func countEvens(nums: [Int]) -> Int {
    var count = 0
    for num in nums {
        if num % 2 == 0 {
            count += 1
        }
    }
    return count
}

func sum13(nums: [Int]) -> Int {
    var sum = 0
    var i = 0
    while i < nums.count {
        if nums[i] != 13 {
            sum += nums[i]
        }
        i += 1
    }
    return sum
}

```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 a string, return the number of vowels contained within it.
// vowelsCount("hello") == 2
func vowelsCount(str: String) -> Int {
    var vowels = ["a", "e", "i", "o", "u"]
    var count = 0
    for char in str {
        if vowels.contains(String(char)) {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the string "hi" appears in the string.
// hiCount("hihi") == 2
func hiCount(str: String) -> Int {
    var count = 0
    for i in 0..<str.count {
        if str[i] == "h" && str[i+1] == "i" {
            count += 1
        }
    }
    return count
}

// Given a string, return a new string made of every other character starting with the first, so "Hello" yields "Hlo".
// stringBits("Hello") == "Hlo"
func stringBits(str: String) -> String {
    var newStr = ""
    for i in 0..<str.count {
        if i % 2 == 0 {
            newStr += String(str[i])
        }
    }
    return newStr
}

// Given two strings, return true if either of the strings appears at the very end of the other string,
// ignoring upper/lower case differences (in other words, the computation should not be "case sensitive").
// endOther("Hiabc", "abc") == true
// endOther("AbC", "HiaBc") == true
// endOther("abc", "abXabc") == true
func endOther(a: String, b: String) -> Bool {
    var aLower = a.lowercased()
    var bLower = b.lowercased()
    if aLower.hasSuffix(bLower) || bLower.hasSuffix(aLower) {
        return true
    }
    return false
}

// Given a string, return a string where for every char in the original,
// there are two chars.
// doubleChar("The") == "TThhee"
// doubleChar("AAbb") == "AAAAbbbb"
// doubleChar("Hi-There") == "HHii--TThheerree"
func doubleChar(str: String) -> String {
    var newStr = ""
    for char in str {
        newStr += String(char) + String(char)
    }
    return newStr
}

// Return the number of even integers in the given array.
// Only include even numbers in your result.
// countEvens([2, 1, 2, 3, 4]) == 3
// countEvens([2, 2, 0]) == 3
// countEvens([1, 3, 5]) == 0
func countEvens(nums: [Int]) -> Int {
    var count = 0
    for num in nums {
        if num % 2 == 0 {
            count += 1
        }
    }
    return count
}

// Return the sum of the numbers in the array, returning 0 for an empty array.
// Except the number 13 is very unlucky, so it does not count and numbers that come immediately after a 13 also do not count.
// sum13([1, 2, 2, 1]) == 6
// sum13([1, 1]) == 2
// sum13([1, 2, 2, 1, 13]) == 6
func sum13(nums: [Int]) -> Int {
    var sum = 0
    var i = 0
    while i < nums.count {
        if nums[i] != 13 {
            sum += nums[i]
        }
        i += 1
    }
    return sum
}

// Return the sum of the numbers in the array, except ignore sections of numbers starting with a 6 and extending to the next 7 (every 6 will be followed by at least one 7).
// Return 0 for no numbers.
// ignore67([1, 2, 2]) == 5
// ignore67([1, 2, 2, 6, 99, 99, 7

func triangleArea(a: Int, h: Int) -> Double {
  return Double(a * h) / 2
}

func divisibleBy3Or5(num: Int) -> Bool {
  return num % 3 == 0 || num % 5 == 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
}

// Given a number return true if it's divisible by 3 or 5 or both.
// divisibleBy3Or5(3) == true
// divisibleBy3Or5(5) == true
// divisibleBy3Or5(15) == true
func divisibleBy3Or5(num: Int) -> Bool {
  return num % 3 == 0 || num % 5 == 0
}

// Given a number return true if it's divisible by 3 or 5 or both.
// divisibleBy3Or5(3) == true
// divisibleBy3Or5(5) == true
// divisibleBy3Or5(15) == true
func divisibleBy3Or5(num: Int) -> Bool {
  return num % 3 == 0 || num % 5 == 0
}

// Given a number return true if it's divisible by 3 or 5 or both.
// divisibleBy3Or5(3) == true
// divisibleBy3Or5(5) == true
// divisibleBy3Or5(15) == true
func divisibleBy3Or5(num: Int) -> Bool {
  return num % 3 == 0 || num % 5 == 0
}

// Given a number return true if it's divisible by 3 or 5 or both.
// divisibleBy3Or5(3) == true
// divisibleBy3Or5(5) == true
// divisibleBy3Or5(15) == true
func divisibleBy3Or5(num: Int) -> Bool {
  return num % 3 == 0 || num % 5 == 0
}

// Given a number return true if it's divisible by 3 or 5 or both.
// divisibleBy3Or5(3) == true
// divisibleBy3Or5(5) == true
// divisibleBy3Or5(15) == true
func divisibleBy3Or5(num: Int) -> Bool {
  return num % 3 == 0 || num % 5 == 0
}

// Given a number return true if it's divisible by 3 or 5 or both.
// divisibleBy3Or5(3) == true
// divisibleBy3Or5(5) == true
// divisibleBy3Or5(15) == true
func divisibleBy3Or5(num: Int) -> Bool {
  return num % 3 == 0 || num % 5 == 0
}

// Given a number return true if it's divisible by 3 or 5 or both.
// divisibleBy3Or5(3) == true
// divisibleBy3Or5(5) == true
// divisibleBy3Or5(15) == true
func divisibleBy3Or5(num: Int) -> Bool {
  return num % 3 == 0 || num % 5 == 0
}

// Given a number return true if it's divisible by 3 or 5 or both.
// divisibleBy3Or5(3) == true
// divisibleBy3Or5(5) == true
// divisibleBy3Or5(15) == true
func divisibleBy3Or5(num: Int) -> Bool {
  return num % 3 == 0 || num % 5 == 0
}

// Given a number return true if it's divisible by 3 or 5 or both.
// divisibleBy3Or5(3) == true
// divisibleBy3Or5(5) == true
// divisibleBy3Or5(15) == true
func divisibleBy3Or5(num: Int) -> Bool {
  return num % 3 == 0 || num % 5 == 0
}

// Given a number return true if it's divisible by 3 or 5 or both.
// divisibleBy3Or5(3) == true
// divisibleBy3Or5(5) == true
// divisibleBy3Or5(15) == true
func divisibleBy3Or5(num: Int) -> Bool {
  return num % 3 == 0 || num % 5 == 0
}

// Given a number return true if it's divisible by 3 or 5 or both.
// divisibleBy3Or5(3) == true
// divisibleBy3Or5(5) == true
// divisibleBy3Or5(15) == true
func divisibleBy3Or5(num: Int) -> Bool {
  return num % 3

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

func countDigits(num: Int) -> Int {
    return String(num).count
}

func sumDigits(num: Int) -> Int {
    var sum = 0
    var n = num
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return sum
}

```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 a number, return the number of digits it has.
// countDigits(12345) == 5
func countDigits(num: Int) -> Int {
    return String(num).count
}

// Given a number, return the sum of its digits.
// sumDigits(12345) == 15
func sumDigits(num: Int) -> Int {
    var sum = 0
    var n = num
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return sum
}

// Given a number, return the sum of its digits.
// sumDigits(12345) == 15
func sumDigits(num: Int) -> Int {
    var sum = 0
    var n = num
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return sum
}

// Given a number, return the sum of its digits.
// sumDigits(12345) == 15
func sumDigits(num: Int) -> Int {
    var sum = 0
    var n = num
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return sum
}

// Given a number, return the sum of its digits.
// sumDigits(12345) == 15
func sumDigits(num: Int) -> Int {
    var sum = 0
    var n = num
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return sum
}

// Given a number, return the sum of its digits.
// sumDigits(12345) == 15
func sumDigits(num: Int) -> Int {
    var sum = 0
    var n = num
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return sum
}

// Given a number, return the sum of its digits.
// sumDigits(12345) == 15
func sumDigits(num: Int) -> Int {
    var sum = 0
    var n = num
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return sum
}

// Given a number, return the sum of its digits.
// sumDigits(12345) == 15
func sumDigits(num: Int) -> Int {
    var sum = 0
    var n = num
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return sum
}

// Given a number, return the sum of its digits.
// sumDigits(12345) == 15
func sumDigits(num: Int) -> Int {
    var sum = 0
    var n = num
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return sum
}

// Given a number, return the sum of its digits.
// sumDigits(12345) == 15
func sumDigits(num: Int) -> Int {
    var sum = 0
    var n = num
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return sum
}

// Given a number, return the sum of its digits.
// sumDigits(12345) == 15
func sumDigits(num: Int) -> Int {
    var sum = 0
    var n = num
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return sum
}

// Given a number, return the sum of its digits.
// sumDigits(12345) == 15
func sumDigits(num: Int) -> Int {
    var sum = 0
    var n = num
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return sum
}

// Given a number, return the sum of its digits.

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

func isEven(num: Int) -> Bool {
    return num % 2 == 0
}

func divisibleByThree(num: Int) -> Bool {
    return num % 3 == 0
}

func divisibleByFive(num: Int) -> Bool {
    return num % 5 == 0
}

func divisibleByThreeAndFive(num: Int) -> Bool {
    return num % 3 == 0 && num % 5 == 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
}

// Given a number return true if it is even or false if it is odd.
// isEven(2) == true
// isEven(3) == false
func isEven(num: Int) -> Bool {
    return num % 2 == 0
}

// Given a number return true if it is divisible by 3 or false if it is not divisible by 3.
// divisibleByThree(3) == true
// divisibleByThree(4) == false
func divisibleByThree(num: Int) -> Bool {
    return num % 3 == 0
}

// Given a number return true if it is divisible by 5 or false if it is not divisible by 5.
// divisibleByFive(5) == true
// divisibleByFive(6) == false
func divisibleByFive(num: Int) -> Bool {
    return num % 5 == 0
}

// Given a number return true if it is divisible by 3 and 5 or false if it is not divisible by 3 and 5.
// divisibleByThreeAndFive(15) == true
// divisibleByThreeAndFive(16) == false
func divisibleByThreeAndFive(num: Int) -> Bool {
    return num % 3 == 0 && num % 5 == 0
}

// Given a number return true if it is divisible by 3 or 5 or 7 or 9 or 11 or 13 or 15 or 17 or 19 or 21 or 23 or 25 or 27 or 29 or 31 or 33 or 35 or 37 or 39 or 41 or 43 or 45 or 47 or 49 or 51 or 53 or 55 or 57 or 59 or 61 or 63 or 65 or 67 or 69 or 71 or 73 or 75 or 77 or 79 or 81 or 83 or 85 or 87 or 89 or 91 or 93 or 95 or 97 or 99 or 101 or 103 or 105 or 107 or 109 or 111 or 113 or 115 or 117 or 119 or 121 or 123 or 125 or 127 or 129 or 131 or 133 or 135 or 137 or 139 or 141 or 143 or 145 or 147 or 149 or 151 or 153 or 155 or 157 or 159 or 161 or 163 or 165 or 167 or 169 or 171 or 173 or 175 or 177 or 179 or 181 or 183 or 185 or 187 or 189 or 191 or 193 or 195 or 197 or 199 or 201 or 203 or 205 or 207 or 209 or 211 or 213 or 215 or 217 or 219 or 221 or 223 or 225 or 227 or 229 or 231 or 233 or 235 or 237 or 239 or 241 or 243 or 245 or 247 or 249 or 251 or 253 or 255 or 257 or 259 or 261 or 263 or 265 or 267 or 269 or 271 or 273 or 275 or 277 or 279 or 281 or 283 or 285 or 287 or 289 or 291 or 293 or 295 or 297 or 299
// divisibleByThreeAndFive(100) == true

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

func vowelsCount(str: String) -> Int {
    let vowels = ["a", "e", "i", "o", "u"]
    var count = 0
    for char in str {
        if vowels.contains(String(char)) {
            count += 1
        }
    }
    return count
}

func aCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "a" {
            count += 1
        }
    }
    return count
}

func xCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "x" {
            count += 1
        }
    }
    return count
}

func yCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "y" {
            count += 1
        }
    }
    return count
}

func zCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "z" {
            count += 1
        }
    }
    return count
}

func wCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "w" {
            count += 1
        }
    }
    return count
}

func vCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "v" {
            count += 1
        }
    }
    return count
}

func uCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "u" {
            count += 1
        }
    }
    return count
}

func tCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "t" {
            count += 1
        }
    }
    return count
}

func sCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "s" {
            count += 1
        }
    }
    return count
}

func rCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "r" {
            count += 1
        }
    }
    return count
}

```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 a string, return the number of vowels in the string.
// vowelsCount("hello") == 2
func vowelsCount(str: String) -> Int {
    let vowels = ["a", "e", "i", "o", "u"]
    var count = 0
    for char in str {
        if vowels.contains(String(char)) {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the letter "a" appears in it.
// aCount("hello") == 1
func aCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "a" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the letter "x" appears in it.
// xCount("hello") == 1
func xCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "x" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the letter "y" appears in it.
// yCount("hello") == 1
func yCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "y" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the letter "z" appears in it.
// zCount("hello") == 1
func zCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "z" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the letter "w" appears in it.
// wCount("hello") == 1
func wCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "w" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the letter "v" appears in it.
// vCount("hello") == 1
func vCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "v" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the letter "u" appears in it.
// uCount("hello") == 1
func uCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "u" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the letter "t" appears in it.
// tCount("hello") == 1
func tCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "t" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the letter "s" appears in it.
// sCount("hello") == 1
func sCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "s" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the letter "r" appears in it.
// rCount("hello") == 1
func rCount(str: String) -> Int {
    var count = 0
    for char in str {
        if String(char) == "r" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the letter "q" appears in it.
// qCount("hello") == 1
func qCount(str: String) -> Int {
    var count = 0

func triangleArea(a: Int, h: Int) -> Double {
    return Double(a * h) / 2
}

func vowels(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            count += 1
        }
    }
    return count
}

func countHi(str: String) -> Int {
    var count = 0
    for i in 0..<str.count - 1 {
        if str[i] == "h" && str[i + 1] == "i" {
            count += 1
        }
    }
    return count
}

func doubleChar(str: String) -> String {
    var result = ""
    for char in str {
        result += String(char) + String(char)
    }
    return result
}

func maxBlock(str: String) -> Int {
    var max = 0
    var current = 1
    for i in 0..<str.count - 1 {
        if str[i] == str[i + 1] {
            current += 1
        } else {
            if current > max {
                max = current
            }
            current = 1
        }
    }
    if current > max {
        max = current
    }
    return max
}

func notNot(str: String) -> Int {
    var count = 0
    var current = 0
    for char in str {
        if char == "n" && current == 0 {
            current = 1
        } else if char == "o" && current == 1 {
            current = 2
        } else if char == "t" && current == 2 {
            count += 1
            current = 0
        }
    }
    return count
}

func xFront(str: String) -> Int {
    var count = 0
    for i in 0..<str.count - 2 {
        if str[i] == "x" && str[i + 1] == "x" && str[i + 2] == "x" {
            count += 1
        }
    }
    return count
}

```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 a string, return the number of vowels in the string.
// vowels("hello") == 2
func vowels(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the string "hi" appears in the string.
// countHi("hihi") == 2
func countHi(str: String) -> Int {
    var count = 0
    for i in 0..<str.count - 1 {
        if str[i] == "h" && str[i + 1] == "i" {
            count += 1
        }
    }
    return count
}

// Given a string, return a string where for every char in the original, there are two chars.
// doubleChar("The") == "TThhee"
func doubleChar(str: String) -> String {
    var result = ""
    for char in str {
        result += String(char) + String(char)
    }
    return result
}

// Given a string, return the length of the largest "block" in the string.
// A block is a run of adjacent chars that are the same.
// maxBlock("hoopla") == 2
// maxBlock("abbCCCddBBBxx") == 3
// maxBlock("") == 0
func maxBlock(str: String) -> Int {
    var max = 0
    var current = 1
    for i in 0..<str.count - 1 {
        if str[i] == str[i + 1] {
            current += 1
        } else {
            if current > max {
                max = current
            }
            current = 1
        }
    }
    if current > max {
        max = current
    }
    return max
}

// Given a string, return the number of times "not" appears in the string.
// However, "not" can be followed by any number of non-letter characters.
// notNot("The not") == 1
// notNot("The notnot") == 2
// notNot("The notnotnot") == 3
func notNot(str: String) -> Int {
    var count = 0
    var current = 0
    for char in str {
        if char == "n" && current == 0 {
            current = 1
        } else if char == "o" && current == 1 {
            current = 2
        } else if char == "t" && current == 2 {
            count += 1
            current = 0
        }
    }
    return count
}

// Given a string, return the number of times "x" appears in the string.
// xFront("xxxhixxx") == 3
// xFront("xhixhixhix") == 3
// xFront("hixxxhixxx") == 1
func xFront(str: String) -> Int {
    var count = 0
    for i in 0..<str.count - 2 {
        if str[i] == "x" && str[i + 1] == "x" && str[i + 2] == "x" {
            count += 1
        }
    }
    return count
}

// Given a string, return a string where for every char in the original, there are two chars.
// doubleChar("The") == "TThhee"
// doubleChar("AAbb") == "AAAAbbbb"
// doubleChar("Hi-There") == "HHii--TThheerree"
func doubleChar(str: String) -> String {
    var result = ""
    for char in str {
        result += String(char) + String(char)
    }
    return result
}

// Given a string, return the number of times "the" appears in the string.
// The "the" in "a"the" does not count.
// the("the the") == 2
// the("a") == 0
// the("a the") == 1
func the(str: String) -> Int {
    var count = 0
    for i

func fib4(n: Int) -> Int {
    if n == 0 {
        return 0
    }
    if n == 1 {
        return 0
    }
    if n == 2 {
        return 2
    }
    if n == 3 {
        return 0
    }
    return fib4(n: n-1) + fib4(n: n-2) + fib4(n: n-3) + fib4(n: n-4)
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    if n == 0 {
        return 0
    }
    if n == 1 {
        return 0
    }
    if n == 2 {
        return 2
    }
    if n == 3 {
        return 0
    }
    return fib4(n: n-1) + fib4(n: n-2) + fib4(n: n-3) + fib4(n: n-4)
}

fib4(n: 5) == 4
fib4(n: 6) == 8
fib4(n: 7) == 14
<|file_separator|>```

func fib4(n: Int) -> Int {
    if n == 0 {
        return 0
    }
    if n == 1 {
        return 0
    }
    if n == 2 {
        return 2
    }
    if n == 3 {
        return 0
    }
    return fib4(n: n-1) + fib4(n: n-2) + fib4(n: n-3) + fib4(n: n-4)
}

func fib4(n: Int) -> Int {
    var fib4 = [Int](repeating: 0, count: n+1)
    fib4[0] = 0
    fib4[1] = 0
    fib4[2] = 2
    fib4[3] = 0
    for i in 4...n {
        fib4[i] = fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4]
    }
    return fib4[n]
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    if n == 0 {
        return 0
    }
    if n == 1 {
        return 0
    }
    if n == 2 {
        return 2
    }
    if n == 3 {
        return 0
    }
    return fib4(n: n-1) + fib4(n: n-2) + fib4(n: n-3) + fib4(n: n-4)
}

func fib4(n: Int) -> Int {
    var fib4 = [Int](repeating: 0, count: n+1)
    fib4[0] = 0
    fib4[1] = 0
    fib4[2] = 2
    fib4[3] = 0
    for i in 4...n {
        fib4[i] = fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4]
    }
    return fib4[n]
}
<|file_separator|>

func fib4(n: Int) -> Int {
    var fib4 = [Int](repeating: 0, count: n+1)
    fib4[0] = 0
    fib4[1] = 0
    fib4[2] = 2
    fib4[3] = 0
    for i in 4...n {
        fib4[i] = fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4]
    }
    return fib4[n]
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var fib4 = [Int](repeating: 0, count: n+1)
    fib4[0] = 0
    fib4[1] = 0
    fib4[2] = 2
    fib4[3] = 0
    for i in 4...n {
        fib4[i] = fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4]
    }
    return fib4[n]
}
<|file_separator|>

func fib4(n: Int) -> Int {
    if n == 0 {
        return 0
    }
    if n == 1 {
        return 0
    }
    if n == 2 {
        return 2
    }
    if n == 3 {
        return 0
    }
    return fib4(n: n-1) + fib4(n: n-2) + fib4(n: n-3) + fib4(n: n-4)
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    if n == 0 {
        return 0
    }
    if n == 1 {
        return 0
    }
    if n == 2 {
        return 2
    }
    if n == 3 {
        return 0
    }
    return fib4(n: n-1) + fib4(n: n-2) + fib4(n: n-3) + fib4(n: n-4)
}
<|file_separator|>```

func fib4(n: Int) -> Int {
    if n == 0 {
        return 0
    } else if n == 1 {
        return 0
    } else if n == 2 {
        return 2
    } else if n == 3 {
        return 0
    } else {
        return fib4(n: n-1) + fib4(n: n-2) + fib4(n: n-3) + fib4(n: n-4)
    }
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    if n == 0 {
        return 0
    } else if n == 1 {
        return 0
    } else if n == 2 {
        return 2
    } else if n == 3 {
        return 0
    } else {
        return fib4(n: n-1) + fib4(n: n-2) + fib4(n: n-3) + fib4(n: n-4)
    }
}

print(fib4(n: 5))
print(fib4(n: 6))
print(fib4(n: 7))
<|file_separator|>```

func fib4(n: Int) -> Int {
    var fib4 = [Int]()
    fib4.append(0)
    fib4.append(0)
    fib4.append(2)
    fib4.append(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 = [Int]()
    fib4.append(0)
    fib4.append(0)
    fib4.append(2)
    fib4.append(0)
    for i in 4...n {
        fib4.append(fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4])
    }
    return fib4[n]
}
<|file_separator|>

func fib4(n: Int) -> Int {
    var a = 0
    var b = 0
    var c = 2
    var d = 0
    var i = 0
    while i < n {
        d = c + b
        b = c
        c = d
        i += 1
    }
    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
    var i = 0
    while i < n {
        d = c + b
        b = c
        c = d
        i += 1
    }
    return d
}
<|file_separator|>```

func fib4(n: Int) -> Int {
    var fib4 = [Int](repeating: 0, count: n + 1)
    fib4[0] = 0
    fib4[1] = 0
    fib4[2] = 2
    fib4[3] = 0
    for i in 4...n {
        fib4[i] = fib4[i - 1] + fib4[i - 2] + fib4[i - 3] + fib4[i - 4]
    }
    return fib4[n]
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var fib4 = [Int](repeating: 0, count: n + 1)
    fib4[0] = 0
    fib4[1] = 0
    fib4[2] = 2
    fib4[3] = 0
    for i in 4...n {
        fib4[i] = fib4[i - 1] + fib4[i - 2] + fib4[i - 3] + fib4[i - 4]
    }
    return fib4[n]
}
<|file_separator|>

func fib4(n: Int) -> Int {
  var fib4 = [Int](repeating: 0, count: n + 1)
  fib4[0] = 0
  fib4[1] = 0
  fib4[2] = 2
  fib4[3] = 0
  for i in 4...n {
    fib4[i] = fib4[i - 1] + fib4[i - 2] + fib4[i - 3] + fib4[i - 4]
  }
  return fib4[n]
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
  var fib4 = [Int](repeating: 0, count: n + 1)
  fib4[0] = 0
  fib4[1] = 0
  fib4[2] = 2
  fib4[3] = 0
  for i in 4...n {
    fib4[i] = fib4[i - 1] + fib4[i - 2] + fib4[i - 3] + fib4[i - 4]
  }
  return fib4[n]
}
<|file_separator|>

func fib4(n: Int) -> Int {
    var fib4 = [Int](repeating: 0, count: n+1)
    fib4[0] = 0
    fib4[1] = 0
    fib4[2] = 2
    fib4[3] = 0
    for i in 4...n {
        fib4[i] = fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4]
    }
    return fib4[n]
}

```swift
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// fib4(n: 5) == 4
// fib4(n: 6) == 8
// fib4(n: 7) == 14
func fib4(n: Int) -> Int {
    var fib4 = [Int](repeating: 0, count: n+1)
    fib4[0] = 0
    fib4[1] = 0
    fib4[2] = 2
    fib4[3] = 0
    for i in 4...n {
        fib4[i] = fib4[i-1] + fib4[i-2] + fib4[i-3] + fib4[i-4]
    }
    return fib4[n]
}
<|file_separator|>```

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        let first = sorted[count / 2 - 1]
        let second = sorted[count / 2]
        return Double(first + second) / 2
    } else {
        return Double(sorted[count / 2])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 0 {
        let first = sorted[count / 2 - 1]
        let second = sorted[count / 2]
        return Double(first + second) / 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 = sorted.count
    if count % 2 == 0 {
        let first = sorted[count / 2 - 1]
        let second = sorted[count / 2]
        return Double(first + second) / 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 = sorted.count
    if count % 2 == 0 {
        let first = sorted[count / 2 - 1]
        let second = sorted[count / 2]
        return Double(first + second) / 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 = sorted.count
    if count % 2 == 0 {
        let first = sorted[count / 2 - 1]
        let second = sorted[count / 2]
        return Double(first + second) / 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 = sorted.count
    if count % 2 == 0 {
        let first = sorted[count / 2 - 1]
        let second = sorted[count / 2]
        return Double(first + second) / 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 = sorted.count
    if count % 2 == 0 {
        let first = sorted[count / 2 - 1]
        let second = sorted[count / 2]
        return Double(first + second) / 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(

func median(l: [Int]) -> Double {
  let sorted = l.sorted()
  let count = sorted.count
  let mid = count / 2
  if count % 2 == 0 {
    return Double(sorted[mid] + sorted[mid - 1]) / 2
  } else {
    return Double(sorted[mid])
  }
}

func count(s: String, t: String) -> Int {
  let s = s.lowercaseString
  let t = t.lowercaseString
  var count = 0
  var i = 0
  while i < t.characters.count {
    if t.substringFromIndex(i) == s {
      count += 1
    }
    i += 1
  }
  return count
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
  let sorted = l.sorted()
  let count = sorted.count
  let mid = count / 2
  if count % 2 == 0 {
    return Double(sorted[mid] + sorted[mid - 1]) / 2
  } else {
    return Double(sorted[mid])
  }
}

// Return the number of times the string s appears in the string t.
// count("a", "banana") == 1
// count("b", "banana") == 0
func count(s: String, t: String) -> Int {
  let s = s.lowercaseString
  let t = t.lowercaseString
  var count = 0
  var i = 0
  while i < t.characters.count {
    if t.substringFromIndex(i) == s {
      count += 1
    }
    i += 1
  }
  return count
}

// Return the number of times the string s appears in the string t.
// count("a", "banana") == 1
// count("b", "banana") == 0
func count(s: String, t: String) -> Int {
  let s = s.lowercaseString
  let t = t.lowercaseString
  var count = 0
  var i = 0
  while i < t.characters.count {
    if t.substringFromIndex(i) == s {
      count += 1
    }
    i += 1
  }
  return count
}

// Return the number of times the string s appears in the string t.
// count("a", "banana") == 1
// count("b", "banana") == 0
func count(s: String, t: String) -> Int {
  let s = s.lowercaseString
  let t = t.lowercaseString
  var count = 0
  var i = 0
  while i < t.characters.count {
    if t.substringFromIndex(i) == s {
      count += 1
    }
    i += 1
  }
  return count
}

// Return the number of times the string s appears in the string t.
// count("a", "banana") == 1
// count("b", "banana") == 0
func count(s: String, t: String) -> Int {
  let s = s.lowercaseString
  let t = t.lowercaseString
  var count = 0
  var i = 0
  while i < t.characters.count {
    if t.substringFromIndex(i) == s {
      count += 1
    }
    i += 1
  }
  return count
}

// Return the number of times the string s appears in the string t.
// count("a", "banana") == 1
// count("b", "banana") == 0
func count(s: String, t: String) -> Int {
  let s = s.lowercaseString
  let t = t.lowercaseString
  var count = 0
  var i = 0
  while i < t.characters.count {
    if t.substringFromIndex(i) == s {
      count += 1
    }
    i += 1
  }
  return count
}

// Return the number of times the string s appears in the string t.
// count("a", "banana") == 1
// count("b", "banana") == 0
func count(s: String, t: String) -> Int {
  let s = s.lowercaseString
  let t = t.lowercaseString
  var count = 0
  var i = 0
  while i < t.characters.count {
    if t.substringFromIndex(i) == s {
      count += 1
    }
    i += 1
  }
  return count
}

// Return the number of times the string s appears in the string t.
// count("a", "banana") == 1
// count("b", "banana") == 0
func count(s: String, t: String) -> Int {
  let s = s.lowercaseString
  let t = t.lowercaseString
  var count = 0
  var i = 0
  while i < t.characters.count {
    if t.substringFromIndex(i) == s {
      count += 1
    }
    i += 1
  }
  

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    let mid = count / 2
    if count % 2 == 0 {
        return (Double(sorted[mid]) + Double(sorted[mid - 1])) / 2
    } else {
        return Double(sorted[mid])
    }
}

```swift
// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    let mid = count / 2
    if count % 2 == 0 {
        return (Double(sorted[mid]) + Double(sorted[mid - 1])) / 2
    } else {
        return Double(sorted[mid])
    }
}

// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    let mid = count / 2
    if count % 2 == 0 {
        return (Double(sorted[mid]) + Double(sorted[mid - 1])) / 2
    } else {
        return Double(sorted[mid])
    }
}

// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    let mid = count / 2
    if count % 2 == 0 {
        return (Double(sorted[mid]) + Double(sorted[mid - 1])) / 2
    } else {
        return Double(sorted[mid])
    }
}

// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    let mid = count / 2
    if count % 2 == 0 {
        return (Double(sorted[mid]) + Double(sorted[mid - 1])) / 2
    } else {
        return Double(sorted[mid])
    }
}

// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    let mid = count / 2
    if count % 2 == 0 {
        return (Double(sorted[mid]) + Double(sorted[mid - 1])) / 2
    } else {
        return Double(sorted[mid])
    }
}

// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    let mid = count / 2
    if count % 2 == 0 {
        return (Double(sorted[mid]) + Double(sorted[mid - 1])) / 2
    } else {
        return Double(sorted[mid])
    }
}

// Return median of elements in the array l.
// median(l: [3, 1, 2, 4, 5]) == 3
// median(l: [-10, 4, 6, 1000, 10, 20]) == 15.0
func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    let mid = count / 2
    if count % 2 == 0 {
        return (Double(sorted[mid]) + Double(sorted[

func median(l: [Int]) -> Double {
    let sorted = l.sorted()
    let count = sorted.count
    if count % 2 == 1 {
        return Double(sorted[count/2])
    } else {
        return Double(sorted[count/2-1] + sorted[count/2]) / 2.0
    }
}

```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 == 1 {
        return Double(sorted[count/2])
    } else {
        return Double(sorted[count/2-1] + sorted[count/2]) / 2.0
    }
}

// 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 == 1 {
        return Double(sorted[count/2])
    } else {
        return Double(sorted[count/2-1] + sorted[count/2]) / 2.0
    }
}

// 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 == 1 {
        return Double(sorted[count/2])
    } else {
        return Double(sorted[count/2-1] + sorted[count/2]) / 2.0
    }
}

// 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 == 1 {
        return Double(sorted[count/2])
    } else {
        return Double(sorted[count/2-1] + sorted[count/2]) / 2.0
    }
}

// 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 == 1 {
        return Double(sorted[count/2])
    } else {
        return Double(sorted[count/2-1] + sorted[count/2]) / 2.0
    }
}

// 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 == 1 {
        return Double(sorted[count/2])
    } else {
        return Double(sorted[count/2-1] + sorted[count/2]) / 2.0
    }
}

// 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 == 1 {
        return Double(sorted[count/2])
    } else {
        return Double(sorted[count/2-1] + sorted[count/2]) / 2.0
    }
}

// Return median of elements in the

func median(l: [Int]) -> Double {
  let sorted = l.sorted()
  let count = l.count
  if count % 2 == 0 {
    return (Double(sorted[count/2]) + Double(sorted[count/2 - 1])) / 2
  } else {
    return Double(sorted[count/2])
  }
}

func vowels(s: String) -> Int {
  let vowels = "aeiou"
  return s.characters.reduce(0) {
    if vowels.contains($1) {
      return $0 + 1
    } else {
      return $0
    }
  }
}

func count_substrings(s: String, sub: String) -> Int {
  let subLength = sub.characters.count
  var count = 0
  for i in 0..<s.characters.count - subLength + 1 {
    let subString = s.substringWithRange(Range(start: i, end: i + subLength))
    if subString == sub {
      count += 1
    }
  }
  return count
}

func count_substrings_first_n(s: String, sub: String, n: Int) -> Int {
  let subLength = sub.characters.count
  var count = 0
  for i in 0..<n {
    let subString = s.substringWithRange(Range(start: i, end: i + subLength))
    if subString == sub {
      count += 1
    }
  }
  return count
}

func count_substrings_last_n(s: String, sub: String, n: Int) -> Int {
  let subLength = sub.characters.count
  var count = 0
  for i in 0..<s.characters.count - n {
    let subString = s.substringWithRange(Range(start: i + n, end: i + n + subLength))
    if subString == sub {
      count += 1
    }
  }
  return count
}

```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]) + Double(sorted[count/2 - 1])) / 2
  } else {
    return Double(sorted[count/2])
  }
}

// Return the number of vowels in the string s.
// vowels("Hi There!") == 3
// vowels("Why do you ask?") == 6
// vowels("Why?") == 1
func vowels(s: String) -> Int {
  let vowels = "aeiou"
  return s.characters.reduce(0) {
    if vowels.contains($1) {
      return $0 + 1
    } else {
      return $0
    }
  }
}

// Return the number of times the string sub appears in the string s.
// count_substrings("Hello, there", "ll") == 2
// count_substrings("Hello, there", "he") == 1
// count_substrings("Hello, there", "Hi") == 0
func count_substrings(s: String, sub: String) -> Int {
  let subLength = sub.characters.count
  var count = 0
  for i in 0..<s.characters.count - subLength + 1 {
    let subString = s.substringWithRange(Range(start: i, end: i + subLength))
    if subString == sub {
      count += 1
    }
  }
  return count
}

// Return the number of times the string sub appears in the string s,
// but only for the first n characters of s.
// count_substrings_first_n("Hello, there", "ll", 2) == 2
// count_substrings_first_n("Hello, there", "he", 2) == 1
// count_substrings_first_n("Hello, there", "Hi", 2) == 0
func count_substrings_first_n(s: String, sub: String, n: Int) -> Int {
  let subLength = sub.characters.count
  var count = 0
  for i in 0..<n {
    let subString = s.substringWithRange(Range(start: i, end: i + subLength))
    if subString == sub {
      count += 1
    }
  }
  return count
}

// Return the number of times the string sub appears in the string s,
// but only for the last n characters of s.
// count_substrings_last_n("Hello, there", "ll", 2) == 2
// count_substrings_last_n("Hello, there", "he", 2) == 1
// count_substrings_last_n("Hello, there", "Hi", 2) == 0
func count_substrings_last_n(s: String, sub: String, n: Int) -> Int {
  let subLength = sub.characters.count
  var count = 0
  for i in 0..<s.characters.count - n {
    let subString = s.substringWithRange(Range(start: i + n, end: i + n + subLength))
    if subString == sub {
      count += 1
    }
  }
  return count
}

// Return the number of times the string sub appears in the string s,
// but only for the first n characters of s, and only for the last m characters of s.
// count_substrings_first_n_last_m("Hello, there", "ll", 2, 2) == 2
// count_substrings_first_n_last_m("Hello, there", "he", 2, 2) == 1
// count_substrings_first_n_last_m("Hello, there", "Hi", 2, 2) == 0
func count_substrings_first_n_last_m(s: String, sub: String, n: Int, m: Int) -> Int {
  let subLength = sub.characters.count
  var count = 0
  for i in 0..<n {
    let subString = s.substringWithRange(Range(start: i, end: i + subLength))
    if subString == sub {
      count += 1
    }
  }
  for i in