func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += char.lowercased()
            } else {
                result += char.uppercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += char.lowercased()
            } else {
                result += char.uppercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result.append(s[i].lowercased())
            } else {
                result.append(s[i].uppercased())
            }
        } else {
            result.append(s[i])
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result.append(s[i].lowercased())
            } else {
                result.append(s[i].uppercased())
            }
        } else {
            result.append(s[i])
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isLowercase {
                result += String(s[i].uppercased())
            } else {
                result += String(s[i].lowercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isLowercase {
                result += String(s[i].uppercased())
            } else {
                result += String(s[i].lowercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += String(char.lowercased())
            } else {
                result += String(char.uppercased())
            }
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += String(char.lowercased())
            } else {
                result += String(char.uppercased())
            }
        } else {
            result += String(char)
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase ? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase ? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase ? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase ? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += String(char.lowercased())
            } else {
                result += String(char.uppercased())
            }
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += String(char.lowercased())
            } else {
                result += String(char.uppercased())
            }
        } else {
            result += String(char)
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += char.lowercased()
            } else {
                result += char.uppercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += char.lowercased()
            } else {
                result += char.uppercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += char.lowercased()
            } else {
                result += char.uppercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += char.lowercased()
            } else {
                result += char.uppercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += String(char.lowercased())
            } else {
                result += String(char.uppercased())
            }
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += String(char.lowercased())
            } else {
                result += String(char.uppercased())
            }
        } else {
            result += String(char)
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLower ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLower ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLower ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLower ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLower ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLower ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLower ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLower ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().map(String.init).joined() : result
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().map(String.init).joined() : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed().joined() : result
}
```

func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0.isUppercase? $0.lowercased() : $0.uppercased())
        }
        return String($0)
    }.joined()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0.isUppercase? $0.lowercased() : $0.uppercased())
        }
        return String($0)
    }.joined()
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0.isUppercase? $0.lowercased() : $0.uppercased())
        } else {
            return String($0)
        }
    }.joined()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0.isUppercase? $0.lowercased() : $0.uppercased())
        } else {
            return String($0)
        }
    }.joined()
}
```

func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0).uppercased()
        }
        return String($0).lowercased()
    }.joined()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0).uppercased()
        }
        return String($0).lowercased()
    }.joined()
}
```

func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0).uppercased()
        } else {
            return String($0).lowercased()
        }
    }.joined()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0).uppercased()
        } else {
            return String($0).lowercased()
        }
    }.joined()
}
```

func solve(s: String) -> String {
    return s.map { $0.isLetter? $0.isUppercase? $0.lowercased() : $0.uppercased() : $0 }.joined()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    return s.map { $0.isLetter? $0.isUppercase? $0.lowercased() : $0.uppercased() : $0 }.joined()
}
```

func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0.isUppercase? $0.lowercased() : $0.uppercased())
        }
        return String($0)
    }.joined()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0.isUppercase? $0.lowercased() : $0.uppercased())
        }
        return String($0)
    }.joined()
}
```

func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0.isUppercase? $0.lowercased() : $0.uppercased())
        } else {
            return String($0)
        }
    }.joined()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0.isUppercase? $0.lowercased() : $0.uppercased())
        } else {
            return String($0)
        }
    }.joined()
}
```

func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0.isUppercase? $0.lowercased() : $0.uppercased())
        } else {
            return String($0)
        }
    }.joined()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0.isUppercase? $0.lowercased() : $0.uppercased())
        } else {
            return String($0)
        }
    }.joined()
}
```

func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0).uppercased()
        } else {
            return String($0).lowercased()
        }
    }.joined()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0).uppercased()
        } else {
            return String($0).lowercased()
        }
    }.joined()
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? String(char).lowercased() : String(char).uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? String(char).lowercased() : String(char).uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty? s.reversed() : result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty? s.reversed() : result
}
```

func solve(s: String) -> String {
    return s.map { $0.isLetter? $0.isLowercase? $0.uppercased() : $0.lowercased() : $0 }.reversed().joined()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    return s.map { $0.isLetter? $0.isLowercase? $0.uppercased() : $0.lowercased() : $0 }.reversed().joined()
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty? s.reversed() : result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty? s.reversed() : result
}
```

func solve(s: String) -> String {
    return s.map { $0.isLetter? $0.isUppercase? $0.lowercased() : $0.uppercased() : $0 }.reversed().joined()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    return s.map { $0.isLetter? $0.isUppercase? $0.lowercased() : $0.uppercased() : $0 }.reversed().joined()
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result.isEmpty? s.reversed() : result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result.isEmpty? s.reversed() : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty? s.reversed() : result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty? s.reversed() : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result.isEmpty? s.reversed() : result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result.isEmpty? s.reversed() : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result.isEmpty? s.reversed() : result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    return result.isEmpty? s.reversed() : result
}
```

func solve(s: String) -> String {
    return s.map { $0.isLetter? $0.isLowercase? $0.uppercased() : $0.lowercased() : $0 }.reversed().joined()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    return s.map { $0.isLetter? $0.isLowercase? $0.uppercased() : $0.lowercased() : $0 }.reversed().joined()
}
```

func solve(s: String) -> String {
    return s.map { $0.isLetter? $0.isUppercase? $0.lowercased() : $0.uppercased() : $0 }.reversed().joined()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    return s.map { $0.isLetter? $0.isUppercase? $0.lowercased() : $0.uppercased() : $0 }.reversed().joined()
}
```

func solve(s: String) -> String {
    let letters = s.filter { $0.isLetter }
    let reversed = letters.reversed()
    let result = letters.prefix(letters.count - reversed.count) + reversed
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    let letters = s.filter { $0.isLetter }
    let reversed = letters.reversed()
    let result = letters.prefix(letters.count - reversed.count) + reversed
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            result.append(c.isUpper? c.lowercased() : c.uppercased())
        } else {
            result.append(c)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            result.append(c.isUpper? c.lowercased() : c.uppercased())
        } else {
            result.append(c)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for character in s {
        if character.isLetter {
            result.append(character.isUpper? character.lowercased() : character.uppercased())
        } else {
            result.append(character)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for character in s {
        if character.isLetter {
            result.append(character.isUpper? character.lowercased() : character.uppercased())
        } else {
            result.append(character)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    let letters = s.filter { $0.isLetter }
    let reversed = letters.reversed()
    let result = letters.count > 0? String(reversed) : s.reversed()
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    let letters = s.filter { $0.isLetter }
    let reversed = letters.reversed()
    let result = letters.count > 0? String(reversed) : s.reversed()
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let char = String(char).unicodeScalars.first {
            if char.isLetter {
                result.append(char.isUpper? String(char).lowercased() : String(char).uppercased())
            } else {
                result.append(char)
            }
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let char = String(char).unicodeScalars.first {
            if char.isLetter {
                result.append(char.isUpper? String(char).lowercased() : String(char).uppercased())
            } else {
                result.append(char)
            }
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let char = String(char).unicodeScalars.first {
            if char.isLetter {
                result.append(char.isUpper? String(char).lowercased() : String(char).uppercased())
            } else {
                result.append(char)
            }
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let char = String(char).unicodeScalars.first {
            if char.isLetter {
                result.append(char.isUpper? String(char).lowercased() : String(char).uppercased())
            } else {
                result.append(char)
            }
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            result.append(c.isUpper? c.lowercased() : c.uppercased())
        } else {
            result.append(c)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            result.append(c.isUpper? c.lowercased() : c.uppercased())
        } else {
            result.append(c)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for character in s {
        if character.isLetter {
            result.append(character.isUpper? character.lowercased() : character.uppercased())
        } else {
            result.append(character)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for character in s {
        if character.isLetter {
            result.append(character.isUpper? character.lowercased() : character.uppercased())
        } else {
            result.append(character)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for character in s {
        if character.isLetter {
            result.append(character.isUpper? character.lowercased() : character.uppercased())
        } else {
            result.append(character)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for character in s {
        if character.isLetter {
            result.append(character.isUpper? character.lowercased() : character.uppercased())
        } else {
            result.append(character)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let upperCase = char.asciiValue, upperCase >= 97 && upperCase <= 122 {
            result.append(Character(UnicodeScalar(upperCase - 32)!))
        } else if let lowerCase = char.asciiValue, lowerCase >= 65 && lowerCase <= 90 {
            result.append(Character(UnicodeScalar(lowerCase + 32)!))
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    } else {
        return result
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let upperCase = char.asciiValue, upperCase >= 97 && upperCase <= 122 {
            result.append(Character(UnicodeScalar(upperCase - 32)!))
        } else if let lowerCase = char.asciiValue, lowerCase >= 65 && lowerCase <= 90 {
            result.append(Character(UnicodeScalar(lowerCase + 32)!))
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    } else {
        return result
    }
}
```

