extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement this method
}

func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement this method
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement this method
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement this method
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement this method
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement this method
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement this method
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement this method
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = [String]()
    var odd = 0
    var even = 0
    var last = ""
    for char in txt {
        if char == " " {
            if last != "" {
                result.append(last)
                last = ""
            }
        } else if char == "," {
            if last != "" {
                result.append(last)
                last = ""
            }
            result.append(String(char))
        } else {
            if char.isLowercase {
                odd += 1
            } else {
                even += 1
            }
            last += String(char)
        }
    }
    if last != "" {
        result.append(last)
    }
    if odd == 0 && even == 0 {
        return .failure(odd)
    }
    return .success(result)
}

func splitWords2(txt: String) -> Result<[String], Int> {
    var result = [String]()
    var odd = 0
    var even = 0
    var last = ""
    for char in txt {
        if char == " " {
            if last != "" {
                result.append(last)
                last = ""
            }
        } else if char == "," {
            if last != "" {
                result.append(last)
                last = ""
            }
            result.append(String(char))
        } else {
            if char.isLowercase {
                odd += 1
            } else {
                even += 1
            }
            last += String(char)
        }
    }
    if last != "" {
        result.append(last)
    }
    if odd == 0 && even == 0 {
        return .failure(odd)
    }
    return .success(result)
}

func splitWords3(txt: String) -> Result<[String], Int> {
    var result = [String]()
    var odd = 0
    var even = 0
    var last = ""
    for char in txt {
        if char == " " {
            if last != "" {
                result.append(last)
                last = ""
            }
        } else if char == "," {
            if last != "" {
                result.append(last)
                last = ""
            }
            result.append(String(char))
        } else {
            if char.isLowercase {
                odd += 1
            } else {
                even += 1
            }
            last += String(char)
        }
    }
    if last != "" {
        result.append(last)
    }
    if odd == 0 && even == 0 {
        return .failure(odd)
    }
    return .success(result)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = [String]()
    var odd = 0
    var even = 0
    var last = ""
    for char in txt {
        if char == " " {
            if last != "" {
                result.append(last)
                last = ""
            }
        } else if char == "," {
            if last != "" {
                result.append(last)
                last = ""
            }
            result.append(String(char))
        } else {
            if char.isLowercase {
                odd += 1
            } else {
                even += 1
            }
            last += String(char)
        }
    }
    if last != "" {
        result.append(last)
    }
    if odd == 0 && even == 0 {
        return .failure(odd)
    }
    return .success(result)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords2(txt: String) -> Result<[String], Int> {
    var result = [String]()
    var odd = 0
    var even = 0
    var last = ""
    for char in txt {
        if char == " " {
            if last != "" {
                result.append(last)
                last = ""
            }
        } else if char == "," {
            if last != "" {
                result.append(last)
                last = ""
            }
            result.append(String(char))
        } else {
            if char.isLowercase {
                odd += 1
            } else {
                even += 1
            }
            last += String(char)
        }
    }
    if last != "" {
        result.append(last)
    }
    if odd == 0 && even == 0 {
        return .failure(odd)
    }
    return .success(result)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords3(txt: String) -> Result<[String], Int> {
    var result = [String]()
    var odd = 0
    var even = 0
    var last = ""
    for char in txt {
        if char == " " {
            if last != "" {
                result.append(last)
                last = ""
            }
        } else if char == "," {
            if last != "" {
                result.append(last)
                last = ""
            }
            result.append(String(char))
        } else {
            if char.isLowercase {
                odd += 1
            } else {
                even += 1
            }
            last += String(char)
        }
    }
    if last != "" {
        result.append(last)
    }
    if odd == 0 && even == 0 {
        return .failure(odd)
    }
    return .success(result)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') =

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.contains(where: { $0.contains(" ") }) {
        return .failure(3)
    }
    if words.contains(where: { $0.contains(",") }) {
        return .failure(3)
    }
    let odd = words.filter { $0.count % 2 == 1 }.map { $0.lowercased() }.sorted { $0 < $1 }
    return .success(odd)
}

func pairsSum(arr: [Int], value: Int) -> Result<Int, Int> {
    var pairs = 0
    for i in 0..<arr.count {
        for j in i+1..<arr.count {
            if arr[i] + arr[j] == value {
                pairs += 1
            }
        }
    }
    return .success(pairs)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.contains(where: { $0.contains(" ") }) {
        return .failure(3)
    }
    if words.contains(where: { $0.contains(",") }) {
        return .failure(3)
    }
    let odd = words.filter { $0.count % 2 == 1 }.map { $0.lowercased() }.sorted { $0 < $1 }
    return .success(odd)
}

// Given an array of integers, return the number of pairs of integers that sum to a given value.
// Examples
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 10) == .success(4)
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 11) == .failure(1)
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 12) == .failure(2)
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 13) == .failure(3)
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 14) == .failure(4)
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 15) == .failure(5)
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 16) == .failure(6)
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 17) == .failure(7)
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 18) == .failure(8)
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 19) == .failure(9)
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 20) == .failure(10)
func pairsSum(arr: [Int], value: Int) -> Result<Int, Int> {
    var pairs = 0
    for i in 0..<arr.count {
        for j in i+1..<arr.count {
            if arr[i] + arr[j] == value {
                pairs += 1
            }
        }
    }
    return .success(pairs)
}

// Given an array of integers, return the number of pairs of integers that sum to a given value.
// Examples
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 10) == .success(4)
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 11) == .failure(1)
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 12) == .failure(2)
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 13) == .failure(3)
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 14) == .failure(4)
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 15) == .failure(5)
// pairsSum(arr: [1,2,3,4,5,6,7,8,9,10], value: 16) == .failure(6)
// pairsSum(arr: [1,2,3,4,5,6,7,8,

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
    return .failure(0)
}

func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
    return .failure(0)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
    return .failure(0)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
    return .failure(0)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
    return .failure(0)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
    return .failure(0)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
    return .failure(0)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
    return .failure(0)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])

extension Int: Error {

}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let wordsCount = words.count
    let wordsWithOddOrder = words.filter { $0.count % 2 != 0 }
    let wordsWithOddOrderCount = wordsWithOddOrder.count
    let wordsWithOddOrderCountWithOddOrder = wordsWithOddOrder.filter { $0.count % 2 != 0 }
    let wordsWithOddOrderCountWithOddOrderCount = wordsWithOddOrderCountWithOddOrder.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrder = wordsWithOddOrderCountWithOddOrderCount.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrderCount = wordsWithOddOrderCountWithOddOrderCountWithOddOrder.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCount = wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountWithOddOrder.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrder = wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountWithOddOrderCount.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCount = wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountWithOddOrderCountCount.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCount = wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCount.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCount = wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCount.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCount = wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCount.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCount = wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCount.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCount = wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCount.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCountCount = wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCountCountCount.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCountCountCount = wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCountCountCountCount.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCountCountCountCount = wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCountCountCountCountCount.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCountCountCountCountCount = wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCountCountCountCountCountCount.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCountCountCountCountCountCount = wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCountCountCountCountCountCountCount.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCountCountCountCountCountCountCount = wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCountCountCountCountCountCountCountCount.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCountCountCountCountCountCountCountCount = wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCountCountCountCountCountCountCountCountCount.count
    let wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCountCountCountCountCountCountCountCountCount = wordsWithOddOrderCountWithOddOrderCountWithOddOrderCountCountWithOddOrderCountCountCountCountCountCountCountCountCountCountCountCountCountCountCount.

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement this function
}

func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement this function
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement this function
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement this function
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement this function
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement this function
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement this function
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement this function
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
    return .failure(3)
}

func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
    return .failure(3)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
    return .failure(3)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
    return .failure(3)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
    return .failure(3)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
    return .failure(3)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
    return .failure(3)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
    return .failure(3)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
}

func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
}

// Given a string of words,

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let letters = words.map { $0.lowercased() }
    let lettersOdd = letters.filter { $0.firstIndex(where: { $0.isLowercase }) % 2 == 1 }
    let lettersEven = letters.filter { $0.firstIndex(where: { $0.isLowercase }) % 2 == 0 }
    let lettersOddCount = lettersOdd.count
    let lettersEvenCount = lettersEven.count
    if lettersOddCount == 0 && lettersEvenCount == 0 {
        return .failure(letters.count)
    }
    if lettersOddCount == 0 {
        return .success(lettersEven)
    }
    if lettersEvenCount == 0 {
        return .success(lettersOdd)
    }
    return .failure(lettersOddCount)
}

func adjacentElementsProduct(arr: [Int]) -> Int {
    var max = 0
    for i in 0..<arr.count - 1 {
        let product = arr[i] * arr[i + 1]
        if product % 2 == 0 {
            max = max > product ? max : product
        }
    }
    return max
}

func addBorder(arr: [[String]]) -> [[String]] {
    var result = [String]()
    for _ in 0..<arr[0].count + 2 {
        result.append("*")
    }
    for i in 0..<arr.count {
        result.append("*" + arr[i].joined(separator: "*") + "*")
    }
    return result
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let letters = words.map { $0.lowercased() }
    let lettersOdd = letters.filter { $0.firstIndex(where: { $0.isLowercase }) % 2 == 1 }
    let lettersEven = letters.filter { $0.firstIndex(where: { $0.isLowercase }) % 2 == 0 }
    let lettersOddCount = lettersOdd.count
    let lettersEvenCount = lettersEven.count
    if lettersOddCount == 0 && lettersEvenCount == 0 {
        return .failure(letters.count)
    }
    if lettersOddCount == 0 {
        return .success(lettersEven)
    }
    if lettersEvenCount == 0 {
        return .success(lettersOdd)
    }
    return .failure(lettersOddCount)
}

// Given an array of integers, return the number of times the sum of adjacent elements in the array is even.
// Examples
// adjacentElementsProduct([2, 4, 6, 8, 10]) == 16
// adjacentElementsProduct([2, 4, 6, 8, 10, 12]) == 20
// adjacentElementsProduct([2, 4, 6, 8, 10, 12, 14]) == 24
func adjacentElementsProduct(arr: [Int]) -> Int {
    var max = 0
    for i in 0..<arr.count - 1 {
        let product = arr[i] * arr[i + 1]
        if product % 2 == 0 {
            max = max > product ? max : product
        }
    }
    return max
}

// Given an array of integers, return the number of times the sum of adjacent elements in the array is odd.
// Examples
// addBorder([["abc"], ["ded"]]) == [["*****"], ["*abc*"], ["*ded*"], ["*****"]]
// addBorder([["abc", "ded"]]) == [["*****", "*****"], ["*abc*", "*ded*"], ["*****", "*****"]]
func addBorder(arr: [[String]]) -> [[String]] {
    var result = [String]()
    for _ in 0..<arr[0].count + 2 {
        result.append("*")
    }
    for i in 0..<arr.count {
        result.append("*" + arr[i].joined(separator: "*") + "*")
    }
    return result
}

// Given an array of integers, return the number of times the sum of adjacent elements in the array is even.
// Examples
// addBorder([["abc"], ["ded"]]) == [["*****"], ["*abc*"], ["*ded*"], ["*****"]]
// addBorder([["abc", "ded"]]) == [["*****", "*****"], ["*abc*", "*ded*"], ["*****", "*****"]]
func addBorder(arr: [[String]]) -> [[String]] {
    var result = [String]()
    for _ in 0..<arr[0].count + 2 {
        result.append("*")
    }
    for i in 0..<arr.count {
        result.append("*" + arr[i].joined(separator: "*") + "*")
    }
    return result
}

// Given an array of integers, return the number of times the sum of adjacent elements in the array is odd.
// Examples
// addBorder([["abc"], ["ded"]]) == [["*****"], ["*abc*"], ["*ded*"], ["*****"]]
// addBorder([["abc", "ded"]]) == [["*****", "*****"], ["*abc*", "*ded*"], ["*****", "*****"]]
func addBorder(arr: [[String]]) -> [[String]] {
    var result = [String]()
    for _ in 0..<arr[0].count + 2 {
        result.append("*")
    }
    for i in 0..<arr.count {
        result.append("*" + arr[i].joined(separator: "*") + "*")
    }
    return result
}

// Given an array of integers, return the number of times the sum of adjacent elements in the array is odd.
// Examples
// addBorder([["abc"], ["ded"]]) == [["*****"], ["*abc*"], ["*ded*"], ["*****"]]
// addBorder([["abc", "ded"]]) == [

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let chars = txt.split(separator: ",")
    let oddChars = chars.filter { $0.isLowercase && $0.firstIndex(of: "a")! % 2 == 1 }
    let oddCharsCount = oddChars.count
    return .success(words)
}

func splitWords2(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let chars = txt.split(separator: ",")
    let oddChars = chars.filter { $0.isLowercase && $0.firstIndex(of: "a")! % 2 == 1 }
    let oddCharsCount = oddChars.count
    return .success(words)
}

func splitWords3(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let chars = txt.split(separator: ",")
    let oddChars = chars.filter { $0.isLowercase && $0.firstIndex(of: "a")! % 2 == 1 }
    let oddCharsCount = oddChars.count
    return .success(words)
}

func splitWords4(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let chars = txt.split(separator: ",")
    let oddChars = chars.filter { $0.isLowercase && $0.firstIndex(of: "a")! % 2 == 1 }
    let oddCharsCount = oddChars.count
    return .success(words)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let chars = txt.split(separator: ",")
    let oddChars = chars.filter { $0.isLowercase && $0.firstIndex(of: "a")! % 2 == 1 }
    let oddCharsCount = oddChars.count
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords2(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let chars = txt.split(separator: ",")
    let oddChars = chars.filter { $0.isLowercase && $0.firstIndex(of: "a")! % 2 == 1 }
    let oddCharsCount = oddChars.count
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords3(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let chars = txt.split(separator: ",")
    let oddChars = chars.filter { $0.isLowercase && $0.firstIndex(of: "a")! % 2 == 1 }
    let oddCharsCount = oddChars.count
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords4(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let chars = txt.split(separator: ",")
    let oddChars = chars.filter { $0.isLowercase && $0.firstIndex(of: "a")! % 2 == 1 }
    let oddCharsCount = oddChars.count
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords5(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let chars = txt.split(separator: ",")
    let oddChars = chars.filter { $0.isLowercase && $0.firstIndex

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: CharacterSet.whitespaces) {
        return .success(txt.components(separatedBy: " "))
    } else if let _ = txt.rangeOfCharacter(from: CharacterSet(charactersIn: ",")) {
        return .success(txt.components(separatedBy: ","))
    } else {
        var count = 0
        for (index, char) in txt.enumerated() {
            if char.isLowercase && index % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: CharacterSet.whitespaces) {
        return .success(txt.components(separatedBy: " "))
    } else if let _ = txt.rangeOfCharacter(from: CharacterSet(charactersIn: ",")) {
        return .success(txt.components(separatedBy: ","))
    } else {
        var count = 0
        for (index, char) in txt.enumerated() {
            if char.isLowercase && index % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: .whitespaces) {
        return .success(txt.components(separatedBy: " "))
    } else if let _ = txt.rangeOfCharacter(from: CharacterSet(charactersIn: ",")) {
        return .success(txt.components(separatedBy: ","))
    } else {
        var count = 0
        for (index, character) in txt.enumerated() {
            if character.isLowercase && index % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: .whitespaces) {
        return .success(txt.components(separatedBy: " "))
    } else if let _ = txt.rangeOfCharacter(from: CharacterSet(charactersIn: ",")) {
        return .success(txt.components(separatedBy: ","))
    } else {
        var count = 0
        for (index, character) in txt.enumerated() {
            if character.isLowercase && index % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: .whitespaces) {
        return .success(txt.components(separatedBy: " "))
    } else if let _ = txt.rangeOfCharacter(from: CharacterSet(charactersIn: ",")) {
        return .success(txt.components(separatedBy: ","))
    } else {
        var count = 0
        for (index, letter) in txt.enumerated() {
            if letter.isLowercase && index % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: .whitespaces) {
        return .success(txt.components(separatedBy: " "))
    } else if let _ = txt.rangeOfCharacter(from: CharacterSet(charactersIn: ",")) {
        return .success(txt.components(separatedBy: ","))
    } else {
        var count = 0
        for (index, letter) in txt.enumerated() {
            if letter.isLowercase && index % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: .whitespaces) {
        return .success(txt.components(separatedBy: " "))
    } else if let _ = txt.rangeOfCharacter(from: CharacterSet(charactersIn: ",")) {
        return .success(txt.components(separatedBy: ","))
    } else {
        var count = 0
        for (index, character) in txt.enumerated() {
            if character.isLowercase && index % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: .whitespaces) {
        return .success(txt.components(separatedBy: " "))
    } else if let _ = txt.rangeOfCharacter(from: CharacterSet(charactersIn: ",")) {
        return .success(txt.components(separatedBy: ","))
    } else {
        var count = 0
        for (index, character) in txt.enumerated() {
            if character.isLowercase && index % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ") {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",") {
        return .success(words)
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                if (char.asciiValue! - 97) % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ") {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",") {
        return .success(words)
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                if (char.asciiValue! - 97) % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: .whitespaces) {
        return .success(txt.components(separatedBy: " "))
    } else if let _ = txt.rangeOfCharacter(from: CharacterSet(charactersIn: ",")) {
        return .success(txt.components(separatedBy: ","))
    } else {
        var count = 0
        for (index, character) in txt.enumerated() {
            if character.isLowercase && index % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: .whitespaces) {
        return .success(txt.components(separatedBy: " "))
    } else if let _ = txt.rangeOfCharacter(from: CharacterSet(charactersIn: ",")) {
        return .success(txt.components(separatedBy: ","))
    } else {
        var count = 0
        for (index, character) in txt.enumerated() {
            if character.isLowercase && index % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                if (char.asciiValue! - 97) % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                if (char.asciiValue! - 97) % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: .whitespaces) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",") {
        return .success(words)
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                if (char.asciiValue! - 97) % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: .whitespaces) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",") {
        return .success(words)
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                if (char.asciiValue! - 97) % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ") {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",") {
        return .success(words)
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                if (char.asciiValue! - 97) % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ") {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",") {
        return .success(words)
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                if (char.asciiValue! - 97) % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                if (char.asciiValue! - ord('a')) % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                if (char.asciiValue! - ord('a')) % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map(String.init))
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map(String.init))
}

splitWords(txt: "Hello world!")
splitWords(txt: "Hello,world!")
splitWords(txt: "abcdef")
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map(String.init))
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: ",").map(String.init))
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(txt.filter { $0.isLowercase }.count)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map(String.init))
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: ",").map(String.init))
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(txt.filter { $0.isLowercase }.count)
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map(String.init))
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map(String.init))
}

splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: ",").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(txt.reduce(0) { $0 + $1.isLowercase? 1 : 0 })
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: ",").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(txt.reduce(0) { $0 + $1.isLowercase? 1 : 0 })
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map(String.init))
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: ",").map(String.init))
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(txt.reduce(0) { $0 + $1.isLowercase? 1 : 0 })
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map(String.init))
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: ",").map(String.init))
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(txt.reduce(0) { $0 + $1.isLowercase? 1 : 0 })
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy: " "))
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy: ","))
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(txt.filter { $0.isLowercase }.count)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy: " "))
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy: ","))
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(txt.filter { $0.isLowercase }.count)
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // Your code here
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // Your code here
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement me!
    return.failure(0)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement me!
    return.failure(0)
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success([])
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success([])
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(0)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(0)
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(0)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(0)
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success([])
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success([])
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success([])
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success([])
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success([])
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success([])
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success([])
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success([])
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(0)
}

func sum(_ arr: [Int]) -> Int {
    return 0
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(0)
}

// Given an array of integers, return the sum of the integers in the array.
// Examples
// sum([1, 2, 3]) == 6
// sum([1, 2, 3, 4]) == 10
func sum(_ arr: [Int]) -> Int {
    return 0
}

// Given an array of integers, return the sum of the integers in the array.
// Examples
// sum([1, 2, 3]) == 6
// sum([1, 2, 3, 4]) == 10
func sum(_ arr: [Int]) -> Int {
    return 0
}

// Given an array of integers, return the sum of the integers in the array.
// Examples
// sum([1, 2, 3]) == 6
// sum([1, 2, 3, 4]) == 10
func sum(_ arr: [Int]) -> Int {
    return 0
}

// Given an array of integers, return the sum of the integers in the array.
// Examples
// sum([1, 2, 3]) == 6
// sum([1, 2, 3, 4]) == 10
func sum(_ arr: [Int]) -> Int {
    return 0
}

// Given an array of integers, return the sum of the integers in the array.
// Examples
// sum([1, 2, 3]) == 6
// sum([1, 2, 3, 4]) == 10
func sum(_ arr: [Int]) -> Int {
    return 0
}

// Given an array of integers, return the sum of the integers in the array.
// Examples
// sum([1, 2, 3]) == 6
// sum([1, 2, 3, 4]) == 10
func sum(_ arr: [Int]) -> Int {
    return 0
}

// Given an array of integers, return the sum of the integers in the array.
// Examples
// sum([1, 2, 3]) == 6
// sum([1, 2, 3, 4]) == 10
func sum(_ arr: [Int]) -> Int {
    return 0
}

// Given an array of integers, return the sum of the integers in the array.
// Examples
// sum([1, 2, 3]) == 6
// sum([1, 2, 3, 4]) == 10
func sum(_ arr: [Int]) -> Int {
    return 0
}

// Given an array of integers, return the sum of the integers in the array.
// Examples
// sum([1, 2, 3]) == 6
// sum([1, 2, 3, 4]) == 10
func sum(_ arr: [Int]) -> Int {
    return 0
}

// Given an array of integers, return the sum of the integers in the array.
// Examples
// sum([1, 2, 3]) == 6
// sum([1, 2, 3, 4]) == 10
func sum(_ arr: [Int]) -> Int {
    return 0
}

// Given an array of integers, return the sum of the integers in the array.
// Examples
// sum([1, 2, 3]) == 6
// sum([1, 2, 3, 4]) == 10
func sum(_ arr: [Int]) -> Int {
    return 0
}

// Given an array of integers, return the sum of the integers in the array.
// Examples
// sum([1, 2, 3]) == 6
// sum([1, 2, 3, 4]) == 10
func sum(_ arr: [Int]) -> Int {
    return 0
}

// Given an array of integers, return the sum of the integers in the array.
// Examples
// sum([1, 2, 3]) == 6
// sum([1, 2, 3, 4]) == 10
func sum(_ arr: [Int]) -> Int {
    return 0
}

// Given an array of integers, return the sum of the integers in the array.
// Examples
// sum([1, 2, 3]) == 6
// sum([1, 2, 3, 4]) ==

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(0)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(0)
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement me!
    return.failure(0)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: Implement me!
    return.failure(0)
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(0)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.failure(0)
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return.success(words)
    }
    let words2 = txt.components(separatedBy: ",")
    if words2.count > 1 {
        return.success(words2)
    }
    var count = 0
    for (index, char) in txt.lowercased().enumerated() {
        if index % 2 == 1 {
            if char.asciiValue! - 97 > 25 {
                return.failure(Int(char.asciiValue! - 97))
            }
            count += Int(char.asciiValue! - 97)
        }
    }
    return.failure(count)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return.success(words)
    }
    let words2 = txt.components(separatedBy: ",")
    if words2.count > 1 {
        return.success(words2)
    }
    var count = 0
    for (index, char) in txt.lowercased().enumerated() {
        if index % 2 == 1 {
            if char.asciiValue! - 97 > 25 {
                return.failure(Int(char.asciiValue! - 97))
            }
            count += Int(char.asciiValue! - 97)
        }
    }
    return.failure(count)
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // Your code here
}

func sumArray(_ arr: [Int]) -> Int {
    // Your code here
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // Your code here
}

// Given an array of integers, return the sum of the array, if the array is empty return 0
// Examples
// sumArray([1, 2, 3, 4]) == 10
// sumArray([1, -2]) == -1
// sumArray([]) == 0
func sumArray(_ arr: [Int]) -> Int {
    // Your code here
}

// Given an array of integers, return the sum of the array, if the array is empty return 0
// Examples
// sumArray([1, 2, 3, 4]) == 10
// sumArray([1, -2]) == -1
// sumArray([]) == 0
func sumArray(_ arr: [Int]) -> Int {
    // Your code here
}

// Given an array of integers, return the sum of the array, if the array is empty return 0
// Examples
// sumArray([1, 2, 3, 4]) == 10
// sumArray([1, -2]) == -1
// sumArray([]) == 0
func sumArray(_ arr: [Int]) -> Int {
    // Your code here
}

// Given an array of integers, return the sum of the array, if the array is empty return 0
// Examples
// sumArray([1, 2, 3, 4]) == 10
// sumArray([1, -2]) == -1
// sumArray([]) == 0
func sumArray(_ arr: [Int]) -> Int {
    // Your code here
}

// Given an array of integers, return the sum of the array, if the array is empty return 0
// Examples
// sumArray([1, 2, 3, 4]) == 10
// sumArray([1, -2]) == -1
// sumArray([]) == 0
func sumArray(_ arr: [Int]) -> Int {
    // Your code here
}

// Given an array of integers, return the sum of the array, if the array is empty return 0
// Examples
// sumArray([1, 2, 3, 4]) == 10
// sumArray([1, -2]) == -1
// sumArray([]) == 0
func sumArray(_ arr: [Int]) -> Int {
    // Your code here
}

// Given an array of integers, return the sum of the array, if the array is empty return 0
// Examples
// sumArray([1, 2, 3, 4]) == 10
// sumArray([1, -2]) == -1
// sumArray([]) == 0
func sumArray(_ arr: [Int]) -> Int {
    // Your code here
}

// Given an array of integers, return the sum of the array, if the array is empty return 0
// Examples
// sumArray([1, 2, 3, 4]) == 10
// sumArray([1, -2]) == -1
// sumArray([]) == 0
func sumArray(_ arr: [Int]) -> Int {
    // Your code here
}

// Given an array of integers, return the sum of the array, if the array is empty return 0
// Examples
// sumArray([1, 2, 3, 4]) == 10
// sumArray([1, -2]) == -1
// sumArray([]) == 0
func sumArray(_ arr: [Int]) -> Int {
    // Your code here
}

// Given an array of integers, return the sum of the array, if the array is empty return 0
// Examples
// sumArray([1, 2, 3, 4]) == 10
// sumArray([1, -2]) == -1
// sumArray([]) == 0
func sumArray(_ arr: [Int]) -> Int {
    // Your code here
}

// Given an array of integers, return the sum of the array, if the array is empty return 0
// Examples
// sumArray([1, 2, 3, 4]) == 10
// sumArray([1, -2]) == -1
// sumArray([]) == 0
func sumArray(_ arr: [Int]) -> Int {
    // Your code here
}

// Given an array of integers, return the sum of the array, if the array is empty return 0
// Examples
// sumArray([1, 2, 3, 4]) == 10
//

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return.success(words)
    }
    let words2 = txt.components(separatedBy: ",")
    if words2.count > 1 {
        return.success(words2)
    }
    var count = 0
    for (i, c) in txt.lowercased().enumerated() {
        if i % 2 == 0 && c.asciiValue! - 97 < 26 {
            count += 1
        }
    }
    return.failure(count)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return.success(words)
    }
    let words2 = txt.components(separatedBy: ",")
    if words2.count > 1 {
        return.success(words2)
    }
    var count = 0
    for (i, c) in txt.lowercased().enumerated() {
        if i % 2 == 0 && c.asciiValue! - 97 < 26 {
            count += 1
        }
    }
    return.failure(count)
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // Your code here
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // Your code here
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
}

func sum(_ arr: [Int]) -> Int {
    // your code here
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
}

// Given an array of integers, return the sum of the integers. If the array is empty, return 0.
// Examples
// sum([]) == 0
// sum([1, 2, 3]) == 6
func sum(_ arr: [Int]) -> Int {
    // your code here
}

// Given an array of integers, return the sum of the integers. If the array is empty, return 0.
// Examples
// sum([]) == 0
// sum([1, 2, 3]) == 6
func sum(_ arr: [Int]) -> Int {
    // your code here
}

// Given an array of integers, return the sum of the integers. If the array is empty, return 0.
// Examples
// sum([]) == 0
// sum([1, 2, 3]) == 6
func sum(_ arr: [Int]) -> Int {
    // your code here
}

// Given an array of integers, return the sum of the integers. If the array is empty, return 0.
// Examples
// sum([]) == 0
// sum([1, 2, 3]) == 6
func sum(_ arr: [Int]) -> Int {
    // your code here
}

// Given an array of integers, return the sum of the integers. If the array is empty, return 0.
// Examples
// sum([]) == 0
// sum([1, 2, 3]) == 6
func sum(_ arr: [Int]) -> Int {
    // your code here
}

// Given an array of integers, return the sum of the integers. If the array is empty, return 0.
// Examples
// sum([]) == 0
// sum([1, 2, 3]) == 6
func sum(_ arr: [Int]) -> Int {
    // your code here
}

// Given an array of integers, return the sum of the integers. If the array is empty, return 0.
// Examples
// sum([]) == 0
// sum([1, 2, 3]) == 6
func sum(_ arr: [Int]) -> Int {
    // your code here
}

// Given an array of integers, return the sum of the integers. If the array is empty, return 0.
// Examples
// sum([]) == 0
// sum([1, 2, 3]) == 6
func sum(_ arr: [Int]) -> Int {
    // your code here
}

// Given an array of integers, return the sum of the integers. If the array is empty, return 0.
// Examples
// sum([]) == 0
// sum([1, 2, 3]) == 6
func sum(_ arr: [Int]) -> Int {
    // your code here
}

// Given an array of integers, return the sum of the integers. If the array is empty, return 0.
// Examples
// sum([]) == 0
// sum([1, 2, 3]) == 6
func sum(_ arr: [Int]) -> Int {
    // your code here
}

// Given an array of integers, return the sum of the integers. If the array is empty, return 0.
// Examples
// sum([]) == 0
// sum([1, 2, 3]) == 6
func sum(_ arr: [Int]) -> Int {
    // your code here
}

// Given an array of integers, return the sum of the integers. If the array is empty, return 0.
// Examples
// sum([]) == 0
// sum([1, 2, 3]) == 6
func sum(_ arr: [Int]) -> Int {
    // your code here
}

// Given an array of integers, return the sum of the integers. If the array is empty, return 0.
// Examples
// sum([]) == 0
// sum([1, 2, 3]) == 6
func sum(_ arr: [Int]) -> Int {
    // your code here
}

// Given an array of integers, return the sum of the integers. If the array is empty, return 0.
// Examples
// sum([]) == 0
// sum([1, 2, 3]) == 6
func sum(_ arr: [Int]) -> Int {
    // your code here
}