func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUppercase? String(char).lowercased() : String(char).uppercased())
        } else {
            result.append(char)
        }
    }
    if!isLetter {
        result = String(s.reversed())
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUppercase? String(char).lowercased() : String(char).uppercased())
        } else {
            result.append(char)
        }
    }
    if!isLetter {
        result = String(s.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let upperCase = char.asciiValue, upperCase >= 97 && upperCase <= 122 {
            result.append(Character(UnicodeScalar(upperCase - 32)!))
        } else if let lowerCase = char.asciiValue, lowerCase >= 65 && lowerCase <= 90 {
            result.append(Character(UnicodeScalar(lowerCase + 32)!))
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    } else {
        return result
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let upperCase = char.asciiValue, upperCase >= 97 && upperCase <= 122 {
            result.append(Character(UnicodeScalar(upperCase - 32)!))
        } else if let lowerCase = char.asciiValue, lowerCase >= 65 && lowerCase <= 90 {
            result.append(Character(UnicodeScalar(lowerCase + 32)!))
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    } else {
        return result
    }
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let char = char.asciiValue, char >= 97 && char <= 122 {
            result.append(Character(UnicodeScalar(char - 32)!))
        } else if let char = char.asciiValue, char >= 65 && char <= 90 {
            result.append(Character(UnicodeScalar(char + 32)!))
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let char = char.asciiValue, char >= 97 && char <= 122 {
            result.append(Character(UnicodeScalar(char - 32)!))
        } else if let char = char.asciiValue, char >= 65 && char <= 90 {
            result.append(Character(UnicodeScalar(char + 32)!))
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let upperCase = char.asciiValue, upperCase >= 97 && upperCase <= 122 {
            result.append(Character(UnicodeScalar(upperCase - 32)!))
        } else if let lowerCase = char.asciiValue, lowerCase >= 65 && lowerCase <= 90 {
            result.append(Character(UnicodeScalar(lowerCase + 32)!))
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    } else {
        return result
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let upperCase = char.asciiValue, upperCase >= 97 && upperCase <= 122 {
            result.append(Character(UnicodeScalar(upperCase - 32)!))
        } else if let lowerCase = char.asciiValue, lowerCase >= 65 && lowerCase <= 90 {
            result.append(Character(UnicodeScalar(lowerCase + 32)!))
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    } else {
        return result
    }
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUpper? String(char).lowercased() : String(char).uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUpper? String(char).lowercased() : String(char).uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let char = char.unicodeScalars.first, char.isLetter {
            result.append(char.isUppercase? String(char.lowercased()) : String(char.uppercased()))
        } else {
            result.append(String(char))
        }
    }
    return result.isEmpty? String(s.reversed()) : result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let char = char.unicodeScalars.first, char.isLetter {
            result.append(char.isUppercase? String(char.lowercased()) : String(char.uppercased()))
        } else {
            result.append(String(char))
        }
    }
    return result.isEmpty? String(s.reversed()) : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let char = char.unicodeScalars.first, char.isLetter {
            result.append(char.isUppercase? String(char.lowercased()) : String(char.uppercased()))
        } else {
            result.append(String(char))
        }
    }
    return result.isEmpty? String(s.reversed()) : result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let char = char.unicodeScalars.first, char.isLetter {
            result.append(char.isUppercase? String(char.lowercased()) : String(char.uppercased()))
        } else {
            result.append(String(char))
        }
    }
    return result.isEmpty? String(s.reversed()) : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.asciiValue, (65...90).contains(letter) {
            result.append(char.isUppercase? String(UnicodeScalar(letter + 32)!) : String(UnicodeScalar(letter - 32)!)
        } else {
            result.append(char)
        }
    }
    return result.isEmpty? String(s.reversed()) : result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.asciiValue, (65...90).contains(letter) {
            result.append(char.isUppercase? String(UnicodeScalar(letter + 32)!) : String(UnicodeScalar(letter - 32)!)
        } else {
            result.append(char)
        }
    }
    return result.isEmpty? String(s.reversed()) : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first, letter.isLetter {
            result.append(letter.isUppercase? String(letter.lowercased()) : String(letter.uppercased()))
        } else {
            result.append(String(char))
        }
    }
    return result.isEmpty? String(s.reversed()) : result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first, letter.isLetter {
            result.append(letter.isUppercase? String(letter.lowercased()) : String(letter.uppercased()))
        } else {
            result.append(String(char))
        }
    }
    return result.isEmpty? String(s.reversed()) : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first {
            if letter.isLowercase {
                result.append(String(UnicodeScalar(letter.value + 32)!))
            } else {
                result.append(String(UnicodeScalar(letter.value - 32)!))
            }
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first {
            if letter.isLowercase {
                result.append(String(UnicodeScalar(letter.value + 32)!))
            } else {
                result.append(String(UnicodeScalar(letter.value - 32)!))
            }
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first {
            if letter.isLowercase {
                result.append(String(UnicodeScalar(letter.value + 32)!))
            } else {
                result.append(String(UnicodeScalar(letter.value - 32)!))
            }
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first {
            if letter.isLowercase {
                result.append(String(UnicodeScalar(letter.value + 32)!))
            } else {
                result.append(String(UnicodeScalar(letter.value - 32)!))
            }
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var isPreviousLetter = false
    
    for char in s {
        if char.isLetter {
            if isPreviousLetter {
                result.append(char.toggleCase())
            } else {
                result.append(char)
            }
            isPreviousLetter = true
        } else {
            result.append(char)
            isPreviousLetter = false
        }
    }
    
    return String(result.reversed())
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isPreviousLetter = false
    
    for char in s {
        if char.isLetter {
            if isPreviousLetter {
                result.append(char.toggleCase())
            } else {
                result.append(char)
            }
            isPreviousLetter = true
        } else {
            result.append(char)
            isPreviousLetter = false
        }
    }
    
    return String(result.reversed())
}
```

func solve(s: String) -> String {
    var result = ""
    var isPreviousLetter = false
    
    for char in s {
        if char.isLetter {
            if isPreviousLetter {
                result.append(char.toggleCase())
            } else {
                result.append(char)
            }
            isPreviousLetter = true
        } else {
            result.append(char)
            isPreviousLetter = false
        }
    }
    
    return String(result.reversed())
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isPreviousLetter = false
    
    for char in s {
        if char.isLetter {
            if isPreviousLetter {
                result.append(char.toggleCase())
            } else {
                result.append(char)
            }
            isPreviousLetter = true
        } else {
            result.append(char)
            isPreviousLetter = false
        }
    }
    
    return String(result.reversed())
}
```

func solve(s: String) -> String {
    var result = ""
    var isPreviousLetter = false
    
    for char in s {
        if char.isLetter {
            if isPreviousLetter {
                result.append(char.toggleCase())
            } else {
                result.append(char)
            }
            isPreviousLetter = true
        } else {
            result.append(char)
            isPreviousLetter = false
        }
    }
    
    return String(result.reversed())
}

func String.toggleCase() -> Character {
    return self.isLowercase? self.uppercased() : self.lowercased()
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isPreviousLetter = false
    
    for char in s {
        if char.isLetter {
            if isPreviousLetter {
                result.append(char.toggleCase())
            } else {
                result.append(char)
            }
            isPreviousLetter = true
        } else {
            result.append(char)
            isPreviousLetter = false
        }
    }
    
    return String(result.reversed())
}

func String.toggleCase() -> Character {
    return self.isLowercase? self.uppercased() : self.lowercased()
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first {
            if letter.isLowercase {
                result.append(String(UnicodeScalar(letter.value + 32)!))
            } else if letter.isUppercase {
                result.append(String(UnicodeScalar(letter.value - 32)!))
            } else {
                result.append(String(char))
            }
        }
    }
    return result.isEmpty? String(s.reversed()) : String(result.reversed())
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first {
            if letter.isLowercase {
                result.append(String(UnicodeScalar(letter.value + 32)!))
            } else if letter.isUppercase {
                result.append(String(UnicodeScalar(letter.value - 32)!))
            } else {
                result.append(String(char))
            }
        }
    }
    return result.isEmpty? String(s.reversed()) : String(result.reversed())
}
```

func solve(s: String) -> String {
    var result = ""
    var isPreviousLetter = false
    
    for char in s {
        if char.isLetter {
            if isPreviousLetter {
                result.append(char.toggleCase())
            } else {
                result.append(char)
            }
            isPreviousLetter = true
        } else {
            result.append(char)
            isPreviousLetter = false
        }
    }
    
    return String(result.reversed())
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isPreviousLetter = false
    
    for char in s {
        if char.isLetter {
            if isPreviousLetter {
                result.append(char.toggleCase())
            } else {
                result.append(char)
            }
            isPreviousLetter = true
        } else {
            result.append(char)
            isPreviousLetter = false
        }
    }
    
    return String(result.reversed())
}
```

func solve(s: String) -> String {
    var result = ""
    var isPreviousLetter = false
    
    for char in s {
        if char.isLetter {
            if isPreviousLetter {
                result.append(char.toggleCase())
            } else {
                result.append(char)
            }
            isPreviousLetter = true
        } else {
            result.append(char)
            isPreviousLetter = false
        }
    }
    
    return String(result.reversed())
}

func String.toggleCase() -> Character {
    return self.isLowercase? self.uppercased() : self.lowercased()
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isPreviousLetter = false
    
    for char in s {
        if char.isLetter {
            if isPreviousLetter {
                result.append(char.toggleCase())
            } else {
                result.append(char)
            }
            isPreviousLetter = true
        } else {
            result.append(char)
            isPreviousLetter = false
        }
    }
    
    return String(result.reversed())
}

func String.toggleCase() -> Character {
    return self.isLowercase? self.uppercased() : self.lowercased()
}
```

func solve(s: String) -> String {
    var result = ""
    var isPreviousLetter = false
    
    for char in s {
        if char.isLetter {
            if isPreviousLetter {
                result.append(char.toggleCase())
            } else {
                result.append(char)
            }
            isPreviousLetter = true
        } else {
            result.append(char)
            isPreviousLetter = false
        }
    }
    
    return String(result.reversed())
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isPreviousLetter = false
    
    for char in s {
        if char.isLetter {
            if isPreviousLetter {
                result.append(char.toggleCase())
            } else {
                result.append(char)
            }
            isPreviousLetter = true
        } else {
            result.append(char)
            isPreviousLetter = false
        }
    }
    
    return String(result.reversed())
}
```

func solve(s: String) -> String {
    var result = ""
    var isPreviousLetter = false
    
    for char in s {
        if char.isLetter {
            if isPreviousLetter {
                result.append(char.toggleCase())
            } else {
                result.append(char)
            }
            isPreviousLetter = true
        } else {
            result.append(char)
            isPreviousLetter = false
        }
    }
    
    return String(result.reversed())
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isPreviousLetter = false
    
    for char in s {
        if char.isLetter {
            if isPreviousLetter {
                result.append(char.toggleCase())
            } else {
                result.append(char)
            }
            isPreviousLetter = true
        } else {
            result.append(char)
            isPreviousLetter = false
        }
    }
    
    return String(result.reversed())
}
```

func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if let index = letters.firstIndex(of: char) {
            result.append(letters[letters.index(index, offsetBy: 32)])
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if let index = letters.firstIndex(of: char) {
            result.append(letters[letters.index(index, offsetBy: 32)])
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if let index = letters.index(of: char) {
            result.append(letters[letters.index(before: index)])
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if let index = letters.index(of: char) {
            result.append(letters[letters.index(before: index)])
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if let index = letters.firstIndex(of: char) {
            result.append(letters[letters.index(index, offsetBy: 32)])
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if let index = letters.firstIndex(of: char) {
            result.append(letters[letters.index(index, offsetBy: 32)])
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if let index = letters.firstIndex(of: char) {
            result.append(letters[letters.index(index, offsetBy: 32)])
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if let index = letters.firstIndex(of: char) {
            result.append(letters[letters.index(index, offsetBy: 32)])
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    let chars = Array(s)
    var result = ""
    for char in chars {
        if let char = Character(char).unicodeScalarValue {
            if char.isASCII {
                if char.isLowercase {
                    result.append(Character(UnicodeScalar(char.uppercaseScalarValue)!))
                } else {
                    result.append(Character(UnicodeScalar(char.lowercaseScalarValue)!))
                }
            } else {
                result.append(Character(char))
            }
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    let chars = Array(s)
    var result = ""
    for char in chars {
        if let char = Character(char).unicodeScalarValue {
            if char.isASCII {
                if char.isLowercase {
                    result.append(Character(UnicodeScalar(char.uppercaseScalarValue)!))
                } else {
                    result.append(Character(UnicodeScalar(char.lowercaseScalarValue)!))
                }
            } else {
                result.append(Character(char))
            }
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    let chars = Array(s)
    let reversed = chars.map { char in
        guard let letter = char.unicodeScalar else { return String(char) }
        return letter.isLowercase? String(letter.uppercase) : String(letter.lowercase)
    }.reversed()
    return String(reversed)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    let chars = Array(s)
    let reversed = chars.map { char in
        guard let letter = char.unicodeScalar else { return String(char) }
        return letter.isLowercase? String(letter.uppercase) : String(letter.lowercase)
    }.reversed()
    return String(reversed)
}
```

func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if let index = letters.firstIndex(of: char) {
            result.append(letters[letters.index(index, offsetBy: 32)])
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if let index = letters.firstIndex(of: char) {
            result.append(letters[letters.index(index, offsetBy: 32)])
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if let index = letters.firstIndex(of: char) {
            result.append(letters[letters.index(index, offsetBy: 32)])
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if let index = letters.firstIndex(of: char) {
            result.append(letters[letters.index(index, offsetBy: 32)])
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    let chars = Array(s)
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in chars {
        if let index = letters.index(of: char) {
            result.append(letters[letters.index(before: index)])
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    let chars = Array(s)
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in chars {
        if let index = letters.index(of: char) {
            result.append(letters[letters.index(before: index)])
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if let index = letters.index(of: char) {
            result.append(letters[letters.index(before: index)])
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if let index = letters.index(of: char) {
            result.append(letters[letters.index(before: index)])
        } else {
            result.append(char)
        }
    }
    return result
}
```

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
}

/*
 You are given a string s.
 if s[i] is a letter, reverse its case from lower to upper or vise versa, 
 otherwise keep it as it is.
 If the string contains no letters, reverse the string.
 The function should return the resulted string.
 Examples
 solve(s: "1234") == "4321"
 solve(s: "ab") == "AB"
 solve(s: "#a@C") == "#A@c"
 */
func solve(s: String) -> String {
    
    
    
    
    var result = [String(

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
}

/*
 You are given a string s.
 if s[i] is a letter, reverse its case from lower to upper or vise versa, 
 otherwise keep it as it is.
 If the string contains no letters, reverse the string.
 The function should return the resulted string.
 Examples
 solve(s: "1234") == "4321"
 solve(s: "ab") == "AB"
 solve(s: "#a@C") == "#A@c"
 */
func solve(s: String) -> String {
    

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
}

/*
 You are given a string s.
 if s[i] is a letter, reverse its case from lower to upper or vise versa, 
 otherwise keep it as it is.
 If the string contains no letters, reverse the string.
 The function should return the resulted string.
 Examples
 solve(s: "1234") == "4321"
 solve(s: "ab") == "AB"
 solve(s: "#a@C") == "#A@c"
 */
func solve(s: String) -> String {
    
    
    
    
    
    
    

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
}

/*
 You are given a string s.
 if s[i] is a letter, reverse its case from lower to upper or vise versa, 
 otherwise keep it as it is.
 If the string contains no letters, reverse the string.
 The function should return the resulted string.
 Examples
 solve(s: "1234") == "4321"
 solve(s: "ab") == "AB"
 solve(s: "#a@C") == "#A@c"
 */
func solve(s: String) -> String {
    
    

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
}

/*
 You are given a string s.
 if s[i] is a letter, reverse its case from lower to upper or vise versa, 
 otherwise keep it as it is.
 If the string contains no letters, reverse the string.
 The function should return the resulted string.
 Examples
 solve(s: "1234") == "4321"
 solve(s: "ab") == "AB"
 solve(s: "#a@C") == "#A@c"
 */
func solve(s: String) -> String {
    
    
    
    
    

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
}

/*
 You are given a string s.
 if s[i] is a letter, reverse its case from lower to upper or vise versa, 
 otherwise keep it as it is.
 If the string contains no letters, reverse the string.
 The function should return the resulted string.
 Examples
 solve(s: "1234") == "4321"
 solve(s: "ab") == "AB"
 solve(s: "#a@C") == "#A@c"
 */
func solve(s: String) -> String {
    
    
    
    var

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
}

/*
 You are given a string s.
 if s[i] is a letter, reverse its case from lower to upper or vise versa, 
 otherwise keep it as it is.
 If the string contains no letters, reverse the string.
 The function should return the resulted string.
 Examples
 solve(s: "1234") == "4321"
 solve(s: "ab") == "AB"
 solve(s: "#a@C") == "#A@c"
 */
func solve(s: String) -> String {
    
    
    
    var result = [String(s

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
}

/*
 You are given a string s.
 if s[i] is a letter, reverse its case from lower to upper or vise versa, 
 otherwise keep it as it is.
 If the string contains no letters, reverse the string.
 The function should return the resulted string.
 Examples
 solve(s: "1234") == "4321"
 solve(s: "ab") == "AB"
 solve(s: "#a@C") == "#A@c"
 */
func solve(s: String) -> String {
    
    

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
}

/*
 You are given a string s.
 if s[i] is a letter, reverse its case from lower to upper or vise versa, 
 otherwise keep it as it is.
 If the string contains no letters, reverse the string.
 The function should return the resulted string.
 Examples
 solve(s: "1234") == "4321"
 solve(s: "ab") == "AB"
 solve(s: "#a@C") == "#A@c"
 */
func solve(s: String) -> String {
    
    var result = ""
    
    
    for i
    

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
}

/*
 You are given a string s.
 if s[i] is a letter, reverse its case from lower to upper or vise versa, 
 otherwise keep it as it is.
 If the string contains no letters, reverse the string.
 The function should return the resulted string.
 Examples
 solve(s: "1234") == "4321"
 solve(s: "ab") == "AB"
 solve(s: "#a@C") == "#A@c"
 */
func solve(s: String) -> String {

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
solve(solve(solve(s: "1234"1234"
s: "s: "solve(s: "
solve
solve"
solve"
solve"
solve(s: "
solve
solve"
solve(s: "

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
solve(solve(solve(s: "1234"1234"
s: "s: "solve"
solve"
solve

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
solve(solve(solve(solve(s: "1234"1234" == "1234"
s: "s: "
solve"
solve"
solve"
solve"
solve"
solve(solve"

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
solve(solve(solve(s: "1234"1234"
s: "s: "
s: "
solve(solve

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
solve(solve(solve(s: "1234"1234"
s: "
solve(s: "solve(s: "solve"
solve"
s: "
solve"
solve"
solve(s: "

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
solve(solve(solve(s: "1234"1234"
solve"
s: "solve"
solve"
solve"
solve"
solve"
solve(s: "solve
solve
s: "solve
solve
solve
s: "solve
solve
solve
solve

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
solve(solve(solve(s: "1234"1234"
solve(s: "1234"
solve"
solve"
solve
solve"
solve(s: "
solve
solve
solve
s

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
solve(solve(solve(solve(s: "s: "s: "s: "s: "s: "s: "s: "s: "s: "solve"
solve"
```

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
solve(solve(solve(s: "1234"1234"
solve(s: "s: "s: "
solve"

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
solve(solve(solve(solve(s: "1234"1234"1234" == "4321"
s: "s: "

func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            if char.isUppercase {
                result += String(char).lowercase()
            } else {
                result += String(char).uppercase()
            }
        } else {
            result += String(char)
            isLetter = false
        }
    }
    if !isLetter {
        result = String(result.reversed())
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            if char.isUppercase {
                result += String(char).lowercase()
            } else {
                result += String(char).uppercase()
            }
        } else {
            result += String(char)
            isLetter = false
        }
    }
    if !isLetter {
        result = String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        let char = s[i]
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else if char.isASCII {
            result += String(char).reversed()
        } else {
            result += String(char)
        }
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        let char = s[i]
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else if char.isASCII {
            result += String(char).reversed()
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in s {
        if CharacterSet.letters.contains(i) {
            if i.isUppercase {
                result += String(i).lowercased()
            } else {
                result += String(i).uppercased()
            }
        } else if CharacterSet.whitespaces.contains(i) {
            result += String(i)
        } else {
            result = String(result.reversed())
        }
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for i in s {
        if CharacterSet.letters.contains(i) {
            if i.isUppercase {
                result += String(i).lowercased()
            } else {
                result += String(i).uppercased()
            }
        } else if CharacterSet.whitespaces.contains(i) {
            result += String(i)
        } else {
            result = String(result.reversed())
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for (index, char) in s.enumerated() {
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for (index, char) in s.enumerated() {
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var reverse = false
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            reverse = !reverse
            if reverse {
                result = String(result.reversed())
            }
        }
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    var reverse = false
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            reverse = !reverse
            if reverse {
                result = String(result.reversed())
            }
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
        }
    }
    if !isLetter {
        return String(result.reversed())
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
        }
    }
    if !isLetter {
        return String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
            isLetter = false
        }
    }
    if !isLetter {
        result = String(result.reversed())
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
            isLetter = false
        }
    }
    if !isLetter {
        result = String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var reverse = false
    for char in s {
        if char.isLetter {
            if reverse {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
            reverse = !reverse
        } else {
            result += String(char)
        }
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    var reverse = false
    for char in s {
        if char.isLetter {
            if reverse {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
            reverse = !reverse
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        let char = s[i]
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        let char = s[i]
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        let isLetter = s[i].isLetter
        if isLetter {
            let isLower = s[i].isLowercase
            if isLower {
                result += String(s[i].uppercased())
            } else {
                result += String(s[i].lowercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        let isLetter = s[i].isLetter
        if isLetter {
            let isLower = s[i].isLowercase
            if isLower {
                result += String(s[i].uppercased())
            } else {
                result += String(s[i].lowercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = [Character]()
    for character in s.reversed() {
        if let letter = Character.isLetter(character) {
            if letter {
                let newCharacter = Character(character.isUppercase ? Character.lowercases(character) : Character.uppercases(character))
                result.append(newCharacter)
            } else {
                result.append(character)
            }
        } else {
            result.append(character)
        }
    }
    return String(result)
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = [Character]()
    for character in s.reversed() {
        if let letter = Character.isLetter(character) {
            if letter {
                let newCharacter = Character(character.isUppercase ? Character.lowercases(character) : Character.uppercases(character))
                result.append(newCharacter)
            } else {
                result.append(character)
            }
        } else {
            result.append(character)
        }
    }
    return String(result)
}
```

func solve(s: String) -> String {
    var result = [Character]()
    let characters = s.unicodeScalars
    if !characters.contains(where: { $0.isLetter }) {
        for char in characters.reversed() {
            result.append(Character(char))
        }
    } else {
        for char in characters {
            if char.isLetter {
                let newChar = Character(char.isUppercase ? Character($0.lowercased().unicodeScalars.first!) : Character($0.uppercased().unicodeScalars.first!)
                result.append(newChar)
            } else {
                result.append(Character(char))
            }
        }
    }
    return String(result)
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = [Character]()
    let characters = s.unicodeScalars
    if !characters.contains(where: { $0.isLetter }) {
        for char in characters.reversed() {
            result.append(Character(char))
        }
    } else {
        for char in characters {
            if char.isLetter {
                let newChar = Character(char.isUppercase ? Character($0.lowercased().unicodeScalars.first!) : Character($0.uppercased().unicodeScalars.first!)
                result.append(newChar)
            } else {
                result.append(Character(char))
            }
        }
    }
    return String(result)
}
```

func solve(s: String) -> String {
    var result = [Character]()
    for character in s.characters {
        if let letter = character.asciiValue {
            if (letter >= 65 && letter <= 90) {
                result.append(Character(UnicodeScalar((letter + 32))))
            } else if (letter >= 97 && letter <= 122) {
                result.append(Character(UnicodeScalar((letter - 32))))
            } else {
                result.insert(character, at: 0)
            }
        }
    }
    return String(result)
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = [Character]()
    for character in s.characters {
        if let letter = character.asciiValue {
            if (letter >= 65 && letter <= 90) {
                result.append(Character(UnicodeScalar((letter + 32))))
            } else if (letter >= 97 && letter <= 122) {
                result.append(Character(UnicodeScalar((letter - 32))))
            } else {
                result.insert(character, at: 0)
            }
        }
    }
    return String(result)
}
```

func solve(s: String) -> String {
    var result = [Character]()
    let characters = s.unicodeScalars
    var hasLetters = false
    
    for character in characters {
        if CharacterSet.letters.contains(character) {
            hasLetters = true
            let newCharacter = Character(UnicodeScalar(character.value ^ 32)!)
            result.append(newCharacter)
        } else {
            result.append(Character(character))
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return String(result)
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = [Character]()
    let characters = s.unicodeScalars
    var hasLetters = false
    
    for character in characters {
        if CharacterSet.letters.contains(character) {
            hasLetters = true
            let newCharacter = Character(UnicodeScalar(character.value ^ 32)!)
            result.append(newCharacter)
        } else {
            result.append(Character(character))
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return String(result)
}
```

func solve(s: String) -> String {
    var result = [Character]()
    for character in s.characters {
        if let letter = Character.isLetter(character) {
            if letter {
                if Character.isUppercase(character) {
                    result.append(Character(character.lowercased()))
                } else {
                    result.append(Character(character.uppercased()))
                }
            } else {
                result.append(character)
            }
        }
    }
    return String(result)
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = [Character]()
    for character in s.characters {
        if let letter = Character.isLetter(character) {
            if letter {
                if Character.isUppercase(character) {
                    result.append(Character(character.lowercased()))
                } else {
                    result.append(Character(character.uppercased()))
                }
            } else {
                result.append(character)
            }
        }
    }
    return String(result)
}
```

func solve(s: String) -> String {
    var result = [Character]()
    var reverse = false
    
    for character in s {
        if character.isLetter {
            if character.isUppercase {
                result.append(character.lowercased())
            } else {
                result.append(character.uppercased())
            }
            reverse = true
        } else {
            result.append(character)
        }
    }
    
    if !reverse {
        result = result.reversed()
    }
    
    return String(result)
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = [Character]()
    var reverse = false
    
    for character in s {
        if character.isLetter {
            if character.isUppercase {
                result.append(character.lowercased())
            } else {
                result.append(character.uppercased())
            }
            reverse = true
        } else {
            result.append(character)
        }
    }
    
    if !reverse {
        result = result.reversed()
    }
    
    return String(result)
}
```

func solve(s: String) -> String {
    var result = [Character]()
    for character in s.reversed() {
        if let letter = Character.isLetter(character) {
            if letter {
                if let uppercase = character.uppercased() {
                    result.append(uppercase == character ? lowercase : uppercase)
                }
            } else {
                result.append(character)
            }
        } else {
            result.append(character)
        }
    }
    return String(result)
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = [Character]()
    for character in s.reversed() {
        if let letter = Character.isLetter(character) {
            if letter {
                if let uppercase = character.uppercased() {
                    result.append(uppercase == character ? lowercase : uppercase)
                }
            } else {
                result.append(character)
            }
        } else {
            result.append(character)
        }
    }
    return String(result)
}
```

func solve(s: String) -> String {
    var result = [Character]()
    for character in s.reversed() {
        if let letter = Character.isLetter(character) {
            if letter {
                let newCharacter = character.isUppercase ? Character(character.lowercased()) : Character(character.uppercased())
                result.append(newCharacter)
            } else {
                result.append(character)
            }
        } else {
            result.append(character)
        }
    }
    return String(result)
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = [Character]()
    for character in s.reversed() {
        if let letter = Character.isLetter(character) {
            if letter {
                let newCharacter = character.isUppercase ? Character(character.lowercased()) : Character(character.uppercased())
                result.append(newCharacter)
            } else {
                result.append(character)
            }
        } else {
            result.append(character)
        }
    }
    return String(result)
}
```

func solve(s: String) -> String {
    var result = [Character]()
    for character in s.unicodeScalars {
        if CharacterSet.letters.contains(character) {
            if Character.isUpper(character) {
                result.append(Character(UnicodeScalar(character.value + 32)))
            } else {
                result.append(Character(UnicodeScalar(character.value - 32)))
            }
        } else {
            result.insert(character, at: 0)
        }
    }
    return String(result)
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = [Character]()
    for character in s.unicodeScalars {
        if CharacterSet.letters.contains(character) {
            if Character.isUpper(character) {
                result.append(Character(UnicodeScalar(character.value + 32)))
            } else {
                result.append(Character(UnicodeScalar(character.value - 32)))
            }
        } else {
            result.insert(character, at: 0)
        }
    }
    return String(result)
}
```

func solve(s: String) -> String {
    var reversed = s.reversed()
    var result = ""
    
    for char in reversed {
        if let letter = char.asciiValue {
            if (letter >= UInt8(65) && letter <= UInt8(90)) {
                result += String(char).lowercased()
            } else if (letter >= UInt8(97) && letter <= UInt8(122)) {
                result += String(char).uppercased()
            } else {
                result += String(char)
            }
        }
    }
    
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var reversed = s.reversed()
    var result = ""
    
    for char in reversed {
        if let letter = char.asciiValue {
            if (letter >= UInt8(65) && letter <= UInt8(90)) {
                result += String(char).lowercased()
            } else if (letter >= UInt8(97) && letter <= UInt8(122)) {
                result += String(char).uppercased()
            } else {
                result += String(char)
            }
        }
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    if !hasLetter {
        result = String(result.reversed())
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    if !hasLetter {
        result = String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    if !hasLetter {
        result = String(result.reversed())
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    if !hasLetter {
        result = String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var hasLetters = false
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    if !hasLetters {
        result = String(result.reversed())
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    var hasLetters = false
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    if !hasLetters {
        result = String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    if !hasLetter {
        result = String(result.reversed())
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    if !hasLetter {
        result = String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    let characters = Array(s)
    var hasLetter = false
    
    for character in characters {
        if character.isLetter {
            hasLetter = true
            if character.isUppercase {
                result += String(character).lowercased()
            } else {
                result += String(character).uppercased()
            }
        } else {
            result += String(character)
        }
    }
    
    if !hasLetter {
        result = String(result.reversed())
    }
    
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    let characters = Array(s)
    var hasLetter = false
    
    for character in characters {
        if character.isLetter {
            hasLetter = true
            if character.isUppercase {
                result += String(character).lowercased()
            } else {
                result += String(character).uppercased()
            }
        } else {
            result += String(character)
        }
    }
    
    if !hasLetter {
        result = String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    if !hasLetter {
        result = String(result.reversed())
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    if !hasLetter {
        result = String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    let sArray = Array(s)
    var hasLetter = false
    for char in sArray {
        if let char = char.lowercased() {
            result += String(char)
            hasLetter = true
        } else if let char = char.uppercased() {
            result += String(char)
            hasLetter = true
        } else {
            result += String(char)
        }
    }
    if !hasLetter {
        result = String(sArray.reversed())
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    let sArray = Array(s)
    var hasLetter = false
    for char in sArray {
        if let char = char.lowercased() {
            result += String(char)
            hasLetter = true
        } else if let char = char.uppercased() {
            result += String(char)
            hasLetter = true
        } else {
            result += String(char)
        }
    }
    if !hasLetter {
        result = String(sArray.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    if !hasLetter {
        result = String(result.reversed())
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    if !hasLetter {
        result = String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    if !hasLetter {
        result = String(result.reversed())
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    if !hasLetter {
        result = String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    if !hasLetter {
        result = String(result.reversed())
    }
    return result
}

<｜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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    if !hasLetter {
        result = String(result.reversed())
    }
    return result
}
```

import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}
```

import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}
```

import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            result += char.isLowercase ? char.uppercased() : char.lowercased()
        } else {
            result += String(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            result += char.isLowercase ? char.uppercased() : char.lowercased()
        } else {
            result += String(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}
```

import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}
```

import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}
```

import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            result += char.isLowercase ? char.uppercased() : char.lowercased()
        } else {
            result += String(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            result += char.isLowercase ? char.uppercased() : char.lowercased()
        } else {
            result += String(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}
```

import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}
```

import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}
```

import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}
```

import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
import Foundation

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false

    for char in s {
        if char.isLetter {
            hasLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetter {
        result = String(result.reversed())
    }

    return result
}
```

func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isUppercase {
                result += String(char.lowercased())
            } else {
                result += String(char.uppercased())
            }
        } else {
            result += String(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isUppercase {
                result += String(char.lowercased())
            } else {
                result += String(char.uppercased())
            }
        } else {
            result += String(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            result += char.isUppercase ? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    
    return hasLetters ? result : String(result.reversed())
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            result += char.isUppercase ? char.lowercased() : char.uppercased()
        } else {
            result += String(char)
        }
    }
    
    return hasLetters ? result : String(result.reversed())
}
```

func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isUppercase {
                result += String(char.lowercased())
            } else {
                result += String(char.uppercased())
            }
        } else {
            result += String(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isUppercase {
                result += String(char.lowercased())
            } else {
                result += String(char.uppercased())
            }
        } else {
            result += String(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var hasLetters = false
    var result = ""
    
    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !hasLetters {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var hasLetters = false
    var result = ""

    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetters {
        return String(result.reversed())
    }

    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var hasLetters = false
    var result = ""

    for char in s {
        if char.isLetter {
            hasLetters = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }

    if !hasLetters {
        return String(result.reversed())
    }

    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    var containsLetter = false
    
    for char in s {
        if char.isLetter {
            containsLetter = true
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    
    if !containsLetter {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in s {
        if i.isLetter {
            if i.isLowercase {
                result += String(i).uppercased()
            } else {
                result += String(i).lowercased()
            }
        } else {
            result += String(i)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in s {
        if i.isLetter {
            if i.isLowercase {
                result += String(i).uppercased()
            } else {
                result += String(i).lowercased()
            }
        } else {
            result += String(i)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in s {
        if i.isLetter {
            if i.isUppercase {
                result += String(i).lowercased()
            } else {
                result += String(i).uppercased()
            }
        } else {
            result += String(i)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in s {
        if i.isLetter {
            if i.isUppercase {
                result += String(i).lowercased()
            } else {
                result += String(i).uppercased()
            }
        } else {
            result += String(i)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result.append(char.lowercased())
            } else {
                result.append(char.uppercased())
            }
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in s {
        if i.isLetter {
            if i.isUppercase {
                result += i.lowercased()
            } else {
                result += i.uppercased()
            }
        } else {
            result += String(i)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in s {
        if i.isLetter {
            if i.isUppercase {
                result += i.lowercased()
            } else {
                result += i.uppercased()
            }
        } else {
            result += String(i)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in s {
        if i.isLetter {
            if i.isUppercase {
                result += String(i).lowercased()
            } else {
                result += String(i).uppercased()
            }
        } else {
            result += String(i)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in s {
        if i.isLetter {
            if i.isUppercase {
                result += String(i).lowercased()
            } else {
                result += String(i).uppercased()
            }
        } else {
            result += String(i)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in s {
        if i.isLetter {
            if i.isUppercase {
                result += String(i.lowercased())
            } else {
                result += String(i.uppercased())
            }
        } else {
            result += String(i)
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    } else {
        return result
    }
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in s {
        if i.isLetter {
            if i.isUppercase {
                result += String(i.lowercased())
            } else {
                result += String(i.uppercased())
            }
        } else {
            result += String(i)
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    } else {
        return result
    }
}
```

func solve(s: String) -> String {
    var result = ""
    for i in s {
        if i.isLetter {
            if i.isLowercase {
                result += String(i).uppercased()
            } else {
                result += String(i).lowercased()
            }
        } else {
            result += String(i)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in s {
        if i.isLetter {
            if i.isLowercase {
                result += String(i).uppercased()
            } else {
                result += String(i).lowercased()
            }
        } else {
            result += String(i)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            if c.isLowercase {
                result.append(String(c.uppercased))
            } else {
                result.append(String(c.lowercased))
            }
        } else {
            result.append(String(c))
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            if c.isLowercase {
                result.append(String(c.uppercased))
            } else {
                result.append(String(c.lowercased))
            }
        } else {
            result.append(String(c))
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter() {
            if c.isLower() {
                result.append(String(c.uppercased()))
            } else {
                result.append(String(c.lowercased()))
            }
        } else {
            result.append(String(c))
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter() {
            if c.isLower() {
                result.append(String(c.uppercased()))
            } else {
                result.append(String(c.lowercased()))
            }
        } else {
            result.append(String(c))
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter() {
            if c.isLowercase() {
                result.append(String(c.uppercased()))
            } else {
                result.append(String(c.lowercased()))
            }
        } else {
            result.append(String(c))
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter() {
            if c.isLowercase() {
                result.append(String(c.uppercased()))
            } else {
                result.append(String(c.lowercased()))
            }
        } else {
            result.append(String(c))
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            if c.isLowercase {
                result.append(String(c.uppercased()))
            } else {
                result.append(String(c.lowercased()))
            }
        } else {
            result.append(String(c))
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            if c.isLowercase {
                result.append(String(c.uppercased()))
            } else {
                result.append(String(c.lowercased()))
            }
        } else {
            result.append(String(c))
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            if c.isLowercase {
                result.append(String(c.uppercased))
            } else {
                result.append(String(c.lowercased))
            }
        } else {
            result.append(String(c))
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            if c.isLowercase {
                result.append(String(c.uppercased))
            } else {
                result.append(String(c.lowercased))
            }
        } else {
            result.append(String(c))
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            if c.isLowercase {
                result.append(String(c.uppercased))
            } else {
                result.append(String(c.lowercased))
            }
        } else {
            result.append(String(c))
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            if c.isLowercase {
                result.append(String(c.uppercased))
            } else {
                result.append(String(c.lowercased))
            }
        } else {
            result.append(String(c))
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = [Character]()
    for c in s {
        if c.isLetter() {
            if c.isLowercase() {
                result.append(String(c.uppercased()))
            } else {
                result.append(String(c.lowercased()))
            }
        } else {
            result.append(String(c))
        }
    }
    return String(result)
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = [Character]()
    for c in s {
        if c.isLetter() {
            if c.isLowercase() {
                result.append(String(c.uppercased()))
            } else {
                result.append(String(c.lowercased()))
            }
        } else {
            result.append(String(c))
        }
    }
    return String(result)
}
```

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            if c.isLowercase {
                result.append(String(c.uppercased()))
            } else {
                result.append(String(c.lowercased()))
            }
        } else {
            result.append(String(c))
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            if c.isLowercase {
                result.append(String(c.uppercased()))
            } else {
                result.append(String(c.lowercased()))
            }
        } else {
            result.append(String(c))
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = [Character]()
    for c in s {
        if c.isLetter() {
            if c.isLowercase() {
                result.append(String(c.uppercased()))
            } else {
                result.append(String(c.lowercased()))
            }
        } else {
            result.append(c)
        }
    }
    return String(result)
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = [Character]()
    for c in s {
        if c.isLetter() {
            if c.isLowercase() {
                result.append(String(c.uppercased()))
            } else {
                result.append(String(c.lowercased()))
            }
        } else {
            result.append(c)
        }
    }
    return String(result)
}
```

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            if c.isLowercase {
                result.append(String(c.uppercased()))
            } else {
                result.append(String(c.lowercased()))
            }
        } else {
            result.append(String(c))
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            if c.isLowercase {
                result.append(String(c.uppercased()))
            } else {
                result.append(String(c.lowercased()))
            }
        } else {
            result.append(String(c))
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    let letters = CharacterSet.letters
    for char in s {
        if letters.contains(char) {
            if let range = s.rangeOfCharacter(from: char) {
                let newChar = (char == char.lowercased())? char.uppercased() : char.lowercased()
                result.append(String(s[range.lowerBound..<range.upperBound].reversed()))
            } else {
                let newChar = (char == char.lowercased())? char.uppercased() : char.lowercased()
                result.append(newChar)
            }
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    }
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    let letters = CharacterSet.letters
    for char in s {
        if letters.contains(char) {
            if let range = s.rangeOfCharacter(from: char) {
                let newChar = (char == char.lowercased())? char.uppercased() : char.lowercased()
                result.append(String(s[range.lowerBound..<range.upperBound].reversed()))
            } else {
                let newChar = (char == char.lowercased())? char.uppercased() : char.lowercased()
                result.append(newChar)
            }
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if let _ = char.asciiValue {
            hasLetter = true
            if char.isLowercase {
                result.append(Character(char.uppercased()))
            } else {
                result.append(Character(char.lowercased()))
            }
        } else {
            result.append(char)
        }
    }
    if!hasLetter {
        result = String(result.reversed())
    }
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if let _ = char.asciiValue {
            hasLetter = true
            if char.isLowercase {
                result.append(Character(char.uppercased()))
            } else {
                result.append(Character(char.lowercased()))
            }
        } else {
            result.append(char)
        }
    }
    if!hasLetter {
        result = String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if let _ = char.asciiValue {
            hasLetter = true
            if char.isLowercase {
                result.append(Character(char.uppercased()))
            } else {
                result.append(Character(char.lowercased()))
            }
        } else {
            result.append(char)
        }
    }
    if!hasLetter {
        result = String(result.reversed())
    }
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if let _ = char.asciiValue {
            hasLetter = true
            if char.isLowercase {
                result.append(Character(char.uppercased()))
            } else {
                result.append(Character(char.lowercased()))
            }
        } else {
            result.append(char)
        }
    }
    if!hasLetter {
        result = String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if let _ = char.asciiValue {
            hasLetter = true
            if char.isLowercase {
                result.append(Character(char.uppercased()))
            } else {
                result.append(Character(char.lowercased()))
            }
        } else {
            result.append(char)
        }
    }
    if!hasLetter {
        result = String(result.reversed())
    }
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if let _ = char.asciiValue {
            hasLetter = true
            if char.isLowercase {
                result.append(Character(char.uppercased()))
            } else {
                result.append(Character(char.lowercased()))
            }
        } else {
            result.append(char)
        }
    }
    if!hasLetter {
        result = String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if let _ = char.asciiValue {
            hasLetter = true
            if char.isLowercase {
                result.append(Character(char.uppercased()))
            } else {
                result.append(Character(char.lowercased()))
            }
        } else {
            result.append(char)
        }
    }
    if!hasLetter {
        result = String(result.reversed())
    }
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if let _ = char.asciiValue {
            hasLetter = true
            if char.isLowercase {
                result.append(Character(char.uppercased()))
            } else {
                result.append(Character(char.lowercased()))
            }
        } else {
            result.append(char)
        }
    }
    if!hasLetter {
        result = String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    
    for char in s {
        if let _ = char.asciiValue {
            let newChar = char.isLowercase? Character(char.uppercased()) : Character(char.lowercased())
            result = "\(newChar)" + result
            hasLetter = true
        } else {
            result = "\(char)" + result
        }
    }
    
    if!hasLetter {
        result = String(result.reversed())
    }
    
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    
    for char in s {
        if let _ = char.asciiValue {
            let newChar = char.isLowercase? Character(char.uppercased()) : Character(char.lowercased())
            result = "\(newChar)" + result
            hasLetter = true
        } else {
            result = "\(char)" + result
        }
    }
    
    if!hasLetter {
        result = String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    let letters = CharacterSet.letters
    for char in s {
        if letters.contains(char) {
            if let range = s.rangeOfCharacter(from: char) {
                let newChar = (char == char.lowercased())? char.uppercased() : char.lowercased()
                result.append(String(newChar)[range.lowerBound - s.startIndex])
            }
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    }
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    let letters = CharacterSet.letters
    for char in s {
        if letters.contains(char) {
            if let range = s.rangeOfCharacter(from: char) {
                let newChar = (char == char.lowercased())? char.uppercased() : char.lowercased()
                result.append(String(newChar)[range.lowerBound - s.startIndex])
            }
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return String(s.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if let _ = char.asciiValue {
            hasLetter = true
            if char.isLowercase {
                result.append(Character(char.uppercased()))
            } else {
                result.append(Character(char.lowercased()))
            }
        } else {
            result.append(char)
        }
    }
    if!hasLetter {
        result = String(result.reversed())
    }
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if let _ = char.asciiValue {
            hasLetter = true
            if char.isLowercase {
                result.append(Character(char.uppercased()))
            } else {
                result.append(Character(char.lowercased()))
            }
        } else {
            result.append(char)
        }
    }
    if!hasLetter {
        result = String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if let _ = char.asciiValue {
            hasLetter = true
            if char.isLowercase {
                result.append(Character(char.uppercased()))
            } else {
                result.append(Character(char.lowercased()))
            }
        } else {
            result.append(char)
        }
    }
    if!hasLetter {
        result = String(result.reversed())
    }
    return result
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    var hasLetter = false
    for char in s {
        if let _ = char.asciiValue {
            hasLetter = true
            if char.isLowercase {
                result.append(Character(char.uppercased()))
            } else {
                result.append(Character(char.lowercased()))
            }
        } else {
            result.append(char)
        }
    }
    if!hasLetter {
        result = String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    let letters = CharacterSet.letters
    for char in s {
        if letters.contains(char) {
            if let range = s.rangeOfCharacter(from: char) {
                let newChar = (char == char.lowercased())? char.uppercased() : char.lowercased()
                result.append(String(newChar)[range.lowerBound == range.upperBound? 0 : 1])
            }
        } else {
            result.append(char)
        }
    }
    return String(result.reversed())
}

<|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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<|im_end|>
<|im_start|>assistant
```swift
func solve(s: String) -> String {
    var result = ""
    let letters = CharacterSet.letters
    for char in s {
        if letters.contains(char) {
            if let range = s.rangeOfCharacter(from: char) {
                let newChar = (char == char.lowercased())? char.uppercased() : char.lowercased()
                result.append(String(newChar)[range.lowerBound == range.upperBound? 0 : 1])
            }
        } else {
            result.append(char)
        }
    }
    return String(result.reversed())
}
```

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i] >= "a" && s[i] <= "z" {
            result += String(s[i]).uppercased()
        } else if s[i] >= "A" && s[i] <= "Z" {
            result += String(s[i]).lowercased()
        } else {
            result += String(s[i])
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i] >= "a" && s[i] <= "z" {
            result += String(s[i]).uppercased()
        } else if s[i] >= "A" && s[i] <= "Z" {
            result += String(s[i]).lowercased()
        } else {
            result += String(s[i])
        }
    }
    return result
}
```
### Challenge

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char >= "a" && char <= "z" {
            result.append(char.uppercased())
        } else if char >= "A" && char <= "Z" {
            result.append(char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char >= "a" && char <= "z" {
            result.append(char.uppercased())
        } else if char >= "A" && char <= "Z" {
            result.append(char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char >= "a" && char <= "z" {
            result.append(String(char.uppercased()))
        } else if char >= "A" && char <= "Z" {
            result.append(String(char.lowercased()))
        } else {
            result.append(String(char))
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char >= "a" && char <= "z" {
            result.append(String(char.uppercased()))
        } else if char >= "A" && char <= "Z" {
            result.append(String(char.lowercased()))
        } else {
            result.append(String(char))
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char >= "a" && char <= "z" {
            result.append(char.uppercased())
        } else if char >= "A" && char <= "Z" {
            result.append(char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char >= "a" && char <= "z" {
            result.append(char.uppercased())
        } else if char >= "A" && char <= "Z" {
            result.append(char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```
### Challenge

func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        if s[i] >= "a" && s[i] <= "z" {
            result += String(s[i]).uppercased()
        } else if s[i] >= "A" && s[i] <= "Z" {
            result += String(s[i]).lowercased()
        } else {
            result += String(s[i])
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        if s[i] >= "a" && s[i] <= "z" {
            result += String(s[i]).uppercased()
        } else if s[i] >= "A" && s[i] <= "Z" {
            result += String(s[i]).lowercased()
        } else {
            result += String(s[i])
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char >= "a" && char <= "z" {
            result.append(char.uppercased())
        } else if char >= "A" && char <= "Z" {
            result.append(char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char >= "a" && char <= "z" {
            result.append(char.uppercased())
        } else if char >= "A" && char <= "Z" {
            result.append(char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        if s[i] >= "a" && s[i] <= "z" {
            result += String(s[i]).uppercased()
        } else if s[i] >= "A" && s[i] <= "Z" {
            result += String(s[i]).lowercased()
        } else {
            result += s[i]
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        if s[i] >= "a" && s[i] <= "z" {
            result += String(s[i]).uppercased()
        } else if s[i] >= "A" && s[i] <= "Z" {
            result += String(s[i]).lowercased()
        } else {
            result += s[i]
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        if s[i] >= "a" && s[i] <= "z" {
            result += String(s[i]).uppercased()
        } else if s[i] >= "A" && s[i] <= "Z" {
            result += String(s[i]).lowercased()
        } else {
            result += String(s[i])
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        if s[i] >= "a" && s[i] <= "z" {
            result += String(s[i]).uppercased()
        } else if s[i] >= "A" && s[i] <= "Z" {
            result += String(s[i]).lowercased()
        } else {
            result += String(s[i])
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char >= "a" && char <= "z" {
            result.append(char.uppercased())
        } else if char >= "A" && char <= "Z" {
            result.append(char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char >= "a" && char <= "z" {
            result.append(char.uppercased())
        } else if char >= "A" && char <= "Z" {
            result.append(char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```
### Challenge

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed() : result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed() : result
}
```
### Link

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return String(result)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return String(result)
}
```

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            result.append(c.isUppercase ? c.lowercased() : c.uppercased())
        } else {
            result.append(c)
        }
    }
    return result.isEmpty ? s.reversed() : result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            result.append(c.isUppercase ? c.lowercased() : c.uppercased())
        } else {
            result.append(c)
        }
    }
    return result.isEmpty ? s.reversed() : result
}
```
### Link

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed() : result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed() : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed() : result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed() : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return String(result)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return String(result)
}
```

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            result.append(c.isUppercase ? c.lowercased() : c.uppercased())
        } else {
            result.append(c)
        }
    }
    return result.isEmpty ? s.reversed() : result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            result.append(c.isUppercase ? c.lowercased() : c.uppercased())
        } else {
            result.append(c)
        }
    }
    return result.isEmpty ? s.reversed() : result
}
```
### Link

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed() : result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? s.reversed() : result
}
```
### Link

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return String(result)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return String(result)
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.count > 0 ? result : s.reversed()
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.count > 0 ? result : s.reversed()
}
```

func solve(s: String) -> String {
    var result = ""
    if s.contains(where: { $0.isLetter }) {
        for char in s {
            if char.isLetter {
                result.append(char.isUppercase ? char.lowercased() : char.uppercased())
            } else {
                result.append(char)
            }
        }
    } else {
        result = String(s.reversed())
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    if s.contains(where: { $0.isLetter }) {
        for char in s {
            if char.isLetter {
                result.append(char.isUppercase ? char.lowercased() : char.uppercased())
            } else {
                result.append(char)
            }
        }
    } else {
        result = String(s.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}
```

func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if letters.contains(char) {
            result += String(char).lowercased() == String(char) ? String(char).uppercased() : String(char).lowercased()
        } else {
            result += String(char)
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if letters.contains(char) {
            result += String(char).lowercased() == String(char) ? String(char).uppercased() : String(char).lowercased()
        } else {
            result += String(char)
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}
```

func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    let reversed = String(s.reversed())
    let isLetter = letters.contains(where: { $0 == s.first! })
    if isLetter {
        return reversed
    } else {
        return s
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    let reversed = String(s.reversed())
    let isLetter = letters.contains(where: { $0 == s.first! })
    if isLetter {
        return reversed
    } else {
        return s
    }
}
```

func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if letters.contains(char) {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if letters.contains(char) {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}
```

func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    let sArray = Array(s)
    var result = ""
    var isLetter = false
    for char in sArray {
        if letters.contains(char) {
            isLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    if isLetter {
        return String(result.reversed())
    } else {
        return String(s.reversed())
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    let sArray = Array(s)
    var result = ""
    var isLetter = false
    for char in sArray {
        if letters.contains(char) {
            isLetter = true
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    if isLetter {
        return String(result.reversed())
    } else {
        return String(s.reversed())
    }
}
```

func solve(s: String) -> String {
    let letters = s.compactMap { $0.isLetter ? $0 : nil }
    if letters.isEmpty {
        return String(s.reversed())
    } else {
        return String(s.map { $0.isLetter ? $0.toggledCase : $0 })
    }
}

extension Character {
    var isLetter: Bool {
        return isUppercase || isLowercase
    }

    var toggledCase: Character {
        if isLowercase {
            return String(self).uppercased().first!
        } else if isUppercase {
            return String(self).lowercased().first!
        } else {
            return self
        }
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    let letters = s.compactMap { $0.isLetter ? $0 : nil }
    if letters.isEmpty {
        return String(s.reversed())
    } else {
        return String(s.map { $0.isLetter ? $0.toggledCase : $0 })
    }
}

extension Character {
    var isLetter: Bool {
        return isUppercase || isLowercase
    }

    var toggledCase: Character {
        if isLowercase {
            return String(self).uppercased().first!
        } else if isUppercase {
            return String(self).lowercased().first!
        } else {
            return self
        }
    }
}
```

func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if letters.contains(char) {
            result += String(char).lowercased() == String(char) ? String(char).uppercased() : String(char).lowercased()
        } else {
            result += String(char)
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var result = ""
    for char in s {
        if letters.contains(char) {
            result += String(char).lowercased() == String(char) ? String(char).uppercased() : String(char).lowercased()
        } else {
            result += String(char)
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}
```

func solve(s: String) -> String {
    let letters = s.compactMap { $0.isLetter ? $0 : nil }
    let result = letters.reduce("") { $0 + $1.isLowercase ? String($1).uppercased() : String($1).lowercased() }
    return result.isEmpty ? String(s.reversed()) : result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    let letters = s.compactMap { $0.isLetter ? $0 : nil }
    let result = letters.reduce("") { $0 + $1.isLowercase ? String($1).uppercased() : String($1).lowercased() }
    return result.isEmpty ? String(s.reversed()) : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += char.lowercased()
            } else {
                result += char.uppercased()
            }
        } else {
            result += String(char)
        }
    }
    return result.reversed()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += char.lowercased()
            } else {
                result += char.uppercased()
            }
        } else {
            result += String(char)
        }
    }
    return result.reversed()
}
// Test
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
solve(s: "") == ""
solve(s: "AbCdEf") == "aBcDeF"
solve(s: "aBcDeF") == "AbCdEf"
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
solve(s: "") == ""
solve(s: "AbCdEf") == "aBcDeF"
solve(s: "A") == "a"
solve(s: "a") == "a"
solve(s: "Ab") == "Ab"
solve(s: "Ab") == "Ab"
solve(s: "AbC") == "AbC"
solve(s: "AbC") == "AbC"
solve(s: "AbCd") == "AbCd"
solve(s: "AbCd") == "AbCd"
solve(s: "AbCdEf") == "AbCdEf"
solve(s: "AbCdEf") == "AbCdEf"
solve(s: "AbCdEfGh") == "AbCdEfGh"
solve(s: "AbCdEfGh") == "AbCdEfGh"
solve(s: "AbCdEfGhIj") == "AbCdEfGhIj"
solve(s: "AbCdEfGhIj") == "AbCdEfGhIj"
solve(s: "AbCdEfGhIjKl") == "AbCdEfGhIjKl"
solve(s: "AbCdEfGhIjKl") == "AbCdEfGhIjKl"
solve(s: "AbCdEfGhIjKlMn") == "AbCdEfGhIjKlMn"
solve(s: "AbCdEfGhIjKlMn") == "AbCdEfGhIjKlMn"
solve(s: "AbCdEfGhIjKlMnOp") == "AbCdEfGhIjKlMnOp"
solve(s: "AbCdEfGhIjKlMnOp") == "AbCdEfGhIjKlMnOp"
solve(s: "AbCdEfGhIjKlMnOpQr") == "AbCdEfGhIjKlMnOpQr"
solve(s: "AbCdEfGhIjKlMnOpQr") == "AbCdEfGhIjKlMnOpQr"
solve(s: "AbCdEfGhIjKlMnOpQrSt") == "AbCdEfGhIjKlMnOpQrSt"
solve(s: "AbCdEfGhIjKlMnOpQrSt") == "AbCdEfGhIjKlMnOpQrSt"
solve(s: "AbCdEfGhIjKlMnOpQrStUv") == "AbCdEfGhIjKlMnOpQrStUv"
solve(s: "AbCdEfGhIjKlMnOpQrStUv") == "AbCdEfGhIjKlMnOpQrSt

func solve(s: String) -> String {
    // your code here
    var newString = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                newString += String(char.lowercased())
            } else {
                newString += String(char.uppercased())
            }
        } else {
            newString += String(char)
        }
    }
    return newString.reversed()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    // your code here
    var newString = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                newString += String(char.lowercased())
            } else {
                newString += String(char.uppercased())
            }
        } else {
            newString += String(char)
        }
    }
    return newString.reversed()
}
```

func solve(s: String) -> String {
    // your code here
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += char.lowercased()
            } else {
                result += char.uppercased()
            }
        } else {
            result += String(char)
        }
    }
    return result.reversed()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    // your code here
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += char.lowercased()
            } else {
                result += char.uppercased()
            }
        } else {
            result += String(char)
        }
    }
    return result.reversed()
}
```

func solve(s: String) -> String {
    // your code here
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    // your code here
}

// Example usage:
print(solve(s: "1234"))  // Output: "4321"
print(solve(s: "ab"))     // Output: "AB"
print(solve(s: "#a@C"))   // Output: "#A@c"
```

This Swift program defines a function `solve` that takes a string `s` as input and returns a string where each letter's case is reversed (lower to upper or vice versa), and non-letter characters remain unchanged. If the string contains no letters, the entire string is reversed.

func solve(s: String) -> String {
    // your code here
    var newString = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                newString += char.lowercased()
            } else {
                newString += char.uppercased()
            }
        } else {
            newString += String(char)
        }
    }
    return newString.reversed()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    // your code here
    var newString = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                newString += char.lowercased()
            } else {
                newString += char.uppercased()
            }
        } else {
            newString += String(char)
        }
    }
    return newString.reversed()
}
// Test
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
solve(s: "") == ""
solve(s: "1234567890") == "0987654321"
solve(s: "aBcDeFg") == "abCdEfG"
solve(s: "aBcDeFgH") == "hGfEdCbA"
solve(s: "aBcDeFgH1") == "1hGfEdCbA"
solve(s: "A") == "a"
solve(s: "a1") == "1a"
solve(s: "a1B") == "1bA"
solve(s: "A1B2") == "2b1A"
solve(s: "A1B2C") == "C2b1A"
solve(s: "A1B2C3") == "3c2b1A"
solve(s: "A1B2C3D") == "D3c2b1A"
solve(s: "A1B2C3D4") == "4d3c2b1A"
solve(s: "A1B2C3D4E") == "E4d3c2b1A"
solve(s: "A1B2C3D4E5") == "5e4d3c2b1A"
solve(s: "A1B2C3D4E5F") == "F5e4d3c2b1A"
solve(s: "A1B2C3D4E5F6") == "6f5e4d3c2b1A"
solve(s: "A1B2C3D4E5F6G") == "G6f5e4d3c2b1A"
solve(s: "A1B2C3D4E5F6G7") == "7g6f5e4d3c2b1A"
solve(s: "A1B2C3D4E5F6G7H") == "H7g6f5e4d3c2b1A"
solve(s: "A1B2C3D4E5F6G7H8") == "8h7g6f5e4d3c2b1A"
solve(s: "A1B2C3D4E5F6G7H8I") == "I8h7g6f5e4d3c2b1A"
solve(s: "A1B2C3D4E5F6G7H8I9") == "9i8h7g6f5e4d3c2b1A"
solve(s: "A1B2C3D4E5F6G7H8I9J") == "J9i8h7g6f5e4d3c2b1A"
solve(s: "A1B2C3D4E5F6G7H8I9J1") == "1j9i8h7g6f5e4d3c2b1A"
solve(s: "A1B2C3D4E5F6G7H8I9J1K") == "K1j9i8h7g6f5e4d3c2b1A"
solve(s: "A1B2C3D4E5F6G7H8I9J1K2") == "2k1j9i8h7g6f5e4d3c2b1A"
solve(s: "A1B2C3D4E5F6G

func solve(s: String) -> String {
    // your code here
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += char.lowercased()
            } else {
                result += char.uppercased()
            }
        } else {
            result += String(char)
        }
    }
    return result.reversed()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    // your code here
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += char.lowercased()
            } else {
                result += char.uppercased()
            }
        } else {
            result += String(char)
        }
    }
    return result.reversed()
}
```

func solve(s: String) -> String {
    // your code here
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += String(char.lowercased())
            } else {
                result += String(char.uppercased())
            }
        } else {
            result += String(char)
        }
    }
    return result.reversed()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    // your code here
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += String(char.lowercased())
            } else {
                result += String(char.uppercased())
            }
        } else {
            result += String(char)
        }
    }
    return result.reversed()
}

// Example usage:
print(solve(s: "1234"))  // Output: "4321"
print(solve(s: "ab"))     // Output: "AB"
print(solve(s: "#a@C"))   // Output: "#A@c"
```

func solve(s: String) -> String {
    // your code here
    var newString = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                newString += char.lowercased()
            } else {
                newString += char.uppercased()
            }
        } else {
            newString += String(char)
        }
    }
    return newString.reversed()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    // your code here
    var newString = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                newString += char.lowercased()
            } else {
                newString += char.uppercased()
            }
        } else {
            newString += String(char)
        }
    }
    return newString.reversed()
}
// Test
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
solve(s: "") == ""
solve(s: "aBc") == "AbC"
solve(s: "AbC") == "aBc"
solve(s: "aBcD") == "AbCd"
solve(s: "AbCd") == "aBcD"
solve(s: "AbCdE") == "aBcDe"
solve(s: "AbCdEf") == "AbCdEf"
solve(s: "AbCdEfG") == "AbCdEfG"
solve(s: "AbCdEfGh") == "AbCdEfGh"
solve(s: "AbCdEfGhI") == "AbCdEfGhI"
solve(s: "AbCdEfGhIj") == "AbCdEfGhIj"
solve(s: "AbCdEfGhIjK") == "AbCdEfGhIjK"
solve(s: "AbCdEfGhIjKl") == "AbCdEfGhIjKl"
solve(s: "AbCdEfGhIjKlM") == "AbCdEfGhIjKlM"
solve(s: "AbCdEfGhIjKlMn") == "AbCdEfGhIjKlMn"
solve(s: "AbCdEfGhIjKlMnO") == "AbCdEfGhIjKlMnO"
solve(s: "AbCdEfGhIjKlMnOp") == "AbCdEfGhIjKlMnOp"
solve(s: "AbCdEfGhIjKlMnOpQ") == "AbCdEfGhIjKlMnOpQ"
solve(s: "AbCdEfGhIjKlMnOpQr") == "AbCdEfGhIjKlMnOpQr"
solve(s: "AbCdEfGhIjKlMnOpQrS") == "AbCdEfGhIjKlMnOpQrS"
solve(s: "AbCdEfGhIjKlMnOpQrSt") == "AbCdEfGhIjKlMnOpQrSt"
solve(s: "AbCdEfGhIjKlMnOpQrStU") == "AbCdEfGhIjKlMnOpQrStU"
solve(s: "AbCdEfGhIjKlMnOpQrStUv") == "AbCdEfGhIjKlMnOpQrStUv"
solve(s: "AbCdEfGhIjKlMnOpQrStUvW") == "AbCdEfGhIjKlMnOpQrStUvW"
solve(s: "AbCdEfGhIjKlMnOpQrStUvWx") == "AbCdEfGhIjKlMnOpQrStUvWx"
solve(s: "AbCdEfGhIjKlMnOpQrStUvWxY") == "AbCdEfGhIjKlMnOpQrStUvWxY"
solve(s: "

func solve(s: String) -> String {
    // your code here
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += char.lowercased()
            } else {
                result += char.uppercased()
            }
        } else {
            result += String(char)
        }
    }
    return result.reversed()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    // your code here
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isUppercase {
                result += char.lowercased()
            } else {
                result += char.uppercased()
            }
        } else {
            result += String(char)
        }
    }
    return result.reversed()
}

// Example usage:
print(solve(s: "1234"))  // Output: "4321"
print(solve(s: "ab"))     // Output: "AB"
print(solve(s: "#a@C"))   // Output: "#A@c"
```

func solve(s: String) -> String {
    // your code here
    return ""
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    // your code here
    return ""
}
```

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += s[i].lowercased()
            } else {
                result += s[i].uppercased()
            }
        } else {
            result += s[i]
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += s[i].lowercased()
            } else {
                result += s[i].uppercased()
            }
        } else {
            result += s[i]
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += s[i].lowercased()
            } else {
                result += s[i].uppercased()
            }
        } else {
            result += s[i]
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += s[i].lowercased()
            } else {
                result += s[i].uppercased()
            }
        } else {
            result += s[i]
        }
    }
    return result
}
<|file_separator|>```

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter() {
            if c.isUppercase() {
                result += String(c.lowercased())
            } else {
                result += String(c.uppercased())
            }
        } else {
            result += String(c)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter() {
            if c.isUppercase() {
                result += String(c.lowercased())
            } else {
                result += String(c.uppercased())
            }
        } else {
            result += String(c)
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i].lowercased())
            } else {
                result += String(s[i].uppercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i].lowercased())
            } else {
                result += String(s[i].uppercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i].lowercased())
            } else {
                result += String(s[i].uppercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i].lowercased())
            } else {
                result += String(s[i].uppercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}
<|file_separator|>```

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i]).lowercased()
            } else {
                result += String(s[i]).uppercased()
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i]).lowercased()
            } else {
                result += String(s[i]).uppercased()
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}
<|file_separator|>```

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += s[i].lowercased()
            } else {
                result += s[i].uppercased()
            }
        } else {
            result += s[i]
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += s[i].lowercased()
            } else {
                result += s[i].uppercased()
            }
        } else {
            result += s[i]
        }
    }
    return result
}
<|file_separator|>```

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += s[i].lowercased()
            } else {
                result += s[i].uppercased()
            }
        } else {
            result += s[i]
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += s[i].lowercased()
            } else {
                result += s[i].uppercased()
            }
        } else {
            result += s[i]
        }
    }
    return result
}
<|file_separator|>```

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += s[i].lowercased()
            } else {
                result += s[i].uppercased()
            }
        } else {
            result += s[i]
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += s[i].lowercased()
            } else {
                result += s[i].uppercased()
            }
        } else {
            result += s[i]
        }
    }
    return result
}
<|file_separator|>```

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i].lowercased())
            } else {
                result += String(s[i].uppercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i].lowercased())
            } else {
                result += String(s[i].uppercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter() {
            if c.isUppercase() {
                result += c.lowercased()
            } else {
                result += c.uppercased()
            }
        } else {
            result += String(c)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter() {
            if c.isUppercase() {
                result += c.lowercased()
            } else {
                result += c.uppercased()
            }
        } else {
            result += String(c)
        }
    }
    return result
}<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for i in s {
        if i.isLetter() {
            if i.isUppercase() {
                result += i.lowercased()
            } else {
                result += i.uppercased()
            }
        } else {
            result += String(i)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in s {
        if i.isLetter() {
            if i.isUppercase() {
                result += i.lowercased()
            } else {
                result += i.uppercased()
            }
        } else {
            result += String(i)
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i].lowercased())
            } else {
                result += String(s[i].uppercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i].lowercased())
            } else {
                result += String(s[i].uppercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isLowercase {
                result += s[i].uppercased()
            } else {
                result += s[i].lowercased()
            }
        } else {
            result += s[i]
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isLowercase {
                result += s[i].uppercased()
            } else {
                result += s[i].lowercased()
            }
        } else {
            result += s[i]
        }
    }
    return result
}
<|file_separator|>```

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += s[i].lowercased()
            } else {
                result += s[i].uppercased()
            }
        } else {
            result += s[i]
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += s[i].lowercased()
            } else {
                result += s[i].uppercased()
            }
        } else {
            result += s[i]
        }
    }
    return result
}
<|file_separator|>```

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i].lowercased())
            } else {
                result += String(s[i].uppercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i].lowercased())
            } else {
                result += String(s[i].uppercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i].lowercased())
            } else {
                result += String(s[i].uppercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i].lowercased())
            } else {
                result += String(s[i].uppercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i].lowercased())
            } else {
                result += String(s[i].uppercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i].lowercased())
            } else {
                result += String(s[i].uppercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[s.index(s.startIndex, offsetBy: i)] >= "a" && s[s.index(s.startIndex, offsetBy: i)] <= "z" {
            result += String(s[s.index(s.startIndex, offsetBy: i)].uppercased())
        } else if s[s.index(s.startIndex, offsetBy: i)] >= "A" && s[s.index(s.startIndex, offsetBy: i)] <= "Z" {
            result += String(s[s.index(s.startIndex, offsetBy: i)].lowercased())
        } else {
            result += String(s[s.index(s.startIndex, offsetBy: i)])
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[s.index(s.startIndex, offsetBy: i)] >= "a" && s[s.index(s.startIndex, offsetBy: i)] <= "z" {
            result += String(s[s.index(s.startIndex, offsetBy: i)].uppercased())
        } else if s[s.index(s.startIndex, offsetBy: i)] >= "A" && s[s.index(s.startIndex, offsetBy: i)] <= "Z" {
            result += String(s[s.index(s.startIndex, offsetBy: i)].lowercased())
        } else {
            result += String(s[s.index(s.startIndex, offsetBy: i)])
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i].lowercased())
            } else {
                result += String(s[i].uppercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isLetter {
            if s[i].isUppercase {
                result += String(s[i].lowercased())
            } else {
                result += String(s[i].uppercased())
            }
        } else {
            result += String(s[i])
        }
    }
    return result
}
<|file_separator|>

func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            if $0.isLowercase {
                return $0.uppercased()
            } else {
                return $0.lowercased()
            }
        } else {
            return $0
        }
    }.joined()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            if $0.isLowercase {
                return $0.uppercased()
            } else {
                return $0.lowercased()
            }
        } else {
            return $0
        }
    }.joined()
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char >= "A" && char <= "Z" {
            result.append(char.lowercaseString)
        } else if char >= "a" && char <= "z" {
            result.append(char.uppercaseString)
        } else {
            result.append(char)
        }
    }
    if result == s {
        return String(s.characters.reverse())
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char >= "A" && char <= "Z" {
            result.append(char.lowercaseString)
        } else if char >= "a" && char <= "z" {
            result.append(char.uppercaseString)
        } else {
            result.append(char)
        }
    }
    if result == s {
        return String(s.characters.reverse())
    }
    return result
}
```

func solve(s: String) -> String {
    let sArr = Array(s)
    var resultArr = [Character]()
    for i in sArr {
        if i.isLetter {
            if i.isUppercase {
                resultArr.append(i.lowercased().first!)
            } else {
                resultArr.append(i.uppercased().first!)
            }
        } else {
            resultArr.append(i)
        }
    }
    if resultArr.count == 0 {
        return s.reversed()
    }
    return String(resultArr)
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    let sArr = Array(s)
    var resultArr = [Character]()
    for i in sArr {
        if i.isLetter {
            if i.isUppercase {
                resultArr.append(i.lowercased().first!)
            } else {
                resultArr.append(i.uppercased().first!)
            }
        } else {
            resultArr.append(i)
        }
    }
    if resultArr.count == 0 {
        return s.reversed()
    }
    return String(resultArr)
}
```