// Given an array of integers, return the sum of the integers. If the array is empty, return 0.
// Examples
// sum([]) == 0

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy: " "))
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy: " "))
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy: " "))
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy: " "))
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
  // your code here
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
  // your code here
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // Your code here
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // Your code here
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    let letters = txt.lowercased().characters.map { String($0) }
    let oddLetters = letters.filter { $0.distance(from: "a") % 2 == 1 }
    return words.isEmpty?.success(oddLetters) :.success(words)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    let letters = txt.lowercased().characters.map { String($0) }
    let oddLetters = letters.filter { $0.distance(from: "a") % 2 == 1 }
    return words.isEmpty?.success(oddLetters) :.success(words)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().map { String($0) }
        let oddLetters = letters.filter { Int(String($0).first!)! % 2!= 0 }
        return.success(oddLetters)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().map { String($0) }
        let oddLetters = letters.filter { Int(String($0).first!)! % 2!= 0 }
        return.success(oddLetters)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    let letters = txt.lowercased().map { String($0) }
    let oddLetters = letters.filter { Int($0.description) % 2 == 1 }
    return words.count > 0?.success(words) :.success(oddLetters)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    let letters = txt.lowercased().map { String($0) }
    let oddLetters = letters.filter { Int($0.description) % 2 == 1 }
    return words.count > 0?.success(words) :.success(oddLetters)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().characters.map { String($0) }
        let oddLetters = letters.filter { $0.characters.count % 2 == 1 }
        return.success(oddLetters)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().characters.map { String($0) }
        let oddLetters = letters.filter { $0.characters.count % 2 == 1 }
        return.success(oddLetters)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    let commas = txt.components(separatedBy: ",")
    
    if words.count > 0 {
        return.success(words)
    } else if commas.count > 0 {
        return.success(commas)
    } else {
        let letters = txt.lowercased().map { String($0) }
        var count = 0
        for (index, letter) in letters.enumerated() {
            if index % 2!= 0 {
                count += 1
            }
        }
        return.failure(count)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    let commas = txt.components(separatedBy: ",")
    
    if words.count > 0 {
        return.success(words)
    } else if commas.count > 0 {
        return.success(commas)
    } else {
        let letters = txt.lowercased().map { String($0) }
        var count = 0
        for (index, letter) in letters.enumerated() {
            if index % 2!= 0 {
                count += 1
            }
        }
        return.failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    let letters = txt.lowercased().filter { $0.isLetter }
    let oddLetters = letters.filter { Int($0.asciiValue?? 0) % 2!= 0 }
    return words.count > 0?.success(words) : oddLetters.count > 0?.success(oddLetters) :.failure(3)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    let letters = txt.lowercased().filter { $0.isLetter }
    let oddLetters = letters.filter { Int($0.asciiValue?? 0) % 2!= 0 }
    return words.count > 0?.success(words) : oddLetters.count > 0?.success(oddLetters) :.failure(3)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.map { String(UnicodeScalar($0.element)!) }
        return.success(oddLetters)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.map { String(UnicodeScalar($0.element)!) }
        return.success(oddLetters)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    let letters = txt.lowercased().map { String($0) }
    let oddLetters = letters.filter { Int(String($0).first?? "")?? 0 % 2 == 1 }
    return words.count > 0?.success(words) :.success(oddLetters)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    let letters = txt.lowercased().map { String($0) }
    let oddLetters = letters.filter { Int(String($0).first?? "")?? 0 % 2 == 1 }
    return words.count > 0?.success(words) :.success(oddLetters)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let letters = txt.lowercased().map { String($0) }
    let oddLetters = letters.filter { Int($0.description, radix: 10) % 2 == 1 }
    let count = oddLetters.count
    
    return count > 0?.failure(count) :.success(words)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let letters = txt.lowercased().map { String($0) }
    let oddLetters = letters.filter { Int($0.description, radix: 10) % 2 == 1 }
    let count = oddLetters.count
    
    return count > 0?.failure(count) :.success(words)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    let letters = txt.lowercased().characters.map { String($0) }
    let oddLetters = letters.filter { $0.characters.count % 2 == 1 }
    return words.count > 0?.success(words) :.success(oddLetters)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    let letters = txt.lowercased().characters.map { String($0) }
    let oddLetters = letters.filter { $0.characters.count % 2 == 1 }
    return words.count > 0?.success(words) :.success(oddLetters)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy:.whitespacesAndNewlines)
    if words.count > 1 {
        return.success(words)
    } else {
        let characters = txt.lowercased().map { String($0) }
        let oddOrderedLetters = characters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        let oddOrderedLettersCount = oddOrderedLetters.count
        if oddOrderedLettersCount > 0 {
            return.success(oddOrderedLetters)
        } else {
            return.failure(oddOrderedLettersCount)
        }
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy:.whitespacesAndNewlines)
    if words.count > 1 {
        return.success(words)
    } else {
        let characters = txt.lowercased().map { String($0) }
        let oddOrderedLetters = characters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        let oddOrderedLettersCount = oddOrderedLetters.count
        if oddOrderedLettersCount > 0 {
            return.success(oddOrderedLetters)
        } else {
            return.failure(oddOrderedLettersCount)
        }
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy:.whitespacesAndNewlines)
    if words.count > 1 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { "abcdefghijklmnopqrstuvwxyz".contains($0) }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        return oddLetters.count > 0?.failure(oddLetters.count) :.success(words)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy:.whitespacesAndNewlines)
    if words.count > 1 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { "abcdefghijklmnopqrstuvwxyz".contains($0) }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        return oddLetters.count > 0?.failure(oddLetters.count) :.success(words)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy:.whitespacesAndNewlines)
    if words.count > 1 {
        return.success(words)
    } else {
        let letters = txt.filter { $0.is lowercase }
        let oddLetters = letters.filter { Int($0.asciiValue!) % 2 == 1 }
        return.failure(oddLetters.count)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy:.whitespacesAndNewlines)
    if words.count > 1 {
        return.success(words)
    } else {
        let letters = txt.filter { $0.is lowercase }
        let oddLetters = letters.filter { Int($0.asciiValue!) % 2 == 1 }
        return.failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy:.whitespacesAndNewlines)
    if words.count > 1 {
        return.success(words)
    } else {
        let characters = txt.lowercased().map { String($0) }
        let oddOrderedLetters = characters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        let oddOrderedLettersCount = oddOrderedLetters.count
        if oddOrderedLettersCount > 0 {
            return.success(oddOrderedLetters)
        } else {
            return.failure(oddOrderedLettersCount)
        }
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy:.whitespacesAndNewlines)
    if words.count > 1 {
        return.success(words)
    } else {
        let characters = txt.lowercased().map { String($0) }
        let oddOrderedLetters = characters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        let oddOrderedLettersCount = oddOrderedLetters.count
        if oddOrderedLettersCount > 0 {
            return.success(oddOrderedLetters)
        } else {
            return.failure(oddOrderedLettersCount)
        }
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy:.whitespacesAndNewlines)
    if words.count > 1 {
        return.success(words)
    } else {
        let characters = txt.lowercased().map { String($0) }
        let oddOrderedLetters = characters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        let oddOrderedLettersCount = oddOrderedLetters.count
        if oddOrderedLettersCount > 0 {
            return.success(oddOrderedLetters)
        } else {
            return.failure(oddOrderedLettersCount)
        }
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy:.whitespacesAndNewlines)
    if words.count > 1 {
        return.success(words)
    } else {
        let characters = txt.lowercased().map { String($0) }
        let oddOrderedLetters = characters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        let oddOrderedLettersCount = oddOrderedLetters.count
        if oddOrderedLettersCount > 0 {
            return.success(oddOrderedLetters)
        } else {
            return.failure(oddOrderedLettersCount)
        }
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let letters = txt.filter { $0.is lowercase }
        let oddLetters = letters.filter { Int($0.asciiValue!) % 2 == 1 }
        return oddLetters.count > 0?.failure(oddLetters.count) :.success([])
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let letters = txt.filter { $0.is lowercase }
        let oddLetters = letters.filter { Int($0.asciiValue!) % 2 == 1 }
        return oddLetters.count > 0?.failure(oddLetters.count) :.success([])
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let letters = txt.filter { $0.is lowercase }
        let oddLetters = letters.filter { Int($0.asciiValue!) % 2 == 1 }
        return.failure(oddLetters.count)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let letters = txt.filter { $0.is lowercase }
        let oddLetters = letters.filter { Int($0.asciiValue!) % 2 == 1 }
        return.failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy:.whitespacesAndNewlines)
    if words.count > 1 {
        return.success(words)
    } else {
        let chars = txt.lowercased().map { String($0) }
        let oddCount = chars.enumerated().filter { $0.offset % 2 == 1 }.count
        return oddCount < chars.count?.success(words) :.failure(oddCount)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy:.whitespacesAndNewlines)
    if words.count > 1 {
        return.success(words)
    } else {
        let chars = txt.lowercased().map { String($0) }
        let oddCount = chars.enumerated().filter { $0.offset % 2 == 1 }.count
        return oddCount < chars.count?.success(words) :.failure(oddCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy:.whitespacesAndNewlines)
    if words.count > 1 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { "abcdefghijklmnopqrstuvwxyz".contains($0) }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.count
        return oddLetters > 0?.failure(oddLetters) :.success(words)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy:.whitespacesAndNewlines)
    if words.count > 1 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { "abcdefghijklmnopqrstuvwxyz".contains($0) }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.count
        return oddLetters > 0?.failure(oddLetters) :.success(words)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy:.whitespacesAndNewlines)
    if words.count > 1 {
        return.success(words)
    } else {
        let letters = txt.filter { $0.is lowercase }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        return oddLetters.count > 0?.failure(oddLetters.count) :.success(words)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy:.whitespacesAndNewlines)
    if words.count > 1 {
        return.success(words)
    } else {
        let letters = txt.filter { $0.is lowercase }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        return oddLetters.count > 0?.failure(oddLetters.count) :.success(words)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return.success(words)
    } else {
        let letters = txt.filter { $0.isLetter }
        let oddLetters = letters.filter { letter in
            let index = letter.unicodeScalars.first!.value - "a".unicodeScalars.first!.value
            return index % 2 == 1
        }
        return.failure(oddLetters.count)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return.success(words)
    } else {
        let letters = txt.filter { $0.isLetter }
        let oddLetters = letters.filter { letter in
            let index = letter.unicodeScalars.first!.value - "a".unicodeScalars.first!.value
            return index % 2 == 1
        }
        return.failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return.success(words)
    } else {
        let letters = txt.filter { $0.isLetter }
        let lowerLetters = letters.filter { $0.isLowercase }
        let orderedLetters = lowerLetters.sorted { $0.unicodeScalars.first!.value < $1.unicodeScalars.first!.value }
        let orderedOddLetters = orderedLetters.enumerated().filter { $0.offset % 2 == 0 }
        return.failure(orderedOddLetters.count)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return.success(words)
    } else {
        let letters = txt.filter { $0.isLetter }
        let lowerLetters = letters.filter { $0.isLowercase }
        let orderedLetters = lowerLetters.sorted { $0.unicodeScalars.first!.value < $1.unicodeScalars.first!.value }
        let orderedOddLetters = orderedLetters.enumerated().filter { $0.offset % 2 == 0 }
        return.failure(orderedOddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return.success(words)
    } else {
        let letters = txt.filter { $0.isLetter }
        let oddLetters = letters.filter { $0.unicodeScalars.first!.value % 2 == 1 }
        return.failure(oddLetters.count)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return.success(words)
    } else {
        let letters = txt.filter { $0.isLetter }
        let oddLetters = letters.filter { $0.unicodeScalars.first!.value % 2 == 1 }
        return.failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    }
    let commas = txt.components(separatedBy: ",")
    if commas.count > 0 {
        return.success(commas)
    }
    var count = 0
    for char in txt {
        if char.isLowercase {
            count += 1
        }
    }
    return.failure(count)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    }
    let commas = txt.components(separatedBy: ",")
    if commas.count > 0 {
        return.success(commas)
    }
    var count = 0
    for char in txt {
        if char.isLowercase {
            count += 1
        }
    }
    return.failure(count)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let words = txt.components(separatedBy: ",")
        if words.count > 0 {
            return.success(words)
        } else {
            let count = txt.filter { $0.isLowercase && Int($0.unicodeScalars.first!.value) % 2 == 1 }.count
            return.failure(count)
        }
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let words = txt.components(separatedBy: ",")
        if words.count > 0 {
            return.success(words)
        } else {
            let count = txt.filter { $0.isLowercase && Int($0.unicodeScalars.first!.value) % 2 == 1 }.count
            return.failure(count)
        }
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.filter { $0.isLetter }
        let oddLetters = letters.filter { $0.unicodeScalars.first!.value % 2 == 1 }
        return.failure(oddLetters.count)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.filter { $0.isLetter }
        let oddLetters = letters.filter { $0.unicodeScalars.first!.value % 2 == 1 }
        return.failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.filter { $0.isLetter }
        let oddLetters = letters.filter { letter in
            let index = letter.unicodeScalars.first!.value - 96
            return index % 2 == 1
        }
        return.failure(oddLetters.count)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.filter { $0.isLetter }
        let oddLetters = letters.filter { letter in
            let index = letter.unicodeScalars.first!.value - 96
            return index % 2 == 1
        }
        return.failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let words = txt.components(separatedBy: ",")
        if words.count > 0 {
            return.success(words)
        } else {
            let count = txt.filter { $0.isLetter && CharacterSet.lowercaseLetters.contains($0) }.count
            let oddCount = count.filter { $0 % 2 == 1 }
            return.failure(oddCount)
        }
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let words = txt.components(separatedBy: ",")
        if words.count > 0 {
            return.success(words)
        } else {
            let count = txt.filter { $0.isLetter && CharacterSet.lowercaseLetters.contains($0) }.count
            let oddCount = count.filter { $0 % 2 == 1 }
            return.failure(oddCount)
        }
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return.success(words)
    } else {
        let letters = txt.filter { $0.isLetter }
        let lowerLetters = letters.filter { $0.lowercased() == $0 }
        let orderedLetters = lowerLetters.sorted { $0.unicodeScalars.first!.value < $1.unicodeScalars.first!.value }
        let orderedOddLetters = orderedLetters.enumerated().filter { $0.offset % 2 == 1 }
        return.failure(orderedOddLetters.count)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return.success(words)
    } else {
        let letters = txt.filter { $0.isLetter }
        let lowerLetters = letters.filter { $0.lowercased() == $0 }
        let orderedLetters = lowerLetters.sorted { $0.unicodeScalars.first!.value < $1.unicodeScalars.first!.value }
        let orderedOddLetters = orderedLetters.enumerated().filter { $0.offset % 2 == 1 }
        return.failure(orderedOddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.contains(where: " \n\t".contains)? txt.components(separatedBy: " \n\t") : txt.components(separatedBy: ",")
    guard!words.isEmpty else { return.failure(0) }
    return.success(words)
}

func countLowercaseOddOrder(txt: String) -> Result<Int, Int> {
    let lowercase = txt.filter { $0 >= "a" && $0 <= "z" }
    let order = lowercase.map { Int($0.unicodeScalars.first!.value)?? 0 }
    let oddOrder = order.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
    guard!oddOrder.isEmpty else { return.failure(0) }
    return.success(oddOrder.reduce(0, +))
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.contains(where: " \n\t".contains)? txt.components(separatedBy: " \n\t") : txt.components(separatedBy: ",")
    guard!words.isEmpty else { return.failure(0) }
    return.success(words)
}

func countLowercaseOddOrder(txt: String) -> Result<Int, Int> {
    let lowercase = txt.filter { $0 >= "a" && $0 <= "z" }
    let order = lowercase.map { Int($0.unicodeScalars.first!.value)?? 0 }
    let oddOrder = order.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
    guard!oddOrder.isEmpty else { return.failure(0) }
    return.success(oddOrder.reduce(0, +))
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    let words = txt.split(separator: ",")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    var count = 0
    for (index, _) in txt.enumerated() {
        if index % 2 == 0 {
            count += 1
        }
    }
    return.failure(count)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    let words = txt.split(separator: ",")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    var count = 0
    for (index, _) in txt.enumerated() {
        if index % 2 == 0 {
            count += 1
        }
    }
    return.failure(count)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    let words = txt.split(separator: ",")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    var count = 0
    for (index, _) in txt.enumerated() {
        if index % 2 == 0 {
            count += 1
        }
    }
    return.failure(count)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    let words = txt.split(separator: ",")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    var count = 0
    for (index, _) in txt.enumerated() {
        if index % 2 == 0 {
            count += 1
        }
    }
    return.failure(count)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    let words = txt.split(separator: ",")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    var count = 0
    for (index, _) in txt.enumerated() {
        if index % 2 == 0 {
            count += 1
        }
    }
    return.failure(count)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    let words = txt.split(separator: ",")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    var count = 0
    for (index, _) in txt.enumerated() {
        if index % 2 == 0 {
            count += 1
        }
    }
    return.failure(count)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(words)
    }
    let words = txt.split(separator: ",")
    if words.count > 1 {
        return.success(words)
    }
    var count = 0
    for (index, _) in txt.enumerated() {
        if index % 2 == 0 {
            count += 1
        }
    }
    return.failure(count)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(words)
    }
    let words = txt.split(separator: ",")
    if words.count > 1 {
        return.success(words)
    }
    var count = 0
    for (index, _) in txt.enumerated() {
        if index % 2 == 0 {
            count += 1
        }
    }
    return.failure(count)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    let words = txt.split(separator: ",")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    var count = 0
    for (idx, _) in txt.enumerated() {
        if idx % 2 == 0 {
            count += 1
        }
    }
    return.failure(count)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    let words = txt.split(separator: ",")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    var count = 0
    for (idx, _) in txt.enumerated() {
        if idx % 2 == 0 {
            count += 1
        }
    }
    return.failure(count)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    let words = txt.split(separator: ",")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    var count = 0
    for (index, _) in txt.enumerated() {
        if index % 2 == 0 {
            count += 1
        }
    }
    return.failure(count)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    let words = txt.split(separator: ",")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    var count = 0
    for (index, _) in txt.enumerated() {
        if index % 2 == 0 {
            count += 1
        }
    }
    return.failure(count)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return.success(Array(words))
    } else if let words = txt.split(separator: ",") {
        return.success(Array(words))
    } else {
        var count = 0
        for (index, _) in txt.enumerated() {
            if index % 2 == 0 {
                count += 1
            }
        }
        return.failure(count)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return.success(Array(words))
    } else if let words = txt.split(separator: ",") {
        return.success(Array(words))
    } else {
        var count = 0
        for (index, _) in txt.enumerated() {
            if index % 2 == 0 {
                count += 1
            }
        }
        return.failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(words)
    }
    let words = txt.split(separator: ",")
    if words.count > 1 {
        return.success(words)
    }
    var count = 0
    for (idx, _) in txt.enumerated() {
        if idx % 2 == 0 {
            count += 1
        }
    }
    return.failure(count)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(words)
    }
    let words = txt.split(separator: ",")
    if words.count > 1 {
        return.success(words)
    }
    var count = 0
    for (idx, _) in txt.enumerated() {
        if idx % 2 == 0 {
            count += 1
        }
    }
    return.failure(count)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    let words = txt.split(separator: ",")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    var count = 0
    for (index, _) in txt.enumerated() {
        if index % 2 == 0 {
            count += 1
        }
    }
    return.failure(count)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    let words = txt.split(separator: ",")
    if words.count > 1 {
        return.success(words.map(String.init))
    }
    var count = 0
    for (index, _) in txt.enumerated() {
        if index % 2 == 0 {
            count += 1
        }
    }
    return.failure(count)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return.success(Array(words))
    } else if let words = txt.split(separator: ",") {
        return.success(Array(words))
    } else {
        var count = 0
        for (index, _) in txt.enumerated() {
            if index % 2 == 0 {
                count += 1
            }
        }
        return.failure(count)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return.success(Array(words))
    } else if let words = txt.split(separator: ",") {
        return.success(Array(words))
    } else {
        var count = 0
        for (index, _) in txt.enumerated() {
            if index % 2 == 0 {
                count += 1
            }
        }
        return.failure(count)
    }
}
```

extension Int: Error {

}

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

extension Int: Error {}

/*
 Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
 should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
 alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
 Examples
 splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
 splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
 splitWords(txt: "abcdef") == .failure(3)
 */
func splitWords(txt: String) -> Result<[String], Int> {
    
    
    
    let

extension Int: Error {

}

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

extension Int: Error {}

/*
 Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
 should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
 alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
 Examples
 splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
 splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
 splitWords(txt: "abcdef") == .failure(3)
 */
func splitWords(txt: String) -> Result<[String], Int> {

extension Int: Error {

}

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

extension Int: Error {}

/*
 Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
 should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
 alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
 Examples
 splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
 splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
 splitWords(txt: "abcdef") == .failure(3)
 */
func splitWords(txt: String) -> Result<[String], Int> {

extension Int: Error {

}

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

extension Int: Error {}

/*
 Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
 should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
 alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
 Examples
 splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
 splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
 splitWords(txt: "abcdef") == .failure(3)
 */
func splitWords(txt: String) -> Result<[String], Int> {

extension Int: Error {

}

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

extension Int: Error {}

/*
 Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
 should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
 alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
 Examples
 splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
 splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
 splitWords(txt: "abcdef") == .failure(3)
 */
func splitWords(txt: String) -> Result<[String], Int> {
    
    let words = []
    for word in txt.components =

extension Int: Error {

}

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

extension Int: Error {}

/*
 Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
 should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
 alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
 Examples
 splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
 splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
 splitWords(txt: "abcdef") == .failure(3)
 */
func splitWords(txt: String) -> Result<[String], Int> {
    
    
    
    

extension Int: Error {

}

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

extension Int: Error {}

/*
 Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
 should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
 alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
 Examples
 splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
 splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
 splitWords(txt: "abcdef") == .failure(3)
 */
func splitWords(txt: String) -> Result<[String], Int> {
    

extension Int: Error {

}

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

extension Int: Error {}

/*
 Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
 should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
 alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
 Examples
 splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
 splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
 splitWords(txt: "abcdef") == .failure(3)
 */
func splitWords(txt: String) -> Result<[String], Int> {
    

extension Int: Error {

}

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

extension Int: Error {}

/*
 Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
 should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
 alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
 Examples
 splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
 splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
 splitWords(txt: "abcdef") == .failure(3)
 */
func splitWords(txt: String) -> Result<[String], Int> {

extension Int: Error {

}

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

extension Int: Error {}

/*
 Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
 should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
 alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
 Examples
 splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
 splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
 splitWords(txt: "abcdef") == .failure(3)
 */
func splitWords(txt: String) -> Result<[String], Int> {

extension Int: Error {

}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {





```

extension Int: Error {

}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {






```

extension Int: Error {

}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {

extension Int: Error {

}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {





```

extension Int: Error {

}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {







```

extension Int: Error {

}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {




```

extension Int: Error {

}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {





```

extension Int: Error {

}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {




```

extension Int: Error {

}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {



```

extension Int: Error {

}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {





```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.components(separatedBy: ",")
        guard commas.count > 0 else {
            let lowercaseOddOrder = txt.filter { $0.isLowercase && ($0 as UnicodeScalar).value % 2 == 1 }.count
            return .failure(lowercaseOddOrder)
        }
        return .failure(commas.count)
    }
    return .success(words)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.components(separatedBy: ",")
        guard commas.count > 0 else {
            let lowercaseOddOrder = txt.filter { $0.isLowercase && ($0 as UnicodeScalar).value % 2 == 1 }.count
            return .failure(lowercaseOddOrder)
        }
        return .failure(commas.count)
    }
    return .success(words)
}

print(splitWords(txt: "Hello world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "Hello,world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "abcdef")) // .failure(3)
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: CharacterSet.whitespacesAndNewlines)
    guard words.count > 0 else {
        let lowercaseOddOrders = txt.filter(.isLowercase).enumerated().compactMap { $0.offset % 2 == 1 }
        return .failure(lowercaseOddOrders.count)
    }
    return .success(words)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: CharacterSet.whitespacesAndNewlines)
    guard words.count > 0 else {
        let lowercaseOddOrders = txt.filter(.isLowercase).enumerated().compactMap { $0.offset % 2 == 1 }
        return .failure(lowercaseOddOrders.count)
    }
    return .success(words)
}

print(splitWords(txt: "Hello world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "Hello,world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "abcdef")) // .failure(3)
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.components(separatedBy: ",")
        guard commas.count > 0 else {
            let lowerCaseOddOrder = txt.filter { $0.isLowercase && ($0 as Int - 97) % 2 == 1 }.count
            return .failure(lowerCaseOddOrder)
        }
        return .failure(commas.count)
    }
    return .success(words)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.components(separatedBy: ",")
        guard commas.count > 0 else {
            let lowerCaseOddOrder = txt.filter { $0.isLowercase && ($0 as Int - 97) % 2 == 1 }.count
            return .failure(lowerCaseOddOrder)
        }
        return .failure(commas.count)
    }
    return .success(words)
}

print(splitWords(txt: "Hello world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "Hello,world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "abcdef")) // .failure(3)
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.components(separatedBy: ",")
        guard commas.count > 0 else {
            let lowercaseOddOrder = txt.filter { $0.isLowercase && ($0 as Int - 97) % 2 == 1 }.count
            return .failure(lowercaseOddOrder)
        }
        return .failure(commas.count)
    }
    return .success(words)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.components(separatedBy: ",")
        guard commas.count > 0 else {
            let lowercaseOddOrder = txt.filter { $0.isLowercase && ($0 as Int - 97) % 2 == 1 }.count
            return .failure(lowercaseOddOrder)
        }
        return .failure(commas.count)
    }
    return .success(words)
}

print(splitWords(txt: "Hello world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "Hello,world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "abcdef")) // .failure(3)
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.components(separatedBy: ",")
        guard commas.count > 0 else {
            let lowerCaseOddOrder = txt.filter { $0.isLowercase && ($0 as UnicodeScalar).value % 2 == 1 }.count
            return .failure(lowerCaseOddOrder)
        }
    }
    return .success(words)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.components(separatedBy: ",")
        guard commas.count > 0 else {
            let lowerCaseOddOrder = txt.filter { $0.isLowercase && ($0 as UnicodeScalar).value % 2 == 1 }.count
            return .failure(lowerCaseOddOrder)
        }
    }
    return .success(words)
}

print(splitWords(txt: "Hello world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "Hello,world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "abcdef")) // .failure(3)
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.filter({ $0 == "," })
        guard commas.count > 0 else {
            let lowercase = txt.filter({ $0.isLowercase })
            guard lowercase.count > 0 else {
                return .failure(0)
            }
            let oddOrder = lowercase.filter({
                let index = lowercase.index(lowercase.startIndex, offsetBy: $0.asciiValue - 97)
                let previous = lowercase.index(lowercase.startIndex, offsetBy: index.previous?.asciiValue ?? 0)
                let next = lowercase.index(lowercase.startIndex, offsetBy: index.offset(by: 1, from: index, wrapping: true))
                let previousValue = CharacterSet.lowercaseLetters.index(previous, offsetBy: 1)
                let nextValue = CharacterSet.lowercaseLetters.index(next, offsetBy: 1)
                let previousIsOdd = previousValue % 2 != 0
                let nextIsOdd = nextValue % 2 != 0
                return previousIsOdd && nextIsOdd
            })
            return .failure(oddOrder.count)
        }
        return .failure(words.count)
    }
    return .success(words)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.filter({ $0 == "," })
        guard commas.count > 0 else {
            let lowercase = txt.filter({ $0.isLowercase })
            guard lowercase.count > 0 else {
                return .failure(0)
            }
            let oddOrder = lowercase.filter({
                let index = lowercase.index(lowercase.startIndex, offsetBy: $0.asciiValue - 97)
                let previous = lowercase.index(lowercase.startIndex, offsetBy: index.previous?.asciiValue ?? 0)
                let next = lowercase.index(lowercase.startIndex, offsetBy: index.offset(by: 1, from: index, wrapping: true))
                let previousValue = CharacterSet.lowercaseLetters.index(previous, offsetBy: 1)
                let nextValue = CharacterSet.lowercaseLetters.index(next, offsetBy: 1)
                let previousIsOdd = previousValue % 2 != 0
                let nextIsOdd = nextValue % 2 != 0
                return previousIsOdd && nextIsOdd
            })
            return .failure(oddOrder.count)
        }
        return .failure(words.count)
    }
    return .success(words)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.components(separatedBy: ",")
        guard commas.count > 0 else {
            let lowercaseOddOrders = txt.filter { $0.isLowercase && ($0 as UnicodeScalar).value % 2 == 1 }.count
            return .failure(lowercaseOddOrders)
        }
        return .failure(commas.count)
    }
    return .success(words)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.components(separatedBy: ",")
        guard commas.count > 0 else {
            let lowercaseOddOrders = txt.filter { $0.isLowercase && ($0 as UnicodeScalar).value % 2 == 1 }.count
            return .failure(lowercaseOddOrders)
        }
        return .failure(commas.count)
    }
    return .success(words)
}

print(splitWords(txt: "Hello world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "Hello,world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "abcdef")) // .failure(3)
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.filter { $0 == "," }
        guard commas.count > 0 else {
            let lowercaseOdd = txt.filter { $0.isLowercase && Int($0) % 2 == 1 }
            guard let count = lowercaseOdd.count else { return .failure(0) }
            return .failure(count)
        }
        return .success(words)
    }
    return .success(words)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.filter { $0 == "," }
        guard commas.count > 0 else {
            let lowercaseOdd = txt.filter { $0.isLowercase && Int($0) % 2 == 1 }
            guard let count = lowercaseOdd.count else { return .failure(0) }
            return .failure(count)
        }
        return .success(words)
    }
    return .success(words)
}

print(splitWords(txt: "Hello world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "Hello,world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "abcdef")) // .failure(3)
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.components(separatedBy: ",")
        guard commas.count > 0 else {
            let lowerCaseOddOrder = txt.filter { $0.isLowercase && $0.asciiValue % 2 == 1 }.count
            return .failure(lowerCaseOddOrder)
        }
        return .failure(commas.count)
    }
    return .success(words)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.components(separatedBy: ",")
        guard commas.count > 0 else {
            let lowerCaseOddOrder = txt.filter { $0.isLowercase && $0.asciiValue % 2 == 1 }.count
            return .failure(lowerCaseOddOrder)
        }
        return .failure(commas.count)
    }
    return .success(words)
}

print(splitWords(txt: "Hello world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "Hello,world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "abcdef")) // .failure(3)
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.components(separatedBy: ",")
        guard commas.count > 0 else {
            let lowerCaseOddOrders = txt.filter { $0.isLowercase && (Int($0.asciiValue!) - Int(txt.startIndex.asciiValue!) % 2 == 1) }.count
            return .failure(lowerCaseOddOrders)
        }
    }
    return .success(words)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    guard words.count > 0 else {
        let commas = txt.components(separatedBy: ",")
        guard commas.count > 0 else {
            let lowerCaseOddOrders = txt.filter { $0.isLowercase && (Int($0.asciiValue!) - Int(txt.startIndex.asciiValue!) % 2 == 1) }.count
            return .failure(lowerCaseOddOrders)
        }
    }
    return .success(words)
}

print(splitWords(txt: "Hello world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "Hello,world!")) // .success(["Hello", "world!"])
print(splitWords(txt: "abcdef")) // .failure(3)
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
        return .failure(oddCount)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
        return .failure(oddCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
        return .failure(oddCount)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
        return .failure(oddCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
        return .failure(oddCount)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
        return .failure(oddCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
        return .failure(oddCount)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
        return .failure(oddCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
        return .failure(oddCount)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
        return .failure(oddCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
        return .failure(oddCount)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
        return .failure(oddCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
        return .failure(oddCount)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
        return .failure(oddCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0, { $0 + ($1.asciiValue! - 97) % 2 })
        return .failure(oddCount)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0, { $0 + ($1.asciiValue! - 97) % 2 })
        return .failure(oddCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0, { $0 + ($1.asciiValue! - 97) % 2 })
        return .failure(oddCount)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.filter { $0.isLetter }.lowercased()
        let oddCount = lowercase.reduce(0, { $0 + ($1.asciiValue! - 97) % 2 })
        return .failure(oddCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.lowercase()
        let oddCount = lowercase.filter { "abcdefghijklmnopqrstuvwxyz".contains($0) }
            .reduce(0) { $0 + ($1.asciiValue! - 97) % 2 == 1 ? 1 : 0 }
        return .failure(oddCount)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(where: { $0.isWhitespace }) {
        return .success(txt.components(separatedBy: .whitespaces).map { String($0) })
    } else if txt.contains(where: { $0 == ',' }) {
        return .success(txt.components(separatedBy: ",").map { String($0) })
    } else {
        let lowercase = txt.lowercase()
        let oddCount = lowercase.filter { "abcdefghijklmnopqrstuvwxyz".contains($0) }
            .reduce(0) { $0 + ($1.asciiValue! - 97) % 2 == 1 ? 1 : 0 }
        return .failure(oddCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").filter { !$0.isEmpty } {
        return .success(words)
    } else if let words = txt.split(separator: ",").filter { !$0.isEmpty } {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter { $0.isASCII && $0.isLowercase }
        let oddLowerCaseLetters = lowerCaseLetters.filter { ($0.asciiValue ?? 0) % 2 != 0 }
        return .failure(oddLowerCaseLetters.count)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").filter { !$0.isEmpty } {
        return .success(words)
    } else if let words = txt.split(separator: ",").filter { !$0.isEmpty } {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter { $0.isASCII && $0.isLowercase }
        let oddLowerCaseLetters = lowerCaseLetters.filter { ($0.asciiValue ?? 0) % 2 != 0 }
        return .failure(oddLowerCaseLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").filter({ !$0.isEmpty }), words.count > 1 {
        return .success(words)
    } else if let words = txt.split(separator: ",").filter({ !$0.isEmpty }), words.count > 1 {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter({ $0.isASCII && $0.isLowercase })
        let oddLowerCaseLetters = lowerCaseLetters.filter({ ($0.asciiValue ?? 0) % 2 == 1 })
        return .failure(oddLowerCaseLetters.count)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").filter({ !$0.isEmpty }), words.count > 1 {
        return .success(words)
    } else if let words = txt.split(separator: ",").filter({ !$0.isEmpty }), words.count > 1 {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter({ $0.isASCII && $0.isLowercase })
        let oddLowerCaseLetters = lowerCaseLetters.filter({ ($0.asciiValue ?? 0) % 2 == 1 })
        return .failure(oddLowerCaseLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter { $0.isASCII && $0.isLowercase }
        let oddLowerCaseLetters = lowerCaseLetters.filter { ($0.asciiValue ?? 0) % 2 == 1 }
        return .failure(oddLowerCaseLetters.count)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter { $0.isASCII && $0.isLowercase }
        let oddLowerCaseLetters = lowerCaseLetters.filter { ($0.asciiValue ?? 0) % 2 == 1 }
        return .failure(oddLowerCaseLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").filter({ !$0.isEmpty }), words.count > 1 {
        return .success(words)
    } else if let words = txt.split(separator: ",").filter({ !$0.isEmpty }), words.count > 1 {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter({ $0.isLowercase })
        let oddLowerCaseLetters = lowerCaseLetters.filter({ (Int(String($0.unicodeScalars.first!.value).lowercased() ?? "") ?? 0) % 2 != 0 })
        return .failure(oddLowerCaseLetters.count)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").filter({ !$0.isEmpty }), words.count > 1 {
        return .success(words)
    } else if let words = txt.split(separator: ",").filter({ !$0.isEmpty }), words.count > 1 {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter({ $0.isLowercase })
        let oddLowerCaseLetters = lowerCaseLetters.filter({ (Int(String($0.unicodeScalars.first!.value).lowercased() ?? "") ?? 0) % 2 != 0 })
        return .failure(oddLowerCaseLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter { $0.isASCII && $0.isLowercase }
        let oddCount = lowerCaseLetters.filter { ($0.asciiValue ?? 0) % 2 == 1 }.count
        return .failure(oddCount)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter { $0.isASCII && $0.isLowercase }
        let oddCount = lowerCaseLetters.filter { ($0.asciiValue ?? 0) % 2 == 1 }.count
        return .failure(oddCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter { $0.isASCII && $0.isLowercase }
        let oddCount = lowerCaseLetters.filter { ($0.asciiValue ?? 0) % 2 == 1 }.count
        return .failure(oddCount)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter { $0.isASCII && $0.isLowercase }
        let oddCount = lowerCaseLetters.filter { ($0.asciiValue ?? 0) % 2 == 1 }.count
        return .failure(oddCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").filter({ !$0.isEmpty }), words.count > 1 {
        return .success(words)
    } else if let words = txt.split(separator: ",").filter({ !$0.isEmpty }), words.count > 1 {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter({ $0.isASCII && $0.isLowercase })
        let oddCount = lowerCaseLetters.filter({ Int(String($0.asciiValue!).unicodeScalars.first!.value!) % 2 != 0 }).count
        return .failure(oddCount)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").filter({ !$0.isEmpty }), words.count > 1 {
        return .success(words)
    } else if let words = txt.split(separator: ",").filter({ !$0.isEmpty }), words.count > 1 {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter({ $0.isASCII && $0.isLowercase })
        let oddCount = lowerCaseLetters.filter({ Int(String($0.asciiValue!).unicodeScalars.first!.value!) % 2 != 0 }).count
        return .failure(oddCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter { $0.isASCII && $0.isLowercase }
        let oddLetters = lowerCaseLetters.filter { ($0.asciiValue ?? 0) % 2 == 1 }
        return .failure(oddLetters.count)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter { $0.isASCII && $0.isLowercase }
        let oddLetters = lowerCaseLetters.filter { ($0.asciiValue ?? 0) % 2 == 1 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").filter({ !$0.isEmpty }), words.count > 1 {
        return .success(words)
    } else if let words = txt.split(separator: ",").filter({ !$0.isEmpty }), words.count > 1 {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter({ $0.isASCII && $0.isLowercase })
        let oddCount = lowerCaseLetters.filter({ Int(String($0.asciiValue!).unicodeScalars.first!.value!) % 2 != 0 }).count
        return .failure(oddCount)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").filter({ !$0.isEmpty }), words.count > 1 {
        return .success(words)
    } else if let words = txt.split(separator: ",").filter({ !$0.isEmpty }), words.count > 1 {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.filter({ $0.isASCII && $0.isLowercase })
        let oddCount = lowerCaseLetters.filter({ Int(String($0.asciiValue!).unicodeScalars.first!.value!) % 2 != 0 }).count
        return .failure(oddCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").filter({ !$0.isEmpty }).joined(separator: " ") {
        return .success(words.components(separatedBy: " "))
    } else if let words = txt.split(separator: ",").filter({ !$0.isEmpty }).joined(separator: ",") {
        return .success(words.components(separatedBy: ","))
    } else {
        let lowerCaseLetters = txt.filter({ $0.isASCII && $0.isLowercase })
        let oddCount = lowerCaseLetters.filter({ Int(String($0.asciiValue!).unicodeScalars.first!.value!) % 2 != 0 }).count
        return .failure(oddCount)
    }
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").filter({ !$0.isEmpty }).joined(separator: " ") {
        return .success(words.components(separatedBy: " "))
    } else if let words = txt.split(separator: ",").filter({ !$0.isEmpty }).joined(separator: ",") {
        return .success(words.components(separatedBy: ","))
    } else {
        let lowerCaseLetters = txt.filter({ $0.isASCII && $0.isLowercase })
        let oddCount = lowerCaseLetters.filter({ Int(String($0.asciiValue!).unicodeScalars.first!.value!) % 2 != 0 }).count
        return .failure(oddCount)
    }
}
```

extension Int: Error {

}

import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ").filter({ !$0.isEmpty }) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",").filter({ !$0.isEmpty }) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ").filter({ !$0.isEmpty }) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",").filter({ !$0.isEmpty }) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ").filter({ !$0.isEmpty }) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",").filter({ !$0.isEmpty }) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ").filter({ !$0.isEmpty }) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",").filter({ !$0.isEmpty }) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ").filter({ !$0.isEmpty }) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",").filter({ !$0.isEmpty }) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ").filter({ !$0.isEmpty }) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",").filter({ !$0.isEmpty }) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ").filter({ !$0.isEmpty }) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",").filter({ !$0.isEmpty }) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ").filter({ !$0.isEmpty }) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",").filter({ !$0.isEmpty }) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ").filter({ !$0.isEmpty }) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",").filter({ !$0.isEmpty }) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ").filter({ !$0.isEmpty }) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",").filter({ !$0.isEmpty }) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ").filter({ !$0.isEmpty }) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",").filter({ !$0.isEmpty }) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ").filter({ !$0.isEmpty }) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",").filter({ !$0.isEmpty }) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ").filter({ !$0.isEmpty }) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",").filter({ !$0.isEmpty }) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ").filter({ !$0.isEmpty }) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",").filter({ !$0.isEmpty }) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ").filter({ !$0.isEmpty }) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",").filter({ !$0.isEmpty }) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.components(separatedBy: " ").filter({ !$0.isEmpty }) {
        return .success(words)
    } else if let words = txt.components(separatedBy: ",").filter({ !$0.isEmpty }) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
import Foundation

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.components(separatedBy: " "))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.components(separatedBy: " "))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.components(separatedBy: " "))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.components(separatedBy: " "))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.components(separatedBy: " "))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.components(separatedBy: " "))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let count = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }.count
        return count > 0 ? .failure(count) : .failure(0)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let count = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }.count
        return count > 0 ? .failure(count) : .failure(0)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words.map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words.map(String.init))
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words.map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words.map(String.init))
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words.map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words.map(String.init))
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words.map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words.map(String.init))
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.components(separatedBy: " "))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.components(separatedBy: " "))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words.map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words.map(String.init))
    } else {
        let oddLetterCount = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }.count
        return .failure(oddLetterCount)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words.map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words.map(String.init))
    } else {
        let oddLetterCount = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }.count
        return .failure(oddLetterCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.components(separatedBy: " "))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.components(separatedBy: " "))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let count = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }.count
        return count > 0 ? .failure(count) : .failure(0)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let count = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }.count
        return count > 0 ? .failure(count) : .failure(0)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.components(separatedBy: " "))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.components(separatedBy: " "))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words.map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words.map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(lowercaseLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words.map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words.map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(lowercaseLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words.map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words.map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(lowercaseLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words.map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words.map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(lowercaseLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words.map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words.map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddOrderLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words.map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words.map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 != 0 }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words.map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words.map(String.init))
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words.map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words.map(String.init))
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let oddLetters = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let count = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }.count
        return count > 0 ? .failure(count) : .failure(0)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let count = txt.filter { $0.isLowercase && Int($0.asciiValue! - 97) % 2 == 1 }.count
        return count > 0 ? .failure(count) : .failure(0)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words.map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words.map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words.map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words.map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.filter { Int($0.asciiValue! - 97) % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.isEmpty {
        let letters = txt.components(separatedBy: ",")
        if letters.isEmpty {
            let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
            return .failure(count)
        } else {
            return .success(letters)
        }
    } else {
        return .success(words)
    }
}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.isEmpty {
        let letters = txt.components(separatedBy: ",")
        if letters.isEmpty {
            let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
            return .failure(count)
        } else {
            return .success(letters)
        }
    } else {
        return .success(words)
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.isEmpty {
        let letters = txt.components(separatedBy: ",")
        if letters.isEmpty {
            let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
            return .failure(count)
        } else {
            return .success(letters)
        }
    } else {
        return .success(words)
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.isEmpty {
        let letters = txt.components(separatedBy: ",")
        if letters.isEmpty {
            let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
            return .failure(count)
        } else {
            return .success(letters)
        }
    } else {
        return .success(words)
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.isEmpty {
        let letters = txt.components(separatedBy: ",")
        if letters.isEmpty {
            let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
            return .failure(count)
        } else {
            return .success(letters)
        }
    } else {
        return .success(words)
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.isEmpty {
        let letters = txt.components(separatedBy: ",")
        if letters.isEmpty {
            let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
            return .failure(count)
        } else {
            return .success(letters)
        }
    } else {
        return .success(words)
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.isEmpty {
        let lowerCaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowerCaseLetters.filter { $0.asciiValue! % 2 == 1 }
        return .failure(oddOrderLetters.count)
    } else {
        return .success(words)
    }
}

func mostVowels(words: [String]) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var maxVowels = 0
    var maxVowelWord = ""
    for word in words {
        var vowelsCount = 0
        for char in word {
            if vowels.contains(String(char)) {
                vowelsCount += 1
            }
        }
        if vowelsCount > maxVowels {
            maxVowels = vowelsCount
            maxVowelWord = word
        }
    }
    return maxVowelWord
}

func mostConsonants(words: [String]) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var maxConsonants = 0
    var maxConsonantWord = ""
    for word in words {
        var consonantsCount = 0
        for char in word {
            if !vowels.contains(String(char)) {
                consonantsCount += 1
            }
        }
        if consonantsCount > maxConsonants {
            maxConsonants = consonantsCount
            maxConsonantWord = word
        }
    }
    return maxConsonantWord
}

func mostVowelsAndConsonants(words: [String]) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var maxVowels = 0
    var maxConsonants = 0
    var maxVowelWord = ""
    var maxConsonantWord = ""
    for word in words {
        var vowelsCount = 0
        var consonantsCount = 0
        for char in word {
            if vowels.contains(String(char)) {
                vowelsCount += 1
            } else {
                consonantsCount += 1
            }
        }
        if vowelsCount > maxVowels {
            maxVowels = vowelsCount
            maxVowelWord = word
        }
        if consonantsCount > maxConsonants {
            maxConsonants = consonantsCount
            maxConsonantWord = word
        }
    }
    return maxVowelWord + maxConsonantWord
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.isEmpty {
        let lowerCaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowerCaseLetters.filter { $0.asciiValue! % 2 == 1 }
        return .failure(oddOrderLetters.count)
    } else {
        return .success(words)
    }
}

// Given a list of words, return the word with the most vowels
// Examples
// mostVowels(words: ["apple", "banana", "orange"]) == "banana"
// mostVowels(words: ["apple", "banana", "orange", "pear"]) == "banana"
func mostVowels(words: [String]) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var maxVowels = 0
    var maxVowelWord = ""
    for word in words {
        var vowelsCount = 0
        for char in word {
            if vowels.contains(String(char)) {
                vowelsCount += 1
            }
        }
        if vowelsCount > maxVowels {
            maxVowels = vowelsCount
            maxVowelWord = word
        }
    }
    return maxVowelWord
}

// Given a list of words, return the word with the most consonants
// Examples
// mostConsonants(words: ["apple", "banana", "orange"]) == "apple"
// mostConsonants(words: ["apple", "banana", "orange", "pear"]) == "apple"
func mostConsonants(words: [String]) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var maxConsonants = 0
    var maxConsonantWord = ""
    for word in words {
        var consonantsCount = 0
        for char in word {
            if !vowels.contains(String(char)) {
                consonantsCount += 1
            }
        }
        if consonantsCount > maxConsonants {
            maxConsonants = consonantsCount
            maxConsonantWord = word
        }
    }
    return maxConsonantWord
}

// Given a list of words, return the word with the most vowels and consonants
// Examples
// mostVowelsAndConsonants(words: ["apple", "banana", "orange"]) == "banana"
// mostVowelsAndConsonants(words: ["apple", "banana", "orange", "pear"]) == "banana"
func mostVowelsAndConsonants(words: [String]) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var maxVowels = 0
    var maxConsonants = 0
    var maxVowelWord = ""
    var maxConsonantWord = ""
    for word in words {
        var vowelsCount = 0
        var consonantsCount = 0
        for char in word {
            if vowels.contains(String(char)) {
                vowelsCount += 1
            } else {
                consonantsCount += 1
            }
        }
        if vowelsCount > maxVowels {
            maxVowels = vowelsCount
            maxVowelWord = word
        }
        if consonantsCount > maxConsonants {
            maxConsonants = consonantsCount
            maxConsonantWord = word
        }
    }
    return maxVowelWord + maxConsonantWord
}

// Given a list of words, return the word with the most vowels and consonants
// Examples
// mostVowelsAndConsonants(words: ["apple", "banana", "orange"]) == "banana"
// mostVowelsAndConsonants(words: ["apple", "banana", "orange", "pear"]) == "banana"
func mostVowelsAndConsonants(words: [String]) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var maxVowels = 0
    var maxConsonants = 0
    var maxVowelWord = ""
    var maxConsonantWord = ""
    for word in words {
        var vowelsCount = 0
        var consonantsCount = 0
        for char in word {
            if vowels.contains(String(char)) {
                vowelsCount += 1
            } else {
                consonantsCount += 1
            }
        

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map { String($0) })
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map { String($0) })
    } else {
        let lowerCaseLetters = txt.lowercased()
        let oddOrderLetters = lowerCaseLetters.filter { $0.asciiValue! % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map { String($0) })
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map { String($0) })
    } else {
        let lowerCaseLetters = txt.lowercased()
        let oddOrderLetters = lowerCaseLetters.filter { $0.asciiValue! % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map { String($0) })
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map { String($0) })
    } else {
        let lowerCaseLetters = txt.lowercased()
        let oddOrderLetters = lowerCaseLetters.filter { $0.asciiValue! % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map { String($0) })
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map { String($0) })
    } else {
        let lowerCaseLetters = txt.lowercased()
        let oddOrderLetters = lowerCaseLetters.filter { $0.asciiValue! % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map { String($0) })
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map { String($0) })
    } else {
        let lowerCaseLetters = txt.lowercased()
        let oddOrderLetters = lowerCaseLetters.filter { $0.asciiValue! % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map { String($0) })
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map { String($0) })
    } else {
        let lowerCaseLetters = txt.lowercased()
        let oddOrderLetters = lowerCaseLetters.filter { $0.asciiValue! % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a')

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 0 {
        return .success(words.map { String($0) })
    }
    let commas = txt.split(separator: ",")
    if commas.count > 0 {
        return .success(commas.map { String($0) })
    }
    let letters = txt.filter { $0.isLowercase }
    let count = letters.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
    return .failure(count)
}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 0 {
        return .success(words.map { String($0) })
    }
    let commas = txt.split(separator: ",")
    if commas.count > 0 {
        return .success(commas.map { String($0) })
    }
    let letters = txt.filter { $0.isLowercase }
    let count = letters.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
    return .failure(count)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 0 {
        return .success(words.map { String($0) })
    }
    let commas = txt.split(separator: ",")
    if commas.count > 0 {
        return .success(commas.map { String($0) })
    }
    let letters = txt.filter { $0.isLowercase }
    let count = letters.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
    return .failure(count)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 0 {
        return .success(words.map { String($0) })
    }
    let commas = txt.split(separator: ",")
    if commas.count > 0 {
        return .success(commas.map { String($0) })
    }
    let letters = txt.filter { $0.isLowercase }
    let count = letters.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
    return .failure(count)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 0 {
        return .success(words.map { String($0) })
    }
    let commas = txt.split(separator: ",")
    if commas.count > 0 {
        return .success(commas.map { String($0) })
    }
    let letters = txt.filter { $0.isLowercase }
    let count = letters.reduce(0) { $0 + ($1.asciiValue! - 97) % 2 }
    return .failure(count)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 0 {
        return .success(words.map { String($0) })
    }
    let commas = txt.split(separator: ",")
    if commas.count > 0 {
        return .success(commas.map { String($0) })
    }
    let letters = txt.filter { $0.isLowercase }
    let count = letters.reduce(0) { $0 + ($1.asciiValue! - 97) % 

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map { String($0) })
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map { String($0) })
    } else {
        let count = txt.reduce(0) { partialResult, char in
            let char = char.lowercased()
            if char.isLetter && char.unicodeScalars.first!.value % 2 == 1 {
                return partialResult + 1
            }
            return partialResult
        }
        return .failure(count)
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map { String($0) })
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map { String($0) })
    } else {
        let count = txt.reduce(0) { partialResult, char in
            let char = char.lowercased()
            if char.isLetter && char.unicodeScalars.first!.value % 2 == 1 {
                return partialResult + 1
            }
            return partialResult
        }
        return .failure(count)
    }
}

print(splitWords(txt: "Hello world!"))
print(splitWords(txt: "Hello,world!"))
print(splitWords(txt: "abcdef"))
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.isEmpty {
        let chars = txt.components(separatedBy: ",")
        if chars.isEmpty {
            let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
            return .failure(count)
        } else {
            return .success(chars)
        }
    } else {
        return .success(words)
    }
}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.isEmpty {
        let chars = txt.components(separatedBy: ",")
        if chars.isEmpty {
            let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
            return .failure(count)
        } else {
            return .success(chars)
        }
    } else {
        return .success(words)
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.isEmpty {
        let chars = txt.components(separatedBy: ",")
        if chars.isEmpty {
            let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
            return .failure(count)
        } else {
            return .success(chars)
        }
    } else {
        return .success(words)
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.isEmpty {
        let chars = txt.components(separatedBy: ",")
        if chars.isEmpty {
            let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
            return .failure(count)
        } else {
            return .success(chars)
        }
    } else {
        return .success(words)
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.isEmpty {
        let chars = txt.components(separatedBy: ",")
        if chars.isEmpty {
            let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
            return .failure(count)
        } else {
            return .success(chars)
        }
    } else {
        return .success(words)
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.isEmpty {
        let chars = txt.components(separatedBy: ",")
        if chars.isEmpty {
            let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
            return .failure(count)
        } else {
            return .success(chars)
        }
    } else {
        return .success(words)
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return .success(words)
    }
    let words2 = txt.components(separatedBy: ",")
    if words2.count > 1 {
        return .success(words2)
    }
    var count = 0
    for char in txt {
        if char.isLowercase {
            let index = char.asciiValue! - 97
            if index % 2 == 1 {
                count += 1
            }
        }
    }
    return .failure(count)
}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return .success(words)
    }
    let words2 = txt.components(separatedBy: ",")
    if words2.count > 1 {
        return .success(words2)
    }
    var count = 0
    for char in txt {
        if char.isLowercase {
            let index = char.asciiValue! - 97
            if index % 2 == 1 {
                count += 1
            }
        }
    }
    return .failure(count)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return .success(words)
    }
    let words2 = txt.components(separatedBy: ",")
    if words2.count > 1 {
        return .success(words2)
    }
    var count = 0
    for char in txt {
        if char.isLowercase {
            let index = char.asciiValue! - 97
            if index % 2 == 1 {
                count += 1
            }
        }
    }
    return .failure(count)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return .success(words)
    }
    let words2 = txt.components(separatedBy: ",")
    if words2.count > 1 {
        return .success(words2)
    }
    var count = 0
    for char in txt {
        if char.isLowercase {
            let index = char.asciiValue! - 97
            if index % 2 == 1 {
                count += 1
            }
        }
    }
    return .failure(count)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return .success(words)
    }
    let words2 = txt.components(separatedBy: ",")
    if words2.count > 1 {
        return .success(words2)
    }
    var count = 0
    for char in txt {
        if char.isLowercase {
            let index = char.asciiValue! - 97
            if index % 2 == 1 {
                count += 1
            }
        }
    }
    return .failure(count)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 1 {
        return .success(words)
    }
    let words2 = txt.components(separatedBy: ",")
    if words2.count > 1 {
        return .success(words2)
    }
    var count = 0
    for char in txt {
        if char.isLowercase {
            let index = char.asciiValue!

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let words2 = txt.split(separator: ",")
    let words3 = txt.split(separator: "")
    
    if words.count > 0 {
        return .success(words.map { String($0) })
    } else if words2.count > 0 {
        return .success(words2.map { String($0) })
    } else {
        let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
        return .failure(count)
    }
}

func splitWords2(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let words2 = txt.split(separator: ",")
    
    if words.count > 0 {
        return .success(words.map { String($0) })
    } else if words2.count > 0 {
        return .success(words2.map { String($0) })
    } else {
        let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
        return .failure(count)
    }
}

func splitWords3(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let words2 = txt.split(separator: ",")
    
    if words.count > 0 {
        return .success(words.map { String($0) })
    } else if words2.count > 0 {
        return .success(words2.map { String($0) })
    } else {
        let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
        return .failure(count)
    }
}

func splitWords4(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let words2 = txt.split(separator: ",")
    
    if words.count > 0 {
        return .success(words.map { String($0) })
    } else if words2.count > 0 {
        return .success(words2.map { String($0) })
    } else {
        let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
        return .failure(count)
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let words2 = txt.split(separator: ",")
    let words3 = txt.split(separator: "")
    
    if words.count > 0 {
        return .success(words.map { String($0) })
    } else if words2.count > 0 {
        return .success(words2.map { String($0) })
    } else {
        let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
        return .failure(count)
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords2(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let words2 = txt.split(separator: ",")
    
    if words.count > 0 {
        return .success(words.map { String($0) })
    } else if words2.count > 0 {
        return .success(words2.map { String($0) })
    } else {
        let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
        return .failure(count)
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords3(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let words2 = txt.split(separator: ",")
    
    if words.count > 0 {
        return .success(words.map { String($0) })
    } else if words2.count > 0 {
        return .success(words2.map { String($0) })
    } else {
        let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
        return .failure(count)
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords4(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let words2 = txt.split(separator: ",")
    
    if words.count > 0 {
        return .success(words.map { String($0) })
    } else if words2.count > 0 {
        return .success(words2.map { String($0) })
    } else {
        let count = txt.filter { $0.isLowercase && $0.asciiValue! % 2 == 1 }.count
        return .failure(count)
    }
}

// Given a

extension Int: Error {

}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let words2 = txt.split(separator: ",")
    let words3 = txt.split(separator: "a")
    let words4 = txt.split(separator: "b")
    let words5 = txt.split(separator: "c")
    let words6 = txt.split(separator: "d")
    let words7 = txt.split(separator: "e")
    let words8 = txt.split(separator: "f")
    let words9 = txt.split(separator: "g")
    let words10 = txt.split(separator: "h")
    let words11 = txt.split(separator: "i")
    let words12 = txt.split(separator: "j")
    let words13 = txt.split(separator: "k")
    let words14 = txt.split(separator: "l")
    let words15 = txt.split(separator: "m")
    let words16 = txt.split(separator: "n")
    let words17 = txt.split(separator: "o")
    let words18 = txt.split(separator: "p")
    let words19 = txt.split(separator: "q")
    let words20 = txt.split(separator: "r")
    let words21 = txt.split(separator: "s")
    let words22 = txt.split(separator: "t")
    let words23 = txt.split(separator: "u")
    let words24 = txt.split(separator: "v")
    let words25 = txt.split(separator: "w")
    let words26 = txt.split(separator: "x")
    let words27 = txt.split(separator: "y")
    let words28 = txt.split(separator: "z")
    
    if words.count > 0 {
        return .success(words)
    } else if words2.count > 0 {
        return .success(words2)
    } else if words3.count > 0 {
        return .success(words3)
    } else if words4.count > 0 {
        return .success(words4)
    } else if words5.count > 0 {
        return .success(words5)
    } else if words6.count > 0 {
        return .success(words6)
    } else if words7.count > 0 {
        return .success(words7)
    } else if words8.count > 0 {
        return .success(words8)
    } else if words9.count > 0 {
        return .success(words9)
    } else if words10.count > 0 {
        return .success(words10)
    } else if words11.count > 0 {
        return .success(words11)
    } else if words12.count > 0 {
        return .success(words12)
    } else if words13.count > 0 {
        return .success(words13)
    } else if words14.count > 0 {
        return .success(words14)
    } else if words15.count > 0 {
        return .success(words15)
    } else if words16.count > 0 {
        return .success(words16)
    } else if words17.count > 0 {
        return .success(words17)
    } else if words18.count > 0 {
        return .success(words18)
    } else if words19.count > 0 {
        return .success(words19)
    } else if words20.count > 0 {
        return .success(words20)
    } else if words21.count > 0 {
        return .success(words21)
    } else if words22.count > 0 {
        return .success(words22)
    } else if words23.count > 0 {
        return .success(words23)
    } else if words24.count > 0 {
        return .success(words24)
    } else if words25.count > 0 {
        return .success(words25)
    } else if words26

extension Int: Error {

}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let words2 = txt.split(separator: ",")
    let words3 = txt.lowercased().filter { $0.isLetter }
    let words4 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words5 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words6 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words7 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words8 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words9 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words10 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words11 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words12 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words13 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words14 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words15 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words16 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words17 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words18 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words19 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words20 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words21 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words22 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words23 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words24 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words25 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words26 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words27 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words28 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words29 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words30 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words31 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words32 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words33 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words34 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words35 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words36 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words37 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words38 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words39 = txt.lowercased().filter { $0.isLetter }.map { String($0) }
    let words40 = txt.lowercased().

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement me!
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement me!
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement me!
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement me!
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement me
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // TODO: implement me
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    //...
}

func splitWords(txt: String) -> Result<[String], Int> {
    //...
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    //...
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    //...
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    //...
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    //...
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    //...
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    //...
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    //...
}

func splitWords(txt: String) -> Result<[String], Int> {
    //...
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    //...
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    //...
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy:.whitespacesAndNewlines))
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy:.whitespacesAndNewlines))
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy:.whitespacesAndNewlines))
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy:.whitespacesAndNewlines))
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy:.whitespacesAndNewlines))
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy:.whitespacesAndNewlines))
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy:.whitespacesAndNewlines))
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy:.whitespacesAndNewlines))
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    //...
}

func splitWords(txt: String) -> Result<[String], Int> {
    //...
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    //...
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    //...
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy: ",").map { String($0) })
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.split(separator: " ").map { String($0) })
}

// Given a string of words, return an array of words split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy: ",").map { String($0) })
}

// Given a string of words, return an array of words split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy: ",").map { String($0) })
}

// Given a string of words, return an array of words split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    return.success(txt.components(separatedBy: ",").map { String($0) })
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    return.success(words.map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    return.success(words.map { String($0) })
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    return.success(words.map { String($0) })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    return.success(words.map { String($0) })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
// splitWords(txt: "abcdef") ==.failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    return.success(words.map { String($0) })
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowercaseTxt = txt.lowercased()
    
    if lowercaseTxt.contains(" ") {
        return.success(lowercaseTxt.components(separatedBy: " "))
    } else if lowercaseTxt.contains(",") {
        return.success(lowercaseTxt.components(separatedBy: ","))
    } else {
        let oddLetters = lowercaseTxt.filter { $0.isLetter && $0.asciiValue! % 2 == 1 }
        return.failure(oddLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowercaseTxt = txt.lowercased()
    
    if lowercaseTxt.contains(" ") {
        return.success(lowercaseTxt.components(separatedBy: " "))
    } else if lowercaseTxt.contains(",") {
        return.success(lowercaseTxt.components(separatedBy: ","))
    } else {
        let oddLetters = lowercaseTxt.filter { $0.isLetter && $0.asciiValue! % 2 == 1 }
        return.failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowercaseTxt = txt.lowercased()
    
    if lowercaseTxt.contains(" ") {
        return.success(lowercaseTxt.components(separatedBy: " "))
    } else if lowercaseTxt.contains(",") {
        return.success(lowercaseTxt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = lowercaseTxt.filter { $0.isLetter }
        let oddLettersCount = lowercaseLetters.filter { $0.distance(from: $0.asciiValue!) % 2!= 0 }.count
        return.failure(oddLettersCount)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowercaseTxt = txt.lowercased()
    
    if lowercaseTxt.contains(" ") {
        return.success(lowercaseTxt.components(separatedBy: " "))
    } else if lowercaseTxt.contains(",") {
        return.success(lowercaseTxt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = lowercaseTxt.filter { $0.isLetter }
        let oddLettersCount = lowercaseLetters.filter { $0.distance(from: $0.asciiValue!) % 2!= 0 }.count
        return.failure(oddLettersCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowerCaseTxt = txt.lowercased()
    
    if lowerCaseTxt.contains(" ") {
        return.success(lowerCaseTxt.components(separatedBy: " "))
    } else if lowerCaseTxt.contains(",") {
        return.success(lowerCaseTxt.components(separatedBy: ","))
    } else {
        let lowerCaseLetters = lowerCaseTxt.filter { $0.isLetter }
        let oddLettersCount = lowerCaseLetters.filter { $0.distance(from: $0.uppercased()) % 2!= 0 }.count
        return.failure(oddLettersCount)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowerCaseTxt = txt.lowercased()
    
    if lowerCaseTxt.contains(" ") {
        return.success(lowerCaseTxt.components(separatedBy: " "))
    } else if lowerCaseTxt.contains(",") {
        return.success(lowerCaseTxt.components(separatedBy: ","))
    } else {
        let lowerCaseLetters = lowerCaseTxt.filter { $0.isLetter }
        let oddLettersCount = lowerCaseLetters.filter { $0.distance(from: $0.uppercased()) % 2!= 0 }.count
        return.failure(oddLettersCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowercaseLetters = txt.lowercased().filter { $0.isLetter }
    
    if lowercaseLetters.contains(" ") {
        return.success(lowercaseLetters.components(separatedBy: " "))
    } else if lowercaseLetters.contains(",") {
        return.success(lowercaseLetters.components(separatedBy: ","))
    } else {
        let oddLetters = lowercaseLetters.filter { $0.distance(from: $0.asciiValue!) % 2!= 0 }
        return.failure(oddLetters.count)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowercaseLetters = txt.lowercased().filter { $0.isLetter }
    
    if lowercaseLetters.contains(" ") {
        return.success(lowercaseLetters.components(separatedBy: " "))
    } else if lowercaseLetters.contains(",") {
        return.success(lowercaseLetters.components(separatedBy: ","))
    } else {
        let oddLetters = lowercaseLetters.filter { $0.distance(from: $0.asciiValue!) % 2!= 0 }
        return.failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowercaseTxt = txt.lowercased()
    
    if lowercaseTxt.contains(" ") {
        return.success(lowercaseTxt.components(separatedBy: " "))
    } else if lowercaseTxt.contains(",") {
        return.success(lowercaseTxt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = lowercaseTxt.filter { $0.isLetter }
        let oddLettersCount = lowercaseLetters.filter { $0.distance(from: $0.advanced(by: 1)) % 2!= 0 }.count
        return.failure(oddLettersCount)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowercaseTxt = txt.lowercased()
    
    if lowercaseTxt.contains(" ") {
        return.success(lowercaseTxt.components(separatedBy: " "))
    } else if lowercaseTxt.contains(",") {
        return.success(lowercaseTxt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = lowercaseTxt.filter { $0.isLetter }
        let oddLettersCount = lowercaseLetters.filter { $0.distance(from: $0.advanced(by: 1)) % 2!= 0 }.count
        return.failure(oddLettersCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowerCaseTxt = txt.lowercased()
    
    if lowerCaseTxt.contains(" ") {
        return.success(lowerCaseTxt.components(separatedBy: " "))
    } else if lowerCaseTxt.contains(",") {
        return.success(lowerCaseTxt.components(separatedBy: ","))
    } else {
        let lowerCaseLetters = lowerCaseTxt.filter { $0.isLetter }
        let oddLettersCount = lowerCaseLetters.filter { $0.distance(from: $0.uppercased()) % 2!= 0 }.count
        return.failure(oddLettersCount)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowerCaseTxt = txt.lowercased()
    
    if lowerCaseTxt.contains(" ") {
        return.success(lowerCaseTxt.components(separatedBy: " "))
    } else if lowerCaseTxt.contains(",") {
        return.success(lowerCaseTxt.components(separatedBy: ","))
    } else {
        let lowerCaseLetters = lowerCaseTxt.filter { $0.isLetter }
        let oddLettersCount = lowerCaseLetters.filter { $0.distance(from: $0.uppercased()) % 2!= 0 }.count
        return.failure(oddLettersCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowerCaseTxt = txt.lowercased()
    
    if lowerCaseTxt.contains(" ") {
        return.success(lowerCaseTxt.components(separatedBy: " "))
    } else if lowerCaseTxt.contains(",") {
        return.success(lowerCaseTxt.components(separatedBy: ","))
    } else {
        let lowerCaseLetters = lowerCaseTxt.filter { $0.isLetter }
        let oddLettersCount = lowerCaseLetters.filter { $0.distance(from: $0.uppercased()) % 2!= 0 }.count
        return.failure(oddLettersCount)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowerCaseTxt = txt.lowercased()
    
    if lowerCaseTxt.contains(" ") {
        return.success(lowerCaseTxt.components(separatedBy: " "))
    } else if lowerCaseTxt.contains(",") {
        return.success(lowerCaseTxt.components(separatedBy: ","))
    } else {
        let lowerCaseLetters = lowerCaseTxt.filter { $0.isLetter }
        let oddLettersCount = lowerCaseLetters.filter { $0.distance(from: $0.uppercased()) % 2!= 0 }.count
        return.failure(oddLettersCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowerCaseTxt = txt.lowercased()
    
    if lowerCaseTxt.contains(" ") {
        return.success(lowerCaseTxt.components(separatedBy: " "))
    } else if lowerCaseTxt.contains(",") {
        return.success(lowerCaseTxt.components(separatedBy: ","))
    } else {
        let lowerCaseLetters = lowerCaseTxt.filter { $0.isLetter }
        let oddLettersCount = lowerCaseLetters.filter { $0.distance(from: $0.uppercased()) % 2!= 0 }.count
        return.failure(oddLettersCount)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowerCaseTxt = txt.lowercased()
    
    if lowerCaseTxt.contains(" ") {
        return.success(lowerCaseTxt.components(separatedBy: " "))
    } else if lowerCaseTxt.contains(",") {
        return.success(lowerCaseTxt.components(separatedBy: ","))
    } else {
        let lowerCaseLetters = lowerCaseTxt.filter { $0.isLetter }
        let oddLettersCount = lowerCaseLetters.filter { $0.distance(from: $0.uppercased()) % 2!= 0 }.count
        return.failure(oddLettersCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowercaseTxt = txt.lowercased()
    
    if let words = lowercaseTxt.components(separatedBy: "\\s") {
        return.success(words)
    }
    
    if let words = lowercaseTxt.components(separatedBy: ",") {
        return.success(words)
    }
    
    let oddLetters = lowercaseTxt.filter { $0.isLetter && $0.asciiValue! % 2 == 1 }
    return.failure(oddLetters.count)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowercaseTxt = txt.lowercased()
    
    if let words = lowercaseTxt.components(separatedBy: "\\s") {
        return.success(words)
    }
    
    if let words = lowercaseTxt.components(separatedBy: ",") {
        return.success(words)
    }
    
    let oddLetters = lowercaseTxt.filter { $0.isLetter && $0.asciiValue! % 2 == 1 }
    return.failure(oddLetters.count)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowercaseTxt = txt.lowercased()
    
    if lowercaseTxt.contains(" ") {
        return.success(lowercaseTxt.components(separatedBy: " "))
    } else if lowercaseTxt.contains(",") {
        return.success(lowercaseTxt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = lowercaseTxt.filter { $0.isLetter }
        let oddLettersCount = lowercaseLetters.filter { $0.distance(from: $0.uppercased()) % 2!= 0 }.count
        return.failure(oddLettersCount)
    }
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)<|im_end|>
<|im_start|>assistant
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let lowercaseTxt = txt.lowercased()
    
    if lowercaseTxt.contains(" ") {
        return.success(lowercaseTxt.components(separatedBy: " "))
    } else if lowercaseTxt.contains(",") {
        return.success(lowercaseTxt.components(separatedBy: ","))
    } else {
        let lowercaseLetters = lowercaseTxt.filter { $0.isLetter }
        let oddLettersCount = lowercaseLetters.filter { $0.distance(from: $0.uppercased()) % 2!= 0 }.count
        return.failure(oddLettersCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let whitespace = CharacterSet.whitespaces
    let comma = CharacterSet(charactersIn: ",")
    let characters = CharacterSet.lowercaseLetters
    let isWhitespace = whitespace.contains(in: txt)
    let isComma = comma.contains(in: txt)
    if isWhitespace {
        return .success(txt.components(separatedBy: whitespace))
    } else if isComma {
        return .success(txt.components(separatedBy: comma))
    } else {
        let lowercase = txt.lowercased()
        let letters = lowercase.unicodeScalars
        let oddLetters = letters.filter { characters.contains($0) }
        let count = oddLetters.count
        return .failure(count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let whitespace = CharacterSet.whitespaces
    let comma = CharacterSet(charactersIn: ",")
    let characters = CharacterSet.lowercaseLetters
    let isWhitespace = whitespace.contains(in: txt)
    let isComma = comma.contains(in: txt)
    if isWhitespace {
        return .success(txt.components(separatedBy: whitespace))
    } else if isComma {
        return .success(txt.components(separatedBy: comma))
    } else {
        let lowercase = txt.lowercased()
        let letters = lowercase.unicodeScalars
        let oddLetters = letters.filter { characters.contains($0) }
        let count = oddLetters.count
        return .failure(count)
    }
}
```
### Description

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let range = txt.rangeOfCharacter(from: .whitespaces) {
        return .success(Array(txt[..<range.lowerBound]).split(separator: " "))
    } else if let range = txt.rangeOfCharacter(from: .punctuationCharacters) {
        return .success(Array(txt[..<range.lowerBound]).split(separator: ","))
    } else {
        return .failure(txt.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let range = txt.rangeOfCharacter(from: .whitespaces) {
        return .success(Array(txt[..<range.lowerBound]).split(separator: " "))
    } else if let range = txt.rangeOfCharacter(from: .punctuationCharacters) {
        return .success(Array(txt[..<range.lowerBound]).split(separator: ","))
    } else {
        return .failure(txt.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        var lowercaseCount = 0
        for char in txt.lowercased() {
            if char.isLetter {
                lowercaseCount += 1
            }
        }
        return .failure(lowercaseCount)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        var lowercaseCount = 0
        for char in txt.lowercased() {
            if char.isLetter {
                lowercaseCount += 1
            }
        }
        return .failure(lowercaseCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return Result.success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return Result.success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercase = txt.lowercased()
        var count = 0
        for c in lowercase {
            if c.isLetter && Int(c.asciiValue!) % 2 == 1 {
                count += 1
            }
        }
        return Result.failure(count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return Result.success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return Result.success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercase = txt.lowercased()
        var count = 0
        for c in lowercase {
            if c.isLetter && Int(c.asciiValue!) % 2 == 1 {
                count += 1
            }
        }
        return Result.failure(count)
    }
}
```
### Description

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let whitespace = CharacterSet.whitespaces
    let comma = CharacterSet(charactersIn: ",")
    let characters = CharacterSet.lowercaseLetters
    let isWhitespace = whitespace.contains(in: txt)
    let isComma = comma.contains(in: txt)
    if isWhitespace {
        return .success(txt.components(separatedBy: whitespace))
    } else if isComma {
        return .success(txt.components(separatedBy: comma))
    } else {
        let lowercase = txt.lowercased()
        let count = lowercase.filter { characters.contains($0) }.count
        let odd = lowercase.filter { characters.contains($0) && Int($0.asciiValue! - 97) % 2 == 1 }.count
        return .failure(odd)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let whitespace = CharacterSet.whitespaces
    let comma = CharacterSet(charactersIn: ",")
    let characters = CharacterSet.lowercaseLetters
    let isWhitespace = whitespace.contains(in: txt)
    let isComma = comma.contains(in: txt)
    if isWhitespace {
        return .success(txt.components(separatedBy: whitespace))
    } else if isComma {
        return .success(txt.components(separatedBy: comma))
    } else {
        let lowercase = txt.lowercased()
        let count = lowercase.filter { characters.contains($0) }.count
        let odd = lowercase.filter { characters.contains($0) && Int($0.asciiValue! - 97) % 2 == 1 }.count
        return .failure(odd)
    }
}
```
### Description

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let range = txt.rangeOfCharacter(from: .whitespaces) {
        return .success(Array(txt[..<range.lowerBound]).split(separator: " ").map(String.init))
    } else if let range = txt.rangeOfCharacter(from: .punctuationCharacters) {
        return .success(Array(txt[..<range.lowerBound]).split(separator: ",").map(String.init))
    } else {
        return .failure(txt.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let range = txt.rangeOfCharacter(from: .whitespaces) {
        return .success(Array(txt[..<range.lowerBound]).split(separator: " ").map(String.init))
    } else if let range = txt.rangeOfCharacter(from: .punctuationCharacters) {
        return .success(Array(txt[..<range.lowerBound]).split(separator: ",").map(String.init))
    } else {
        return .failure(txt.count)
    }
}
```
### Problem

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let whitespace = CharacterSet.whitespaces
    let comma = CharacterSet(charactersIn: ",")
    let characters = CharacterSet.alphanumerics
    let range = txt.startIndex..<txt.endIndex
    let whitespaceRange = txt.rangeOfCharacter(from: whitespace, options: [], range: range)
    let commaRange = txt.rangeOfCharacter(from: comma, options: [], range: range)
    if let whitespaceRange = whitespaceRange {
        let whitespaceIndex = txt.index(before: whitespaceRange.upperBound)
        let word = String(txt[range.lowerBound..<whitespaceIndex])
        let rest = String(txt[whitespaceIndex..<range.upperBound])
        return splitWords(txt: rest).map { [word] + $0 }
    } else if let commaRange = commaRange {
        let commaIndex = txt.index(before: commaRange.upperBound)
        let word = String(txt[range.lowerBound..<commaIndex])
        let rest = String(txt[commaIndex..<range.upperBound])
        return splitWords(txt: rest).map { [word] + $0 }
    } else if characters.contains(txt) {
        return .success([txt])
    } else {
        return .failure(txt.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let whitespace = CharacterSet.whitespaces
    let comma = CharacterSet(charactersIn: ",")
    let characters = CharacterSet.alphanumerics
    let range = txt.startIndex..<txt.endIndex
    let whitespaceRange = txt.rangeOfCharacter(from: whitespace, options: [], range: range)
    let commaRange = txt.rangeOfCharacter(from: comma, options: [], range: range)
    if let whitespaceRange = whitespaceRange {
        let whitespaceIndex = txt.index(before: whitespaceRange.upperBound)
        let word = String(txt[range.lowerBound..<whitespaceIndex])
        let rest = String(txt[whitespaceIndex..<range.upperBound])
        return splitWords(txt: rest).map { [word] + $0 }
    } else if let commaRange = commaRange {
        let commaIndex = txt.index(before: commaRange.upperBound)
        let word = String(txt[range.lowerBound..<commaIndex])
        let rest = String(txt[commaIndex..<range.upperBound])
        return splitWords(txt: rest).map { [word] + $0 }
    } else if characters.contains(txt) {
        return .success([txt])
    } else {
        return .failure(txt.count)
    }
}
```
### Description

extension Int: Error {

}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let whitespace = CharacterSet.whitespaces
    let comma = CharacterSet(charactersIn: ",")
    let all = CharacterSet.alphanumerics
    let lowercase = CharacterSet.lowercaseLetters
    let uppercase = CharacterSet.uppercaseLetters
    let letters = CharacterSet.letters
    let digits = CharacterSet.decimalDigits
    let isWhitespace = whitespace.contains
    let isComma = comma.contains
    let isAll = all.contains
    let isLowercase = lowercase.contains
    let isUppercase = uppercase.contains
    let isLetter = letters.contains
    let isDigit = digits.contains
    let isNumber = isDigit
    let isWord = isLetter || isDigit
    let isText = isWord || isWhitespace || isComma
    let isValid = isText || isNumber
    let isInvalid = !isValid
    let isValidChar = isValid
    let isInvalidChar = isInvalid
    let isWhitespaceChar = isWhitespace
    let isCommaChar = isComma
    let isAllChar = isAll
    let isLowercaseChar = isLowercase
    let isUppercaseChar = isUppercase
    let isLetterChar = isLetter
    let isDigitChar = isDigit
    let isNumberChar = isNumber
    let isWordChar = isWord
    let isTextChar = isText
    let isValidChar = isValid
    let isInvalidChar = isInvalid
    let isWhitespace = isWhitespace
    let isComma = isComma
    let isAll = isAll
    let isLowercase = isLowercase
    let isUppercase = isUppercase
    let isLetter = isLetter
    let isDigit = isDigit
    let isNumber = isNumber
    let isWord = isWord
    let isText = isText
    let isValid = isValid
    let isInvalid = isInvalid
    let isValidChar = isValid
    let isInvalidChar = isInvalid
    let isWhitespaceChar = isWhitespace
    let isCommaChar = isComma
    let isAllChar = isAll
    let isLowercaseChar = isLowercase
    let isUppercaseChar = isUppercase
    let isLetterChar = isLetter
    let isDigitChar = isDigit
    let isNumberChar = isNumber
    let isWordChar = isWord
    let isTextChar = isText
    let isValidChar = isValid
    let isInvalidChar = isInvalid
    let isWhitespace = isWhitespace
    let isComma = isComma
    let isAll = isAll
    let isLowercase = isLowercase
    let isUppercase = isUppercase
    let isLetter = isLetter
    let isDigit = isDigit
    let isNumber = isNumber
    let isWord = isWord
    let isText = isText
    let isValid = isValid
    let isInvalid = isInvalid
    let isValidChar = isValid
    let isInvalidChar = isInvalid
    let isWhitespaceChar = isWhitespace
    let isCommaChar = isComma
    let isAllChar = isAll
    let isLowercaseChar = isLowercase
    let isUppercaseChar = isUppercase
    let isLetterChar = isLetter
    let isDigitChar = isDigit
    let isNumberChar = isNumber
    let isWordChar = isWord
    let isTextChar = isText
    let isValidChar = isValid
    let isInvalidChar = isInvalid
    let isWhitespace = isWhitespace
    let isComma = isComma
    let isAll = isAll
    let isLowercase = isLowercase
    let isUppercase = isUppercase
    let isLetter = isLetter
    let isDigit = isDigit
    let isNumber = isNumber
    let isWord = isWord
    let isText = isText
    let isValid = isValid
    let isInvalid = isInvalid
    let isValidChar = isValid
    let isInvalidChar = isInvalid
    let isWhitespaceChar = isWhitespace
    let isCommaChar = isComma
    let isAllChar = isAll
    let isLowercaseChar

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return Result.success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return Result.success(txt.split(separator: ",").map(String.init))
    } else {
        var count = 0
        for c in txt {
            if c.isLowercase {
                count += (c.asciiValue - 96) % 2 == 0 ? 0 : 1
            }
        }
        return Result.failure(count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return Result.success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return Result.success(txt.split(separator: ",").map(String.init))
    } else {
        var count = 0
        for c in txt {
            if c.isLowercase {
                count += (c.asciiValue - 96) % 2 == 0 ? 0 : 1
            }
        }
        return Result.failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        var count = 0
        for c in txt {
            if c.isLowercase {
                count += (c.asciiValue - 96) % 2 == 0 ? 0 : 1
            }
        }
        return .failure(count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        var count = 0
        for c in txt {
            if c.isLowercase {
                count += (c.asciiValue - 96) % 2 == 0 ? 0 : 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success(words.split(separator: ","))
    } else if let words = txt.split(separator: ",").first {
        return .success(words.split(separator: " "))
    } else {
        return .failure(txt.filter { $0.isLowercase && $0.isASCII }.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success(words.split(separator: ","))
    } else if let words = txt.split(separator: ",").first {
        return .success(words.split(separator: " "))
    } else {
        return .failure(txt.filter { $0.isLowercase && $0.isASCII }.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success([String(words)])
    } else if let words = txt.split(separator: ",").first {
        return .success([String(words)])
    } else {
        return .failure(txt.filter { $0.isLowercase && $0.isASCII }.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success([String(words)])
    } else if let words = txt.split(separator: ",").first {
        return .success([String(words)])
    } else {
        return .failure(txt.filter { $0.isLowercase && $0.isASCII }.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success(words.split(separator: ","))
    } else if let words = txt.split(separator: ",").first {
        return .success(words.split(separator: " "))
    } else {
        let count = txt.filter { $0.isLowercase && $0.isLetter }.count
        return .failure(count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success(words.split(separator: ","))
    } else if let words = txt.split(separator: ",").first {
        return .success(words.split(separator: " "))
    } else {
        let count = txt.filter { $0.isLowercase && $0.isLetter }.count
        return .failure(count)
    }
}
```
### Link

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        return .failure(txt.filter { $0.isLowercase && $0.isASCII }.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        return .failure(txt.filter { $0.isLowercase && $0.isASCII }.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success(words.split(separator: ","))
    } else if let words = txt.split(separator: ",").first {
        return .success(words.split(separator: " "))
    } else {
        let oddLetters = txt.filter { $0.isLowercase && $0.isLetter }
        return .failure(oddLetters.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success(words.split(separator: ","))
    } else if let words = txt.split(separator: ",").first {
        return .success(words.split(separator: " "))
    } else {
        let oddLetters = txt.filter { $0.isLowercase && $0.isLetter }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success(words.split(separator: ","))
    } else if let words = txt.split(separator: ",").first {
        return .success(words.split(separator: " "))
    } else {
        let count = txt.filter { $0.isLowercase && $0.isASCII }.count
        return .failure(count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success(words.split(separator: ","))
    } else if let words = txt.split(separator: ",").first {
        return .success(words.split(separator: " "))
    } else {
        let count = txt.filter { $0.isLowercase && $0.isASCII }.count
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success(words)
    } else if let words = txt.split(separator: ",").first {
        return .success(words)
    } else {
        let count = txt.filter { $0.isLowercase && $0.isASCII }.count
        return .failure(count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success(words)
    } else if let words = txt.split(separator: ",").first {
        return .success(words)
    } else {
        let count = txt.filter { $0.isLowercase && $0.isASCII }.count
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success(words.split(separator: ","))
    } else if let words = txt.split(separator: ",").first {
        return .success(words.split(separator: " "))
    } else {
        let count = txt.filter { $0.isLowercase && $0.isLetter }.count
        return .failure(count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success(words.split(separator: ","))
    } else if let words = txt.split(separator: ",").first {
        return .success(words.split(separator: " "))
    } else {
        let count = txt.filter { $0.isLowercase && $0.isLetter }.count
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success(words)
    } else if let words = txt.split(separator: ",").first {
        return .success(words)
    } else {
        return .failure(txt.filter { $0.isLowercase && $0.isASCII }.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success(words)
    } else if let words = txt.split(separator: ",").first {
        return .success(words)
    } else {
        return .failure(txt.filter { $0.isLowercase && $0.isASCII }.count)
    }
}
```
### Link

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success([String(words)])
    } else if let words = txt.split(separator: ",").first {
        return .success([String(words)])
    } else {
        return .failure(txt.filter { $0.isLowercase && $0.isASCII }.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").first {
        return .success([String(words)])
    } else if let words = txt.split(separator: ",").first {
        return .success([String(words)])
    } else {
        return .failure(txt.filter { $0.isLowercase && $0.isASCII }.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let split = txt.split(separator: " ").first {
        return .success([String(split)])
    }
    if let split = txt.split(separator: ",").first {
        return .success([String(split)])
    }
    let lowercase = txt.lowercased()
    let letters = lowercase.compactMap { $0.isLetter ? $0 : nil }
    let oddLetters = letters.enumerated().compactMap { $0.offset % 2 == 0 ? $0.element : nil }
    let count = oddLetters.count
    return .failure(count)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let split = txt.split(separator: " ").first {
        return .success([String(split)])
    }
    if let split = txt.split(separator: ",").first {
        return .success([String(split)])
    }
    let lowercase = txt.lowercased()
    let letters = lowercase.compactMap { $0.isLetter ? $0 : nil }
    let oddLetters = letters.enumerated().compactMap { $0.offset % 2 == 0 ? $0.element : nil }
    let count = oddLetters.count
    return .failure(count)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map({ String($0) }) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map({ String($0) }) {
        return .success(words)
    } else {
        let letters = txt.lowercased().filter({ $0.isLetter })
        var count = 0
        for letter in letters {
            count += Int(letter.asciiValue!) - 97
        }
        return .failure(count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map({ String($0) }) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map({ String($0) }) {
        return .success(words)
    } else {
        let letters = txt.lowercased().filter({ $0.isLetter })
        var count = 0
        for letter in letters {
            count += Int(letter.asciiValue!) - 97
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let split = txt.split(separator: " ").map({ String($0) }) {
        return .success(split)
    } else if let split = txt.split(separator: ",").map({ String($0) }) {
        return .success(split)
    } else {
        return .failure(txt.filter({ $0.isLowercase }).enumerated().reduce(0) { $0 + (Int($1.element.asciiValue!) - 97) * (1 - Int($1.offset % 2) * 2) })
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let split = txt.split(separator: " ").map({ String($0) }) {
        return .success(split)
    } else if let split = txt.split(separator: ",").map({ String($0) }) {
        return .success(split)
    } else {
        return .failure(txt.filter({ $0.isLowercase }).enumerated().reduce(0) { $0 + (Int($1.element.asciiValue!) - 97) * (1 - Int($1.offset % 2) * 2) })
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let split = txt.split(separator: " ").map({ String($0) }) {
        return .success(split)
    } else if let split = txt.split(separator: ",").map({ String($0) }) {
        return .success(split)
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                count += 1
            }
        }
        return .failure(count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let split = txt.split(separator: " ").map({ String($0) }) {
        return .success(split)
    } else if let split = txt.split(separator: ",").map({ String($0) }) {
        return .success(split)
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map({ String($0) }) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map({ String($0) }) {
        return .success(words)
    } else {
        let letters = txt.lowercased().filter({ $0.isLetter })
        var count = 0
        for letter in letters {
            count += letter.asciiValue! - 96
        }
        return .failure(count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map({ String($0) }) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map({ String($0) }) {
        return .success(words)
    } else {
        let letters = txt.lowercased().filter({ $0.isLetter })
        var count = 0
        for letter in letters {
            count += letter.asciiValue! - 96
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let split = txt.split(separator: " ").first {
        return .success(split)
    } else if let split = txt.split(separator: ",").first {
        return .success(split)
    } else {
        return .failure(txt.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let split = txt.split(separator: " ").first {
        return .success(split)
    } else if let split = txt.split(separator: ",").first {
        return .success(split)
    } else {
        return .failure(txt.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let split = txt.split(separator: " ").first {
        return .success([String(split)])
    } else if let split = txt.split(separator: ",").first {
        return .success([String(split)])
    } else {
        return .failure(txt.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let split = txt.split(separator: " ").first {
        return .success([String(split)])
    } else if let split = txt.split(separator: ",").first {
        return .success([String(split)])
    } else {
        return .failure(txt.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let split = txt.split(separator: " ").map({ String($0) }) {
        return .success(split)
    } else if let split = txt.split(separator: ",").map({ String($0) }) {
        return .success(split)
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                count += 1
            }
        }
        return .failure(count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let split = txt.split(separator: " ").map({ String($0) }) {
        return .success(split)
    } else if let split = txt.split(separator: ",").map({ String($0) }) {
        return .success(split)
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map({ String($0) }) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map({ String($0) }) {
        return .success(words)
    } else {
        return .failure(txt.count)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map({ String($0) }) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map({ String($0) }) {
        return .success(words)
    } else {
        return .failure(txt.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let split = txt.split(separator: " ").map({ String($0) }) {
        return .success(split)
    } else if let split = txt.split(separator: ",").map({ String($0) }) {
        return .success(split)
    } else {
        return .failure(txt.reduce(0) { $0 + ($1.isLowercase ? 1 : 0) })
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let split = txt.split(separator: " ").map({ String($0) }) {
        return .success(split)
    } else if let split = txt.split(separator: ",").map({ String($0) }) {
        return .success(split)
    } else {
        return .failure(txt.reduce(0) { $0 + ($1.isLowercase ? 1 : 0) })
    }
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let whitespace = CharacterSet.whitespaces
    let comma = CharacterSet(charactersIn: ",")
    let lowercaseLetters = CharacterSet(charactersIn: "abcdefghijklmnopqrstuvwxyz")

    // Check for whitespace
    if txt.rangeOfCharacter(from: whitespace) != nil {
        return .success(txt.components(separatedBy: whitespace))
    }

    // Check for comma
    if txt.rangeOfCharacter(from: comma) != nil {
        return .success(txt.components(separatedBy: ","))
    }

    // Count lowercase letters with odd order in the alphabet
    let count = txt.lowercased().reduce(0) { (count, char) -> Int in
        if lowercaseLetters.contains(char) {
            return count + (Character(char).asciiValue! - Character("a").asciiValue!) % 2 == 1 ? 1 : 0
        }
        return count
    }

    return .failure(count)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let whitespace = CharacterSet.whitespaces
    let comma = CharacterSet(charactersIn: ",")
    let lowercaseLetters = CharacterSet(charactersIn: "abcdefghijklmnopqrstuvwxyz")

    // Check for whitespace
    if txt.rangeOfCharacter(from: whitespace) != nil {
        return .success(txt.components(separatedBy: whitespace))
    }

    // Check for comma
    if txt.rangeOfCharacter(from: comma) != nil {
        return .success(txt.components(separatedBy: ","))
    }

    // Count lowercase letters with odd order in the alphabet
    let count = txt.lowercased().reduce(0) { (count, char) -> Int in
        if lowercaseLetters.contains(char) {
            return count + (Character(char).asciiValue! - Character("a").asciiValue!) % 2 == 1 ? 1 : 0
        }
        return count
    }

    return .failure(count)
}

// Example usage:
let exampleText = "Hello, world!"
let result = splitWords(txt: exampleText)
switch result {
case .success(let words):
    print("Success: \(words)")
case .failure(let count):
    print("Failure: \(count)")
}
```

This code defines a function `splitWords` that takes a string `txt` and returns a `Result<[String], Int>`. The `Result` type is a custom enum that can either be a `.success` with an array of strings or a `.failure` with an integer.

The function first checks for whitespace using `CharacterSet.whitespaces`. If found, it splits the string on whitespace and returns a `.success` with the resulting array of strings.

If no whitespace is found, it checks for commas using `CharacterSet(charactersIn: ",")`. If found, it splits the string on commas and returns a `.success` with the resulting array of strings.

If neither whitespace nor commas are found, it counts the number of lowercase letters with an odd order in the alphabet (0-indexed) and returns a `.failure` with the count.

The example usage shows how to call the function with a sample text and print the result.

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let whitespace = CharacterSet.whitespaces
    let comma = CharacterSet(charactersIn: ",")
    
    if txt.rangeOfCharacter(from: whitespace) != nil {
        return .success(txt.components(separatedBy: whitespace))
    } else if txt.rangeOfCharacter(from: comma) != nil {
        return .success(txt.components(separatedBy: ","))
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase && Int(char.unicodeScalars.first!.value - "a".unicodeScalars.first!.value) % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let whitespace = CharacterSet.whitespaces
    let comma = CharacterSet(charactersIn: ",")
    
    if txt.rangeOfCharacter(from: whitespace) != nil {
        return .success(txt.components(separatedBy: whitespace))
    } else if txt.rangeOfCharacter(from: comma) != nil {
        return .success(txt.components(separatedBy: ","))
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase && Int(char.unicodeScalars.first!.value - "a".unicodeScalars.first!.value) % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

// Example usage:
let exampleText = "Hello, world!"
let result = splitWords(txt: exampleText)
switch result {
case .success(let words):
    print("Success: \(words)")
case .failure(let count):
    print("Failure: \(count)")
}
```

This code defines a function `splitWords` that takes a string `txt` and returns a `Result` object. The `Result` object can either be a `.success` with an array of words split on whitespace or a `.failure` with an integer representing the count of lower-case letters with odd order in the alphabet.

The function first checks if there is any whitespace in the text using `CharacterSet.whitespaces`. If there is, it splits the text on whitespace and returns a `.success` with the resulting array of words.

If there is no whitespace, it checks if there is a comma using `CharacterSet(charactersIn: ",")`. If there is, it splits the text on commas and returns a `.success` with the resulting array of words.

If neither whitespace nor commas are found, the function counts the number of lower-case letters with odd order in the alphabet and returns a `.failure` with the count.

To use the function, you can call it with a string and handle the result accordingly:

```swift
let exampleText = "Hello, world!"
let result = splitWords(txt: exampleText)
switch result {
case .success(let words):
    print("Success: \(words)")
case .failure(let count):
    print("Failure: \(count)")
}
```

This will print either `Success: ["Hello", "world!"]` or `Failure: <count of lower-case letters with odd order in the alphabet>`.

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: .whitespaces)
    if !words.isEmpty {
        return .success(words)
    }
    
    let commas = txt.components(separatedBy: ",")
    if !commas.isEmpty {
        return .success(commas)
    }
    
    let lowerCaseLetters = txt.filter { $0.isLowercase }
    let oddOrderLetters = lowerCaseLetters.filter { "acegimkpyv".contains($0) }
    return .failure(oddOrderLetters.count)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: .whitespaces)
    if !words.isEmpty {
        return .success(words)
    }
    
    let commas = txt.components(separatedBy: ",")
    if !commas.isEmpty {
        return .success(commas)
    }
    
    let lowerCaseLetters = txt.filter { $0.isLowercase }
    let oddOrderLetters = lowerCaseLetters.filter { "acegimkpyv".contains($0) }
    return .failure(oddOrderLetters.count)
}

// Example usage:
let exampleText = "Hello, world!"
let result = splitWords(txt: exampleText)
switch result {
case .success(let words):
    print("Success: \(words)")
case .failure(let count):
    print("Failure: \(count)")
}
```

This code defines a function `splitWords` that takes a string `txt` as input and returns a `Result` object. The `Result` object can either be a `.success` with an array of words split on whitespace or a `.failure` with an integer representing the number of lower-case letters with odd order in the alphabet.

The function first checks if the string contains any whitespaces using `components(separatedBy: .whitespaces)`. If it does, it splits the string on whitespaces and returns a `.success` with the resulting array of words.

If no whitespaces are found, it checks if the string contains any commas using `components(separatedBy: ",")`. If it does, it splits the string on commas and returns a `.success` with the resulting array of words.

If neither whitespaces nor commas are found, it filters the string to only include lower-case letters and checks for any letters with an odd order in the alphabet (using the string "acegimkpyv"). It then returns a `.failure` with the count of such letters.

Note that the code assumes that the input string is a valid string of characters. If the input is not a string, the code will not compile.

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let whitespace = CharacterSet.whitespaces
    let comma = CharacterSet(charactersIn: ",")
    
    if txt.rangeOfCharacter(from: whitespace) != nil {
        return .success(txt.components(separatedBy: whitespace))
    } else if txt.rangeOfCharacter(from: comma) != nil {
        return .success(txt.components(separatedBy: ","))
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase && Int(char.unicodeScalars.first!.value - "a".unicodeScalars.first!.value) % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let whitespace = CharacterSet.whitespaces
    let comma = CharacterSet(charactersIn: ",")
    
    if txt.rangeOfCharacter(from: whitespace) != nil {
        return .success(txt.components(separatedBy: whitespace))
    } else if txt.rangeOfCharacter(from: comma) != nil {
        return .success(txt.components(separatedBy: ","))
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase && Int(char.unicodeScalars.first!.value - "a".unicodeScalars.first!.value) % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

// Example usage:
let exampleText = "Hello, world!"
let result = splitWords(txt: exampleText)
switch result {
case .success(let words):
    print("Success: \(words)")
case .failure(let count):
    print("Failure: \(count)")
}
```

This code defines an extension on `Int` to conform to the `Error` protocol, which allows us to use `Int` as an error type in our `splitWords` function. The function takes a string `txt` and returns a `Result` which can either be a `.success` with an array of words or a `.failure` with an `Int` representing the count of lower-case letters with odd order in the alphabet.

The function first checks if there are any whitespaces in the text using `CharacterSet.whitespaces`. If there are, it splits the text on whitespaces and returns the result as a `.success`.

If there are no whitespaces, it checks if there are any commas using `CharacterSet(charactersIn: ",")`. If there are, it splits the text on commas and returns the result as a `.success`.

If neither whitespaces nor commas are present, it counts the number of lower-case letters with odd order in the alphabet and returns the count as a `.failure`.

To use the `splitWords` function, you can call it with a string and handle the result accordingly:

```swift
let exampleText = "Hello, world!"
let result = splitWords(txt: exampleText)
switch result {
case .success(let words):
    print("Success: \(words)")
case .failure(let count):
    print("Failure: \(count)")
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: .whitespaces)
    if !words.isEmpty {
        return .success(words)
    } else {
        let lowercaseLetters = Array("abcdefghijklmnopqrstuvwxyz")
        var oddOrderCount = 0
        for char in txt {
            if let index = lowercaseLetters.firstIndex(of: char), index % 2 != 0 {
                oddOrderCount += 1
            }
        }
        return .failure(oddOrderCount)
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: .whitespaces)
    if !words.isEmpty {
        return .success(words)
    } else {
        let lowercaseLetters = Array("abcdefghijklmnopqrstuvwxyz")
        var oddOrderCount = 0
        for char in txt {
            if let index = lowercaseLetters.firstIndex(of: char), index % 2 != 0 {
                oddOrderCount += 1
            }
        }
        return .failure(oddOrderCount)
    }
}

// Example usage:
let exampleText = "Hello world!"
let result = splitWords(txt: exampleText)
switch result {
case .success(let words):
    print("Result: \(words)")
case .failure(let count):
    print("Result: \(count)")
}
```

This code defines a function `splitWords` that takes a string `txt` as input and returns a `Result` object. The `Result` object can either be a `.success` with an array of words split on whitespaces, or a `.failure` with an integer representing the number of lower-case letters with odd order in the alphabet.

The function first checks if the text contains any whitespaces using `components(separatedBy: .whitespaces)`. If it does, it splits the text on whitespaces and returns a `.success` with the resulting array of words.

If there are no whitespaces, the function splits the text on commas using `components(separatedBy: ",")`. If there are no commas, the function iterates over each character in the text and checks if it is a lowercase letter with an odd order in the alphabet. If it is, it increments the `oddOrderCount`. Finally, it returns a `.failure` with the `oddOrderCount`.

Note that the code assumes that the input text is a valid string containing only ASCII characters. If the input text contains non-ASCII characters, the code may not work as expected.

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: .whitespaces)
    if !words.isEmpty {
        return .success(words)
    }
    
    let commas = txt.components(separatedBy: ",")
    if !commas.isEmpty {
        return .success(commas)
    }
    
    let lowerCaseLetters = txt.filter { $0.isLowercase }
    let oddOrderLetters = lowerCaseLetters.filter { "aceimnorsuvwxz".contains($0) }
    return .failure(oddOrderLetters.count)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: .whitespaces)
    if !words.isEmpty {
        return .success(words)
    }
    
    let commas = txt.components(separatedBy: ",")
    if !commas.isEmpty {
        return .success(commas)
    }
    
    let lowerCaseLetters = txt.filter { $0.isLowercase }
    let oddOrderLetters = lowerCaseLetters.filter { "aceimnorsuvwxz".contains($0) }
    return .failure(oddOrderLetters.count)
}

// Example usage:
let exampleText = "Hello, world!"
let result = splitWords(txt: exampleText)
switch result {
case .success(let words):
    print("Success: \(words)")
case .failure(let count):
    print("Failure: \(count)")
}
```

This code defines a function `splitWords` that takes a string `txt` and returns a `Result` object. The `Result` object can either be a `.success` with an array of words split on whitespace or a `.failure` with an integer representing the number of lower-case letters with odd order in the alphabet.

The function first checks if the string contains any whitespaces by splitting the string using `components(separatedBy: .whitespaces)`. If it does, it returns a `.success` with the split words.

If no whitespaces are found, it checks if the string contains any commas by splitting the string using `components(separatedBy: ",")`. If it does, it returns a `.success` with the split words.

If neither whitespaces nor commas are found, it calculates the number of lower-case letters with odd order in the alphabet by filtering the string using `filter` and `contains`. It then returns a `.failure` with the count of odd order letters.

To use the function, you can call it with a string and handle the result accordingly:

```swift
let exampleText = "Hello, world!"
let result = splitWords(txt: exampleText)
switch result {
case .success(let words):
    print("Success: \(words)")
case .failure(let count):
    print("Failure: \(count)")
}
```

This will print either `Success: ["Hello", "world!"]` or `Failure: 3` depending on the input string.

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: .whitespaces)
    if !words.isEmpty {
        return .success(words)
    } else {
        let commas = txt.components(separatedBy: ",")
        if !commas.isEmpty {
            return .success(commas)
        } else {
            let lowerCaseLetters = txt.lowercased().filter { $0.isLowercase }
            let oddOrderLetters = lowerCaseLetters.filter { $0.asciiValue! % 2 != 0 }
            return .failure(oddOrderLetters.count)
        }
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: .whitespaces)
    if !words.isEmpty {
        return .success(words)
    } else {
        let commas = txt.components(separatedBy: ",")
        if !commas.isEmpty {
            return .success(commas)
        } else {
            let lowerCaseLetters = txt.lowercased().filter { $0.isLowercase }
            let oddOrderLetters = lowerCaseLetters.filter { $0.asciiValue! % 2 != 0 }
            return .failure(oddOrderLetters.count)
        }
    }
}

// Example usage:
let exampleText = "Hello, world!"
let result = splitWords(txt: exampleText)
switch result {
case .success(let words):
    print("Success: \(words)")
case .failure(let count):
    print("Failure: \(count)")
}
```

This code defines a function `splitWords` that takes a string `txt` and returns a `Result` object. The `Result` object can either be a `.success` with an array of words split on whitespace or a `.failure` with an integer representing the number of lower-case letters with odd order in the alphabet.

The function first checks if the string contains any whitespaces by splitting the string using `.whitespaces` as the separator. If it does, it splits the string on whitespaces and returns a `.success` with the resulting array of words.

If no whitespaces are found, it checks if the string contains any commas by splitting the string using `","` as the separator. If it does, it splits the string on commas and returns a `.success` with the resulting array of words.

If neither whitespaces nor commas are found, it calculates the number of lower-case letters with odd order in the alphabet by filtering the string for lower-case letters and then counting the number of letters with an ASCII value that is odd. It then returns a `.failure` with the count of such letters.

Note that the code assumes that the input string contains only ASCII characters. If the string contains non-ASCII characters, the code may not work as expected.

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: .whitespaces)
    if !words.isEmpty {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.lowercased().filter { $0.isLetter }
        let oddOrderLetters = lowerCaseLetters.filter { $0.asciiValue! % 2 != 0 }
        return .failure(oddOrderLetters.count)
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: .whitespaces)
    if !words.isEmpty {
        return .success(words)
    } else {
        let lowerCaseLetters = txt.lowercased().filter { $0.isLetter }
        let oddOrderLetters = lowerCaseLetters.filter { $0.asciiValue! % 2 != 0 }
        return .failure(oddOrderLetters.count)
    }
}

// Example usage:
let exampleText = "Hello, world!"
let result = splitWords(txt: exampleText)
switch result {
case .success(let words):
    print("Success: \(words)")
case .failure(let count):
    print("Failure: \(count)")
}
```

This code defines a function `splitWords` that takes a string `txt` and returns a `Result` object. The `Result` object can either be a `.success` with an array of words split on whitespaces, or a `.failure` with an integer representing the number of lower-case letters with odd order in the alphabet.

The function first checks if there are any whitespaces in the text using `components(separatedBy: .whitespaces)`. If there are whitespaces, it splits the text on whitespaces and returns a `.success` with the resulting array of words.

If there are no whitespaces, the function splits the text on commas ',' using `components(separatedBy: ",")`. If there are no commas, the function filters the lower-case letters in the text and counts the number of letters with odd order in the alphabet. It then returns a `.failure` with the count of such letters.

Note that the code assumes that the input text is a valid string containing only ASCII characters. If the input is not valid, the behavior of the function is undefined.

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: .whitespaces)
    if !words.isEmpty {
        return .success(words)
    } else {
        let commas = txt.components(separatedBy: ",")
        if !commas.isEmpty {
            return .success(commas)
        } else {
            var count = 0
            for char in txt {
                if char.isLowercase && Int(String(char.uppercased().first!))! % 2 == 1 {
                    count += 1
                }
            }
            return .failure(count)
        }
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: .whitespaces)
    if !words.isEmpty {
        return .success(words)
    } else {
        let commas = txt.components(separatedBy: ",")
        if !commas.isEmpty {
            return .success(commas)
        } else {
            var count = 0
            for char in txt {
                if char.isLowercase && Int(String(char.uppercased().first!))! % 2 == 1 {
                    count += 1
                }
            }
            return .failure(count)
        }
    }
}

// Example usage:
let exampleText = "Hello, world!"
let result = splitWords(txt: exampleText)
switch result {
case .success(let words):
    print("Success: \(words)")
case .failure(let count):
    print("Failure: \(count)")
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: .whitespaces)
    if !words.isEmpty {
        return .success(words)
    } else {
        let commas = txt.components(separatedBy: ",")
        if !commas.isEmpty {
            return .success(commas)
        } else {
            let lowerCaseLetters = txt.lowercased().filter { $0.isLowercase }
            let oddOrderLetters = lowerCaseLetters.filter { $0.asciiValue! % 2 != 0 }
            return .failure(oddOrderLetters.count)
        }
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: .whitespaces)
    if !words.isEmpty {
        return .success(words)
    } else {
        let commas = txt.components(separatedBy: ",")
        if !commas.isEmpty {
            return .success(commas)
        } else {
            let lowerCaseLetters = txt.lowercased().filter { $0.isLowercase }
            let oddOrderLetters = lowerCaseLetters.filter { $0.asciiValue! % 2 != 0 }
            return .failure(oddOrderLetters.count)
        }
    }
}

// Example usage:
let result = splitWords(txt: "Hello world!")
switch result {
case .success(let words):
    print("Success: \(words)")
case .failure(let count):
    print("Failure: \(count)")
}
```

This code defines an extension on `Int` to conform to the `Error` protocol, which allows it to be used as an error type in Swift. The `splitWords` function takes a string `txt` and returns a `Result` which is either a `Success` with an array of words or a `Failure` with an integer representing the count of lower-case letters with odd order in the alphabet.

The function first checks if the string contains any whitespaces by splitting it on whitespaces and checking if the resulting array is non-empty. If it is non-empty, it means that the string contains whitespaces and the function returns a `Success` with the array of words.

If the string does not contain whitespaces, the function checks if it contains commas by splitting it on commas and checking if the resulting array is non-empty. If it is non-empty, it means that the string contains commas and the function returns a `Success` with the array of words.

If neither whitespaces nor commas are present, the function calculates the count of lower-case letters with odd order in the alphabet and returns a `Failure` with that count.

Note that the code assumes that the input string only contains ASCII characters. If the input string contains non-ASCII characters, the code may not work as expected.

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var oddLetters = 0
    for word in words {
        for char in word {
            if char.lowercased() == char {
                oddLetters += 1
            }
        }
    }
    return .success(words)
}

func sumPairs(arr: [Int], target: Int) -> Result<Int, Int> {
    var count = 0
    for i in 0..<arr.count {
        for j in i+1..<arr.count {
            if arr[i] + arr[j] == target {
                count += 1
            }
        }
    }
    return .success(count)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var oddLetters = 0
    for word in words {
        for char in word {
            if char.lowercased() == char {
                oddLetters += 1
            }
        }
    }
    return .success(words)
}

// Given an array of integers, return the number of times the sum of two integers in the array equals the target
// number.
// Examples
// sumPairs([1, 2, 3, 4, 5, 6], 7) == .success(2)
// sumPairs([1, 2, 3, 4, 5, 6], 10) == .success(1)
// sumPairs([1, 2, 3, 4, 5, 6], 11) == .success(0)
func sumPairs(arr: [Int], target: Int) -> Result<Int, Int> {
    var count = 0
    for i in 0..<arr.count {
        for j in i+1..<arr.count {
            if arr[i] + arr[j] == target {
                count += 1
            }
        }
    }
    return .success(count)
}

// Given an array of integers, return the number of times the sum of two integers in the array equals the target
// number.
// Examples
// sumPairs([1, 2, 3, 4, 5, 6], 7) == .success(2)
// sumPairs([1, 2, 3, 4, 5, 6], 10) == .success(1)
// sumPairs([1, 2, 3, 4, 5, 6], 11) == .success(0)
func sumPairs(arr: [Int], target: Int) -> Result<Int, Int> {
    var count = 0
    for i in 0..<arr.count {
        for j in i+1..<arr.count {
            if arr[i] + arr[j] == target {
                count += 1
            }
        }
    }
    return .success(count)
}

// Given an array of integers, return the number of times the sum of two integers in the array equals the target
// number.
// Examples
// sumPairs([1, 2, 3, 4, 5, 6], 7) == .success(2)
// sumPairs([1, 2, 3, 4, 5, 6], 10) == .success(1)
// sumPairs([1, 2, 3, 4, 5, 6], 11) == .success(0)
func sumPairs(arr: [Int], target: Int) -> Result<Int, Int> {
    var count = 0
    for i in 0..<arr.count {
        for j in i+1..<arr.count {
            if arr[i] + arr[j] == target {
                count += 1
            }
        }
    }
    return .success(count)
}

// Given an array of integers, return the number of times the sum of two integers in the array equals the target
// number.
// Examples
// sumPairs([1, 2, 3, 4, 5, 6], 7) == .success(2)
// sumPairs([1, 2, 3, 4, 5, 6], 10) == .success(1)
// sumPairs([1, 2, 3, 4, 5, 6], 11) == .success(0)
func sumPairs(arr: [Int], target: Int) -> Result<Int, Int> {
    var count = 0
    for i in 0..<arr.count {
        for j in i+1..<arr.count {
            if arr[i] + arr[j] == target {
                count += 1
            }
        }
    }
    return .success(count)
}

// Given an array of integers, return the number of times the sum of two integers in the array equals the target
// number.
// Examples
// sumPairs([1, 2, 3, 4, 5, 6], 7) == .success(2)
// sum

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var odd = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
    }
    for word in words {
        if word.contains(",") {
            return .failure(3)
        }
    }
    for word in words {
        if word.count % 2 != 0 {
            odd += 1
        }
    }
    return .success(words)
}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var odd = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
    }
    for word in words {
        if word.contains(",") {
            return .failure(3)
        }
    }
    for word in words {
        if word.count % 2 != 0 {
            odd += 1
        }
    }
    return .success(words)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var odd = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
    }
    for word in words {
        if word.contains(",") {
            return .failure(3)
        }
    }
    for word in words {
        if word.count % 2 != 0 {
            odd += 1
        }
    }
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var odd = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
    }
    for word in words {
        if word.contains(",") {
            return .failure(3)
        }
    }
    for word in words {
        if word.count % 2 != 0 {
            odd += 1
        }
    }
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var odd = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
    }
    for word in words {
        if word.contains(",") {
            return .failure(3)
        }
    }
    for word in words {
        if word.count % 2 != 0 {
            odd += 1
        }
    }
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var odd = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
    }
    for word in words {
        if word.contains(",") {
            return .failure(3)
        }
    }
    for word in words {
        if word.count % 2 != 0 {
            odd += 1
        }
    }
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var oddLetters = 0
    for word in words {
        let lowerCaseLetters = word.filter { $0.isLowercase }
        if lowerCaseLetters.count % 2 == 1 {
            oddLetters += 1
        }
    }
    return .success(words)
}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var oddLetters = 0
    for word in words {
        let lowerCaseLetters = word.filter { $0.isLowercase }
        if lowerCaseLetters.count % 2 == 1 {
            oddLetters += 1
        }
    }
    return .success(words)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var oddLetters = 0
    for word in words {
        let lowerCaseLetters = word.filter { $0.isLowercase }
        if lowerCaseLetters.count % 2 == 1 {
            oddLetters += 1
        }
    }
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var oddLetters = 0
    for word in words {
        let lowerCaseLetters = word.filter { $0.isLowercase }
        if lowerCaseLetters.count % 2 == 1 {
            oddLetters += 1
        }
    }
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var oddLetters = 0
    for word in words {
        let lowerCaseLetters = word.filter { $0.isLowercase }
        if lowerCaseLetters.count % 2 == 1 {
            oddLetters += 1
        }
    }
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var oddLetters = 0
    for word in words {
        let lowerCaseLetters = word.filter { $0.isLowercase }
        if lowerCaseLetters.count % 2 == 1 {
            oddLetters += 1
        }
    }
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let letters = words.map { $0.filter { $0.isLetter }.lowercased() }
    let oddLetters = letters.filter { $0.count % 2 != 0 }
    let oddLettersCount = oddLetters.count
    return Result.success(words.map { $0.filter { $0.isLetter }.lowercased() })
}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let letters = words.map { $0.filter { $0.isLetter }.lowercased() }
    let oddLetters = letters.filter { $0.count % 2 != 0 }
    let oddLettersCount = oddLetters.count
    return Result.success(words.map { $0.filter { $0.isLetter }.lowercased() })
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let letters = words.map { $0.filter { $0.isLetter }.lowercased() }
    let oddLetters = letters.filter { $0.count % 2 != 0 }
    let oddLettersCount = oddLetters.count
    return Result.success(words.map { $0.filter { $0.isLetter }.lowercased() })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let letters = words.map { $0.filter { $0.isLetter }.lowercased() }
    let oddLetters = letters.filter { $0.count % 2 != 0 }
    let oddLettersCount = oddLetters.count
    return Result.success(words.map { $0.filter { $0.isLetter }.lowercased() })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let letters = words.map { $0.filter { $0.isLetter }.lowercased() }
    let oddLetters = letters.filter { $0.count % 2 != 0 }
    let oddLettersCount = oddLetters.count
    return Result.success(words.map { $0.filter { $0.isLetter }.lowercased() })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    let letters = words.map { $0.filter { $0.isLetter }.lowercased() }
    let oddLetters = letters.filter { $0.count % 2 != 0 }
    let oddLettersCount = oddLetters.count
    return Result.success(words.map { $0.filter { $0.isLetter }.lowercased() })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var odd = 0
    for word in words {
        let lower = word.lowercased()
        if lower.contains(" ") {
            return .failure(3)
        }
        if lower.contains(",") {
            return .failure(3)
        }
        for char in lower {
            if char.isLowercase {
                odd += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var odd = 0
    for word in words {
        let lower = word.lowercased()
        if lower.contains(" ") {
            return .failure(3)
        }
        if lower.contains(",") {
            return .failure(3)
        }
        for char in lower {
            if char.isLowercase {
                odd += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var odd = 0
    for word in words {
        let lower = word.lowercased()
        if lower.contains(" ") {
            return .failure(3)
        }
        if lower.contains(",") {
            return .failure(3)
        }
        for char in lower {
            if char.isLowercase {
                odd += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var odd = 0
    for word in words {
        let lower = word.lowercased()
        if lower.contains(" ") {
            return .failure(3)
        }
        if lower.contains(",") {
            return .failure(3)
        }
        for char in lower {
            if char.isLowercase {
                odd += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var odd = 0
    for word in words {
        let lower = word.lowercased()
        if lower.contains(" ") {
            return .failure(3)
        }
        if lower.contains(",") {
            return .failure(3)
        }
        for char in lower {
            if char.isLowercase {
                odd += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var odd = 0
    for word in words {
        let lower = word.lowercased()
        if lower.contains(" ") {
            return .failure(3)
        }
        if lower.contains(",") {
            return .failure(3)
        }
        for char in lower {
            if char.isLowercase {
                odd += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var odd = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        for char in word {
            if char.isLowercase && char.value % 2 == 1 {
                odd += 1
            }
        }
    }
    return .success(words)
}

func productExceptSelf(arr: [Int]) -> Result<[Int], Int> {
    var result = [Int]()
    for i in 0..<arr.count {
        var product = 1
        for j in 0..<arr.count {
            if j != i {
                product *= arr[j]
            }
        }
        result.append(product)
    }
    return .success(result)
}

func sumExceptSelf(arr: [Int]) -> Result<[Int], Int> {
    var result = [Int]()
    for i in 0..<arr.count {
        var sum = 0
        for j in 0..<arr.count {
            if j != i {
                sum += arr[j]
            }
        }
        result.append(sum)
    }
    return .success(result)
}

func diffAvg(arr: [Int]) -> Result<[Int], Int> {
    var sum = 0
    for i in 0..<arr.count {
        sum += arr[i]
    }
    let avg = sum / arr.count
    var result = [Int]()
    for i in 0..<arr.count {
        result.append(arr[i] - avg)
    }
    return .success(result)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var odd = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        for char in word {
            if char.isLowercase && char.value % 2 == 1 {
                odd += 1
            }
        }
    }
    return .success(words)
}

// Given an array of integers, return an array of integers, where each element is the product of all the elements in the
// array except for the element at the current index.
// Examples
// productExceptSelf([1, 2, 3, 4]) == .success([24, 12, 8, 6])
// productExceptSelf([1, 2, 3, 4, 5]) == .success([120, 60, 40, 30, 24])
// productExceptSelf([1, 2, 3, 4, 0]) == .success([0, 0, 0, 0, 120])
func productExceptSelf(arr: [Int]) -> Result<[Int], Int> {
    var result = [Int]()
    for i in 0..<arr.count {
        var product = 1
        for j in 0..<arr.count {
            if j != i {
                product *= arr[j]
            }
        }
        result.append(product)
    }
    return .success(result)
}

// Given an array of integers, return an array of integers, where each element is the sum of all the elements in the
// array except for the element at the current index.
// Examples
// sumExceptSelf([1, 2, 3, 4]) == .success([6, 3, 2, 1])
// sumExceptSelf([1, 2, 3, 4, 5]) == .success([15, 10, 5, 0, 5])
// sumExceptSelf([1, 2, 3, 4, 0]) == .success([15, 10, 5, 0, 15])
func sumExceptSelf(arr: [Int]) -> Result<[Int], Int> {
    var result = [Int]()
    for i in 0..<arr.count {
        var sum = 0
        for j in 0..<arr.count {
            if j != i {
                sum += arr[j]
            }
        }
        result.append(sum)
    }
    return .success(result)
}

// Given an array of integers, return an array of integers, where each element is the difference between the current
// element and the average of all the elements in the array.
// Examples
// diffAvg([1, 2, 3, 4]) == .success([2, 1, 0, -1])
// diffAvg([1, 2, 3, 4, 5]) == .success([4, 3, 2, 1, 0])
// diffAvg([1, 2, 3, 4, 0]) == .success([4, 3, 2, 1, 0])
func diffAvg(arr: [Int]) -> Result<[Int], Int> {
    var sum = 0
    for i in 0..<arr.count {
        sum += arr[i]
    }
    let avg = sum / arr.count
    var result = [Int]()
    for i in 0..<arr.count {
        result.append(arr[i] - avg)
    }
    return .success(result)
}

// Given an array of integers, return an array of integers, where each element is the product of all the elements in the
// array except for the element at the current index.
// Examples
// productExceptSelf([1, 2, 3, 4]) == .success([24, 12, 8, 6])
// productExceptSelf([1, 2, 3, 4, 5]) == .success([120, 60, 40, 30, 24])
// productExceptSelf([1, 2, 3, 4, 0]) == .success([0, 0, 0, 0, 12

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var odd = 0
    for word in words {
        let lower = word.lowercased()
        if lower.contains(" ") {
            return .failure(lower.count)
        }
        for char in lower {
            if char.isLowercase && char.value % 2 != 0 {
                odd += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var odd = 0
    for word in words {
        let lower = word.lowercased()
        if lower.contains(" ") {
            return .failure(lower.count)
        }
        for char in lower {
            if char.isLowercase && char.value % 2 != 0 {
                odd += 1
            }
        }
    }
    return .success(words.map { String($0) })
}
<|file_separator|>

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = [String]()
    var odd = 0
    var even = 0
    var last = ""
    for char in txt {
        if char == " " {
            result.append(last)
            last = ""
        } else if char == "," {
            result.append(last)
            last = ""
        } else {
            last += String(char)
        }
    }
    if last.count % 2 == 1 {
        odd = last.count
    } else {
        even = last.count
    }
    return Result {
        if odd > even {
            return odd
        } else {
            return even
        }
    }
}

func splitWords(txt: String) -> Result<[String], Int> {
    var result = [String]()
    var odd = 0
    var even = 0
    var last = ""
    for char in txt {
        if char == " " {
            result.append(last)
            last = ""
        } else if char == "," {
            result.append(last)
            last = ""
        } else {
            last += String(char)
        }
    }
    if last.count % 2 == 1 {
        odd = last.count
    } else {
        even = last.count
    }
    return Result {
        if odd > even {
            return odd
        } else {
            return even
        }
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = [String]()
    var odd = 0
    var even = 0
    var last = ""
    for char in txt {
        if char == " " {
            result.append(last)
            last = ""
        } else if char == "," {
            result.append(last)
            last = ""
        } else {
            last += String(char)
        }
    }
    if last.count % 2 == 1 {
        odd = last.count
    } else {
        even = last.count
    }
    return Result {
        if odd > even {
            return odd
        } else {
            return even
        }
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = [String]()
    var odd = 0
    var even = 0
    var last = ""
    for char in txt {
        if char == " " {
            result.append(last)
            last = ""
        } else if char == "," {
            result.append(last)
            last = ""
        } else {
            last += String(char)
        }
    }
    if last.count % 2 == 1 {
        odd = last.count
    } else {
        even = last.count
    }
    return Result {
        if odd > even {
            return odd
        } else {
            return even
        }
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = [String]()
    var odd = 0
    var even = 0
    var last = ""
    for char in txt {
        if char == " " {
            result.append(last)
            last = ""
        } else if char == "," {
            result.append(last)
            last = ""
        } else {
            last += String(char)
        }
    }
    if last.count % 2 == 1 {
        odd = last.count
    } else {
        even = last.count
    }
    return Result {
        if odd > even {
            return odd
        } else {
            return even
        }
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = [String]()
    var odd = 0
    var even = 0
    var last = ""
    for char in txt {
        if char == " " {
            result.append(

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var oddOrderLetters = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        for char in word {
            if char.isLowercase && char.asciiValue! % 2 != 0 {
                oddOrderLetters += 1
            }
        }
    }
    return .success(words)
}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var oddOrderLetters = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        for char in word {
            if char.isLowercase && char.asciiValue! % 2 != 0 {
                oddOrderLetters += 1
            }
        }
    }
    return .success(words)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var oddOrderLetters = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        for char in word {
            if char.isLowercase && char.asciiValue! % 2 != 0 {
                oddOrderLetters += 1
            }
        }
    }
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    var oddOrderLetters = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        for char in word {
            if char.isLowercase && char.asciiValue! % 2 != 0 {
                oddOrderLetters += 1
            }
        }
    }
    return .success(words)
}
<|file_separator|>

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
    var result = [String]()
    var count = 0
    for i in txt.indices {
        if txt[i] == " " {
            result.append(String(txt[..<i]))
            result.append(String(txt[i+1..<txt.endIndex]))
        }
    }
    return .success(result)
}

func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
    var result = [String]()
    var count = 0
    for i in txt.indices {
        if txt[i] == " " {
            result.append(String(txt[..<i]))
            result.append(String(txt[i+1..<txt.endIndex]))
        }
    }
    return .success(result)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
    var result = [String]()
    var count = 0
    for i in txt.indices {
        if txt[i] == " " {
            result.append(String(txt[..<i]))
            result.append(String(txt[i+1..<txt.endIndex]))
        }
    }
    return .success(result)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
    var result = [String]()
    var count = 0
    for i in txt.indices {
        if txt[i] == " " {
            result.append(String(txt[..<i]))
            result.append(String(txt[i+1..<txt.endIndex]))
        }
    }
    return .success(result)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
    var result = [String]()
    var count = 0
    for i in txt.indices {
        if txt[i] == " " {
            result.append(String(txt[..<i]))
            result.append(String(txt[i+1..<txt.endIndex]))
        }
    }
    return .success(result)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
    var result = [String]()
    var count = 0
    for i in txt.indices {
        if txt[i] == " " {
            result.append(String(txt[..<i]))
            result.append(String(txt[i+1..<txt.endIndex]))
        }
    }
    return .success(result)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
    var result = [String]()
    var count = 0
    for i in txt.indices {
        

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var odd = 0
    var result = [String]()
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        if word.contains(",") {
            result.append(word)
        } else {
            odd += 1
        }
    }
    return .success(result)
}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var odd = 0
    var result = [String]()
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        if word.contains(",") {
            result.append(word)
        } else {
            odd += 1
        }
    }
    return .success(result)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var odd = 0
    var result = [String]()
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        if word.contains(",") {
            result.append(word)
        } else {
            odd += 1
        }
    }
    return .success(result)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var odd = 0
    var result = [String]()
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        if word.contains(",") {
            result.append(word)
        } else {
            odd += 1
        }
    }
    return .success(result)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var odd = 0
    var result = [String]()
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        if word.contains(",") {
            result.append(word)
        } else {
            odd += 1
        }
    }
    return .success(result)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var odd = 0
    var result = [String]()
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        if word.contains(",") {
            result.append(word)
        } else {
            odd += 1
        }
    }
    return .success(result)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String)

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ").map { String($0) }
    var count = 0
    for i in 0..<words.count {
        if words[i].contains(" ") {
            return .failure(count)
        }
        if words[i].contains(",") {
            words[i] = words[i].replacingOccurrences(of: ",", with: "")
        }
    }
    for i in 0..<words.count {
        if words[i].lowercased().firstIndex(of: "a")!.utf16Offset(in: words[i]) % 2 != 0 {
            count += 1
        }
    }
    return .success(words)
}

func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ").map { String($0) }
    var count = 0
    for i in 0..<words.count {
        if words[i].contains(" ") {
            return .failure(count)
        }
        if words[i].contains(",") {
            words[i] = words[i].replacingOccurrences(of: ",", with: "")
        }
    }
    for i in 0..<words.count {
        if words[i].lowercased().firstIndex(of: "a")!.utf16Offset(in: words[i]) % 2 != 0 {
            count += 1
        }
    }
    return .success(words)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ").map { String($0) }
    var count = 0
    for i in 0..<words.count {
        if words[i].contains(" ") {
            return .failure(count)
        }
        if words[i].contains(",") {
            words[i] = words[i].replacingOccurrences(of: ",", with: "")
        }
    }
    for i in 0..<words.count {
        if words[i].lowercased().firstIndex(of: "a")!.utf16Offset(in: words[i]) % 2 != 0 {
            count += 1
        }
    }
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ").map { String($0) }
    var count = 0
    for i in 0..<words.count {
        if words[i].contains(" ") {
            return .failure(count)
        }
        if words[i].contains(",") {
            words[i] = words[i].replacingOccurrences(of: ",", with: "")
        }
    }
    for i in 0..<words.count {
        if words[i].lowercased().firstIndex(of: "a")!.utf16Offset(in: words[i]) % 2 != 0 {
            count += 1
        }
    }
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ").map { String($0) }
    var count = 0
    for i in 0..<words.count {
        if words[i].contains(" ") {
            return .failure(count)
        }
        if words[i].contains(",") {
            words[i] = words[i].replacingOccurrences(of: ",", with: "")
        }
    }
    for i in 0..<words.count {
        if words[i].lowercased().firstIndex(of: "a")!.utf16Offset(in: words[i]) % 2 != 0 {
            count += 1
        }
    }
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ").map { String($0) }
    var count = 0
    for i in 0..<words.

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    let oddLetters = words.filter { $0.count % 2 != 0 }
    let oddLettersCount = oddLetters.count
    if oddLettersCount == 0 {
        return .failure(oddLettersCount)
    }
    return .success(words)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    let oddLetters = words.filter { $0.count % 2 != 0 }
    let oddLettersCount = oddLetters.count
    if oddLettersCount == 0 {
        return .failure(oddLettersCount)
    }
    return .success(words)
}
<|file_separator|>

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    let oddLetters = words.filter { $0.count % 2 != 0 }
    let lowerCaseLetters = words.filter { $0.lowercased() == $0 }
    let lowerCaseLettersCount = lowerCaseLetters.count
    let oddLettersCount = oddLetters.count
    if oddLettersCount == 0 {
        return .failure(lowerCaseLettersCount)
    }
    return .success(words)
}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    let oddLetters = words.filter { $0.count % 2 != 0 }
    let lowerCaseLetters = words.filter { $0.lowercased() == $0 }
    let lowerCaseLettersCount = lowerCaseLetters.count
    let oddLettersCount = oddLetters.count
    if oddLettersCount == 0 {
        return .failure(lowerCaseLettersCount)
    }
    return .success(words)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    let oddLetters = words.filter { $0.count % 2 != 0 }
    let lowerCaseLetters = words.filter { $0.lowercased() == $0 }
    let lowerCaseLettersCount = lowerCaseLetters.count
    let oddLettersCount = oddLetters.count
    if oddLettersCount == 0 {
        return .failure(lowerCaseLettersCount)
    }
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    let oddLetters = words.filter { $0.count % 2 != 0 }
    let lowerCaseLetters = words.filter { $0.lowercased() == $0 }
    let lowerCaseLettersCount = lowerCaseLetters.count
    let oddLettersCount = oddLetters.count
    if oddLettersCount == 0 {
        return .failure(lowerCaseLettersCount)
    }
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    let oddLetters = words.filter { $0.count % 2 != 0 }
    let lowerCaseLetters = words.filter { $0.lowercased() == $0 }
    let lowerCaseLettersCount = lowerCaseLetters.count
    let oddLettersCount = oddLetters.count
    if oddLettersCount == 0 {
        return .failure(lowerCaseLettersCount)
    }
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    let oddLetters = words.filter { $0.count % 2 != 0 }
    let lowerCaseLetters = words.filter { $0.lowercased() == $0 }
    let lowerCaseLettersCount = lowerCaseLetters.count
    let oddLettersCount = oddLetters.count
    if oddLettersCount == 0 {
        return .failure(lowerCaseLettersCount)
    }
    return .success(words)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0,

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddCount = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        for char in word {
            if char.isLowercase {
                oddCount += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddCount = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        for char in word {
            if char.isLowercase {
                oddCount += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddCount = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        for char in word {
            if char.isLowercase {
                oddCount += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddCount = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        for char in word {
            if char.isLowercase {
                oddCount += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddCount = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        for char in word {
            if char.isLowercase {
                oddCount += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddCount = 0
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        for char in word {
            if char.isLowercase {
                oddCount += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    let oddLetters = words.filter { $0.count % 2 == 1 }.map { $0.lowercased() }.sorted { $0 < $1 }
    return oddLetters.count
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    let oddLetters = words.filter { $0.count % 2 == 1 }.map { $0.lowercased() }.sorted { $0 < $1 }
    return oddLetters.count
}
<|file_separator|>

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddLetters = 0
    for word in words {
        let letters = Array(word)
        for letter in letters {
            if letter.isLowercase && (Int(letter) ?? 0) % 2 != 0 {
                oddLetters += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddLetters = 0
    for word in words {
        let letters = Array(word)
        for letter in letters {
            if letter.isLowercase && (Int(letter) ?? 0) % 2 != 0 {
                oddLetters += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddLetters = 0
    for word in words {
        let letters = Array(word)
        for letter in letters {
            if letter.isLowercase && (Int(letter) ?? 0) % 2 != 0 {
                oddLetters += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddLetters = 0
    for word in words {
        let letters = Array(word)
        for letter in letters {
            if letter.isLowercase && (Int(letter) ?? 0) % 2 != 0 {
                oddLetters += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddLetters = 0
    for word in words {
        let letters = Array(word)
        for letter in letters {
            if letter.isLowercase && (Int(letter) ?? 0) % 2 != 0 {
                oddLetters += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddLetters = 0
    for word in words {
        let letters = Array(word)
        for letter in letters {
            if letter.isLowercase && (Int(letter) ?? 0) % 2 != 0 {
                oddLetters += 1
            }
        }
    }
    return .success(words.map { String($0) })
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddLetters = 0
    var result = [String]()
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        if word.contains(",") {
            result.append(word.replacingOccurrences(of: ",", with: ""))
        } else {
            for letter in word {
                if letter.isLowercase && (Int(letter) ?? 0) % 2 != 0 {
                    oddLetters += 1
                }
            }
            result.append(word)
        }
    }
    return .success(result)
}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddLetters = 0
    var result = [String]()
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        if word.contains(",") {
            result.append(word.replacingOccurrences(of: ",", with: ""))
        } else {
            for letter in word {
                if letter.isLowercase && (Int(letter) ?? 0) % 2 != 0 {
                    oddLetters += 1
                }
            }
            result.append(word)
        }
    }
    return .success(result)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddLetters = 0
    var result = [String]()
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        if word.contains(",") {
            result.append(word.replacingOccurrences(of: ",", with: ""))
        } else {
            for letter in word {
                if letter.isLowercase && (Int(letter) ?? 0) % 2 != 0 {
                    oddLetters += 1
                }
            }
            result.append(word)
        }
    }
    return .success(result)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddLetters = 0
    var result = [String]()
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        if word.contains(",") {
            result.append(word.replacingOccurrences(of: ",", with: ""))
        } else {
            for letter in word {
                if letter.isLowercase && (Int(letter) ?? 0) % 2 != 0 {
                    oddLetters += 1
                }
            }
            result.append(word)
        }
    }
    return .success(result)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddLetters = 0
    var result = [String]()
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        if word.contains(",") {
            result.append(word.replacingOccurrences(of: ",", with: ""))
        } else {
            for letter in word {
                if letter.isLowercase && (Int(letter) ?? 0) % 2 != 0 {
                    oddLetters += 1
                }
            }
            result.append(word)
        }
    }
    return .success(result)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    var oddLetters = 0
    var result = [String]()
    for word in words {
        if word.contains(" ") {
            return .failure(3)
        }
        if word.contains(",") {
            result.append(word.replacingOccurrences(of

extension Int: Error {

}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    let wordsWithOddOrder = words.filter { $0.count % 2 == 1 }
    let wordsWithEvenOrder = words.filter { $0.count % 2 == 0 }
    let oddOrderLetters = wordsWithOddOrder.map { $0.lowercased() }
    let evenOrderLetters = wordsWithEvenOrder.map { $0.lowercased() }
    let oddOrderLettersCount = oddOrderLetters.count
    let evenOrderLettersCount = evenOrderLetters.count
    let oddOrderLettersSorted = oddOrderLetters.sorted()
    let evenOrderLettersSorted = evenOrderLetters.sorted()
    let oddOrderLettersSortedCount = oddOrderLettersSorted.count
    let evenOrderLettersSortedCount = evenOrderLettersSorted.count
    let oddOrderLettersSortedFirst = oddOrderLettersSorted.first ?? ""
    let evenOrderLettersSortedFirst = evenOrderLettersSorted.first ?? ""
    let oddOrderLettersSortedLast = oddOrderLettersSorted.last ?? ""
    let evenOrderLettersSortedLast = evenOrderLettersSorted.last ?? ""
    let oddOrderLettersSortedFirstIndex = oddOrderLettersSorted.firstIndex(of: oddOrderLettersSortedFirst) ?? 0
    let evenOrderLettersSortedFirstIndex = evenOrderLettersSorted.firstIndex(of: evenOrderLettersSortedFirst) ?? 0
    let oddOrderLettersSortedLastIndex = oddOrderLettersSorted.lastIndex(of: oddOrderLettersSortedLast) ?? 0
    let evenOrderLettersSortedLastIndex = evenOrderLettersSorted.lastIndex(of: evenOrderLettersSortedLast) ?? 0
    let oddOrderLettersSortedFirstIndexDiff = oddOrderLettersSortedFirstIndex - evenOrderLettersSortedFirstIndex
    let evenOrderLettersSortedFirstIndexDiff = evenOrderLettersSortedFirstIndex - oddOrderLettersSortedFirstIndex
    let oddOrderLettersSortedLastIndexDiff = oddOrderLettersSortedLastIndex - evenOrderLettersSortedLastIndex
    let evenOrderLettersSortedLastIndexDiff = evenOrderLettersSortedLastIndex - oddOrderLettersSortedLastIndex
    let oddOrderLettersSortedFirstIndexDiffAbs = abs(oddOrderLettersSortedFirstIndexDiff)
    let evenOrderLettersSortedFirstIndexDiffAbs = abs(evenOrderLettersSortedFirstIndexDiff)
    let oddOrderLettersSortedLastIndexDiffAbs = abs(oddOrderLettersSortedLastIndexDiff)
    let evenOrderLettersSortedLastIndexDiffAbs = abs(evenOrderLettersSortedLastIndexDiff)
    let oddOrderLettersSortedFirstIndexDiffAbsSum = oddOrderLettersSortedFirstIndexDiffAbs + evenOrderLettersSortedFirstIndexDiffAbs
    let evenOrderLettersSortedFirstIndexDiffAbsSum = oddOrderLettersSortedFirstIndexDiffAbs + evenOrderLettersSortedFirstIndexDiffAbs
    let oddOrderLettersSortedLastIndexDiffAbsSum = oddOrderLettersSortedLastIndexDiffAbs + evenOrderLettersSortedLastIndexDiffAbs
    let evenOrderLettersSortedLastIndexDiffAbsSum = oddOrderLettersSortedLastIndexDiffAbs + evenOrderLettersSortedLastIndexDiffAbs
    let oddOrderLettersSortedFirstIndexDiffAbsSumAbs = abs(oddOrderLettersSortedFirstIndexDiffAbsSum)
    let evenOrderLettersSortedFirstIndexDiffAbsSumAbs = abs(evenOrderLettersSortedFirstIndexDiffAbsSum)
    let oddOrderLettersSortedLastIndexDiffAbsSumAbs = abs(oddOrderLettersSortedLastIndexDiffAbsSum)
    let evenOrderLettersSortedLastIndexDiffAbsSumAbs = abs(evenOrderLettersSortedLastIndexDiffAbsSum)
    let oddOrderLettersSortedFirstIndexDiffAbsSumAbsSum = oddOrderLettersSortedFirstIndexDiffAbsSumAbs + evenOrderLettersSortedFirstIndexDiffAbsSumAbs
    let evenOrderLettersSortedFirstIndexDiffAbsSumAbsSum = oddOrderLettersSortedFirstIndexDiffAbsSumAbs + evenOrderLettersSortedFirstIndexDiffAbsSumAbs
    let oddOrderLettersSortedLastIndexDiffAbsSumAbsSum = oddOrderLettersSortedLastIndexDiffAbsSumAbs + evenOrderLettersSortedLastIndexDiffAbsSumAbs
    let evenOrderLettersSortedLastIndexDiffAbsSumAbsSum = oddOrderLettersSortedLastIndexDiffAbsSumAbs + evenOrderLettersSortedLastIndexDiffAbsSumAbs
    let oddOrderLettersSortedFirstIndexDiffAbsSumAbsSumAbs = abs(oddOrderLettersSortedFirstIndexDiffAbsSumAbsSum)
    let evenOrderLettersSortedFirstIndexDiffAbsSumAbsSumAbs = abs(evenOrderLettersSortedFirstIndexDiffAbsSumAbsSum)
    let oddOrderLettersSortedLastIndexDiffAbsSumAbsSumAbs = abs(oddOrderLettersSortedLastIndexDiffAbsSumAbsSum)
    let evenOrderLettersSortedLast

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    let oddLetters = words.filter { $0.count % 2 != 0 }.map { $0.lowercased() }.sorted { ord($0) < ord($1) }
    return oddLetters.count
}

func sumPairs(arr: [Int], target: Int) -> Result<Int, Int> {
    var count = 0
    for i in 0..<arr.count {
        for j in i+1..<arr.count {
            if arr[i] + arr[j] == target {
                count += 1
            }
        }
    }
    return count
}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    let oddLetters = words.filter { $0.count % 2 != 0 }.map { $0.lowercased() }.sorted { ord($0) < ord($1) }
    return oddLetters.count
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    let oddLetters = words.filter { $0.count % 2 != 0 }.map { $0.lowercased() }.sorted { ord($0) < ord($1) }
    return oddLetters.count
}

// Given an array of integers, return the number of times the sum of two integers in the array equals the target sum.
// Examples
// sumPairs([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 11) == .success(2)
// sumPairs([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 12) == .success(1)
// sumPairs([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 13) == .failure(0)
func sumPairs(arr: [Int], target: Int) -> Result<Int, Int> {
    var count = 0
    for i in 0..<arr.count {
        for j in i+1..<arr.count {
            if arr[i] + arr[j] == target {
                count += 1
            }
        }
    }
    return count
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    let oddLetters = words.filter { $0.count % 2 != 0 }.map { $0.lowercased() }.sorted { ord($0) < ord($1) }
    return oddLetters.count
}

// Given an array of integers, return the number of times the sum of two integers in the array equals the target sum.
// Examples
// sumPairs([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 11) == .success(2)
// sumPairs([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 12) == .success(1)
// sumPairs([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 13) == .failure(0)
func sumPairs(arr: [Int], target: Int) -> Result<Int, Int> {
    var count = 0
    for i in 0..<arr.count {
        for j in i+1..<arr.count {
            if arr[i] + arr[j] == target {
                count += 1
            }
        }
    }
    return count
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ").map { String($0) }
    let oddLetters = words.filter { $0.count % 2 != 0 }.map { $0.lowercased() }.sorted { ord($

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    let words2 = txt.components(separatedBy: ",")
    if words.count > 1 {
        return .success(words)
    } else if words2.count > 1 {
        return .success(words2)
    } else {
        return .failure(oddLetters(txt: txt))
    }
}

func oddLetters(txt: String) -> Int {
    let alphabet = "abcdefghijklmnopqrstuvwxyz"
    var count = 0
    for letter in txt {
        let index = alphabet.firstIndex(of: letter)!
        if index % 2 != 0 {
            count += 1
        }
    }
    return count
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    let words2 = txt.components(separatedBy: ",")
    if words.count > 1 {
        return .success(words)
    } else if words2.count > 1 {
        return .success(words2)
    } else {
        return .failure(oddLetters(txt: txt))
    }
}

// Given a string of lower-case letters, return the number of lower-case letters with odd order in the alphabet,
// ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// oddLetters(txt: "abcdef") == 3
// oddLetters(txt: "az") == 1
// oddLetters(txt: "z") == 0
func oddLetters(txt: String) -> Int {
    let alphabet = "abcdefghijklmnopqrstuvwxyz"
    var count = 0
    for letter in txt {
        let index = alphabet.firstIndex(of: letter)!
        if index % 2 != 0 {
            count += 1
        }
    }
    return count
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return .success(words.map(String.init))
    } else {
        let chars = txt.split(separator: ",")
        if chars.count > 1 {
            return .success(chars.map(String.init))
        } else {
            let count = txt.reduce(0) { $0 + ($1.isLowercase && $1.asciiValue! % 2 == 1 ? 1 : 0) }
            return .failure(count)
        }
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return .success(words.map(String.init))
    } else {
        let chars = txt.split(separator: ",")
        if chars.count > 1 {
            return .success(chars.map(String.init))
        } else {
            let count = txt.reduce(0) { $0 + ($1.isLowercase && $1.asciiValue! % 2 == 1 ? 1 : 0) }
            return .failure(count)
        }
    }
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map { String($0) })
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map { String($0) })
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                if char.asciiValue! % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map { String($0) })
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map { String($0) })
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                if char.asciiValue! % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: .whitespacesAndNewlines)
    if words.count > 1 {
        return .success(words)
    }
    let words2 = txt.components(separatedBy: ",")
    if words2.count > 1 {
        return .success(words2)
    }
    return .failure(txt.lowercased().filter { $0.isLetter && $0.asciiValue! % 2 == 1 }.count)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: .whitespacesAndNewlines)
    if words.count > 1 {
        return .success(words)
    }
    let words2 = txt.components(separatedBy: ",")
    if words2.count > 1 {
        return .success(words2)
    }
    return .failure(txt.lowercased().filter { $0.isLetter && $0.asciiValue! % 2 == 1 }.count)
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: CharacterSet.whitespaces) {
        return .success(txt.components(separatedBy: " "))
    }
    if let _ = txt.range(of: ",") {
        return .success(txt.components(separatedBy: ","))
    }
    
    var count = 0
    for (index, char) in txt.enumerated() {
        if char.isLowercase {
            if index % 2 == 1 {
                count += 1
            }
        }
    }
    
    return .failure(count)
}

func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: CharacterSet.whitespaces) {
        return .success(txt.components(separatedBy: " "))
    }
    if let _ = txt.range(of: ",") {
        return .success(txt.components(separatedBy: ","))
    }
    
    var count = 0
    for (index, char) in txt.enumerated() {
        if char.isLowercase {
            if index % 2 == 1 {
                count += 1
            }
        }
    }
    
    return .failure(count)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: CharacterSet.whitespaces) {
        return .success(txt.components(separatedBy: " "))
    }
    if let _ = txt.range(of: ",") {
        return .success(txt.components(separatedBy: ","))
    }
    
    var count = 0
    for (index, char) in txt.enumerated() {
        if char.isLowercase {
            if index % 2 == 1 {
                count += 1
            }
        }
    }
    
    return .failure(count)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: CharacterSet.whitespaces) {
        return .success(txt.components(separatedBy: " "))
    }
    if let _ = txt.range(of: ",") {
        return .success(txt.components(separatedBy: ","))
    }
    
    var count = 0
    for (index, char) in txt.enumerated() {
        if char.isLowercase {
            if index % 2 == 1 {
                count += 1
            }
        }
    }
    
    return .failure(count)
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
    let words = txt.components(separatedBy: .whitespacesAndNewlines)
    if words.isEmpty {
        return .failure(0)
    }
    let words2 = txt.components(separatedBy: ",")
    if words2.count > 1 {
        return .success(words2)
    }
    let count = txt.lowercased().filter { $0.isLetter && $0.asciiValue! % 2 == 1 }.count
    return .failure(count)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
    let words = txt.components(separatedBy: .whitespacesAndNewlines)
    if words.isEmpty {
        return .failure(0)
    }
    let words2 = txt.components(separatedBy: ",")
    if words2.count > 1 {
        return .success(words2)
    }
    let count = txt.lowercased().filter { $0.isLetter && $0.asciiValue! % 2 == 1 }.count
    return .failure(count)
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.components(separatedBy: " "))
    } else if txt.contains(",") {
        return .success(txt.components(separatedBy: ","))
    } else {
        let count = txt.filter { $0.isLowercase }.map { $0.asciiValue! - 97 }.filter { $0 % 2 != 0 }.count
        return .failure(count)
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.components(separatedBy: " "))
    } else if txt.contains(",") {
        return .success(txt.components(separatedBy: ","))
    } else {
        let count = txt.filter { $0.isLowercase }.map { $0.asciiValue! - 97 }.filter { $0 % 2 != 0 }.count
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    // your code here
}
```

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: CharacterSet.whitespaces) {
        return .success(txt.split(separator: " "))
    } else if let _ = txt.rangeOfCharacter(from: CharacterSet.decimalDigits) {
        return .success(txt.split(separator: ","))
    } else {
        return .failure(txt.lowercased().reduce(0) { $0 + $1.unicodeScalars.first!.value % 2 })
    }
}

func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: CharacterSet.whitespaces) {
        return .success(txt.split(separator: " "))
    } else if let _ = txt.rangeOfCharacter(from: CharacterSet.decimalDigits) {
        return .success(txt.split(separator: ","))
    } else {
        return .failure(txt.lowercased().reduce(0) { $0 + $1.unicodeScalars.first!.value % 2 })
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: CharacterSet.whitespaces) {
        return .success(txt.split(separator: " "))
    } else if let _ = txt.rangeOfCharacter(from: CharacterSet.decimalDigits) {
        return .success(txt.split(separator: ","))
    } else {
        return .failure(txt.lowercased().reduce(0) { $0 + $1.unicodeScalars.first!.value % 2 })
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: CharacterSet.whitespaces) {
        return .success(txt.split(separator: " "))
    } else if let _ = txt.rangeOfCharacter(from: CharacterSet.decimalDigits) {
        return .success(txt.split(separator: ","))
    } else {
        return .failure(txt.lowercased().reduce(0) { $0 + $1.unicodeScalars.first!.value % 2 })
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: CharacterSet.whitespaces) {
        return .success(txt.split(separator: " "))
    } else if let _ = txt.rangeOfCharacter(from: CharacterSet.decimalDigits) {
        return .success(txt.split(separator: ","))
    } else {
        return .failure(txt.lowercased().reduce(0) { $0 + $1.unicodeScalars.first!.value % 2 })
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    if let _ = txt.rangeOfCharacter(from: CharacterSet.whitespaces) {
        return .success(txt.split(separator: " "))
    } else if let _ = txt.rangeOfCharacter(from: CharacterSet.decimalDigits) {
        return .success(txt.split(separator: ","))
    } else {
        return .failure(txt.lowercased().reduce(0) { $0 + $1.unicodeScalars.first!.value % 2 })
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = Array<String>()
    var words = txt.split(" ")
    for word in words {
        if word.contains(" ") {
            result.append(word)
        } else {
            var letters = word.map { (it.codePointAt(0) - 97) % 2 == 1 }.filter { it }
            result.append(letters.count.toString())
        }
    }
    return result.makeResult()
}

func sumIntegers(nums: [Int]) -> Result<Int, Int> {
    var sum = 0
    for num in nums {
        if num < 0 {
            sum += num
        }
    }
    return sum.makeResult()
}

func removeVowels(txt: String) -> Result<String, Int> {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    for _, c in txt.codePoints {
        if !vowels.contains(String(c)) {
            result += String(c)
        }
    }
    return result.makeResult()
}

func removeConsonants(txt: String) -> Result<String, Int> {
    var consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var result = ""
    for _, c in txt.codePoints {
        if !consonants.contains(String(c)) {
            result += String(c)
        }
    }
    return result.makeResult()
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = Array<String>()
    var words = txt.split(" ")
    for word in words {
        if word.contains(" ") {
            result.append(word)
        } else {
            var letters = word.map { (it.codePointAt(0) - 97) % 2 == 1 }.filter { it }
            result.append(letters.count.toString())
        }
    }
    return result.makeResult()
}

// Given an array of integers, return the sum of the integers, if the sum is negative, return the sum of the negative
// integers, if no negative integers exist, return 0
// Examples
// sumIntegers([1, 2, 3, 4, 5]) == .success(15)
// sumIntegers([-1, -2, -3, -4, -5]) == .success(-15)
// sumIntegers([1, 2, -3, -4, 5]) == .success(-2)
// sumIntegers([1, 2, -3, -4, 5, 6, -7, -8, -9, -10]) == .success(-55)
// sumIntegers([1, 2, -3, -4, 5, 6, -7, -8, -9, -10, 11, -12, -13, -14, -15, -16, -17, -18, -19, -20]) == .success(0)
func sumIntegers(nums: [Int]) -> Result<Int, Int> {
    var sum = 0
    for num in nums {
        if num < 0 {
            sum += num
        }
    }
    return sum.makeResult()
}

// Given a string, return a string with all the vowels removed
// Examples
// removeVowels("Hello World!") == .success("Hll Wrld!")
// removeVowels("Hello, World!") == .success("Hll, Wrld!")
// removeVowels("Hello, World?") == .success("Hll, Wrld?")
// removeVowels("Hello, World??") == .success("Hll, Wrld?")
func removeVowels(txt: String) -> Result<String, Int> {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    for _, c in txt.codePoints {
        if !vowels.contains(String(c)) {
            result += String(c)
        }
    }
    return result.makeResult()
}

// Given a string, return a string with all the consonants removed
// Examples
// removeConsonants("Hello World!") == .success("Hll Wrld!")
// removeConsonants("Hello, World!") == .success("Hll, Wrld!")
// removeConsonants("Hello, World?") == .success("Hll, Wrld?")
// removeConsonants("Hello, World??") == .success("Hll, Wrld?")
func removeConsonants(txt: String) -> Result<String, Int> {
    var consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var result = ""
    for _, c in txt.codePoints {
        if !consonants.contains(String(c)) {
            result += String(c)
        }
    }
    return result.makeResult()
}

// Given a string, return a string with all the vowels and consonants removed
// Examples
// removeVowelsAndConsonants("Hello World!") == .success("Hll Wrld!")
// removeVowelsAndConsonants("Hello, World!") == .success("Hll, Wrld!")
// removeVowelsAndConsonants("Hello, World?") == .success("Hll, Wrld?")
// removeVowelsAndConsonants("Hello, World??") == .success("Hll, Wrld?")
func removeVowelsAndConsonants(txt: String) -> Result<String, Int> {
    var vowels = ["a", "e", "i", "o", "u"]
    var consonants = ["b", "c", "d", "f

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ")
    if words.isEmpty {
        return words.split(separator: ",")
    }
    return .success(words)
}

func sortWords(words: [String]) -> Result<[String], Int> {
    if words.isEmpty {
        return .success([])
    }
    return .success(words.sorted())
}

func sortWordsByLength(words: [String]) -> Result<[String], Int> {
    if words.isEmpty {
        return .success([])
    }
    return .success(words.sorted(by: { |a, b| a.length - b.length }))
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ")
    if words.isEmpty {
        return words.split(separator: ",")
    }
    return .success(words)
}

// Given an array of words, return the words sorted alphabetically, if the array is empty return an empty array
// Examples
// sortWords(words: ["Hello", "world!"]) == .success(["Hello", "world!"])
// sortWords(words: ["Hello", "world!", "!"]) == .success(["!", "Hello", "world!"])
// sortWords(words: ["Hello", "world!", "!", "a", "b", "c"]) == .success(["!", "a", "b", "c", "Hello", "world!"])
// sortWords(words: []) == .success([])
func sortWords(words: [String]) -> Result<[String], Int> {
    if words.isEmpty {
        return .success([])
    }
    return .success(words.sorted())
}

// Given an array of words, return the words sorted by length, if the array is empty return an empty array
// Examples
// sortWords(words: ["Hello", "world!"]) == .success(["Hello", "world!"])
// sortWords(words: ["Hello", "world!", "!"]) == .success(["!", "Hello", "world!"])
// sortWords(words: ["Hello", "world!", "!", "a", "b", "c"]) == .success(["!", "a", "b", "c", "Hello", "world!"])
// sortWords(words: []) == .success([])
func sortWordsByLength(words: [String]) -> Result<[String], Int> {
    if words.isEmpty {
        return .success([])
    }
    return .success(words.sorted(by: { |a, b| a.length - b.length }))
}

// Given an array of words, return the words sorted by length, if the array is empty return an empty array
// Examples
// sortWords(words: ["Hello", "world!"]) == .success(["Hello", "world!"])
// sortWords(words: ["Hello", "world!", "!"]) == .success(["!", "Hello", "world!"])
// sortWords(words: ["Hello", "world!", "!", "a", "b", "c"]) == .success(["!", "a", "b", "c", "Hello", "world!"])
// sortWords(words: []) == .success([])
func sortWordsByLength(words: [String]) -> Result<[String], Int> {
    if words.isEmpty {
        return .success([])
    }
    return .success(words.sorted(by: { |a, b| a.length - b.length }))
}

// Given an array of words, return the words sorted by length, if the array is empty return an empty array
// Examples
// sortWords(words: ["Hello", "world!"]) == .success(["Hello", "world!"])
// sortWords(words: ["Hello", "world!", "!"]) == .success(["!", "Hello", "world!"])
// sortWords(words: ["Hello", "world!", "!", "a", "b", "c"]) == .success(["!", "a", "b", "c", "Hello", "world!"])
// sortWords(words: []) == .success([])
func sortWordsByLength(words: [String]) -> Result<[String], Int> {
    if words.isEmpty {
        return .success([])
    }
    return .success(words.sorted(by: { |a, b| a.length - b.length }))
}

// Given an array of words, return the words sorted by length, if the array is empty return an empty array
// Examples
// sortWords(words: ["Hello", "world!"]) == .success(["Hello", "world!"])
// sortWords(words: ["Hello", "world!", "!"]) == .success(["!", "Hello", "world!"])
// sortWords(words: ["Hello", "world!", "!", "a", "b", "c"]) == .success(["!", "a", "b", "c", "Hello", "world!"])
// sortWords(words: []) == .success([])
func sortWordsByLength(words: [String]) -> Result<[String], Int> {
    if words.isEmpty {
        return .success([])
    }
    return .success(words.sorted(by: { |a, b| a.length - b.length }))

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ")
    if words.isEmpty {
        return .success(words)
    }
    var letters = 0
    for word in words {
        letters += word.count { $0.isLower && $0.order > 0 }
    }
    return .failure(letters)
}

func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ")
    if words.isEmpty {
        return .success(words)
    }
    var letters = 0
    for word in words {
        letters += word.count { $0.isLower && $0.order > 0 }
    }
    return .failure(letters)
}

func joinWords(words: Result<[String], Int>) -> String {
    if let words = words.unwrap() {
        return words.join(separator: ",")
    }
    return words.error.toString()
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ")
    if words.isEmpty {
        return .success(words)
    }
    var letters = 0
    for word in words {
        letters += word.count { $0.isLower && $0.order > 0 }
    }
    return .failure(letters)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ")
    if words.isEmpty {
        return .success(words)
    }
    var letters = 0
    for word in words {
        letters += word.count { $0.isLower && $0.order > 0 }
    }
    return .failure(letters)
}

// Given an array of words, return a string of words joined by commas ','
// Examples
// joinWords(words: .success(["Hello", "world!"]) == "Hello,world!"
// joinWords(words: .success(["Hello", "world!"]) == "Hello,world!"
// joinWords(words: .failure(3) == "3"
func joinWords(words: Result<[String], Int>) -> String {
    if let words = words.unwrap() {
        return words.join(separator: ",")
    }
    return words.error.toString()
}

// Given an array of words, return a string of words joined by commas ','
// Examples
// joinWords(words: .success(["Hello", "world!"]) == "Hello,world!"
// joinWords(words: .success(["Hello", "world!"]) == "Hello,world!"
// joinWords(words: .failure(3) == "3"
func joinWords(words: Result<[String], Int>) -> String {
    if let words = words.unwrap() {
        return words.join(separator: ",")
    }
    return words.error.toString()
}

// Given an array of words, return a string of words joined by commas ','
// Examples
// joinWords(words: .success(["Hello", "world!"]) == "Hello,world!"
// joinWords(words: .success(["Hello", "world!"]) == "Hello,world!"
// joinWords(words: .failure(3) == "3"
func joinWords(words: Result<[String], Int>) -> String {
    if let words = words.unwrap() {
        return words.join(separator: ",")
    }
    return words.error.toString()
}

// Given an array of words, return a string of words joined by commas ','
// Examples
// joinWords(words: .success(["Hello", "world!"]) == "Hello,world!"
// joinWords(words: .success(["Hello", "world!"]) == "Hello,world!"
// joinWords(words: .failure(3) == "3"
func joinWords(words: Result<[String], Int>) -> String {
    if let words = words.unwrap() {
        return words.join(separator: ",")
    }
    return words.error.toString()
}

// Given an array of words, return a string of words joined by commas ','
// Examples
// joinWords(words: .success(["Hello", "world!"]) == "Hello,world!"
// joinWords(words: .success(["Hello", "world!"]) == "Hello,world!"
// joinWords(words: .failure(3) == "3"
func joinWords(words: Result<[String], Int>) -> String {
    if let words = words.unwrap() {
        return words.join(separator: ",")
    }
    return words.error.toString()
}

// Given an array of words, return a string of words joined by commas ','
// Examples
// joinWords(words: .success(["Hello", "world!"]) == "Hello,world!"
//

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ")
    if words.count > 0 {
        return .success(words)
    }
    words = txt.split(separator: ",")
    if words.count > 0 {
        return .success(words)
    }
    var letters = 0
    for i in 0..<txt.count {
        if txt[i].isLower {
            if txt[i].code - 97 % 2 == 1 {
                letters += 1
            }
        }
    }
    return .failure(letters)
}

func joinWords(words: Result<[String], Int>, separator: String) -> Result<String, Int> {
    if let words = words.unwrap() {
        return .success(words.joined(separator: separator))
    }
    return .failure(words.unwrapError())
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ")
    if words.count > 0 {
        return .success(words)
    }
    words = txt.split(separator: ",")
    if words.count > 0 {
        return .success(words)
    }
    var letters = 0
    for i in 0..<txt.count {
        if txt[i].isLower {
            if txt[i].code - 97 % 2 == 1 {
                letters += 1
            }
        }
    }
    return .failure(letters)
}

// Given an array of words, return a string of words joined by the given separator
// Examples
// joinWords(words: .success(["Hello", "world!"]) separator: " ") == .success("Hello world!")
// joinWords(words: .success(["Hello", "world!"]) separator: ",") == .success("Hello,world!")
// joinWords(words: .failure(3)) == .failure(3)
func joinWords(words: Result<[String], Int>, separator: String) -> Result<String, Int> {
    if let words = words.unwrap() {
        return .success(words.joined(separator: separator))
    }
    return .failure(words.unwrapError())
}

// Given an array of words, return a string of words joined by the given separator
// Examples
// joinWords(words: .success(["Hello", "world!"]) separator: " ") == .success("Hello world!")
// joinWords(words: .success(["Hello", "world!"]) separator: ",") == .success("Hello,world!")
// joinWords(words: .failure(3)) == .failure(3)
func joinWords(words: Result<[String], Int>, separator: String) -> Result<String, Int> {
    if let words = words.unwrap() {
        return .success(words.joined(separator: separator))
    }
    return .failure(words.unwrapError())
}

// Given an array of words, return a string of words joined by the given separator
// Examples
// joinWords(words: .success(["Hello", "world!"]) separator: " ") == .success("Hello world!")
// joinWords(words: .success(["Hello", "world!"]) separator: ",") == .success("Hello,world!")
// joinWords(words: .failure(3)) == .failure(3)
func joinWords(words: Result<[String], Int>, separator: String) -> Result<String, Int> {
    if let words = words.unwrap() {
        return .success(words.joined(separator: separator))
    }
    return .failure(words.unwrapError())
}

// Given an array of words, return a string of words joined by the given separator
// Examples
// joinWords(words: .success(["Hello", "world!"]) separator: " ") == .success("Hello world!")
// joinWords(words: .success(["Hello", "world!"]) separator: ",") == .success("Hello,world!")
// joinWords(words: .failure(3)) == .failure(3)
func joinWords(words: Result<[String], Int>, separator: String) -> Result<String, Int> {
    if let words = words.unwrap() {
        return .success(words.joined(separator: separator))
    }
    return .failure(words.unwrapError())
}

// Given an array of words, return a string of words joined by the given separator
// Examples
// joinWords(words: .success(["Hello", "world!"]) separator: " ") == .success("Hello world!")
// joinWords(words: .success(["Hello", "world!"]) separator: ",") == .success("Hello,world!")
// joinWords(words: .failure(3)) == .failure(3)
func joinWords(words: Result<[String], Int>, separator: String) -> Result<String, Int> {
    if let words = words.unwrap() {
        return .success(words.joined(separator: separator))
    }
    return .failure(words.unwrapError())
}

// Given an array of words, return a string of words joined by the given separator
// Examples
// joinWords(words: .success(["Hello", "world!"]) separator: " ") == .success("Hello world!")
// joinWords(words: .success(["Hello", "world!"]) separator: ",") == .success("Hello,world!")
// joinWords(words: .

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = Array<String>()
    var words = txt.split(separator: " ")
    for word in words {
        if word.contains(" ") {
            result.append(word)
        }
    }
    return result.success(result.count)
}

func splitWords(txt: String) -> Result<[String], Int> {
    var result = Array<String>()
    var words = txt.split(separator: " ")
    for word in words {
        if word.contains(" ") {
            result.append(word)
        }
    }
    return result.success(result.count)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = Array<String>()
    var words = txt.split(separator: " ")
    for word in words {
        if word.contains(" ") {
            result.append(word)
        }
    }
    return result.success(result.count)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = Array<String>()
    var words = txt.split(separator: " ")
    for word in words {
        if word.contains(" ") {
            result.append(word)
        }
    }
    return result.success(result.count)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = Array<String>()
    var words = txt.split(separator: " ")
    for word in words {
        if word.contains(" ") {
            result.append(word)
        }
    }
    return result.success(result.count)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = Array<String>()
    var words = txt.split(separator: " ")
    for word in words {
        if word.contains(" ") {
            result.append(word)
        }
    }
    return result.success(result.count)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = Array<String>()
    var words = txt.split(separator: " ")
    for word in words {
        if word.contains(" ") {
            result.append(word)
        }
    }
    return result.success(result.count)
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = [String]()
    var isWhitespace = false
    var isComma = false
    for i in 0..<txt.count {
        var c = txt[i]
        if c.isWhitespace {
            isWhitespace = true
        } else if c.isComma {
            isComma = true
        } else {
            if isWhitespace {
                isWhitespace = false
                result.append(txt[i..<i + 1])
            } else if isComma {
                isComma = false
                result.append(txt[i..<i + 1])
            } else {
                return .failure(1)
            }
        }
    }
    return .success(result)
}

func joinWords(words: Result<[String], Int>) -> Result<String, Int> {
    if let words = words.unwrap() {
        var result = ""
        for i in 0..<words.count {
            result += words[i]
            if i < words.count - 1 {
                result += " "
            }
        }
        return .success(result)
    } else {
        return .failure(1)
    }
}

func joinWordsWithCommas(words: Result<[String], Int>) -> Result<String, Int> {
    if let words = words.unwrap() {
        var result = ""
        for i in 0..<words.count {
            result += words[i]
            if i < words.count - 1 {
                result += ","
            }
        }
        return .success(result)
    } else {
        return .failure(1)
    }
}

func oddOrder(txt: String) -> Result<Int, Int> {
    var result = 0
    var isWhitespace = false
    var isComma = false
    for i in 0..<txt.count {
        var c = txt[i]
        if c.isWhitespace {
            isWhitespace = true
        } else if c.isComma {
            isComma = true
        } else {
            if isWhitespace {
                isWhitespace = false
                if (ord(txt[i]) - ord('a')) % 2 == 1 {
                    result += 1
                }
            } else if isComma {
                isComma = false
                if (ord(txt[i]) - ord('a')) % 2 == 1 {
                    result += 1
                }
            } else {
                return .failure(1)
            }
        }
    }
    return .success(result)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = [String]()
    var isWhitespace = false
    var isComma = false
    for i in 0..<txt.count {
        var c = txt[i]
        if c.isWhitespace {
            isWhitespace = true
        } else if c.isComma {
            isComma = true
        } else {
            if isWhitespace {
                isWhitespace = false
                result.append(txt[i..<i + 1])
            } else if isComma {
                isComma = false
                result.append(txt[i..<i + 1])
            } else {
                return .failure(1)
            }
        }
    }
    return .success(result)
}

// Given an array of words, return a string of words joined by spaces
// Examples
// joinWords(words: .success(["Hello", "world!"]) == .success("Hello world!")
// joinWords(words: .success(["Hello", "world!"]) == .success("Hello,world!")
// joinWords(words: .failure(3)) == .failure(3)
func joinWords(words: Result<[String], Int>) -> Result<String, Int> {
    if let words = words.unwrap() {
        var result = ""
        for i in 0..<words.count {
            result += words[i]
            if i < words.count - 1 {
                result += " "
            }
        }
        return .success(result)
    } else {
        return .failure(1)
    }
}

// Given a string of words, return a string of words joined by commas
// Examples
// joinWords(words: .success(["Hello", "world!"]) == .success("Hello,world!")
// joinWords(words: .success(["Hello", "world!"]) == .success("Hello,world!")
// joinWords(words: .failure(3)) == .failure(3)
func joinWordsWithCommas(words: Result<[String], Int>) -> Result<String, Int> {
    if let words = words.unwrap() {
        var result = ""
        for i in 0..<words.count {
            result += words[i]
            if i < words.count - 1 {
                result += ","
            }
        }
        return .success(result)
    } else {
        return .failure(1)
    }
}

// Given a string of words, return the number of words with odd order in the alphabet
// Examples
// oddOrder(txt: "Hello world!") == .success(1)
// oddOrder(txt: "Hello,world!") == .success(1)
// oddOrder(txt: "abcdef") == .success(0)
// oddOrder(txt: "abcdefg") == .success(1)
// oddOrder(txt: "abcdefgh") == .success(2)
func oddOrder(txt: String) -> Result<Int, Int> {
    var result = 0
    var isWhitespace = false
    var isComma = false
    for i in 0..<txt.count {
        var c = txt[i]
        if c.isWhitespace {
            isWhitespace = true
        } else if c.isComma {
            isComma = true
        } else {
            if isWhitespace {
                isWhitespace = false
                if (ord(txt[i]) - ord('a')) % 2 == 1 {
                    result += 1
                }
            } else if isComma {
                isComma = false
                if (ord(txt[i]) - ord('a')) % 2 == 1 {
                    result += 1
                }
            } else {
                return .failure(1)
            }
        }
    }
    return .success(result)
}

// Given a string of words, return the number of words with even order in the alphabet
// Examples
// evenOrder(txt: "Hello world!") == .success(0)
// evenOrder(txt: "Hello,world!") == .success(0)
// evenOrder(txt: "abcdef") == .success(6)
// evenOrder(txt: "abcdefg") == .success(5)
// evenOrder(txt: "abcdefgh") == .success(4)
func evenOrder(txt: String) -> Result<Int, Int> {
    var result = 0
    var isWhitespace = false
    var isComma = false
    for i in

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ")
    if words.count == 0 {
        words = txt.split(separator: ",")
        if words.count == 0 {
            return .failure(3)
        }
    }
    return .success(words)
}

func countPalindromes(txt: String) -> Result<Int, Int> {
    var words = txt.split(separator: " ")
    var count = 0
    for word in words {
        if word.reversed().casefold() == word.casefold() {
            count += 1
        }
    }
    return .success(count)
}

func countAnagrams(txt: String) -> Result<Int, Int> {
    var words = txt.split(separator: " ")
    var count = 0
    for i in 0..<words.count {
        for j in i..<words.count {
            if words[i].casefold().sorted() == words[j].casefold().sorted() {
                count += 1
            }
        }
    }
    return .success(count)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ")
    if words.count == 0 {
        words = txt.split(separator: ",")
        if words.count == 0 {
            return .failure(3)
        }
    }
    return .success(words)
}

// Given a string of words, return the number of words that are palindromes, a palindrome is a word that is the same
// forwards and backwards, e.g. "racecar" is a palindrome.
// Examples
// countPalindromes(txt: "Hello world!") == .success(0)
// countPalindromes(txt: "A man, a plan, a canal, Panama!") == .success(5)
// countPalindromes(txt: "abcdef") == .failure(3)
func countPalindromes(txt: String) -> Result<Int, Int> {
    var words = txt.split(separator: " ")
    var count = 0
    for word in words {
        if word.reversed().casefold() == word.casefold() {
            count += 1
        }
    }
    return .success(count)
}

// Given a string of words, return the number of words that are anagrams of each other, an anagram is a word that
// can be made by rearranging the letters of another word, e.g. "listen" is an anagram of "silent".
// Examples
// countAnagrams(txt: "Hello world!") == .success(0)
// countAnagrams(txt: "A man, a plan, a canal, Panama!") == .success(1)
// countAnagrams(txt: "abcdef") == .failure(3)
func countAnagrams(txt: String) -> Result<Int, Int> {
    var words = txt.split(separator: " ")
    var count = 0
    for i in 0..<words.count {
        for j in i..<words.count {
            if words[i].casefold().sorted() == words[j].casefold().sorted() {
                count += 1
            }
        }
    }
    return .success(count)
}

// Given a string of words, return the number of words that are anagrams of each other, an anagram is a word that
// can be made by rearranging the letters of another word, e.g. "listen" is an anagram of "silent".
// Examples
// countAnagrams(txt: "Hello world!") == .success(0)
// countAnagrams(txt: "A man, a plan, a canal, Panama!") == .success(1)
// countAnagrams(txt: "abcdef") == .failure(3)
func countAnagrams(txt: String) -> Result<Int, Int> {
    var words = txt.split(separator: " ")
    var count = 0
    for i in 0..<words.count {
        for j in i..<words.count {
            if words[i].casefold().sorted() == words[j].casefold().sorted() {
                count += 1
            }
        }
    }
    return .success(count)
}

// Given a string of words, return the number of words that are anagrams of each other, an anagram is a word that
// can be made by rearranging the letters of another word, e.g. "listen" is an anagram of "silent".
// Examples
// countAnagrams(txt: "Hello world!") == .success(0)
// countAnagrams(txt: "A man, a plan, a canal, Panama!") == .success(1)
// countAnagrams(txt: "abcdef") == .failure(3)
func countAnagrams(txt: String) -> Result<Int, Int> {
    var words = txt.split(separator: " ")
    var count = 0
    for i in 0..<words.count {
        for j in i..<words.count {
            if words[i].casefold().sorted() == words[j].casefold().sorted() {
                count += 1
            }
        }
    }
    return .success(count)
}

// Given a string of words, return the number of words that are anagrams of each other, an anagram is a word that
// can be made by rearranging the letters of another word, e.g. "listen" is an anagram of "silent".
// Examples
// countAnagrams(txt: "Hello world

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ")
    if words.isEmpty {
        words = txt.split(separator: ",")
    }
    if words.isEmpty {
        return .failure(3)
    }
    return .success(words)
}

func countPalindromes(txt: String) -> Result<Int, Int> {
    var words = txt.split(separator: " ")
    if words.isEmpty {
        words = txt.split(separator: ",")
    }
    if words.isEmpty {
        return .failure(3)
    }
    var count = 0
    for i in 0..<words.count {
        var word = words[i]
        if word.length == 1 {
            continue
        }
        var reversedWord = ""
        for j in (word.length - 1)..<0 {
            reversedWord += word[j]
        }
        if word == reversedWord {
            count += 1
        }
    }
    return .success(count)
}

func countAnagrams(txt: String) -> Result<Int, Int> {
    var words = txt.split(separator: " ")
    if words.isEmpty {
        words = txt.split(separator: ",")
    }
    if words.isEmpty {
        return .failure(3)
    }
    var count = 0
    for i in 0..<words.count {
        var word = words[i]
        if word.length == 1 {
            continue
        }
        var reversedWord = ""
        for j in (word.length - 1)..<0 {
            reversedWord += word[j]
        }
        if word == reversedWord {
            count += 1
        }
    }
    return .success(count)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var words = txt.split(separator: " ")
    if words.isEmpty {
        words = txt.split(separator: ",")
    }
    if words.isEmpty {
        return .failure(3)
    }
    return .success(words)
}

// Given a string of words, return the number of words that are palindromes, a palindrome is a word that is the same
// forwards and backwards, for example:
// "racecar" is a palindrome
// "hello" is not a palindrome
// "a" is a palindrome
// "A man, a plan, a canal, Panama!" is a palindrome
// "A man, a plan, a canal, Panama" is not a palindrome
// Examples
// countPalindromes(txt: "Hello world!") == .success(0)
// countPalindromes(txt: "racecar") == .success(1)
// countPalindromes(txt: "A man, a plan, a canal, Panama!") == .success(1)
// countPalindromes(txt: "A man, a plan, a canal, Panama") == .success(0)
// countPalindromes(txt: "abcdef") == .failure(3)
func countPalindromes(txt: String) -> Result<Int, Int> {
    var words = txt.split(separator: " ")
    if words.isEmpty {
        words = txt.split(separator: ",")
    }
    if words.isEmpty {
        return .failure(3)
    }
    var count = 0
    for i in 0..<words.count {
        var word = words[i]
        if word.length == 1 {
            continue
        }
        var reversedWord = ""
        for j in (word.length - 1)..<0 {
            reversedWord += word[j]
        }
        if word == reversedWord {
            count += 1
        }
    }
    return .success(count)
}

// Given a string of words, return the number of words that are anagrams of another word, an anagram is a word that
// is the same forwards and backwards, for example:
// "racecar" is an anagram of "racecar"
// "hello" is not an anagram of "world"
// "a" is an anagram of "a"
// "A man, a plan, a canal, Panama!" is an anagram of "A man, a plan, a canal, Panama!"
// "A man, a plan, a canal, Panama" is an anagram of "A man, a plan, a canal, Panama"
// Examples
// countAnagrams(txt: "Hello world!") == .success(0)
// countAnagrams(txt: "racecar") == .success(1)
// countAnagrams(txt: "A man, a plan, a canal, Panama!") == .success(1)
// countAnagrams(txt: "A man, a plan, a canal, Panama") == .success(1)
// countAnagrams(txt: "abcdef") == .failure(3)
func countAnagrams(txt: String) -> Result<Int, Int> {
    var words = txt.split(separator: " ")
    if words.isEmpty {
        words = txt.split(separator: ",")
    }
    if words.isEmpty {
        return .failure(3)
    }
    var count = 0
    for i in 0..<words.count {
        var word = words[i]
        if word.length == 1 {
            continue
        }
        var reversedWord = ""
        for j in (word.length - 1)..<0 {
            reversedWord += word[j]
        }
        if word == reversedWord {
            count += 1
        }
    }
    return .success(count)
}

// Given a string of words, return the number of words that are anagrams of another word, an anagram is a word that
// is the same forwards and backwards, for example:
// "racecar" is an anagram of "racecar"
// "hello" is not an anagram of "world"
// "a" is an anagram of "a"
// "A man, a plan, a canal, Panama!" is an anagram of "A man, a plan, a canal, Panama!"
// "A man, a plan, a canal, Panama" is an anagram of "A man, a

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = Array<String>()
    var word = String()
    var word_count = 0
    var word_count_odd = 0
    var word_count_even = 0
    for i in 0..<txt.length {
        if txt[i] == ' ' {
            if word.length > 0 {
                result.append(word)
                word = String()
            }
        } else if txt[i] == ',' {
            if word.length > 0 {
                result.append(word)
                word = String()
            }
        } else {
            word += txt[i]
        }
    }
    if word.length > 0 {
        result.append(word)
    }
    for i in 0..<result.count {
        if result[i].length > 1 {
            if result[i][0].character.caseMapped == result[i][0].character.uppercase {
                word_count_even += 1
            } else {
                word_count_odd += 1
            }
        }
    }
    if word_count_even > word_count_odd {
        return .success(result)
    } else {
        return .failure(word_count_odd)
    }
}

func joinWords(words: [String]) -> Result<String, Int> {
    var result = String()
    var word_count = 0
    var word_count_odd = 0
    var word_count_even = 0
    for i in 0..<words.count {
        if words[i].length > 1 {
            if words[i][0].character.caseMapped == words[i][0].character.uppercase {
                word_count_even += 1
            } else {
                word_count_odd += 1
            }
        }
    }
    if word_count_even > word_count_odd {
        for i in 0..<words.count {
            if i > 0 {
                result += ","
            }
            result += words[i]
        }
        return .success(result)
    } else {
        return .failure(word_count_odd)
    }
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = Array<String>()
    var word = String()
    var word_count = 0
    var word_count_odd = 0
    var word_count_even = 0
    for i in 0..<txt.length {
        if txt[i] == ' ' {
            if word.length > 0 {
                result.append(word)
                word = String()
            }
        } else if txt[i] == ',' {
            if word.length > 0 {
                result.append(word)
                word = String()
            }
        } else {
            word += txt[i]
        }
    }
    if word.length > 0 {
        result.append(word)
    }
    for i in 0..<result.count {
        if result[i].length > 1 {
            if result[i][0].character.caseMapped == result[i][0].character.uppercase {
                word_count_even += 1
            } else {
                word_count_odd += 1
            }
        }
    }
    if word_count_even > word_count_odd {
        return .success(result)
    } else {
        return .failure(word_count_odd)
    }
}

// Given an array of words, return a string of words joined by commas ',' if no commas exists you should return the
// number of lower-case letters with odd order in the alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// joinWords(words: ["Hello", "world!"]) == .success("Hello,world!")
// joinWords(words: ["Hello", "world!"]) == .success("Hello,world!")
// joinWords(words: ["abcdef"]) == .failure(3)
func joinWords(words: [String]) -> Result<String, Int> {
    var result = String()
    var word_count = 0
    var word_count_odd = 0
    var word_count_even = 0
    for i in 0..<words.count {
        if words[i].length > 1 {
            if words[i][0].character.caseMapped == words[i][0].character.uppercase {
                word_count_even += 1
            } else {
                word_count_odd += 1
            }
        }
    }
    if word_count_even > word_count_odd {
        for i in 0..<words.count {
            if i > 0 {
                result += ","
            }
            result += words[i]
        }
        return .success(result)
    } else {
        return .failure(word_count_odd)
    }
}

// Given an array of words, return a string of words joined by commas ',' if no commas exists you should return the
// number of lower-case letters with odd order in the alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// joinWords(words: ["Hello", "world!"]) == .success("Hello,world!")
// joinWords(words: ["Hello", "world!"]) == .success("Hello,world!")
// joinWords(words: ["abcdef"]) == .failure(3)
func joinWords(words: [String]) -> Result<String, Int> {
    var result = String()
    var word_count = 0
    var word_count_odd = 0
    var word_count_even = 0
    for i in 0..<words.count {
        if words[i].length > 1 {
            if words[i][0].character.caseMapped == words[i][0].character.uppercase {
                word_count_even += 1
            } else {
                word_count_odd += 1
            }
        }
    }
    if word_count_even > word_count_odd {
        for i in 0..<words.count {
            if i > 0 {
                result += ","
            }
            result += words[i]
        }
        return .success(result)
    } else {
        return .failure(word_count_odd)
    }
}

// Given a string of words, return an array of words split on whitespace, if no whitespaces

extension Int: Error {

}

extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = Array<String>()
    var word = ""
    var count = 0
    for i in txt.indices {
        if txt[i] == ',' {
            result.append(word)
            word = ""
        } else if txt[i] == ' ' {
            if word.length > 0 {
                result.append(word)
                word = ""
            }
        } else {
            word = word + txt[i]
        }
    }
    if word.length > 0 {
        result.append(word)
    }
    if result.count == 0 {
        return .failure(count)
    }
    return .success(result)
}

func joinWords(words: Result<[String], Int>) -> Result<String, Int> {
    if let result = words.unwrap() {
        var str = ""
        for i in 0..<result.count {
            str = str + result[i]
            if i < result.count - 1 {
                str = str + ","
            }
        }
        return .success(str)
    }
    return .failure(words.error)
}

func countVowels(txt: String) -> Result<Int, Int> {
    var count = 0
    for i in txt.indices {
        if txt[i] == 'a' || txt[i] == 'e' || txt[i] == 'i' || txt[i] == 'o' || txt[i] == 'u' {
            count = count + 1
        }
    }
    return .success(count)
}

func countConsonants(txt: String) -> Result<Int, Int> {
    var count = 0
    for i in txt.indices {
        if txt[i] != 'a' && txt[i] != 'e' && txt[i] != 'i' && txt[i] != 'o' && txt[i] != 'u' {
            count = count + 1
        }
    }
    return .success(count)
}

func countEvenLetters(txt: String) -> Result<Int, Int> {
    var count = 0
    for i in txt.indices {
        if (i + 1) % 2 == 0 {
            count = count + 1
        }
    }
    return .success(count)
}

```swift
extension Int: Error {}

// Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
// should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
// alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// Examples
// splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
// splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
// splitWords(txt: "abcdef") == .failure(3)
func splitWords(txt: String) -> Result<[String], Int> {
    var result = Array<String>()
    var word = ""
    var count = 0
    for i in txt.indices {
        if txt[i] == ',' {
            result.append(word)
            word = ""
        } else if txt[i] == ' ' {
            if word.length > 0 {
                result.append(word)
                word = ""
            }
        } else {
            word = word + txt[i]
        }
    }
    if word.length > 0 {
        result.append(word)
    }
    if result.count == 0 {
        return .failure(count)
    }
    return .success(result)
}

// Given an array of words, return a string of words joined by commas ',' if there are no commas in the array,
// return a string of words joined by whitespace if there are commas in the array
// Examples
// joinWords(words: .success(["Hello", "world!"]) == .success("Hello,world!")
// joinWords(words: .success(["Hello", "world!"]) == .success("Hello world!")
// joinWords(words: .failure(3) == .failure(3)
func joinWords(words: Result<[String], Int>) -> Result<String, Int> {
    if let result = words.unwrap() {
        var str = ""
        for i in 0..<result.count {
            str = str + result[i]
            if i < result.count - 1 {
                str = str + ","
            }
        }
        return .success(str)
    }
    return .failure(words.error)
}

// Given a string of words, return the number of words that contain a vowel
// Examples
// countVowels(txt: "Hello world!") == .success(2)
// countVowels(txt: "Hello,world!") == .success(2)
// countVowels(txt: "abcdef") == .success(0)
func countVowels(txt: String) -> Result<Int, Int> {
    var count = 0
    for i in txt.indices {
        if txt[i] == 'a' || txt[i] == 'e' || txt[i] == 'i' || txt[i] == 'o' || txt[i] == 'u' {
            count = count + 1
        }
    }
    return .success(count)
}

// Given a string of words, return the number of words that contain a consonant
// Examples
// countConsonants(txt: "Hello world!") == .success(2)
// countConsonants(txt: "Hello,world!") == .success(2)
// countConsonants(txt: "abcdef") == .success(0)
func countConsonants(txt: String) -> Result<Int, Int> {
    var count = 0
    for i in txt.indices {
        if txt[i] != 'a' && txt[i] != 'e' && txt[i] != 'i' && txt[i] != 'o' && txt[i] != 'u' {
            count = count + 1
        }
    }
    return .success(count)
}

// Given a string of words, return the number of words that contain a letter that occurs at an even index
// Examples
// countEvenLetters(txt: "Hello world!") == .success(2)
// countEvenLetters(txt: "Hello,world!") == .success(2)
// countEvenLetters(txt: "abcdef") == .success(0)
func countEvenLetters(txt: String) -> Result<Int, Int> {
    var count = 0
    for i in txt.indices {
        if (i + 1) % 2 == 0 {
            count = count + 1
        }
    }
    return .success(count)
}

// Given a string of words, return the number of words that contain a letter that occurs at an odd index
// Examples
// countOddLetters(txt: "Hello world!") == .success(2)
// countOddLetters(txt: "Hello,world!") == .success(2)
// countOddLetters(txt: "abcdef") == .success(0)
func countOddLetters(txt: String) -> Result<Int, Int> {
    var count = 0
    for i in txt.indices {
        if (i + 

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for i in 0..<txt.count {
            if txt[i].isLowercase && i % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for i in 0..<txt.count {
            if txt[i].isLowercase && i % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for c in txt {
            if c.isLowercase {
                if c.asciiValue! % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for c in txt {
            if c.isLowercase {
                if c.asciiValue! % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map({ String($0) }) {
        return .success(Array(words))
    } else if let words = txt.split(separator: ",").map({ String($0) }) {
        return .success(Array(words))
    } else {
        var count = 0
        for c in txt.lowercased() {
            if c.isLetter, c.asciiValue! % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map({ String($0) }) {
        return .success(Array(words))
    } else if let words = txt.split(separator: ",").map({ String($0) }) {
        return .success(Array(words))
    } else {
        var count = 0
        for c in txt.lowercased() {
            if c.isLetter, c.asciiValue! % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                if char.asciiValue! % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase {
                if char.asciiValue! % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map({ String($0) }) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map({ String($0) }) {
        return .success(words)
    } else {
        var count = 0
        for c in txt.lowercased() {
            if c.isLetter {
                if c.asciiValue! % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map({ String($0) }) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map({ String($0) }) {
        return .success(words)
    } else {
        var count = 0
        for c in txt.lowercased() {
            if c.isLetter {
                if c.asciiValue! % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for c in txt.lowercased() {
            if c.isLetter {
                count += Int(c.asciiValue!) % 26
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for c in txt.lowercased() {
            if c.isLetter {
                count += Int(c.asciiValue!) % 26
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for char in txt where char.isLowercase {
            let index = Int(char.asciiValue!) - Int(Character("a").asciiValue!)
            if index % 2 != 0 {
                count += 1
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for char in txt where char.isLowercase {
            let index = Int(char.asciiValue!) - Int(Character("a").asciiValue!)
            if index % 2 != 0 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for c in txt where c.isLowercase {
            if (c.asciiValue! - ord("a")) % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for c in txt where c.isLowercase {
            if (c.asciiValue! - ord("a")) % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map({ String($0) }) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map({ String($0) }) {
        return .success(words)
    } else {
        var count = 0
        for c in txt.lowercased() {
            if (c.asciiValue! - ord("a".lowercased())) % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map({ String($0) }) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map({ String($0) }) {
        return .success(words)
    } else {
        var count = 0
        for c in txt.lowercased() {
            if (c.asciiValue! - ord("a".lowercased())) % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for i in 0..<txt.count {
            if txt[i].isLowercase {
                if (Int(txt[i]) - Int('a')) % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for i in 0..<txt.count {
            if txt[i].isLowercase {
                if (Int(txt[i]) - Int('a')) % 2 == 1 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for (i, char) in txt.enumerated() where char.isLowercase && i % 2 == 1 {
            count += 1
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for (i, char) in txt.enumerated() where char.isLowercase && i % 2 == 1 {
            count += 1
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for char in txt.lowercased() {
            if char.asciiValue! % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for char in txt.lowercased() {
            if char.asciiValue! % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for (i, c) in txt.lowercased().enumerated() where i % 2 == 1 {
            count += c.asciiValue! - "a".asciiValue!
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for (i, c) in txt.lowercased().enumerated() where i % 2 == 1 {
            count += c.asciiValue! - "a".asciiValue!
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for char in txt where char.isLowercase {
            if (Int(char.asciiValue!) % 2) == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for char in txt where char.isLowercase {
            if (Int(char.asciiValue!) % 2) == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase && (char.asciiValue! % 2) == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words.map { String($0) })
    } else if let words = txt.split(separator: ",") {
        return .success(words.map { String($0) })
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase && (char.asciiValue! % 2) == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for char in txt.lowercased() {
            if char.asciiValue! % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for char in txt.lowercased() {
            if char.asciiValue! % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for i in 0..<txt.count {
            let letter = txt[txt.index(txt.startIndex, offsetBy: i)]
            if letter.isLowercase && i % 2 != 0 {
                count += 1
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for i in 0..<txt.count {
            let letter = txt[txt.index(txt.startIndex, offsetBy: i)]
            if letter.isLowercase && i % 2 != 0 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for i in 0..<txt.count {
            if txt[txt.index(txt.startIndex, offsetBy: i)].isLowercase {
                count += i % 2 == 1 ? 1 : 0
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for i in 0..<txt.count {
            if txt[txt.index(txt.startIndex, offsetBy: i)].isLowercase {
                count += i % 2 == 1 ? 1 : 0
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase && char.asciiValue! % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for char in txt {
            if char.isLowercase && char.asciiValue! % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for i in 0..<txt.count {
            let letter = txt[txt.index(txt.startIndex, offsetBy: i)]
            if letter.isLowercase && i % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)<end_of_turn>
<start_of_turn>model
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        var count = 0
        for i in 0..<txt.count {
            let letter = txt[txt.index(txt.startIndex, offsetBy: i)]
            if letter.isLowercase && i % 2 == 1 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.isEmpty {
        let commas = txt.split(separator: ",")
        if commas.isEmpty {
            let lowercaseLetters = txt.filter { $0.isLowercase }
            let oddLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
            return .failure(oddLetters.count)
        } else {
            return .success(commas.map(String.init))
        }
    } else {
        return .success(words.map(String.init))
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.isEmpty {
        let commas = txt.split(separator: ",")
        if commas.isEmpty {
            let lowercaseLetters = txt.filter { $0.isLowercase }
            let oddLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
            return .failure(oddLetters.count)
        } else {
            return .success(commas.map(String.init))
        }
    } else {
        return .success(words.map(String.init))
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.isEmpty {
        let commas = txt.split(separator: ",")
        if commas.isEmpty {
            let lowercaseLetters = txt.filter { $0.isLowercase }
            let oddLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
            return .failure(oddLetters.count)
        } else {
            return .success(commas.map(String.init))
        }
    } else {
        return .success(words.map(String.init))
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.isEmpty {
        let commas = txt.split(separator: ",")
        if commas.isEmpty {
            let lowercaseLetters = txt.filter { $0.isLowercase }
            let oddLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
            return .failure(oddLetters.count)
        } else {
            return .success(commas.map(String.init))
        }
    } else {
        return .success(words.map(String.init))
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let whitespace = CharacterSet.whitespaces
    let comma = CharacterSet.init(charactersIn: ",")
    let characters = Array(txt)
    var words: [String] = []
    var word: String = ""
    var i = 0
    while i < characters.count {
        let character = characters[i]
        if whitespace.contains(character) || comma.contains(character) {
            if !word.isEmpty {
                words.append(word)
                word = ""
            }
        } else {
            word.append(character)
        }
        i += 1
    }
    if !word.isEmpty {
        words.append(word)
    }
    if words.isEmpty {
        let lowercaseLetters = characters.filter { $0.isLowercase }
        let oddLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
        return .failure(oddLetters.count)
    } else {
        return .success(words)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let whitespace = CharacterSet.whitespaces
    let comma = CharacterSet.init(charactersIn: ",")
    let characters = Array(txt)
    var words: [String] = []
    var word: String = ""
    var i = 0
    while i < characters.count {
        let character = characters[i]
        if whitespace.contains(character) || comma.contains(character) {
            if !word.isEmpty {
                words.append(word)
                word = ""
            }
        } else {
            word.append(character)
        }
        i += 1
    }
    if !word.isEmpty {
        words.append(word)
    }
    if words.isEmpty {
        let lowercaseLetters = characters.filter { $0.isLowercase }
        let oddLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
        return .failure(oddLetters.count)
    } else {
        return .success(words)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.isEmpty {
        let commas = txt.split(separator: ",")
        if commas.isEmpty {
            let lowercaseLetters = txt.filter { $0.isLowercase }
            let oddLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
            return .failure(oddLetters.count)
        } else {
            return .success(commas.map(String.init))
        }
    } else {
        return .success(words.map(String.init))
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.isEmpty {
        let commas = txt.split(separator: ",")
        if commas.isEmpty {
            let lowercaseLetters = txt.filter { $0.isLowercase }
            let oddLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
            return .failure(oddLetters.count)
        } else {
            return .success(commas.map(String.init))
        }
    } else {
        return .success(words.map(String.init))
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let range = txt.range(of: "\\s+", options: .regularExpression) {
        return .success(txt[range].split(separator: " ").map(String.init))
    } else if let range = txt.range(of: ",", options: .regularExpression) {
        return .success(txt[range].split(separator: ",").map(String.init))
    } else {
        var count = 0
        for c in txt.lowercased() {
            if c.isLowercase && (c.asciiValue! % 2) == 0 {
                count += 1
            }
        }
        return .failure(count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let range = txt.range(of: "\\s+", options: .regularExpression) {
        return .success(txt[range].split(separator: " ").map(String.init))
    } else if let range = txt.range(of: ",", options: .regularExpression) {
        return .success(txt[range].split(separator: ",").map(String.init))
    } else {
        var count = 0
        for c in txt.lowercased() {
            if c.isLowercase && (c.asciiValue! % 2) == 0 {
                count += 1
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.isEmpty {
        let commas = txt.split(separator: ",")
        if commas.isEmpty {
            let lowercaseLetters = txt.filter { $0.isLowercase }
            let oddLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
            return .failure(oddLetters.count)
        } else {
            return .success(commas.map(String.init))
        }
    } else {
        return .success(words.map(String.init))
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.isEmpty {
        let commas = txt.split(separator: ",")
        if commas.isEmpty {
            let lowercaseLetters = txt.filter { $0.isLowercase }
            let oddLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
            return .failure(oddLetters.count)
        } else {
            return .success(commas.map(String.init))
        }
    } else {
        return .success(words.map(String.init))
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.isEmpty {
        let commas = txt.split(separator: ",")
        if commas.isEmpty {
            let lowercaseLetters = txt.filter { $0.isLowercase }
            let oddLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
            return .failure(oddLetters.count)
        } else {
            return .success(commas.map { String($0) })
        }
    } else {
        return .success(words.map { String($0) })
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.isEmpty {
        let commas = txt.split(separator: ",")
        if commas.isEmpty {
            let lowercaseLetters = txt.filter { $0.isLowercase }
            let oddLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
            return .failure(oddLetters.count)
        } else {
            return .success(commas.map { String($0) })
        }
    } else {
        return .success(words.map { String($0) })
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.isEmpty {
        let commas = txt.split(separator: ",")
        if commas.isEmpty {
            let lowercaseLetters = txt.filter { $0.isLowercase }
            let oddLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
            return .failure(oddLetters.count)
        } else {
            return .success(commas.map(String.init))
        }
    } else {
        return .success(words.map(String.init))
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.isEmpty {
        let commas = txt.split(separator: ",")
        if commas.isEmpty {
            let lowercaseLetters = txt.filter { $0.isLowercase }
            let oddLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
            return .failure(oddLetters.count)
        } else {
            return .success(commas.map(String.init))
        }
    } else {
        return .success(words.map(String.init))
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.isEmpty {
        let commas = txt.split(separator: ",")
        if commas.isEmpty {
            return .failure(txt.count { $0.isLowercase && $0.isOdd })
        } else {
            return .success(commas.map(String.init))
        }
    } else {
        return .success(words.map(String.init))
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.isEmpty {
        let commas = txt.split(separator: ",")
        if commas.isEmpty {
            return .failure(txt.count { $0.isLowercase && $0.isOdd })
        } else {
            return .success(commas.map(String.init))
        }
    } else {
        return .success(words.map(String.init))
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let range = txt.range(of: "\\s+", options: .regularExpression) {
        return .success(txt.components(separatedBy: range))
    } else if let range = txt.range(of: ",", options: .regularExpression) {
        return .success(txt.components(separatedBy: range))
    } else {
        var count = 0
        for c in txt.lowercased() {
            if c.isLetter && c.isLowercase {
                count += (Int(c.asciiValue!) - Int(UnicodeScalar("a").asciiValue!)) % 2 == 0 ? 1 : 0
            }
        }
        return .failure(count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let range = txt.range(of: "\\s+", options: .regularExpression) {
        return .success(txt.components(separatedBy: range))
    } else if let range = txt.range(of: ",", options: .regularExpression) {
        return .success(txt.components(separatedBy: range))
    } else {
        var count = 0
        for c in txt.lowercased() {
            if c.isLetter && c.isLowercase {
                count += (Int(c.asciiValue!) - Int(UnicodeScalar("a").asciiValue!)) % 2 == 0 ? 1 : 0
            }
        }
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words)
    } else if let words = txt.split(separator: ",") {
        return .success(words)
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddLetters = lowercaseLetters.filter { $0.unicodeScalars.first!.value % 2 == 1 }
        return .failure(oddLetters.count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words)
    } else if let words = txt.split(separator: ",") {
        return .success(words)
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddLetters = lowercaseLetters.filter { $0.unicodeScalars.first!.value % 2 == 1 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddLetters = lowercaseLetters.filter { $0.unicodeScalars.first!.value % 2 == 1 }
        return .failure(oddLetters.count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddLetters = lowercaseLetters.filter { $0.unicodeScalars.first!.value % 2 == 1 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        let count = txt.filter { $0.isLowercase && $0.unicodeScalars.first!.value % 2 == 1 }.count
        return .failure(count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ").map(String.init) {
        return .success(words)
    } else if let words = txt.split(separator: ",").map(String.init) {
        return .success(words)
    } else {
        let count = txt.filter { $0.isLowercase && $0.unicodeScalars.first!.value % 2 == 1 }.count
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddLetters = lowercaseLetters.filter { $0.asciiValue! % 2 == 1 }
        return .failure(oddLetters.count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddLetters = lowercaseLetters.filter { $0.asciiValue! % 2 == 1 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        return .failure(txt.filter { $0.isLowercase && $0.isLetter }.count % 2 == 1 ? txt.count : 0)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        return .failure(txt.filter { $0.isLowercase && $0.isLetter }.count % 2 == 1 ? txt.count : 0)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddLetters = lowercaseLetters.filter { $0.asciiValue! % 2 == 1 }
        return .failure(oddLetters.count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddLetters = lowercaseLetters.filter { $0.asciiValue! % 2 == 1 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words)
    } else if let words = txt.split(separator: ",") {
        return .success(words)
    } else {
        let count = txt.filter { $0.isLowercase && $0.isLetter }.count
        return .failure(count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words)
    } else if let words = txt.split(separator: ",") {
        return .success(words)
    } else {
        let count = txt.filter { $0.isLowercase && $0.isLetter }.count
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        return .failure(txt.filter { $0.isLowercase && $0.isLetter }.count % 2)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        return .failure(txt.filter { $0.isLowercase && $0.isLetter }.count % 2)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words)
    } else if let words = txt.split(separator: ",") {
        return .success(words)
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddLetters = lowercaseLetters.filter { $0.asciiValue! % 2 == 1 }
        return .failure(oddLetters.count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let words = txt.split(separator: " ") {
        return .success(words)
    } else if let words = txt.split(separator: ",") {
        return .success(words)
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddLetters = lowercaseLetters.filter { $0.asciiValue! % 2 == 1 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddLetters = lowercaseLetters.filter { $0.asciiValue! % 2 == 1 }
        return .failure(oddLetters.count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(" ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if txt.contains(",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddLetters = lowercaseLetters.filter { $0.asciiValue! % 2 == 1 }
        return .failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words)
    } else if let commaIndex = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words)
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
        let count = oddOrderLetters.count
        return .failure(count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words)
    } else if let commaIndex = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words)
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
        let count = oddOrderLetters.count
        return .failure(count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        return .failure(oddOrderLetters.count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        return .failure(oddOrderLetters.count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " "))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ","))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " "))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ","))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        return .failure(oddOrderLetters.count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let index = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let index = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words)
    } else if let commaIndex = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words)
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        let words = txt.split(separator: " ")
        return .success(words)
    } else if let commaIndex = txt.firstIndex(of: ",") {
        let words = txt.split(separator: ",")
        return .success(words)
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " ").map(String.init))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ",").map(String.init))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " "))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ","))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3) [/INST] ```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if let whitespaceIndex = txt.firstIndex(of: " ") {
        return .success(txt.split(separator: " "))
    } else if let commaIndex = txt.firstIndex(of: ",") {
        return .success(txt.split(separator: ","))
    } else {
        let lowercaseLetters = txt.filter { $0.isLowercase }
        let oddOrderLetters = lowercaseLetters.enumerated().filter { $0.offset % 2 == 1 }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.count
        return.failure(oddLetters)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.count
        return.failure(oddLetters)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.count
        return.failure(oddLetters)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.count
        return.failure(oddLetters)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.count
        return.failure(oddLetters)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.count
        return.failure(oddLetters)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.count
        return.failure(oddLetters)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.count
        return.failure(oddLetters)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.count
        return.failure(oddLetters)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.count
        return.failure(oddLetters)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.count
        return.failure(oddLetters)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.count
        return.failure(oddLetters)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.count
        return.failure(oddLetters)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.count
        return.failure(oddLetters)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.filter { Int(String($0))?? 0 % 2!= 0 }
        return.failure(oddLetters.count)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.filter { Int(String($0))?? 0 % 2!= 0 }
        return.failure(oddLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2!= 0 }.count
        return.failure(oddLetters)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    } else {
        let letters = txt.lowercased().filter { $0.isLetter }
        let oddLetters = letters.enumerated().filter { $0.offset % 2!= 0 }.count
        return.failure(oddLetters)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    }
    
    let letters = txt.lowercased().filter { $0.isLetter }
    let oddLetters = letters.enumerated().filter { $0.offset % 2!= 0 }.count
    return.failure(oddLetters)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.components(separatedBy: " ")
    if words.count > 0 {
        return.success(words)
    }
    
    let letters = txt.lowercased().filter { $0.isLetter }
    let oddLetters = letters.enumerated().filter { $0.offset % 2!= 0 }.count
    return.failure(oddLetters)
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let commas = txt.split(separator: ",")
        if commas.count > 1 {
            return.success(Array(commas))
        } else {
            let oddCount = txt.filter { $0.asciiValue! % 2 == 1 }.count
            return.failure(oddCount)
        }
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let commas = txt.split(separator: ",")
        if commas.count > 1 {
            return.success(Array(commas))
        } else {
            let oddCount = txt.filter { $0.asciiValue! % 2 == 1 }.count
            return.failure(oddCount)
        }
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split {!$0.isLetter }
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let oddCount = txt.filter { "abcdefghijklmnopqrstuvwxyz".contains($0) && $0.asciiValue! % 2 == 1 }.count
        return.failure(oddCount)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split {!$0.isLetter }
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let oddCount = txt.filter { "abcdefghijklmnopqrstuvwxyz".contains($0) && $0.asciiValue! % 2 == 1 }.count
        return.failure(oddCount)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let commas = txt.split(separator: ",")
        if commas.count > 1 {
            return.success(Array(commas))
        } else {
            let oddCount = txt.filter { "abcdefghijklmnopqrstuvwxyz".contains($0) && $0.asciiValue! % 2 == 1 }.count
            return.failure(oddCount)
        }
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let commas = txt.split(separator: ",")
        if commas.count > 1 {
            return.success(Array(commas))
        } else {
            let oddCount = txt.filter { "abcdefghijklmnopqrstuvwxyz".contains($0) && $0.asciiValue! % 2 == 1 }.count
            return.failure(oddCount)
        }
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let commas = txt.split(separator: ",")
        if commas.count > 1 {
            return.success(Array(commas))
        } else {
            let oddCount = txt.filter { $0.asciiValue! % 2!= 0 }.count
            return.failure(oddCount)
        }
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let commas = txt.split(separator: ",")
        if commas.count > 1 {
            return.success(Array(commas))
        } else {
            let oddCount = txt.filter { $0.asciiValue! % 2!= 0 }.count
            return.failure(oddCount)
        }
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let words = txt.split(separator: ",")
        if words.count > 1 {
            return.success(Array(words))
        } else {
            let count = txt.filter { "abcdefghijklmnopqrstuvwxyz".contains($0) && $0.asciiValue! % 2 == 1 }.count
            return.failure(count)
        }
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let words = txt.split(separator: ",")
        if words.count > 1 {
            return.success(Array(words))
        } else {
            let count = txt.filter { "abcdefghijklmnopqrstuvwxyz".contains($0) && $0.asciiValue! % 2 == 1 }.count
            return.failure(count)
        }
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let letters = txt.lowercased().filter { "abcdefghijklmnopqrstuvwxyz".contains($0) }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        if oddLetters.count > 0 {
            return.success(oddLetters)
        } else {
            return.failure(letters.count)
        }
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let letters = txt.lowercased().filter { "abcdefghijklmnopqrstuvwxyz".contains($0) }
        let oddLetters = letters.enumerated().filter { $0.offset % 2 == 1 }.map { $0.element }
        if oddLetters.count > 0 {
            return.success(oddLetters)
        } else {
            return.failure(letters.count)
        }
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let commas = txt.split(separator: ",")
        if commas.count > 1 {
            return.success(Array(commas))
        } else {
            let oddCount = txt.filter { "abcdefghijklmnopqrstuvwxyz".contains($0) && "abcdefghijklmnopqrstuvwxyz".firstIndex(of: $0)! % 2 == 1 }.count
            return.failure(oddCount)
        }
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let commas = txt.split(separator: ",")
        if commas.count > 1 {
            return.success(Array(commas))
        } else {
            let oddCount = txt.filter { "abcdefghijklmnopqrstuvwxyz".contains($0) && "abcdefghijklmnopqrstuvwxyz".firstIndex(of: $0)! % 2 == 1 }.count
            return.failure(oddCount)
        }
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let commas = txt.split(separator: ",")
        if commas.count > 1 {
            return.success(Array(commas))
        } else {
            let oddCount = txt.filter { "abcdefghijklmnopqrstuvwxyz".contains($0) && "abcdefghijklmnopqrstuvwxyz".firstIndex(of: $0)! % 2 == 1 }.count
            return.failure(oddCount)
        }
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let commas = txt.split(separator: ",")
        if commas.count > 1 {
            return.success(Array(commas))
        } else {
            let oddCount = txt.filter { "abcdefghijklmnopqrstuvwxyz".contains($0) && "abcdefghijklmnopqrstuvwxyz".firstIndex(of: $0)! % 2 == 1 }.count
            return.failure(oddCount)
        }
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let commas = txt.split(separator: ",")
        if commas.count > 1 {
            return.success(Array(commas))
        } else {
            let oddCount = txt.filter { "abcdefghijklmnopqrstuvwxyz".contains($0) && "abcdefghijklmnopqrstuvwxyz".firstIndex(of: $0)! % 2 == 1 }.count
            return.failure(oddCount)
        }
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let commas = txt.split(separator: ",")
        if commas.count > 1 {
            return.success(Array(commas))
        } else {
            let oddCount = txt.filter { "abcdefghijklmnopqrstuvwxyz".contains($0) && "abcdefghijklmnopqrstuvwxyz".firstIndex(of: $0)! % 2 == 1 }.count
            return.failure(oddCount)
        }
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let words = txt.split(separator: ",")
        if words.count > 1 {
            return.success(Array(words))
        } else {
            let count = txt.filter { "abcdefghijklmnopqrstuvwxyz".contains($0) && "abcdefghijklmnopqrstuvwxyz".firstIndex(of: $0)! % 2 == 1 }.count
            return.failure(count)
        }
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1,... ord('z') = 25
Examples
splitWords(txt: "Hello world!") ==.success(["Hello", "world!"])
splitWords(txt: "Hello,world!") ==.success(["Hello", "world!"])
splitWords(txt: "abcdef") ==.failure(3)

Answer:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    let words = txt.split(separator: " ")
    if words.count > 1 {
        return.success(Array(words))
    } else {
        let words = txt.split(separator: ",")
        if words.count > 1 {
            return.success(Array(words))
        } else {
            let count = txt.filter { "abcdefghijklmnopqrstuvwxyz".contains($0) && "abcdefghijklmnopqrstuvwxyz".firstIndex(of: $0)! % 2 == 1 }.count
            return.failure(count)
        }
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(",") {
        return .success(txt.components(separatedBy: ","))
    } else if txt.contains(" ") {
        return .success(txt.components(separatedBy: " "))
    } else {
        let lowerCaseLetters = txt.filter { $0.isLetter && $0.isLowercase }
        let oddOrderLetters = lowerCaseLetters.filter {
            let index = "abcdefghijklmnopqrstuvwxyz".index(of: String($0))!
            return index % 2 != 0
        }
        return .failure(oddOrderLetters.count)
    }
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(",") {
        return .success(txt.components(separatedBy: ","))
    } else if txt.contains(" ") {
        return .success(txt.components(separatedBy: " "))
    } else {
        let lowerCaseLetters = txt.filter { $0.isLetter && $0.isLowercase }
        let oddOrderLetters = lowerCaseLetters.filter {
            let index = "abcdefghijklmnopqrstuvwxyz".index(of: String($0))!
            return index % 2 != 0
        }
        return .failure(oddOrderLetters.count)
    }
}
```

extension Int: Error {

}

extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(",") {
        return .success(txt.components(separatedBy: ","))
    } else if txt.contains(" ") {
        return .success(txt.components(separatedBy: " "))
    } else {
        let lowercase = txt.lowercased()
        var count = 0
        for char in lowercase {
            let ascii = Int(char.asciiValue!)
            if ascii >= Int(CharacterSet.lowercaseLetters.asciiValue) {
                if (ascii - Int(CharacterSet.lowercaseLetters.asciiValue)) % 2 != 0 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a string of words, return an array of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Examples
splitWords(txt: "Hello world!") == .success(["Hello", "world!"])
splitWords(txt: "Hello,world!") == .success(["Hello", "world!"])
splitWords(txt: "abcdef") == .failure(3)
### Response:
```swift
extension Int: Error {}

func splitWords(txt: String) -> Result<[String], Int> {
    if txt.contains(",") {
        return .success(txt.components(separatedBy: ","))
    } else if txt.contains(" ") {
        return .success(txt.components(separatedBy: " "))
    } else {
        let lowercase = txt.lowercased()
        var count = 0
        for char in lowercase {
            let ascii = Int(char.asciiValue!)
            if ascii >= Int(CharacterSet.lowercaseLetters.asciiValue) {
                if (ascii - Int(CharacterSet.lowercaseLetters.asciiValue)) % 2 != 0 {
                    count += 1
                }
            }
        }
        return .failure(count)
    }
}
```