func solve(s: String) -> String {
    let letters = s.filter { $0.isLetter }
    let nonLetters = s.filter { !$0.isLetter }
    var result = ""
    if letters.isEmpty {
        result = String(s.reversed())
    } else {
        for letter in letters {
            if letter.isUppercase {
                result += letter.lowercased()
            } else {
                result += letter.uppercased()
            }
        }
    }
    return result + nonLetters
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    let letters = s.filter { $0.isLetter }
    let nonLetters = s.filter { !$0.isLetter }
    var result = ""
    if letters.isEmpty {
        result = String(s.reversed())
    } else {
        for letter in letters {
            if letter.isUppercase {
                result += letter.lowercased()
            } else {
                result += letter.uppercased()
            }
        }
    }
    return result + nonLetters
}
```

func solve(s: String) -> String {
    let arr = s.map{
        if $0.isLetter{
            return $0.isLowercase ? $0.uppercased() : $0.lowercased()
        }else{
            return $0
        }
    }
    return arr.reversed().reduce("", +)
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    let arr = s.map{
        if $0.isLetter{
            return $0.isLowercase ? $0.uppercased() : $0.lowercased()
        }else{
            return $0
        }
    }
    return arr.reversed().reduce("", +)
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char >= "A" && char <= "Z" {
            result += String(char).lowercased()
        } else if char >= "a" && char <= "z" {
            result += String(char).uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char >= "A" && char <= "Z" {
            result += String(char).lowercased()
        } else if char >= "a" && char <= "z" {
            result += String(char).uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    }
    return result
}
```

func solve(s: String) -> String {
    // your code here
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    // your code here
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    let s = Array(s)
    var result = ""
    for i in s {
        if i.isLetter {
            result += String(i).uppercased()
        } else {
            result += String(i).lowercased()
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    let s = Array(s)
    var result = ""
    for i in s {
        if i.isLetter {
            result += String(i).uppercased()
        } else {
            result += String(i).lowercased()
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char >= "a" && char <= "z" {
            result += String(char.uppercased())
        } else if char >= "A" && char <= "Z" {
            result += String(char.lowercased())
        } else {
            result += String(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char >= "a" && char <= "z" {
            result += String(char.uppercased())
        } else if char >= "A" && char <= "Z" {
            result += String(char.lowercased())
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isUpper {
            result += s[i].lowercase
        } else if s[i].isLower {
            result += s[i].uppercase
        } else {
            result += s[i]
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isUpper {
            result += s[i].lowercase
        } else if s[i].isLower {
            result += s[i].uppercase
        } else {
            result += s[i]
        }
    }
    return result
}
```

func solve(s: String) -> String {
    let mut result = "";
    for c in s.chars() {
        if c.is_digit(10) {
            result += &c;
        } else if c.is_uppercase() {
            result += &c.to_lowercase();
        } else if c.is_lowercase() {
            result += &c.to_uppercase();
        }
    }
    return result;
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    let mut result = "";
    for c in s.chars() {
        if c.is_digit(10) {
            result += &c;
        } else if c.is_uppercase() {
            result += &c.to_lowercase();
        } else if c.is_lowercase() {
            result += &c.to_uppercase();
        }
    }
    return result;
}
```

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.length {
        if s[i].isUpper() {
            result += s[i].lowercase
        } else if s[i].isLower() {
            result += s[i].uppercase
        } else {
            result += s[i]
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.length {
        if s[i].isUpper() {
            result += s[i].lowercase
        } else if s[i].isLower() {
            result += s[i].uppercase
        } else {
            result += s[i]
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.length {
        if s[i].isUpper() {
            result += s[i].lowercase
        } else if s[i].isLower() {
            result += s[i].uppercase
        } else {
            result += s[i]
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.length {
        if s[i].isUpper() {
            result += s[i].lowercase
        } else if s[i].isLower() {
            result += s[i].uppercase
        } else {
            result += s[i]
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.length {
        if s[i].isUpper() {
            result += s[i].lowercase
        } else if s[i].isLower() {
            result += s[i].uppercase
        } else {
            result += s[i]
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.length {
        if s[i].isUpper() {
            result += s[i].lowercase
        } else if s[i].isLower() {
            result += s[i].uppercase
        } else {
            result += s[i]
        }
    }
    return result
}
```

func solve(s: String) -> String {
    let result = String()
    for i in 0..<s.count {
        if let c = s[i] {
            if c.isUpper {
                result += c.lowercase
            } else if c.isLower {
                result += c.uppercase
            } else {
                result += c
            }
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    let result = String()
    for i in 0..<s.count {
        if let c = s[i] {
            if c.isUpper {
                result += c.lowercase
            } else if c.isLower {
                result += c.uppercase
            } else {
                result += c
            }
        }
    }
    return result
}
```

func solve(s: String) -> String {
    let result = String()
    for i in 0..<s.length {
        let ch = s[i]
        if ch.isLetter() {
            result += ch.uppercaseFirstCharacter()
        } else {
            result += ch
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    let result = String()
    for i in 0..<s.length {
        let ch = s[i]
        if ch.isLetter() {
            result += ch.uppercaseFirstCharacter()
        } else {
            result += ch
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.length {
        if s[i].isUpper() {
            result += s[i].lowercaseCharacter
        } else if s[i].isLower() {
            result += s[i].uppercaseCharacter
        } else {
            result += s[i]
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.length {
        if s[i].isUpper() {
            result += s[i].lowercaseCharacter
        } else if s[i].isLower() {
            result += s[i].uppercaseCharacter
        } else {
            result += s[i]
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if let c = s[i] {
            if c.isUpper {
                result += c.lowercase
            } else if c.isLower {
                result += c.uppercase
            } else {
                result += c
            }
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if let c = s[i] {
            if c.isUpper {
                result += c.lowercase
            } else if c.isLower {
                result += c.uppercase
            } else {
                result += c
            }
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isUpper {
            result += s[i].lowercase
        } else if s[i].isLower {
            result += s[i].uppercase
        } else {
            result += s[i]
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for i in 0..<s.count {
        if s[i].isUpper {
            result += s[i].lowercase
        } else if s[i].isLower {
            result += s[i].uppercase
        } else {
            result += s[i]
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLower {
                result += char.uppercased()
            } else {
                result += char.lowercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLower {
                result += char.uppercased()
            } else {
                result += char.lowercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLower ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    }
    return result
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLower ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    return result
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            result.append(c.isLowercase ? c.uppercased() : c.lowercased())
        } else {
            result.append(c)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    } else {
        return result
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            result.append(c.isLowercase ? c.uppercased() : c.lowercased())
        } else {
            result.append(c)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    } else {
        return result
    }
}
```

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            result.append(c.isLowercase ? c.uppercased() : c.lowercased())
        } else {
            result.append(c)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    } else {
        return result
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            result.append(c.isLowercase ? c.uppercased() : c.lowercased())
        } else {
            result.append(c)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    } else {
        return result
    }
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLower ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    } else {
        return result
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLower ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    } else {
        return result
    }
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLower {
                result += char.uppercased()
            } else {
                result += char.lowercased()
            }
        } else {
            result += String(char)
        }
    }
    if result.isEmpty {
        return s.reversed().joined()
    } else {
        return result
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLower {
                result += char.uppercased()
            } else {
                result += char.lowercased()
            }
        } else {
            result += String(char)
        }
    }
    if result.isEmpty {
        return s.reversed().joined()
    } else {
        return result
    }
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    return result
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().reduce("", +)
    } else {
        return result
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result.append(char.uppercased())
            } else {
                result.append(char.lowercased())
            }
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().reduce("", +)
    } else {
        return result
    }
}
```

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            result.append(c.isLowercase ? c.uppercased() : c.lowercased())
        } else {
            result.append(c)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    }
    return result
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            result.append(c.isLowercase ? c.uppercased() : c.lowercased())
        } else {
            result.append(c)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    }
    return result
}
```

func solve(s: String) -> String {
    var result = [Character]()
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    }
    return String(result)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = [Character]()
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    }
    return String(result)
}
```

func solve(s: String) -> String {
    var result = ""
    
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    }
    
    return result
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = [Character]()
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    } else {
        return String(result)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = [Character]()
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    } else {
        return String(result)
    }
}
```

func solve(s: String) -> String {
    var result = [Character]()
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    }
    return String(result)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = [Character]()
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    }
    return String(result)
}
```

func solve(s: String) -> String {
    var result = [Character]()
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    } else {
        return String(result)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = [Character]()
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    } else {
        return String(result)
    }
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().reduce("", { $0 + String($1) })
    } else {
        return result
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().reduce("", { $0 + String($1) })
    } else {
        return result
    }
}
```

func solve(s: String) -> String {
    var result = [Character]()
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    } else {
        return String(result)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = [Character]()
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    } else {
        return String(result)
    }
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().reduce("", +)
    }
    return result
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().reduce("", +)
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    }
    
    return result
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = ""
    
    for char in s {
        if char.isLetter() {
            result.append(char.isLower() ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = [Character]()
    for char in s {
        if char.isLetter() {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    }
    return result.map { String($0) }.joined()
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"<end_of_turn>
<start_of_turn>model
```swift
func solve(s: String) -> String {
    var result = [Character]()
    for char in s {
        if char.isLetter() {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        return s.reversed().map { String($0) }.joined()
    }
    return result.map { String($0) }.joined()
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLowercase ? char.uppercased() : char.lowercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if result.isEmpty {
        result = s.reversed()
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase ? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    if s.containsLetters {
        return s.map {
            if $0.isLetter {
                return $0.isUppercase ? $0.lowercased() : $0.uppercased()
            } else {
                return $0
            }
        }.joined()
    } else {
        return s.reversed()
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    if s.containsLetters {
        return s.map {
            if $0.isLetter {
                return $0.isUppercase ? $0.lowercased() : $0.uppercased()
            } else {
                return $0
            }
        }.joined()
    } else {
        return s.reversed()
    }
}
```

func solve(s: String) -> String {
    if s.containsLetters {
        return s.map {
            if $0.isLetter {
                return $0.isUppercase ? $0.lowercased() : $0.uppercased()
            } else {
                return $0
            }
        }.joined()
    } else {
        return String(s.reversed())
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    if s.containsLetters {
        return s.map {
            if $0.isLetter {
                return $0.isUppercase ? $0.lowercased() : $0.uppercased()
            } else {
                return $0
            }
        }.joined()
    } else {
        return String(s.reversed())
    }
}
```

func solve(s: String) -> String {
    if s.containsLetters {
        return s.map {
            if $0.isLetter {
                return $0.isUppercase ? $0.lowercased() : $0.uppercased()
            } else {
                return $0
            }
        }.joined()
    } else {
        return s.reversed()
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    if s.containsLetters {
        return s.map {
            if $0.isLetter {
                return $0.isUppercase ? $0.lowercased() : $0.uppercased()
            } else {
                return $0
            }
        }.joined()
    } else {
        return s.reversed()
    }
}
```

func solve(s: String) -> String {
    if s.containsLetters {
        return s.map {
            if $0.isLetter {
                return $0.isUppercase ? $0.lowercased() : $0.uppercased()
            } else {
                return $0
            }
        }.joined()
    } else {
        return s.reversed()
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    if s.containsLetters {
        return s.map {
            if $0.isLetter {
                return $0.isUppercase ? $0.lowercased() : $0.uppercased()
            } else {
                return $0
            }
        }.joined()
    } else {
        return s.reversed()
    }
}
```

func solve(s: String) -> String {
    if s.containsLetters {
        return s.map { character in
            if character.isLetter {
                return character.isUppercase ? character.lowercased() : character.uppercased()
            } else {
                return character
            }
        }.joined()
    } else {
        return s.reversed()
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    if s.containsLetters {
        return s.map { character in
            if character.isLetter {
                return character.isUppercase ? character.lowercased() : character.uppercased()
            } else {
                return character
            }
        }.joined()
    } else {
        return s.reversed()
    }
}
```

func solve(s: String) -> String {
    if s.containsLetters {
        return s.map { character in
            if character.isLetter {
                return character.isUppercase ? character.lowercased() : character.uppercased()
            } else {
                return character
            }
        }.joined()
    } else {
        return s.reversed()
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    if s.containsLetters {
        return s.map { character in
            if character.isLetter {
                return character.isUppercase ? character.lowercased() : character.uppercased()
            } else {
                return character
            }
        }.joined()
    } else {
        return s.reversed()
    }
}
```

func solve(s: String) -> String {
    if s.containsLetters {
        return s.map {
            if $0.isLetter {
                return $0.isUppercase ? $0.lowercased() : $0.uppercased()
            } else {
                return $0
            }
        }.joined()
    } else {
        return s.reversed()
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    if s.containsLetters {
        return s.map {
            if $0.isLetter {
                return $0.isUppercase ? $0.lowercased() : $0.uppercased()
            } else {
                return $0
            }
        }.joined()
    } else {
        return s.reversed()
    }
}
```

func solve(s: String) -> String {
    if s.containsLetters {
        return s.map { character in
            if character.isLetter {
                return character.isLowercase ? character.uppercased() : character.lowercased()
            } else {
                return character
            }
        }.joined()
    } else {
        return String(s.reversed())
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    if s.containsLetters {
        return s.map { character in
            if character.isLetter {
                return character.isLowercase ? character.uppercased() : character.lowercased()
            } else {
                return character
            }
        }.joined()
    } else {
        return String(s.reversed())
    }
}
```

func solve(s: String) -> String {
    if s.containsLetters {
        return s.map { $0.isLetter ? $0.toUpperCase : $0.toLowerCase }.joined()
    } else {
        return s.reversed()
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    if s.containsLetters {
        return s.map { $0.isLetter ? $0.toUpperCase : $0.toLowerCase }.joined()
    } else {
        return s.reversed()
    }
}
```

func solve(s: String) -> String {
    if s.containsLetters {
        return s.map { character in
            if character.isLetter {
                return character.isLowercase ? character.uppercased() : character.lowercased()
            } else {
                return character
            }
        }.joined()
    } else {
        return s.reversed()
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c" [/INST] ```swift
func solve(s: String) -> String {
    if s.containsLetters {
        return s.map { character in
            if character.isLetter {
                return character.isLowercase ? character.uppercased() : character.lowercased()
            } else {
                return character
            }
        }.joined()
    } else {
        return s.reversed()
    }
}
```

func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            result.append(c.isLower? c.uppercased() : c.lowercased())
        } else {
            result.append(c)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for c in s {
        if c.isLetter {
            result.append(c.isLower? c.uppercased() : c.lowercased())
        } else {
            result.append(c)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let c = String(char).unicodeScalars.first {
            if c.isLower {
                result.append(String(c.uppercased()))
            } else if c.isUpper {
                result.append(String(c.lowercased()))
            } else {
                result.append(String(c))
            }
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let c = String(char).unicodeScalars.first {
            if c.isLower {
                result.append(String(c.uppercased()))
            } else if c.isUpper {
                result.append(String(c.lowercased()))
            } else {
                result.append(String(c))
            }
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.is uppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.is uppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLower? String(char).uppercased() : String(char).lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLower? String(char).uppercased() : String(char).lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLower? String(char).uppercased() : String(char).lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isLower? String(char).uppercased() : String(char).lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.is uppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.is uppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let ascii = Int(String(char).unicodeScalars.first!),
           (65...90).contains(ascii) {
            result.append(String(UnicodeScalar(ascii > 90? ascii - 32 : ascii + 32)))
        } else {
            result.append(String(char))
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let ascii = Int(String(char).unicodeScalars.first!),
           (65...90).contains(ascii) {
            result.append(String(UnicodeScalar(ascii > 90? ascii - 32 : ascii + 32)))
        } else {
            result.append(String(char))
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = String(char).lowercased().first {
            result.append(String(letter).uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = String(char).lowercased().first {
            result.append(String(letter).uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = String(char).lowercased().first {
            result.append(String(letter).uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = String(char).lowercased().first {
            result.append(String(letter).uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let ascii = Int(String(char).unicodeScalars.first!) {
            if ascii >= 97 && ascii <= 122 {
                result.append(String(UnicodeScalar(ascii - 32)!))
            } else if ascii >= 65 && ascii <= 90 {
                result.append(String(UnicodeScalar(ascii + 32)!))
            } else {
                result.append(String(char))
            }
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let ascii = Int(String(char).unicodeScalars.first!) {
            if ascii >= 97 && ascii <= 122 {
                result.append(String(UnicodeScalar(ascii - 32)!))
            } else if ascii >= 65 && ascii <= 90 {
                result.append(String(UnicodeScalar(ascii + 32)!))
            } else {
                result.append(String(char))
            }
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if!isLetter {
        result = String(result.reversed())
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if!isLetter {
        result = String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if!isLetter {
        result = String(result.reversed())
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    if!isLetter {
        result = String(result.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    
    if!isLetter {
        result = String(result.reversed())
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    
    if!isLetter {
        result = String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? String(char).lowercased() : String(char).uppercased())
        } else {
            result.append(char)
        }
    }
    return isLetter? result : String(s.reversed())
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? String(char).lowercased() : String(char).uppercased())
        } else {
            result.append(char)
        }
    }
    return isLetter? result : String(s.reversed())
}
```

func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? String(char).lowercased() : String(char).uppercased())
        } else {
            result.append(char)
        }
    }
    return isLetter? result : String(s.reversed())
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? String(char).lowercased() : String(char).uppercased())
        } else {
            result.append(char)
        }
    }
    return isLetter? result : String(s.reversed())
}
```

func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return isLetter? String(result.reversed()) : String(s.reversed())
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return isLetter? String(result.reversed()) : String(s.reversed())
}
```

func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return isLetter? String(result.reversed()) : result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return isLetter? String(result.reversed()) : result
}
```

func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    
    if!isLetter {
        result = String(result.reversed())
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    
    if!isLetter {
        result = String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? String(char).lowercased() : String(char).uppercased())
        } else {
            result.append(char)
        }
    }
    
    if!isLetter {
        result = String(result.reversed())
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? String(char).lowercased() : String(char).uppercased())
        } else {
            result.append(char)
        }
    }
    
    if!isLetter {
        result = String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return isLetter? String(result.reversed()) : String(s.reversed())
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"

Answer:
```swift
func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    for char in s {
        if char.isLetter {
            isLetter = true
            result.append(char.isUpper? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return isLetter? String(result.reversed()) : String(s.reversed())
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first, letter.isLetter {
            let newChar = letter.isUppercase ? Character(UnicodeScalar(letter.value + 32)!) : Character(UnicodeScalar(letter.value - 32)!)
            result += String(newChar)
        } else {
            result = String(char) + result
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first, letter.isLetter {
            let newChar = letter.isUppercase ? Character(UnicodeScalar(letter.value + 32)!) : Character(UnicodeScalar(letter.value - 32)!)
            result += String(newChar)
        } else {
            result = String(char) + result
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.asciiValue {
            if (letter >= 65 && letter <= 90) {
                result += String(char).lowercased()
            } else if (letter >= 97 && letter <= 122) {
                result += String(char).uppercased()
            } else {
                result += String(char)
            }
        }
    }
    if result.count == 0 {
        return s.reversed()
    }
    return result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.asciiValue {
            if (letter >= 65 && letter <= 90) {
                result += String(char).lowercased()
            } else if (letter >= 97 && letter <= 122) {
                result += String(char).uppercased()
            } else {
                result += String(char)
            }
        }
    }
    if result.count == 0 {
        return s.reversed()
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first, letter.isLetter {
            let newChar = letter.isUppercase ? Character(UnicodeScalar(letter.value + 32)!) : Character(UnicodeScalar(letter.value - 32)!)
            result += String(newChar)
        } else {
            result = String(char) + result
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first, letter.isLetter {
            let newChar = letter.isUppercase ? Character(UnicodeScalar(letter.value + 32)!) : Character(UnicodeScalar(letter.value - 32)!)
            result += String(newChar)
        } else {
            result = String(char) + result
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first, letter.isLetter {
            let newChar = letter.isUppercase ? Character(UnicodeScalar(letter.value + 32)!) : Character(UnicodeScalar(letter.value - 32)!)
            result += String(newChar)
        } else {
            result = String(char) + result
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first, letter.isLetter {
            let newChar = letter.isUppercase ? Character(UnicodeScalar(letter.value + 32)!) : Character(UnicodeScalar(letter.value - 32)!)
            result += String(newChar)
        } else {
            result = String(char) + result
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}
```

func solve(s: String) -> String {
    var result = ""
    for character in s {
        if let letter = character.asciiValue {
            if (letter >= 65 && letter <= 90) {
                result += String(character).lowercased()
            } else if (letter >= 97 && letter <= 122) {
                result += String(character).uppercased()
            } else {
                result += String(character)
            }
        }
    }
    if result.count == 0 {
        return s.reversed()
    }
    return result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for character in s {
        if let letter = character.asciiValue {
            if (letter >= 65 && letter <= 90) {
                result += String(character).lowercased()
            } else if (letter >= 97 && letter <= 122) {
                result += String(character).uppercased()
            } else {
                result += String(character)
            }
        }
    }
    if result.count == 0 {
        return s.reversed()
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first, letter.isLetter {
            let newChar = letter.isUppercase ? Character(UnicodeScalar(letter.value + 32)) : Character(UnicodeScalar(letter.value - 32))
            result += String(newChar)
        } else {
            result = String(char) + result
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first, letter.isLetter {
            let newChar = letter.isUppercase ? Character(UnicodeScalar(letter.value + 32)) : Character(UnicodeScalar(letter.value - 32))
            result += String(newChar)
        } else {
            result = String(char) + result
        }
    }
    return result.isEmpty ? String(s.reversed()) : result
}
```

func solve(s: String) -> String {
    var result = ""
    for character in s {
        if let letter = character.unicodeScalars.first, CharacterSet.letters.contains(letter) {
            result += String(character).lowercased() == String(character) ? String(character).uppercased() : String(character).lowercased()
        } else {
            result += String(character)
        }
    }
    return result.isEmpty ? s.reversed() : result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for character in s {
        if let letter = character.unicodeScalars.first, CharacterSet.letters.contains(letter) {
            result += String(character).lowercased() == String(character) ? String(character).uppercased() : String(character).lowercased()
        } else {
            result += String(character)
        }
    }
    return result.isEmpty ? s.reversed() : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.asciiValue {
            if (letter >= 65 && letter <= 90) {
                result += String(char).lowercased()
            } else if (letter >= 97 && letter <= 122) {
                result += String(char).uppercased()
            } else {
                result += String(char)
            }
        }
    }
    if result.count == 0 {
        return String(s.reversed())
    }
    return result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.asciiValue {
            if (letter >= 65 && letter <= 90) {
                result += String(char).lowercased()
            } else if (letter >= 97 && letter <= 122) {
                result += String(char).uppercased()
            } else {
                result += String(char)
            }
        }
    }
    if result.count == 0 {
        return String(s.reversed())
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first, CharacterSet.letters.contains(letter) {
            let newChar = Character(letter).lowercased() == char ? Character(letter).uppercased() : Character(letter).lowercased()
            result.append(newChar)
        } else {
            result = String(char) + result
        }
    }
    return result.isEmpty ? s.reversed() : result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first, CharacterSet.letters.contains(letter) {
            let newChar = Character(letter).lowercased() == char ? Character(letter).uppercased() : Character(letter).lowercased()
            result.append(newChar)
        } else {
            result = String(char) + result
        }
    }
    return result.isEmpty ? s.reversed() : result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first, letter.isLetter {
            let newChar = letter.isUppercase ? Character(UnicodeScalar(letter.value + 32)) : Character(UnicodeScalar(letter.value - 32))
            result.append(newChar)
        } else {
            result = String(char) + result
        }
    }
    return result.isEmpty ? s.reversed() : result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if let letter = char.unicodeScalars.first, letter.isLetter {
            let newChar = letter.isUppercase ? Character(UnicodeScalar(letter.value + 32)) : Character(UnicodeScalar(letter.value - 32))
            result.append(newChar)
        } else {
            result = String(char) + result
        }
    }
    return result.isEmpty ? s.reversed() : result
}
```

func solve(s: String) -> String {
    let letters = CharacterSet.letters.inverted
    let digits = CharacterSet.decimalDigits.inverted
    var reversed = ""
    var isReversed = false
    var isDigitReversed = false
    
    for char in s {
        if letters.contains(char) {
            reversed.append(char.isUppercase ? Character(char.lowercased()) : Character(char.uppercased()))
            isReversed = true
        } else if digits.contains(char) {
            reversed.append(char.isUppercase ? Character(char.lowercased()) : Character(char.uppercased()))
            isDigitReversed = true
        } else {
            reversed.append(char)
        }
    }
    
    if isReversed {
        return String(reversed.reversed())
    } else if isDigitReversed {
        return String(reversed.reversed())
    } else {
        return String(reversed.reversed())
    }
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    let letters = CharacterSet.letters.inverted
    let digits = CharacterSet.decimalDigits.inverted
    var reversed = ""
    var isReversed = false
    var isDigitReversed = false
    
    for char in s {
        if letters.contains(char) {
            reversed.append(char.isUppercase ? Character(char.lowercased()) : Character(char.uppercased()))
            isReversed = true
        } else if digits.contains(char) {
            reversed.append(char.isUppercase ? Character(char.lowercased()) : Character(char.uppercased()))
            isDigitReversed = true
        } else {
            reversed.append(char)
        }
    }
    
    if isReversed {
        return String(reversed.reversed())
    } else if isDigitReversed {
        return String(reversed.reversed())
    } else {
        return String(reversed.reversed())
    }
}
```

func solve(s: String) -> String {
    var result = ""
    var reverse = false
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            reverse = true
        }
    }
    if reverse {
        return result.reversed()
    } else {
        return result
    }
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    var reverse = false
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            reverse = true
        }
    }
    if reverse {
        return result.reversed()
    } else {
        return result
    }
}
```

func solve(s: String) -> String {
    var result = ""
    var isReverse = false
    for char in s {
        if char.isLetter {
            if isReverse {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
            isReverse = !isReverse
        } else {
            result += String(char)
        }
    }
    return result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    var isReverse = false
    for char in s {
        if char.isLetter {
            if isReverse {
                result += String(char).lowercased()
            } else {
                result += String(char).uppercased()
            }
            isReverse = !isReverse
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for (index, char) in s.enumerated() {
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for (index, char) in s.enumerated() {
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        let char = s[i]
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else if char.isASCII {
            result += String(char)
        } else {
            result = String(s.reversed())
        }
    }
    return result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        let char = s[i]
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else if char.isASCII {
            result += String(char)
        } else {
            result = String(s.reversed())
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    
    for char in s {
        if char.isLetter {
            isLetter = true
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
        }
    }
    
    if !isLetter {
        return String(result.reversed())
    }
    
    return result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    
    for char in s {
        if char.isLetter {
            isLetter = true
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else {
            result += String(char)
        }
    }
    
    if !isLetter {
        return String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        let char = s[i]
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else if char.isASCII {
            result += String(char)
        } else {
            result = String(result.reversed())
        }
    }
    return result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        let char = s[i]
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else if char.isASCII {
            result += String(char)
        } else {
            result = String(result.reversed())
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    
    for i in s.indices {
        let char = s[i]
        if char.isLetter {
            isLetter = true
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else if !char.isLetter {
            result += String(char)
        }
    }
    
    if !isLetter {
        result = String(result.reversed())
    }
    
    return result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    var isLetter = false
    
    for i in s.indices {
        let char = s[i]
        if char.isLetter {
            isLetter = true
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else if !char.isLetter {
            result += String(char)
        }
    }
    
    if !isLetter {
        result = String(result.reversed())
    }
    
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        let char = s[i]
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else if char.isASCII {
            result += String(char).reversed()
        } else {
            result += String(char)
        }
    }
    return result
}

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.
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa, 
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve(s: "1234") == "4321"
solve(s: "ab") == "AB"
solve(s: "#a@C") == "#A@c"
### Response:
```swift
func solve(s: String) -> String {
    var result = ""
    for i in s.indices {
        let char = s[i]
        if char.isLetter {
            if char.isLowercase {
                result += String(char).uppercased()
            } else {
                result += String(char).lowercased()
            }
        } else if char.isASCII {
            result += String(char).reversed()
        } else {
            result += String(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += char
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += char
        }
    }
    return result
}
```

func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0).uppercased()
        } else {
            return String($0).lowercased()
        }
    }.joined()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    return s.map {
        if $0.isLetter {
            return String($0).uppercased()
        } else {
            return String($0).lowercased()
        }
    }.joined()
}
```

func solve(s: String) -> String {
    return s.map { $0.isLetter? String($0).uppercased() : String($0).lowercased() }.joined()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    return s.map { $0.isLetter? String($0).uppercased() : String($0).lowercased() }.joined()
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += char
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result += char.isUppercase? char.lowercased() : char.uppercased()
        } else {
            result += char
        }
    }
    return result
}
```

func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    var result = ""
    for char in s {
        if char.isLetter {
            result.append(char.isUppercase? char.lowercased() : char.uppercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

func solve(s: String) -> String {
    return s.map { $0.isLetter? String($0).uppercased() : String($0).lowercased() }.joined()
}

```swift
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa, 
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// solve(s: "1234") == "4321"
// solve(s: "ab") == "AB"
// solve(s: "#a@C") == "#A@c"
func solve(s: String) -> String {
    return s.map { $0.isLetter? String($0).uppercased() : String($0).lowercased() }.joined()
}
```