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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += String(char.lowercased())
        } else {
            result += String(char.uppercased())
        }
    }
    return result
}
<|file_separator|>

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += String(char.uppercased())
        } else if char.isUppercase {
            result += String(char.lowercased())
        } else {
            result += String(char)
        }
    }
    return result
}
<|file_separator|>

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += String(char.uppercased())
        } else if char.isUppercase {
            result += String(char.lowercased())
        } else {
            result += String(char)
        }
    }
    return result
}
<|file_separator|>

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += String(char.lowercased())
        } else if char.isLowercase {
            result += String(char.uppercased())
        } else {
            result += String(char)
        }
    }
    return result
}
<|file_separator|>

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

func countA(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "a" {
            count += 1
        }
    }
    return count
}

func countB(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "b" {
            count += 1
        }
    }
    return count
}

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

func countD(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "d" {
            count += 1
        }
    }
    return count
}

func countE(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "e" {
            count += 1
        }
    }
    return count
}

func countF(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "f" {
            count += 1
        }
    }
    return count
}

func countG(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "g" {
            count += 1
        }
    }
    return count
}

func countH(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "h" {
            count += 1
        }
    }
    return count
}

func countI(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "i" {
            count += 1
        }
    }
    return count
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += String(char.lowercased())
        } else {
            result += String(char.uppercased())
        }
    }
    return result
}

// For a given string, return the number of times "a" appears in the string.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "a" {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of times "b" appears in the string.
// countB("Hello") == 0
// countB("Hello, my name is William") == 1
func countB(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "b" {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of times "c" appears in the string.
// countC("Hello") == 0
// countC("Hello, my name is John") == 1
func countC(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "c" {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of times "d" appears in the string.
// countD("Hello") == 0
// countD("Hello, my name is William") == 1
func countD(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "d" {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of times "e" appears in the string.
// countE("Hello") == 1
// countE("Hello, my name is John") == 2
func countE(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "e" {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of times "f" appears in the string.
// countF("Hello") == 0
// countF("Hello, my name is John") == 1
func countF(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "f" {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of times "g" appears in the string.
// countG("Hello") == 0
// countG("Hello, my name is John") == 1
func countG(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "g" {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of times "h" appears in the string.
// countH("Hello") == 1
// countH("Hello, my name is John") == 2
func countH(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "h" {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of times "i" appears in the string.
// countI("Hello") == 1
// countI("Hello, my name is John") == 2
func countI(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "i" {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of times "j" appears in the string.
// countJ("Hello") == 0
// countJ("Hello, my name is John") == 1
func countJ(string: String) -> Int {
    var count = 0
    for char in string {
        if char == "j" {

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += String(char.lowercased())
        } else {
            result += String(char.uppercased())
        }
    }
    return result
}
<|file_separator|>

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += String(char).uppercased()
        } else {
            result += String(char).lowercased()
        }
    }
    return result
}
<|file_separator|>

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += String(char.lowercased())
        } else {
            result += String(char.uppercased())
        }
    }
    return result
}
<|file_separator|>

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += String(char.uppercased())
        } else if char.isUppercase {
            result += String(char.lowercased())
        } else {
            result += String(char)
        }
    }
    return result
}
<|file_separator|>

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += String(char.lowercased())
        } else {
            result += String(char.uppercased())
        }
    }
    return result
}
<|file_separator|>

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0
        }
    }.joined()
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            $0.uppercased()
        } else if $0.isUppercase {
            $0.lowercased()
        } else {
            $0
        }
    }.joined()
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            $0.uppercased()
        } else if $0.isUppercase {
            $0.lowercased()
        } else {
            $0
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}
```

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

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

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .joined()
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .joined()
}
```

func flipCase(string: String) -> String {
    return string.lowercased().map { $0 == $0.lowercased()? $0.uppercased() : $0.lowercased() }
       .joined()
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.lowercased().map { $0 == $0.lowercased()? $0.uppercased() : $0.lowercased() }
       .joined()
}
```

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
  var result = ""
  for char in string {
    if char.isLowercase {
      result += char.uppercased()
    } else {
      result += char.lowercased()
    }
  }
  return result
}
```

func flipCase(string: String) -> String {
    return string.lowercased().map {
        if $0.isUppercase {
            return String($0.lowercased())
        } else {
            return String($0.uppercased())
        }
    }.joined()
}

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

func flipCase(string: String) -> String {
  return string.map {
    if $0.isUppercase {
      return String($0.lowercased())
    } else {
      return String($0.uppercased())
    }
  }
 .joined()
}

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

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

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

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

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

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

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

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

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

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}

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

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isUppercase {
            result.append(character.lowercased())
        } else {
            result.append(character.uppercased())
        }
    }
    return result
}

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

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char.uppercased()
        }
    }
    return result
}
```

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char.uppercased()
        }
    }
    return result
}
```

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result.append(char.lowercased())
        } else {
            result.append(char.uppercased())
        }
    }
    return result
}
```

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

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

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char.uppercased()
        }
    }
    return result
}
```

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

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

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char.lowercased()
        }
    }
    return result
}
```

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result.append(char.lowercased())
        } else {
            result.append(char.uppercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var newString = ""
    for char in string.characters {
        if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char.uppercased())
        }
    }
    return newString
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var newString = ""
    for char in string.characters {
        if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char.uppercased())
        }
    }
    return newString
}
```

func flipCase(string: String) -> String {
    return string.map {
        $0.isUppercase? $0.lowercased() : $0.uppercased()
    }.joined()
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map {
        $0.isUppercase? $0.lowercased() : $0.uppercased()
    }.joined()
}
```

func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char.uppercased())
        }
    }
    return newString
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char.uppercased())
        }
    }
    return newString
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }.joined()
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }.joined()
}
```

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string.characters {
        if char.isUppercase {
            result.append(char.lowercased())
        } else {
            result.append(char.uppercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    return string.map { (char) -> Character in
        if char.isUppercase {
            return char.lowercased()
        } else {
            return char.uppercased()
        }
    }.reduce("", { $0 + String($1) })
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { (char) -> Character in
        if char.isUppercase {
            return char.lowercased()
        } else {
            return char.uppercased()
        }
    }.reduce("", { $0 + String($1) })
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }.joined()
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }.joined()
}
```

func flipCase(string: String) -> String {
    var newString = ""
    for char in string.characters {
        if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char.uppercased())
        }
    }
    return newString
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var newString = ""
    for char in string.characters {
        if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char.uppercased())
        }
    }
    return newString
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }.joined()
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }.joined()
}
```

func flipCase(string: String) -> String {
    var newString = ""
    for char in string.characters {
        if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char.uppercased())
        }
    }
    return newString
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var newString = ""
    for char in string.characters {
        if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char.uppercased())
        }
    }
    return newString
}
```

func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "a-z", with: "A-Z", options:.literal, range: nil)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "a-z", with: "A-Z", options:.literal, range: nil)
}
```

func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "a-z", with: "A-Z", options:.literal, range: nil)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "a-z", with: "A-Z", options:.literal, range: nil)
}
```

func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "a-z", with: "A-Z", options:.literal, range: nil)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "a-z", with: "A-Z", options:.literal, range: nil)
}
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "a-z", with: "A-Z", options:.literal, range: nil)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "a-z", with: "A-Z", options:.literal, range: nil)
}
```

func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "a-z", with: "A-Z", options:.literal, range: nil)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "a-z", with: "A-Z", options:.literal, range: nil)
}
```

func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "a-z", with: "A-Z", options:.literal, range: nil)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "a-z", with: "A-Z", options:.literal, range: nil)
}
```

func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "a-z", with: "A-Z", options:.literal, range: nil)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "a-z", with: "A-Z", options:.literal, range: nil)
}
```

func flipCase(string: String) -> String {
    return string.map {
        switch $0 {
        case let character where character.isLowercase:
            return character.uppercased()
        case let character where character.isUppercase:
            return character.lowercased()
        default:
            return character
        }
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.map {
        switch $0 {
        case let character where character.isLowercase:
            return character.uppercased()
        case let character where character.isUppercase:
            return character.lowercased()
        default:
            return character
        }
    }
}
```

func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "a-z", with: "A-Z", options:.literal, range: nil)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "a-z", with: "A-Z", options:.literal, range: nil)
}
```

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if let uppercaseChar = char.ascii uppercase {
            result.append(Character(uppercaseChar))
        } else if let lowercaseChar = char.ascii lowercase {
            result.append(Character(lowercaseChar))
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if let uppercaseChar = char.ascii uppercase {
            result.append(Character(uppercaseChar))
        } else if let lowercaseChar = char.ascii lowercase {
            result.append(Character(lowercaseChar))
        } else {
            result.append(char)
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.caseFlipped }.reduce("", +)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.caseFlipped }.reduce("", +)
}
```

func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isUppercase? String($0).lowercased() : String($0).uppercased() }.joined()
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isUppercase? String($0).lowercased() : String($0).uppercased() }.joined()
}
```

func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isLowercase? $0.uppercase() : $0.lowercase() }.reduce("", +)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isLowercase? $0.uppercase() : $0.lowercase() }.reduce("", +)
}
```

func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isUppercase? String($0).lowercased() : String($0).uppercased() }.reduce("", +)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isUppercase? String($0).lowercased() : String($0).uppercased() }.reduce("", +)
}
```

func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isLowercase? $0.uppercasesd() : $0.lowercased() }.reduce("", +)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isLowercase? $0.uppercasesd() : $0.lowercased() }.reduce("", +)
}
```

func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isUppercase? String($0).lowercased() : String($0).uppercased() }.reduce("", +)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isUppercase? String($0).lowercased() : String($0).uppercased() }.reduce("", +)
}
```

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if let upperCase = char.ascii uppercase {
            result.append(Character(upperCase))
        } else if let lowerCase = char.ascii lowercase {
            result.append(Character(lowerCase))
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if let upperCase = char.ascii uppercase {
            result.append(Character(upperCase))
        } else if let lowerCase = char.ascii lowercase {
            result.append(Character(lowerCase))
        } else {
            result.append(char)
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isLowercase? $0.uppercase() : $0.lowercase() }.reduce("", +)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isLowercase? $0.uppercase() : $0.lowercase() }.reduce("", +)
}
```

func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isLowercase? $0.uppercasesd() : $0.lowercased() }.reduce("", +)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isLowercase? $0.uppercasesd() : $0.lowercased() }.reduce("", +)
}
```

func flipCase(string: String) -> String {
    return string.map { $0.toggleCase() }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.toggleCase() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.toggleCase() }
}

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

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.toggleCase() }
}

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

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

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var flippedString = ""
    
    for character in string {
        if character.isLowercase {
            flippedString.append(character.uppercased())
        } else {
            flippedString.append(character.lowercased())
        }
    }
    
    return flippedString
}
```

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

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var flippedString = ""
    for character in string {
        if character.isLowercase {
            flippedString.append(character.uppercased())
        } else {
            flippedString.append(character.lowercased())
        }
    }
    return flippedString
}
```

func flipCase(string: String) -> String {
    return string.map { $0.toggleCase() }
}

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

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.toggleCase() }
}

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

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

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var flippedString = ""
    for character in string {
        if character.isLowercase {
            flippedString.append(character.uppercased())
        } else {
            flippedString.append(character.lowercased())
        }
    }
    return flippedString
}
```

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

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var flippedString = ""
    for character in string {
        if character.isLowercase {
            flippedString.append(character.uppercased())
        } else {
            flippedString.append(character.lowercased())
        }
    }
    return flippedString
}
```

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

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var flippedString = ""
    for character in string {
        if character.isLowercase {
            flippedString.append(character.uppercased())
        } else {
            flippedString.append(character.lowercased())
        }
    }
    return flippedString
}
```

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

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var flippedString = ""
    for character in string {
        if character.isLowercase {
            flippedString.append(character.uppercased())
        } else {
            flippedString.append(character.lowercased())
        }
    }
    return flippedString
}
```

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

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var flippedString = ""
    for character in string {
        if character.isLowercase {
            flippedString.append(character.uppercased())
        } else {
            flippedString.append(character.lowercased())
        }
    }
    return flippedString
}
```

func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}
```

func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}
```

func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}
```

func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}
```

func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}
```

func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}
```

func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}
```

func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}
```

func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}
```

func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return String(string.unicodeScalars.map {
        $0.isLowercase? $0.toUppercase() : $0.toLowercase()
    })
}
```

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
}

/*
 For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
 flipCase(string: "Hello") == "hELLO"
 */
func flipCase(string: 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
}

/*
 For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
 flipCase(string: "Hello") == "hELLO"
 */
func flipCase(string: String) -> String {
    
    
    
    
    var result = [[Double]
    
    for i in
    for i in 0..<
    var row in 0..< lhs
    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
}

/*
 For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
 flipCase(string: "Hello") == "hELLO"
 */
func flipCase(string: String) -> String {
    
    
    
    
    var result = [[Double]

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
}

/*
 For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
 flipCase(string: "Hello") == "hELLO"
 */
func flipCase(string: 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
}

/*
 For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
 flipCase(string: "Hello") == "hELLO"
 */
func flipCase(string: String) -> String {
    
    
    
    
    var result = [[Double]

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
}

/*
 For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
 flipCase(string: "Hello") == "hELLO"
 */
func flipCase(string: 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
}

/*
 For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
 flipCase(string: "Hello") == "hELLO"
 */
func flipCase(string: String) -> String {
    
    
    
    
    
    var result = [[Double]
    
    
    
    
    
    

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
}

/*
 For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
 flipCase(string: "Hello") == "hELLO"
 */
func flipCase(string: 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
}

/*
 For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
 flipCase(string: "Hello") == "hELLO"
 */
func flipCase(string: 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
}

/*
 For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
 flipCase(string: "Hello") == "hELLO"
 */
func flipCase(string: 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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: 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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {




Here is a function that takes a single parameter of type String and returns a new String
 which is the input string with all lowercase characters in lowercase letters in uppercase characters

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: 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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: 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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {



return String(string.map {
 switch $0..

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: 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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: 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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: 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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {




return String(string.lowerc

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {



Here is a function that takes a string as input and

func flipCase(string: String) -> String {
    return string.lowercased().uppercased()
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.lowercased().uppercased()
}
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if CharacterSet.lowercaseLetters.contains(character) {
            result += String(character).lowercase()
        } else if CharacterSet.uppercaseLetters.contains(character) {
            result += String(character).uppercase()
        } else {
            result += character
        }
    }
    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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if CharacterSet.lowercaseLetters.contains(character) {
            result += String(character).lowercase()
        } else if CharacterSet.uppercaseLetters.contains(character) {
            result += String(character).uppercase()
        } else {
            result += character
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    return string.lowercased().uppercased()
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.lowercased().uppercased()
}
```

func flipCase(string: String) -> String {
    return string.lowercased().uppercased()
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.lowercased().uppercased()
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isUppercase ? String($0).lowercased() : String($0).uppercased() })
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isUppercase ? String($0).lowercased() : String($0).uppercased() })
}

print(flipCase(string: "Hello")) // hELLO
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if CharacterSet.lowercaseLetters.contains(character) {
            result += String(character).lowercase()
        } else if CharacterSet.uppercaseLetters.contains(character) {
            result += String(character).uppercase()
        } else {
            result += character
        }
    }
    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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if CharacterSet.lowercaseLetters.contains(character) {
            result += String(character).lowercase()
        } else if CharacterSet.uppercaseLetters.contains(character) {
            result += String(character).uppercase()
        } else {
            result += character
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isUppercase ? String($0).lowercased() : String($0).uppercased() })
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isUppercase ? String($0).lowercased() : String($0).uppercased() })
}

print(flipCase(string: "Hello")) // hELLO
```

func flipCase(string: String) -> String {
    return string.lowercased().uppercased()
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.lowercased().uppercased()
}
```

func flipCase(string: String) -> String {
    return string.lowercased().uppercased()
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.lowercased().uppercased()
}
```

func flipCase(string: String) -> String {
    return string.lowercased().uppercased()
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.lowercased().uppercased()
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    var flippedString = ""
    for char in string {
        if char.isUppercase {
            flippedString += String(char).lowercased()
        } else {
            flippedString += String(char).uppercased()
        }
    }
    return flippedString
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var flippedString = ""
    for char in string {
        if char.isUppercase {
            flippedString += String(char).lowercased()
        } else {
            flippedString += String(char).uppercased()
        }
    }
    return flippedString
}
```

func flipCase(string: String) -> String {
    var flippedString = ""
    for char in string {
        if char.isUppercase {
            flippedString += String(char).lowercased()
        } else {
            flippedString += String(char).uppercased()
        }
    }
    return flippedString
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var flippedString = ""
    for char in string {
        if char.isUppercase {
            flippedString += String(char).lowercased()
        } else {
            flippedString += String(char).uppercased()
        }
    }
    return flippedString
}
```

func flipCase(string: String) -> String {
    var flippedString = ""
    for char in string {
        if char.isUppercase {
            flippedString += String(char).lowercased()
        } else {
            flippedString += String(char).uppercased()
        }
    }
    return flippedString
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var flippedString = ""
    for char in string {
        if char.isUppercase {
            flippedString += String(char).lowercased()
        } else {
            flippedString += String(char).uppercased()
        }
    }
    return flippedString
}
```

func flipCase(string: String) -> String {
    var flippedString = ""
    for char in string {
        if char.isUppercase {
            flippedString += String(char).lowercased()
        } else {
            flippedString += String(char).uppercased()
        }
    }
    return flippedString
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var flippedString = ""
    for char in string {
        if char.isUppercase {
            flippedString += String(char).lowercased()
        } else {
            flippedString += String(char).uppercased()
        }
    }
    return flippedString
}
```

func flipCase(string: String) -> String {
    var flippedString = ""
    for char in string {
        if char.isUppercase {
            flippedString += String(char).lowercased()
        } else if char.isLowercase {
            flippedString += String(char).uppercased()
        } else {
            flippedString += String(char)
        }
    }
    return flippedString
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var flippedString = ""
    for char in string {
        if char.isUppercase {
            flippedString += String(char).lowercased()
        } else if char.isLowercase {
            flippedString += String(char).uppercased()
        } else {
            flippedString += String(char)
        }
    }
    return flippedString
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() })
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isUppercase ? $0.lowercased() : $0.uppercased() })
}
```

func flipCase(string: String) -> String {
    var flippedString = ""
    for char in string {
        if char.isUppercase {
            flippedString += String(char).lowercased()
        } else {
            flippedString += String(char).uppercased()
        }
    }
    return flippedString
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var flippedString = ""
    for char in string {
        if char.isUppercase {
            flippedString += String(char).lowercased()
        } else {
            flippedString += String(char).uppercased()
        }
    }
    return flippedString
}
```

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += String(char).lowercased()
        } else if char.isLowercase {
            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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += String(char).lowercased()
        } else if char.isLowercase {
            result += String(char).uppercased()
        } else {
            result += String(char)
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += String(char).lowercased()
        } else {
            result += String(char).uppercased()
        }
    }
    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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += String(char).lowercased()
        } else {
            result += String(char).uppercased()
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var flippedString = ""
    for character in string {
        if character.isUppercase {
            flippedString += String(character).lowercased()
        } else if character.isLowercase {
            flippedString += String(character).uppercased()
        } else {
            flippedString += String(character)
        }
    }
    return flippedString
}

<｜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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var flippedString = ""
    for character in string {
        if character.isUppercase {
            flippedString += String(character).lowercased()
        } else if character.isLowercase {
            flippedString += String(character).uppercased()
        } else {
            flippedString += String(character)
        }
    }
    return flippedString
}
```

import Foundation

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return String(char)
        }
    }.joined()
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
import Foundation

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return String(char)
        }
    }.joined()
}
```

import Foundation

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return String(char)
        }
    }.joined()
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
import Foundation

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return String(char)
        }
    }.joined()
}
```

import Foundation

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
import Foundation

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

import Foundation

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

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
import Foundation

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else if char.isUppercase {
            result.append(char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

import Foundation

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return String(char)
        }
    }.joined()
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
import Foundation

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return String(char)
        }
    }.joined()
}
```

import Foundation

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return String(char)
        }
    }.joined()
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
import Foundation

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return String(char)
        }
    }.joined()
}
```

import Foundation

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

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
import Foundation

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else if char.isUppercase {
            result.append(char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

import Foundation

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

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
import Foundation

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else if char.isUppercase {
            result.append(char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```

import Foundation

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return String(char)
        }
    }.joined()
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
import Foundation

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return String(char)
        }
    }.joined()
}
```

import Foundation

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return String(char)
        }
    }.joined()
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
import Foundation

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return String(char)
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    return String(string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return String(char)
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return String(char)
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    return String(string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else {
            return char.lowercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else {
            return char.lowercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isLowercase ? $0.uppercased() : $0.lowercased() })
}
```

func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString += String(char).uppercased()
        } else {
            newString += String(char).lowercased()
        }
    }
    return newString
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString += String(char).uppercased()
        } else {
            newString += String(char).lowercased()
        }
    }
    return newString
}
```

func flipCase(string: String) -> String {
    var newString = ""
    for character in string {
        if character.isLowercase {
            newString.append(character.uppercased())
        } else {
            newString.append(character.lowercased())
        }
    }
    return newString
}

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

// flipCase(string: "Hello")
// flipCase(string: "hELLO")
// flipCase(string: "Hello, World!")
// flipCase(string: "12345")
// flipCase(string: "12345.67890")
// flipCase(string: "12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890")
// flipCase(string: "12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 12345.67890, 1

func flipCase(string: String) -> String {
    let charArray = Array(string)
    var newString = ""
    for char in charArray {
        if char.isUppercase {
            newString += String(char).lowercased()
        } else {
            newString += String(char).uppercased()
        }
    }
    return newString
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    let charArray = Array(string)
    var newString = ""
    for char in charArray {
        if char.isUppercase {
            newString += String(char).lowercased()
        } else {
            newString += String(char).uppercased()
        }
    }
    return newString
}
```

func flipCase(string: String) -> String {
    let charArray = Array(string)
    var newString = ""
    for char in charArray {
        if char.isLowercase {
            newString += String(char).uppercased()
        } else {
            newString += String(char).lowercased()
        }
    }
    return newString
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    let charArray = Array(string)
    var newString = ""
    for char in charArray {
        if char.isLowercase {
            newString += String(char).uppercased()
        } else {
            newString += String(char).lowercased()
        }
    }
    return newString
}
```

func flipCase(string: String) -> String {
    let charArray = Array(string)
    var newString = ""
    for char in charArray {
        if char.isUppercase {
            newString += String(char).lowercased()
        } else if char.isLowercase {
            newString += String(char).uppercased()
        } else {
            newString += String(char)
        }
    }
    return newString
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    let charArray = Array(string)
    var newString = ""
    for char in charArray {
        if char.isUppercase {
            newString += String(char).lowercased()
        } else if char.isLowercase {
            newString += String(char).uppercased()
        } else {
            newString += String(char)
        }
    }
    return newString
}
```

func flipCase(string: String) -> String {
    var newString = ""
    for character in string {
        if character.isUppercase {
            newString.append(character.lowercased())
        } else if character.isLowercase {
            newString.append(character.uppercased())
        } else {
            newString.append(character)
        }
    }
    return newString
}

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

// flipCase(string: "Hello")
```

func flipCase(string: String) -> String {
    let charArray = Array(string)
    var newString = ""
    for char in charArray {
        if char.isUppercase {
            newString += String(char).lowercased()
        } else {
            newString += String(char).uppercased()
        }
    }
    return newString
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    let charArray = Array(string)
    var newString = ""
    for char in charArray {
        if char.isUppercase {
            newString += String(char).lowercased()
        } else {
            newString += String(char).uppercased()
        }
    }
    return newString
}
```

func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString += String(char).uppercased()
        } else {
            newString += String(char).lowercased()
        }
    }
    return newString
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString += String(char).uppercased()
        } else {
            newString += String(char).lowercased()
        }
    }
    return newString
}
```

func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString += String(char).uppercased()
        } else {
            newString += String(char).lowercased()
        }
    }
    return newString
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString += String(char).uppercased()
        } else {
            newString += String(char).lowercased()
        }
    }
    return newString
}
```

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += String(char).uppercased()
        } else {
            result += String(char).lowercased()
        }
    }
    return result
}
```

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

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

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

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

func flipCase(string: String) -> String {
    let lowercase = string.lowercaseString
    let uppercase = string.uppercaseString
    return lowercase.replacingOccurrences(of: uppercase, with: lowercase)
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    let lowercase = string.lowercaseString
    let uppercase = string.uppercaseString
    return lowercase.replacingOccurrences(of: uppercase, with: lowercase)
}
```

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

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

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

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

func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return String($0.uppercased())
        } else {
            return String($0.lowercased())
        }
    }
}

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

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

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

func flipCase(string: String) -> String {
    return string.uppercased().lowercased()
}

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

func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return String($0.uppercaseString)
        } else {
            return String($0.lowercaseString)
        }
    }
}

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

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

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

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    }
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    }
}
```

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    }
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    }
}
```

func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString.append(char.uppercased())
        } else {
            newString.append(char.lowercased())
        }
    }
    return newString
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString.append(char.uppercased())
        } else {
            newString.append(char.lowercased())
        }
    }
    return newString
}
```
### Challenge

func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString.append(char.uppercased())
        } else {
            newString.append(char.lowercased())
        }
    }
    return newString
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString.append(char.uppercased())
        } else {
            newString.append(char.lowercased())
        }
    }
    return newString
}
```
### Challenge

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

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else if char.isUppercase {
            result.append(char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```
### Challenge

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

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else if char.isUppercase {
            result.append(char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```
### Challenge

func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString.append(char.uppercased())
        } else if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char)
        }
    }
    return newString
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString.append(char.uppercased())
        } else if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char)
        }
    }
    return newString
}
```
### Challenge

func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString.append(char.uppercased())
        } else if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char)
        }
    }
    return newString
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString.append(char.uppercased())
        } else if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char)
        }
    }
    return newString
}
```
### Challenge

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

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else if char.isUppercase {
            result.append(char.lowercased())
        } else {
            result.append(char)
        }
    }
    return result
}
```
### Challenge

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

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```
### Challenge

func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString.append(char.uppercased())
        } else if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char)
        }
    }
    return newString
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString.append(char.uppercased())
        } else if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char)
        }
    }
    return newString
}
```
### Challenge

func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString.append(char.uppercased())
        } else {
            newString.append(char.lowercased())
        }
    }
    return newString
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString.append(char.uppercased())
        } else {
            newString.append(char.lowercased())
        }
    }
    return newString
}
```
### Challenge

func flipCase(string: String) -> String {
    return String(string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    })
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return String(string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? $0.uppercased() : $0.lowercased()
    })
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? $0.uppercased() : $0.lowercased()
    })
}
```

func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? $0.uppercased() : $0.lowercased()
    })
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? $0.uppercased() : $0.lowercased()
    })
}
```
### Test

func flipCase(string: String) -> String {
    return String(string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    })
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return String(string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    })
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return String(string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    })
}
```
### Test

func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? $0.uppercased() : $0.lowercased()
    })
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? $0.uppercased() : $0.lowercased()
    })
}
```
### Link

func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? $0.uppercased() : $0.lowercased()
    })
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? $0.uppercased() : $0.lowercased()
    })
}
```
### Link

func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? $0.uppercased() : $0.lowercased()
    })
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? $0.uppercased() : $0.lowercased()
    })
}
```
### Test

func flipCase(string: String) -> String {
    return String(string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    })
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return String(string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    })
}
```
### Test

func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? $0.uppercased() : $0.lowercased()
    })
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? $0.uppercased() : $0.lowercased()
    })
}
```
### Test

func flipCase(string: String) -> String {
    return string.map {
        let s = String($0)
        return s.lowercased() == s ? s.uppercased() : s.lowercased()
    }.joined()
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map {
        let s = String($0)
        return s.lowercased() == s ? s.uppercased() : s.lowercased()
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        $0.isUppercase ? String($0).lowercased() : String($0).uppercased()
    }.joined()
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map {
        $0.isUppercase ? String($0).lowercased() : String($0).uppercased()
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        let s = String($0)
        return s.lowercased() == s ? s.uppercased() : s.lowercased()
    }.joined()
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map {
        let s = String($0)
        return s.lowercased() == s ? s.uppercased() : s.lowercased()
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        let s = String($0)
        return s.lowercased() == s
            ? s.uppercased()
            : s.lowercased()
    }.joined()
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map {
        let s = String($0)
        return s.lowercased() == s
            ? s.uppercased()
            : s.lowercased()
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        let s = String($0)
        return s.lowercased() == s
            ? s.uppercased()
            : s.lowercased()
    }.joined()
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map {
        let s = String($0)
        return s.lowercased() == s
            ? s.uppercased()
            : s.lowercased()
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        let s = String($0)
        return s.lowercased() == s ? s.uppercased() : s.lowercased()
    }.joined()
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map {
        let s = String($0)
        return s.lowercased() == s ? s.uppercased() : s.lowercased()
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        let s = String($0)
        return s.lowercased() == s ? s.uppercased() : s.lowercased()
    }.joined()
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map {
        let s = String($0)
        return s.lowercased() == s ? s.uppercased() : s.lowercased()
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        let s = String($0)
        return s.lowercased() == s
            ? s.uppercased()
            : s.lowercased()
    }.joined()
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map {
        let s = String($0)
        return s.lowercased() == s
            ? s.uppercased()
            : s.lowercased()
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.unicodeScalars.map {
        Character(UnicodeScalar(
            $0.value ^ (32 * ($0.value >= 65 && $0.value <= 90 ? 1 : 0))
        ))
    }.reduce("", +)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.unicodeScalars.map {
        Character(UnicodeScalar(
            $0.value ^ (32 * ($0.value >= 65 && $0.value <= 90 ? 1 : 0))
        ))
    }.reduce("", +)
}
```

func flipCase(string: String) -> String {
    return string.map {
        let s = String($0)
        return s.lowercased() == s ? s.uppercased() : s.lowercased()
    }.joined()
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map {
        let s = String($0)
        return s.lowercased() == s ? s.uppercased() : s.lowercased()
    }.joined()
}
```

func flipCase(string: String) -> String {
    var flippedString = ""
    for character in string.characters {
        if character.isLowercase {
            flippedString += character.uppercased()
        } else {
            flippedString += character.lowercased()
        }
    }
    return flippedString
}

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

func flipCase(string: String) -> String {
    var flippedString = ""
    for character in string.characters {
        if character.isLowercase {
            flippedString += String(character).uppercased()
        } else {
            flippedString += String(character).lowercased()
        }
    }
    return flippedString
}

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

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

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

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

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

func flipCase(string: String) -> String {
    var flippedString = ""
    for character in string.characters {
        if character.isUppercase {
            flippedString += character.lowercased()
        } else {
            flippedString += character.uppercased()
        }
    }
    return flippedString
}

func mode(string: String) -> String {
    var characterCounts = [Character: Int]()
    var mode = ""
    var modeCount = 0
    for character in string.characters {
        if let count = characterCounts[character] {
            characterCounts[character] = count + 1
        } else {
            characterCounts[character] = 1
        }
        if characterCounts[character] > modeCount {
            mode = String(character)
            modeCount = characterCounts[character]!
        }
    }
    return mode
}

func leastCommon(string: String) -> String {
    var characterCounts = [Character: Int]()
    var leastCommon = ""
    var leastCommonCount = Int.max
    for character in string.characters {
        if let count = characterCounts[character] {
            characterCounts[character] = count + 1
        } else {
            characterCounts[character] = 1
        }
        if characterCounts[character] < leastCommonCount {
            leastCommon = String(character)
            leastCommonCount = characterCounts[character]!
        }
    }
    return leastCommon
}

func mostCommon(string: String) -> String {
    var characterCounts = [Character: Int]()
    var mostCommon = ""
    var mostCommonCount = 0
    for character in string.characters {
        if let count = characterCounts[character] {
            characterCounts[character] = count + 1
        } else {
            characterCounts[character] = 1
        }
        if characterCounts[character] > mostCommonCount {
            mostCommon = String(character)
            mostCommonCount = characterCounts[character]!
        }
    }
    return mostCommon
}

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

// for a given string, return the character, that appears the MOST times.
// mode(string: "Hello") == "l"
// mode(string: "Helloo") == "o"
// mode(string: "Hellooo") == "o"
// mode(string: "Helloooo") == "o"
// mode(string: "Hellooooo") == "o"
func mode(string: String) -> String {
    var characterCounts = [Character: Int]()
    var mode = ""
    var modeCount = 0
    for character in string.characters {
        if let count = characterCounts[character] {
            characterCounts[character] = count + 1
        } else {
            characterCounts[character] = 1
        }
        if characterCounts[character] > modeCount {
            mode = String(character)
            modeCount = characterCounts[character]!
        }
    }
    return mode
}

// For a given string, return the character that appears the LEAST times.
// leastCommon(string: "Hello") == "H"
// leastCommon(string: "Helloo") == "H"
// leastCommon(string: "Hellooo") == "H"
// leastCommon(string: "Helloooo") == "H"
// leastCommon(string: "Hellooooo") == "H"
func leastCommon(string: String) -> String {
    var characterCounts = [Character: Int]()
    var leastCommon = ""
    var leastCommonCount = Int.max
    for character in string.characters {
        if let count = characterCounts[character] {
            characterCounts[character] = count + 1
        } else {
            characterCounts[character] = 1
        }
        if characterCounts[character] < leastCommonCount {
            leastCommon = String(character)
            leastCommonCount = characterCounts[character]!
        }
    }
    return leastCommon
}

// For a given string, return the character that appears THE MOST times.
// mostCommon(string: "Hello") == "l"
// mostCommon(string: "Helloo") == "o"
// mostCommon(string: "Hellooo") == "o"
// mostCommon(string: "Helloooo") == "o"
// mostCommon(string: "Hellooooo") == "o"
func mostCommon(string: String) -> String {
    var characterCounts = [Character: Int]()
    var mostCommon = ""
    var mostCommonCount = 0
    for character in string.characters {
        if let count = characterCounts[character] {
            characterCounts[character] = count + 1
        } else {
            characterCounts[character] = 1
        }
        if characterCounts[character] > mostCommonCount {
            mostCommon = String(character)
            mostCommonCount = characterCounts[character]!
        }
    }
    return mostCommon
}

// For a given string, return the character that appears THE LEAST times.
// leastCommon(string: "Hello") == "H"
// leastCommon(string: "Helloo") == "H"
// leastCommon(string: "Hellooo") == "H"
// leastCommon(string: "Helloooo") == "H"
// leastCommon(string: "Hellooooo") == "H"
func leastCommon(string: String) -> String {
    var characterCounts = [Character: Int]()
    var leastCommon = ""
    var leastCommonCount = Int.max
    for character in string.characters {
        if let count = characterCounts[character] {
            characterCounts[character] = count + 1
        } else {
            characterCounts[character] = 1
        }
        if characterCounts[character] < leastCommonCount {
            leastCommon = String(character)
            leastCommonCount = characterCounts[character]!
        }
    }
    return leastCommon
}

func flipCase(string: String) -> String {
    var flippedString = ""
    for char in string.characters {
        if char.isLowercase {
            flippedString.append(char.uppercased())
        } else {
            flippedString.append(char.lowercased())
        }
    }
    return flippedString
}

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

// Test cases
flipCase(string: "Hello") == "hELLO" // true
flipCase(string: "HELLO") == "hello" // true
flipCase(string: "12345") == "12345" // true
flipCase(string: "") == "" // true
flipCase(string: "Hello World!") == "hELLO wORLD!" // true
flipCase(string: "Python 3.6") == "pYTHON 3.6" // true
flipCase(string: "CamelCase") == "cAMELcASE" // true
flipCase(string: "123") == "123" // true
flipCase(string: "!@#") == "!@#" // true
flipCase(string: "") == "" // true
```

func flipCase(string: String) -> String {
    var flippedString = ""
    for character in string.characters {
        if character.isLowercase {
            flippedString += character.uppercased()
        } else {
            flippedString += character.lowercased()
        }
    }
    return flippedString
}

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

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

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

// Test cases:
flipCase(string: "Hello") == "hELLO"
flipCase(string: "HELLO") == "hello"
flipCase(string: "12345") == "12345"
flipCase(string: "abcDEF") == "ABCdef"
```

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

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

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char.lowercased()
        }
    }
    return result
}

// Example usage:
let exampleString = "Hello World!"
let flippedString = flipCase(string: exampleString)
print("Original: \(exampleString)")
print("Flipped: \(flippedString)")
```

This function takes a string as input and returns a new string where each lowercase letter is converted to uppercase and each uppercase letter is converted to lowercase. It iterates over each character in the input string and checks if it is a lowercase or uppercase letter. If it is, it converts it to the opposite case and appends it to the result string. Otherwise, it appends the character as it is.

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char
        }
    }
    return result
}
<|file_separator|>

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char
        }
    }
    return result
}
<|file_separator|>

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char
        }
    }
    return result
}
<|file_separator|>

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

func countIS(string: String) -> Int {
    var result = 0
    var index = 0
    while index < string.count {
        if string.substring(with: index..<index+2) == "is" {
            result += 1
            index += 2
        } else {
            index += 1
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isUppercase {
            result += c.lowercased()
        } else {
            result += c.uppercased()
        }
    }
    return result
}

// For a given string, return the number of times the string "is" appears in the string.
// countIS(string: "This is a test") == 1
// countIS(string: "This is is a test") == 2
func countIS(string: String) -> Int {
    var result = 0
    var index = 0
    while index < string.count {
        if string.substring(with: index..<index+2) == "is" {
            result += 1
            index += 2
        } else {
            index += 1
        }
    }
    return result
}

// For a given string, return the number of times the string "is" appears in the string.
// countIS(string: "This is a test") == 1
// countIS(string: "This is is a test") == 2
func countIS(string: String) -> Int {
    var result = 0
    var index = 0
    while index < string.count {
        if string.substring(with: index..<index+2) == "is" {
            result += 1
            index += 2
        } else {
            index += 1
        }
    }
    return result
}

// For a given string, return the number of times the string "is" appears in the string.
// countIS(string: "This is a test") == 1
// countIS(string: "This is is a test") == 2
func countIS(string: String) -> Int {
    var result = 0
    var index = 0
    while index < string.count {
        if string.substring(with: index..<index+2) == "is" {
            result += 1
            index += 2
        } else {
            index += 1
        }
    }
    return result
}

// For a given string, return the number of times the string "is" appears in the string.
// countIS(string: "This is a test") == 1
// countIS(string: "This is is a test") == 2
func countIS(string: String) -> Int {
    var result = 0
    var index = 0
    while index < string.count {
        if string.substring(with: index..<index+2) == "is" {
            result += 1
            index += 2
        } else {
            index += 1
        }
    }
    return result
}

// For a given string, return the number of times the string "is" appears in the string.
// countIS(string: "This is a test") == 1
// countIS(string: "This is is a test") == 2
func countIS(string: String) -> Int {
    var result = 0
    var index = 0
    while index < string.count {
        if string.substring(with: index..<index+2) == "is" {
            result += 1
            index += 2
        } else {
            index += 1
        }
    }
    return result
}

// For a given string, return the number of times the string "is" appears in the string.
// countIS(string: "This is a test") == 1
// countIS(string: "This is is a test") == 2
func countIS(string: String) -> Int {
    var result = 0
    var index = 0
    while index < string.count {
        if string.substring(with: index..<index+2) == "is" {
            result += 1
            index += 2
        } else {
            index += 1
        }
    }
    return result
}

// For a given string, return the number of times the string "is" appears in the string.
// countIS(string: "This is a test") == 1
// countIS(string: "This is is a test") == 2
func countIS(string: String) -> Int {
    var result = 0
    var index = 0
    while index < string.count {
        if string.substring(

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

func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isLowercase {
            result += c.uppercased()
        } else if c.isUppercase {
            result += c.lowercased()
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "hello world") == "Hello World"
func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "hello world") == "Hello World"
func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "hello world") == "Hello World"
func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "hello world") == "Hello World"
func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "hello world") == "Hello World"
func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "hello world") == "Hello World"
func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "hello world") == "Hello World"
func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "hello world") == "Hello World"
func capitalizeFirstLetter(string: String) -> String {
    var result = ""
    var isFirstLetter = true
    for c in string {
        if isFirstLetter {
            result += c.uppercased()
            isFirstLetter = false
        } else {
            result += c
        }
    }
    return result
}

// For a given string, return a string with the first character of each word in the string capitalized.
// capitalizeFirstLetter(string: "

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char
        }
    }
    return result
}
<|file_separator|>

func flipCase(string: String) -> String {
  return string.map {
    if $0.isUppercase {
      return $0.lowercased()
    } else {
      return $0.uppercased()
    }
  }.joined()
}

func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

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

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is William") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is William") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello") == 1
// countA("Hello, my name is John") == 2
func countA(string: String) -> Int {
  return string.filter { $0 == "a" }.count
}

// For a given string, return the number of times the character "a" appears.
// countA("Hello

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isUppercase {
            result += c.lowercased()
        } else {
            result += c.uppercased()
        }
    }
    return result
}
<|file_separator|>

func flipCase(string: String) -> String {
    return string.uppercased()
}

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

func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isLowercase {
            result += c.uppercased()
        } else {
            result += c.lowercased()
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isLowercase {
            result += c.uppercased()
        } else {
            result += c.lowercased()
        }
    }
    return result
}
<|file_separator|>

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char
        }
    }
    return result
}
<|file_separator|>

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char
        }
    }
    return result
}
<|file_separator|>

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char
        }
    }
    return result
}
<|file_separator|>

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char
        }
    }
    return result
}
<|file_separator|>

func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isLowercase {
            result += c.uppercased()
        } else {
            result += c.lowercased()
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isLowercase {
            result += c.uppercased()
        } else {
            result += c.lowercased()
        }
    }
    return result
}
<|file_separator|>

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

func countZ(string: String) -> Int {
    var count = 0
    for c in string {
        if c == "z" {
            count += 1
        }
    }
    return count
}

func countZ(string: String) -> Int {
    return string.filter { $0 == "z" }.count
}

func countZ(string: String) -> Int {
    return string.reduce(0) { $0 + ($1 == "z" ? 1 : 0) }
}

func countZ(string: String) -> Int {
    return string.reduce(0) { $0 + (string[$1] == "z" ? 1 : 0) }
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isUppercase {
            result += c.lowercased()
        } else {
            result += c.uppercased()
        }
    }
    return result
}

// For a given string, return the number of times the character "z" appears in it.
// countZ("zzz") == 2
func countZ(string: String) -> Int {
    var count = 0
    for c in string {
        if c == "z" {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of times the character "z" appears in it.
// countZ("zzz") == 2
func countZ(string: String) -> Int {
    return string.filter { $0 == "z" }.count
}

// For a given string, return the number of times the character "z" appears in it.
// countZ("zzz") == 2
func countZ(string: String) -> Int {
    return string.reduce(0) { $0 + ($1 == "z" ? 1 : 0) }
}

// For a given string, return the number of times the character "z" appears in it.
// countZ("zzz") == 2
func countZ(string: String) -> Int {
    return string.reduce(0) { $0 + (string[$1] == "z" ? 1 : 0) }
}

// For a given string, return the number of times the character "z" appears in it.
// countZ("zzz") == 2
func countZ(string: String) -> Int {
    return string.reduce(0) { $0 + (string[$1] == "z" ? 1 : 0) }
}

// For a given string, return the number of times the character "z" appears in it.
// countZ("zzz") == 2
func countZ(string: String) -> Int {
    return string.reduce(0) { $0 + (string[$1] == "z" ? 1 : 0) }
}

// For a given string, return the number of times the character "z" appears in it.
// countZ("zzz") == 2
func countZ(string: String) -> Int {
    return string.reduce(0) { $0 + (string[$1] == "z" ? 1 : 0) }
}

// For a given string, return the number of times the character "z" appears in it.
// countZ("zzz") == 2
func countZ(string: String) -> Int {
    return string.reduce(0) { $0 + (string[$1] == "z" ? 1 : 0) }
}

// For a given string, return the number of times the character "z" appears in it.
// countZ("zzz") == 2
func countZ(string: String) -> Int {
    return string.reduce(0) { $0 + (string[$1] == "z" ? 1 : 0) }
}

// For a given string, return the number of times the character "z" appears in it.
// countZ("zzz") == 2
func countZ(string: String) -> Int {
    return string.reduce(0) { $0 + (string[$1] == "z" ? 1 : 0) }
}

// For a given string, return the number of times the character "z" appears in it.
// countZ("zzz") == 2
func countZ(string: String) -> Int {
    return string.reduce(0) { $0 + (string[$1] == "z" ? 1 : 0) }
}

// For a given string, return the number of times the character "z" appears in it.
// countZ("zzz") == 2
func countZ(string: String) -> Int {
    return string.reduce(0) { $0 + (string[$1] == "z" ? 1 : 0) }
}

// For a given string, return the number of times the character "z" appears in it.
// countZ("zzz") == 2
func countZ(string: String) -> Int {
    return string.reduce(0) { $0 + (string[$1] == "z" ? 1 : 0) }
}

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isUppercase {
            result += c.lowercased()
        } else {
            result += c.uppercased()
        }
    }
    return result
}
<|file_separator|>

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char.uppercased()
        }
    }
    return result
}
<|file_separator|>

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isUppercase {
            result += c.lowercased()
        } else {
            result += c.uppercased()
        }
    }
    return result
}
<|file_separator|>

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char.uppercased()
        }
    }
    return result
}
<|file_separator|>

func flipCase(string: String) -> String {
    return string.map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    }.joined()
}

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

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    
    for char in string {
        if char.isLowercase {
            result += String(char).uppercased()
        } else {
            result += String(char).lowercased()
        }
    }
    
    return result
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isUppercase {
            return $0.lowercaseString
        } else {
            return $0.uppercaseString
        }
    }.joinWithSeparator("")
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map {
        if $0.isUppercase {
            return $0.lowercaseString
        } else {
            return $0.uppercaseString
        }
    }.joinWithSeparator("")
}
```

func flipCase(string: String) -> String {
    let characters = Array(string)
    return characters.map {
        switch $0 {
        case "a"..."z":
            return $0.uppercased()
        case "A"..."Z":
            return $0.lowercased()
        default:
            return $0
        }
    }.joined()
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    let characters = Array(string)
    return characters.map {
        switch $0 {
        case "a"..."z":
            return $0.uppercased()
        case "A"..."Z":
            return $0.lowercased()
        default:
            return $0
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isUppercase {
            return $0.lowercaseString
        } else {
            return $0.uppercaseString
        }
    }.joinWithSeparator("")
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map {
        if $0.isUppercase {
            return $0.lowercaseString
        } else {
            return $0.uppercaseString
        }
    }.joinWithSeparator("")
}
```

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

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

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

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

func flipCase(string: String) -> String {
    var newString = ""
    for char in string {
        if char.isLowercase {
            newString.append(char.uppercased())
        } else {
            newString.append(char.lowercased())
        }
    }
    return newString
}

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

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

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

func flipCase(string: String) -> String {
    let lowerCase = "abcdefghijklmnopqrstuvwxyz"
    let upperCase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    
    var newString = ""
    
    for char in string {
        if lowerCase.contains(char) {
            newString.append(upperCase[upperCase.index(of: char)!])
        } else if upperCase.contains(char) {
            newString.append(lowerCase[lowerCase.index(of: char)!])
        } else {
            newString.append(char)
        }
    }
    
    return newString
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    let lowerCase = "abcdefghijklmnopqrstuvwxyz"
    let upperCase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    
    var newString = ""
    
    for char in string {
        if lowerCase.contains(char) {
            newString.append(upperCase[upperCase.index(of: char)!])
        } else if upperCase.contains(char) {
            newString.append(lowerCase[lowerCase.index(of: char)!])
        } else {
            newString.append(char)
        }
    }
    
    return newString
}
```

func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isUpper {
            result += char.lowercase
        } else {
            result += char.uppercase
        }
    }
    return result
}

func removeVowels(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if !char.isVowel {
            result += char
        }
    }
    return result
}

func firstNonRepeatedCharacter(string: String) -> String {
    var charCounts = map<Char, Int>()
    for _, char in string.characters {
        charCounts[char] = charCounts.get(char, 0) + 1
    }
    for _, char in string.characters {
        if charCounts[char] == 1 {
            return char.toString()
        }
    }
    return ""
}

func firstRepeatedCharacter(string: String) -> String {
    var charCounts = map<Char, Int>()
    for _, char in string.characters {
        charCounts[char] = charCounts.get(char, 0) + 1
    }
    for _, char in string.characters {
        if charCounts[char] > 1 {
            return char.toString()
        }
    }
    return ""
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isUpper {
            result += char.lowercase
        } else {
            result += char.uppercase
        }
    }
    return result
}

// For a given string, remove all vowels.
// removeVowels(string: "Hello") == "Hll"
func removeVowels(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if !char.isVowel {
            result += char
        }
    }
    return result
}

// For a given string, return the first non-repeated character.
// firstNonRepeatedCharacter(string: "Hello") == "H"
func firstNonRepeatedCharacter(string: String) -> String {
    var charCounts = map<Char, Int>()
    for _, char in string.characters {
        charCounts[char] = charCounts.get(char, 0) + 1
    }
    for _, char in string.characters {
        if charCounts[char] == 1 {
            return char.toString()
        }
    }
    return ""
}

// For a given string, return the first repeated character.
// firstRepeatedCharacter(string: "Hello") == "l"
func firstRepeatedCharacter(string: String) -> String {
    var charCounts = map<Char, Int>()
    for _, char in string.characters {
        charCounts[char] = charCounts.get(char, 0) + 1
    }
    for _, char in string.characters {
        if charCounts[char] > 1 {
            return char.toString()
        }
    }
    return ""
}

// For a given string, return the first character that is repeated.
// firstRepeatedCharacter(string: "Hello") == "l"
func firstRepeatedCharacter(string: String) -> String {
    var charCounts = map<Char, Int>()
    for _, char in string.characters {
        charCounts[char] = charCounts.get(char, 0) + 1
    }
    for _, char in string.characters {
        if charCounts[char] > 1 {
            return char.toString()
        }
    }
    return ""
}

// For a given string, return the first character that is repeated.
// firstRepeatedCharacter(string: "Hello") == "l"
func firstRepeatedCharacter(string: String) -> String {
    var charCounts = map<Char, Int>()
    for _, char in string.characters {
        charCounts[char] = charCounts.get(char, 0) + 1
    }
    for _, char in string.characters {
        if charCounts[char] > 1 {
            return char.toString()
        }
    }
    return ""
}

// For a given string, return the first character that is repeated.
// firstRepeatedCharacter(string: "Hello") == "l"
func firstRepeatedCharacter(string: String) -> String {
    var charCounts = map<Char, Int>()
    for _, char in string.characters {
        charCounts[char] = charCounts.get(char, 0) + 1
    }
    for _, char in string.characters {
        if charCounts[char] > 1 {
            return char.toString()
        }
    }
    return ""
}

// For a given string, return the first character that is repeated.
// firstRepeatedCharacter(string: "Hello") == "l"
func firstRepeatedCharacter(string: String) -> String {
    var charCounts = map<Char, Int>()
    for _, char in string.characters {
        charCounts[char] = charCounts.get(char, 0) + 1
    }
    for _, char in string.characters {
        if charCounts[char] > 1 {
            return char.toString()
        }
    }
    return ""
}

// For a given string, return the first character that is repeated.
// firstRepeatedCharacter(string: "Hello") == "l"
func firstRepeatedCharacter(string: String) -> String {
    var charCounts = map<Char, Int>()
    for _, char in string.characters {
        charCounts[char] = charCounts.get(char, 0) + 1
    }
    for _, char in string.characters {
        if charCounts[char

func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isUpper {
            result += char.lowercase
        } else {
            result += char.uppercase
        }
    }
    return result
}

func removeVowels(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if !char.isVowel {
            result += char
        }
    }
    return result
}

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

func countConsonants(string: String) -> Int {
    var count = 0
    for _, char in string.characters {
        if !char.isVowel {
            count++
        }
    }
    return count
}

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

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

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

func countSymbols(string: String) -> Int {
    var count = 0
    for _, char in string.characters {
        if !char.isLetter || !char.isDigit {
            count++
        }
    }
    return count
}

func countWordsStartingWithVowel(string: String) -> Int {
    var count = 0
    for _, word in string.split(" ") {
        if word.firstCharacter.isVowel {
            count++
        }
    }
    return count
}

func countWordsStartingWithConsonant(string: String) -> Int {
    var count = 0
    for _, word in string.split(" ") {
        if !word.firstCharacter.isVowel {
            count++
        }
    }
    return count
}

func countWordsEndingWithVowel(string: String) -> Int {
    var count = 0
    for _, word in string.split(" ") {
        if word.lastCharacter.isVowel {
            count++
        }
    }
    return count
}

func countWordsEndingWithConsonant(string: String) -> Int {
    var count = 0
    for _, word in string.split(" ") {
        if !word.lastCharacter.isVowel {
            count++
        }
    }
    return count
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isUpper {
            result += char.lowercase
        } else {
            result += char.uppercase
        }
    }
    return result
}

// For a given string, remove all vowels.
// removeVowels(string: "Hello") == "Hll"
func removeVowels(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if !char.isVowel {
            result += char
        }
    }
    return result
}

// For a given string, return the number of vowels.
// countVowels(string: "Hello") == 2
func countVowels(string: String) -> Int {
    var count = 0
    for _, char in string.characters {
        if char.isVowel {
            count++
        }
    }
    return count
}

// For a given string, return the number of consonants.
// countConsonants(string: "Hello") == 3
func countConsonants(string: String) -> Int {
    var count = 0
    for _, char in string.characters {
        if !char.isVowel {
            count++
        }
    }
    return count
}

// For a given string, return the number of words.
// countWords(string: "Hello World") == 2
func countWords(string: String) -> Int {
    var count = 1
    for _, char in string.characters {
        if char == " " {
            count++
        }
    }
    return count
}

// For a given string, return the number of characters.
// countCharacters(string: "Hello") == 5
func countCharacters(string: String) -> Int {
    return string.count
}

// For a given string, return the number of digits.
// countDigits(string: "Hello 123") == 3
func countDigits(string: String) -> Int {
    var count = 0
    for _, char in string.characters {
        if char.isDigit {
            count++
        }
    }
    return count
}

// For a given string, return the number of symbols.
// countSymbols(string: "Hello!") == 3
func countSymbols(string: String) -> Int {
    var count = 0
    for _, char in string.characters {
        if !char.isLetter || !char.isDigit {
            count++
        }
    }
    return count
}

// For a given string, return the number of words that start with a vowel.
// countWordsStartingWithVowel(string: "Hello World") == 1
func countWordsStartingWithVowel(string: String) -> Int {
    var count = 0
    for _, word in string.split(" ") {
        if word.firstCharacter.isVowel {
            count++
        }
    }
    return count
}

// For a given string, return the number of words that start with a consonant.
// countWordsStartingWithConsonant(string: "Hello World") == 1
func countWordsStartingWithConsonant(string: String) -> Int {
    var count = 0
    for _, word in string.split(" ") {
        if !word.firstCharacter.isVowel {
            count++
        }
    }
    return count
}

// For a given string, return the number of words that end with a vowel.
// countWordsEndingWithVowel(string: "Hello World") == 1
func countWordsEndingWithVowel(string: String) -> Int {
    var count = 0
    for _, word in string.split(" ") {
        if word.lastCharacter.isVowel {
            count++
        }
    }
    return count
}

// For a given string, return the number of words that end with a consonant.
// countWordsEndingWithConsonant(string: "Hello World") == 1
func countWordsEndingWithConsonant(string: String) -> Int {
    var count = 0
    for _, word in string.split(" ") {
        if !word.lastCharacter.isVowel {
            count++
        }
    }
    return count
}

// For a given string, return the number of words that contain a vowel.
// countWordsContainingVowel(string

func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isUpper {
            result += char.lowercase
        } else if char.isLower {
            result += char.uppercase
        } else {
            result += char
        }
    }
    return result
}

func countFoo(string: String) -> Int {
    var count = 0
    var index = 0
    while index < string.length {
        var fooIndex = string.index(of: "foo", from: index)
        if fooIndex != -1 {
            count++
            index = fooIndex + 3
        } else {
            break
        }
    }
    return count
}

func capitalizeFirst(string: String) -> String {
    var result = ""
    var capitalizeNext = true
    for _, char in string.characters {
        if char.isWhitespace {
            capitalizeNext = true
        } else if capitalizeNext {
            result += char.uppercase
            capitalizeNext = false
        } else {
            result += char
        }
    }
    return result
}

func capitalizeLast(string: String) -> String {
    var result = ""
    var capitalizeNext = false
    for _, char in string.characters {
        if char.isWhitespace {
            capitalizeNext = true
        } else if capitalizeNext {
            result += char.uppercase
            capitalizeNext = false
        } else {
            result += char
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isUpper {
            result += char.lowercase
        } else if char.isLower {
            result += char.uppercase
        } else {
            result += char
        }
    }
    return result
}

// For a given string, return the number of times the string "foo" appears.
// countFoo("foo bar foo") == 2
func countFoo(string: String) -> Int {
    var count = 0
    var index = 0
    while index < string.length {
        var fooIndex = string.index(of: "foo", from: index)
        if fooIndex != -1 {
            count++
            index = fooIndex + 3
        } else {
            break
        }
    }
    return count
}

// For a given string, return the string with the first character of each word capitalized.
// capitalizeFirst("hello world") == "Hello World"
func capitalizeFirst(string: String) -> String {
    var result = ""
    var capitalizeNext = true
    for _, char in string.characters {
        if char.isWhitespace {
            capitalizeNext = true
        } else if capitalizeNext {
            result += char.uppercase
            capitalizeNext = false
        } else {
            result += char
        }
    }
    return result
}

// For a given string, return the string with the last character of each word capitalized.
// capitalizeLast("hello world") == "Hello World"
func capitalizeLast(string: String) -> String {
    var result = ""
    var capitalizeNext = false
    for _, char in string.characters {
        if char.isWhitespace {
            capitalizeNext = true
        } else if capitalizeNext {
            result += char.uppercase
            capitalizeNext = false
        } else {
            result += char
        }
    }
    return result
}

// For a given string, return the string with the first character of each word capitalized.
// capitalizeFirst("hello world") == "Hello World"
func capitalizeFirst(string: String) -> String {
    var result = ""
    var capitalizeNext = true
    for _, char in string.characters {
        if char.isWhitespace {
            capitalizeNext = true
        } else if capitalizeNext {
            result += char.uppercase
            capitalizeNext = false
        } else {
            result += char
        }
    }
    return result
}

// For a given string, return the string with the last character of each word capitalized.
// capitalizeLast("hello world") == "Hello World"
func capitalizeLast(string: String) -> String {
    var result = ""
    var capitalizeNext = false
    for _, char in string.characters {
        if char.isWhitespace {
            capitalizeNext = true
        } else if capitalizeNext {
            result += char.uppercase
            capitalizeNext = false
        } else {
            result += char
        }
    }
    return result
}

// For a given string, return the string with the first character of each word capitalized.
// capitalizeFirst("hello world") == "Hello World"
func capitalizeFirst(string: String) -> String {
    var result = ""
    var capitalizeNext = true
    for _, char in string.characters {
        if char.isWhitespace {
            capitalizeNext = true
        } else if capitalizeNext {
            result += char.uppercase
            capitalizeNext = false
        } else {
            result += char
        }
    }
    return result
}

// For a given string, return the string with the last character of each word capitalized.
// capitalizeLast("hello world") == "Hello World"
func capitalizeLast(string: String) -> String {
    var result = ""
    var capitalizeNext = false
    for _, char in string.characters {
        if char.isWhitespace {
            capitalizeNext = true
        } else if capitalizeNext {
            result += char.uppercase
            capitalizeNext = false
        } else {
            result += char
        }
    }
    return result
}

// For a given string, return the string with the first character of each word capitalized.
// capitalizeFirst("hello world") == "Hello World"
func capitalizeFirst(string: String) -> String {
    var result = ""
    var capitalizeNext = true
    for _, char in string.characters {
        if char.isWhitespace {
            capitalizeNext = true
        

func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isUpper {
            result += char.lowercase
        } else {
            result += char.uppercase
        }
    }
    return result
}

func removeVowels(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if !char.isVowel {
            result += char
        }
    }
    return result
}

func removeConsonants(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isConsonant {
            result += char
        }
    }
    return result
}

func removePunctuation(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if !char.isPunctuation {
            result += char
        }
    }
    return result
}

func removeDigits(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if !char.isDigit {
            result += char
        }
    }
    return result
}

func removeWhitespace(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if !char.isWhitespace {
            result += char
        }
    }
    return result
}

func removeNonAlphanumeric(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isAlphanumeric {
            result += char
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isUpper {
            result += char.lowercase
        } else {
            result += char.uppercase
        }
    }
    return result
}

// For a given string, remove all vowels.
// removeVowels(string: "Hello") == "Hll"
func removeVowels(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if !char.isVowel {
            result += char
        }
    }
    return result
}

// For a given string, remove all consonants.
// removeConsonants(string: "Hello") == "Hll"
func removeConsonants(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isConsonant {
            result += char
        }
    }
    return result
}

// For a given string, remove all punctuation.
// removePunctuation(string: "Hello, World!") == "Hello World"
func removePunctuation(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if !char.isPunctuation {
            result += char
        }
    }
    return result
}

// For a given string, remove all digits.
// removeDigits(string: "Hello, World!") == "Hll, Wrd!"
func removeDigits(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if !char.isDigit {
            result += char
        }
    }
    return result
}

// For a given string, remove all whitespace.
// removeWhitespace(string: "Hello, World!") == "Hello, World!"
func removeWhitespace(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if !char.isWhitespace {
            result += char
        }
    }
    return result
}

// For a given string, remove all non-alphanumeric characters.
// removeNonAlphanumeric(string: "Hello, World!") == "Hello World"
func removeNonAlphanumeric(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isAlphanumeric {
            result += char
        }
    }
    return result
}

// For a given string, remove all non-alphanumeric characters.
// removeNonAlphanumeric(string: "Hello, World!") == "Hello World"
func removeNonAlphanumeric(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isAlphanumeric {
            result += char
        }
    }
    return result
}

// For a given string, remove all non-alphanumeric characters.
// removeNonAlphanumeric(string: "Hello, World!") == "Hello World"
func removeNonAlphanumeric(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isAlphanumeric {
            result += char
        }
    }
    return result
}

// For a given string, remove all non-alphanumeric characters.
// removeNonAlphanumeric(string: "Hello, World!") == "Hello World"
func removeNonAlphanumeric(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isAlphanumeric {
            result += char
        }
    }
    return result
}

// For a given string, remove all non-alphanumeric characters.
// removeNonAlphanumeric(string: "Hello, World!") == "Hello World"
func removeNonAlphanumeric(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isAlphanumeric {
            result += char
        }
    }
    return result
}

// For a given string, remove all non-alphanumeric characters.
// removeNonAlphanumeric(string: "Hello, World!") == "Hello World"
func removeNonAlphanumeric(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isAlphanumeric {
            result += char
        }
    }
    return result
}

// For a given string, remove all

func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isUpper {
            result += char.lowercase
        } else {
            result += char.uppercase
        }
    }
    return result
}

func removeVowels(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if !char.isVowel {
            result += char
        }
    }
    return result
}

func longestVowelSubstring(string: String) -> String {
    var longest = ""
    var current = ""
    for _, char in string.characters {
        if char.isVowel {
            current += char
        } else {
            if current.count > longest.count {
                longest = current
            }
            current = ""
        }
    }
    if current.count > longest.count {
        longest = current
    }
    return longest
}

func firstNonRepeatingCharacter(string: String) -> String {
    var counts = [String: Int]()
    for _, char in string.characters {
        if counts.contains(char) {
            counts[char] += 1
        } else {
            counts[char] = 1
        }
    }
    for _, char in string.characters {
        if counts[char] == 1 {
            return char
        }
    }
    return ""
}

func firstRepeatingCharacter(string: String) -> String {
    var counts = [String: Int]()
    for _, char in string.characters {
        if counts.contains(char) {
            return char
        } else {
            counts[char] = 1
        }
    }
    return ""
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isUpper {
            result += char.lowercase
        } else {
            result += char.uppercase
        }
    }
    return result
}

// For a given string, remove all vowels.
// removeVowels(string: "Hello") == "Hll"
func removeVowels(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if !char.isVowel {
            result += char
        }
    }
    return result
}

// For a given string, return the longest substring of consecutive vowels.
// longestVowelSubstring(string: "Hello") == "oo"
func longestVowelSubstring(string: String) -> String {
    var longest = ""
    var current = ""
    for _, char in string.characters {
        if char.isVowel {
            current += char
        } else {
            if current.count > longest.count {
                longest = current
            }
            current = ""
        }
    }
    if current.count > longest.count {
        longest = current
    }
    return longest
}

// For a given string, return the first non-repeating character.
// firstNonRepeatingCharacter(string: "Hello") == "H"
func firstNonRepeatingCharacter(string: String) -> String {
    var counts = [String: Int]()
    for _, char in string.characters {
        if counts.contains(char) {
            counts[char] += 1
        } else {
            counts[char] = 1
        }
    }
    for _, char in string.characters {
        if counts[char] == 1 {
            return char
        }
    }
    return ""
}

// For a given string, return the first repeating character.
// firstRepeatingCharacter(string: "Hello") == "l"
func firstRepeatingCharacter(string: String) -> String {
    var counts = [String: Int]()
    for _, char in string.characters {
        if counts.contains(char) {
            return char
        } else {
            counts[char] = 1
        }
    }
    return ""
}

// For a given string, return the first character that appears twice.
// firstRepeatingCharacter(string: "Hello") == "l"
func firstRepeatingCharacter(string: String) -> String {
    var counts = [String: Int]()
    for _, char in string.characters {
        if counts.contains(char) {
            return char
        } else {
            counts[char] = 1
        }
    }
    return ""
}

// For a given string, return the first character that appears twice.
// firstRepeatingCharacter(string: "Hello") == "l"
func firstRepeatingCharacter(string: String) -> String {
    var counts = [String: Int]()
    for _, char in string.characters {
        if counts.contains(char) {
            return char
        } else {
            counts[char] = 1
        }
    }
    return ""
}

// For a given string, return the first character that appears twice.
// firstRepeatingCharacter(string: "Hello") == "l"
func firstRepeatingCharacter(string: String) -> String {
    var counts = [String: Int]()
    for _, char in string.characters {
        if counts.contains(char) {
            return char
        } else {
            counts[char] = 1
        }
    }
    return ""
}

// For a given string, return the first character that appears twice.
// firstRepeatingCharacter(string: "Hello") == "l"
func firstRepeatingCharacter(string: String) -> String {
    var counts = [String: Int]()
    for _, char in string.characters {
        if counts.contains(char) {
            return char
        } else {
            counts[char] = 1
        }
    }
    return ""
}

// For a given string, return the first character that appears twice.
// firstRepeatingCharacter(string: "Hello") == "l"
func firstRepeatingCharacter(string: String) -> String {
    var counts = [String: Int]()
    for _, char in string.characters {
        if counts.contains(char) {
            return char
        } else {
            counts[char] = 

func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isUpper {
            result += char.lowercase
        } else {
            result += char.uppercase
        }
    }
    return result
}

func removeVowels(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if !char.isVowel {
            result += char
        }
    }
    return result
}

func reverse(string: String) -> String {
    var result = ""
    for _, char in string.characters.reversed {
        result += char
    }
    return result
}

func removeNonAlphabetic(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isAlphabetic {
            result += char
        }
    }
    return result
}

func isPalindrome(string: String) -> Bool {
    var reversed = reverse(string)
    return string == reversed
}

func countOccurrences(string: String, character: Char) -> Int {
    var count = 0
    for _, char in string.characters {
        if char == character {
            count++
        }
    }
    return count
}

func findFirstOccurrence(string: String, character: Char) -> Int {
    for index, char in string.characters.enumerated {
        if char == character {
            return index
        }
    }
    return -1
}

func findLastOccurrence(string: String, character: Char) -> Int {
    for index in string.characters.count downTo 0 {
        if string[index] == character {
            return index
        }
    }
    return -1
}

func longestSubstringWithoutRepeatingCharacters(string: String) -> String {
    var longest = ""
    var current = ""
    for _, char in string.characters {
        if !current.contains(char) {
            current += char
        } else {
            if current.count > longest.count {
                longest = current
            }
            current = char
        }
    }
    if current.count > longest.count {
        longest = current
    }
    return longest
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isUpper {
            result += char.lowercase
        } else {
            result += char.uppercase
        }
    }
    return result
}

// For a given string, remove all vowels.
// removeVowels(string: "Hello") == "Hll"
func removeVowels(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if !char.isVowel {
            result += char
        }
    }
    return result
}

// For a given string, reverse the order of its characters.
// reverse(string: "Hello") == "olleH"
func reverse(string: String) -> String {
    var result = ""
    for _, char in string.characters.reversed {
        result += char
    }
    return result
}

// For a given string, remove all non-alphabetic characters.
// removeNonAlphabetic(string: "Hello, World!") == "HelloWorld"
func removeNonAlphabetic(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isAlphabetic {
            result += char
        }
    }
    return result
}

// For a given string, check if it is a palindrome.
// isPalindrome(string: "racecar") == true
// isPalindrome(string: "hello") == false
func isPalindrome(string: String) -> Bool {
    var reversed = reverse(string)
    return string == reversed
}

// For a given string, count the number of occurrences of a given character.
// countOccurrences(string: "Hello, World!", character: 'l') == 2
func countOccurrences(string: String, character: Char) -> Int {
    var count = 0
    for _, char in string.characters {
        if char == character {
            count++
        }
    }
    return count
}

// For a given string, find the first occurrence of a given character.
// findFirstOccurrence(string: "Hello, World!", character: 'l') == 2
// findFirstOccurrence(string: "Hello, World!", character: 'x') == -1
func findFirstOccurrence(string: String, character: Char) -> Int {
    for index, char in string.characters.enumerated {
        if char == character {
            return index
        }
    }
    return -1
}

// For a given string, find the last occurrence of a given character.
// findLastOccurrence(string: "Hello, World!", character: 'l') == 8
// findLastOccurrence(string: "Hello, World!", character: 'x') == -1
func findLastOccurrence(string: String, character: Char) -> Int {
    for index in string.characters.count downTo 0 {
        if string[index] == character {
            return index
        }
    }
    return -1
}

// For a given string, find the longest substring without repeating characters.
// longestSubstringWithoutRepeatingCharacters(string: "abcabcbb") == "abc"
// longestSubstringWithoutRepeatingCharacters(string: "bbbbb") == "b"
// longestSubstringWithoutRepeatingCharacters(string: "pwwkew") == "wke"
func longestSubstringWithoutRepeatingCharacters(string: String) -> String {
    var longest = ""
    var current = ""
    for _, char in string.characters {
        if !current.contains(char) {
            current += char
        } else {
            if current.count > longest.count {
                longest = current
            }
            current = char
        }
    }
    if current.count > longest.count {
        longest = current
    }
    return longest
}

// For a given string, find the first non-repeating character.
// firstNonRepeatingCharacter(string: "abcabcbb") == 'd'
// firstNonRepeatingCharacter(string: "bbbbb") == 'b'
// firstNonRepeatingCharacter(string: "pwwkew") == 'k'
func firstNonRepeatingCharacter(string: String) -> Char? {
    var seen = Map<Char, Int>()
    for index, char in string.characters.enumerated {
        if seen.contains(char) {
            seen[char] = seen[char]! + 1
        } else {
            seen[char] = 1

func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isUpper {
            result += char.lowercase
        } else if char.isLower {
            result += char.uppercase
        } else {
            result += char
        }
    }
    return result
}

func capitalizeFirstLetters(string: String) -> String {
    var result = ""
    var capitalizeNext = true
    for _, char in string.characters {
        if char.isWhitespace {
            capitalizeNext = true
        } else if capitalizeNext {
            result += char.uppercase
            capitalizeNext = false
        } else {
            result += char
        }
    }
    return result
}

func capitalizeLastLetters(string: String) -> String {
    var result = ""
    var capitalizeNext = true
    for _, char in string.characters.reversed {
        if char.isWhitespace {
            capitalizeNext = true
        } else if capitalizeNext {
            result += char.uppercase
            capitalizeNext = false
        } else {
            result += char
        }
    }
    return result.reversed
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isUpper {
            result += char.lowercase
        } else if char.isLower {
            result += char.uppercase
        } else {
            result += char
        }
    }
    return result
}

// For a given string, return a string of the same length with the first character of each word capitalized.
// capitalizeFirstLetters(string: "hello world") == "Hello World"
func capitalizeFirstLetters(string: String) -> String {
    var result = ""
    var capitalizeNext = true
    for _, char in string.characters {
        if char.isWhitespace {
            capitalizeNext = true
        } else if capitalizeNext {
            result += char.uppercase
            capitalizeNext = false
        } else {
            result += char
        }
    }
    return result
}

// For a given string, return a string of the same length with the last character of each word capitalized.
// capitalizeLastLetters(string: "hello world") == "Hello World"
func capitalizeLastLetters(string: String) -> String {
    var result = ""
    var capitalizeNext = true
    for _, char in string.characters.reversed {
        if char.isWhitespace {
            capitalizeNext = true
        } else if capitalizeNext {
            result += char.uppercase
            capitalizeNext = false
        } else {
            result += char
        }
    }
    return result.reversed
}

// For a given string, return a string of the same length with the first character of each word capitalized.
// capitalizeFirstLetters(string: "hello world") == "Hello World"
func capitalizeFirstLetters(string: String) -> String {
    var result = ""
    var capitalizeNext = true
    for _, char in string.characters {
        if char.isWhitespace {
            capitalizeNext = true
        } else if capitalizeNext {
            result += char.uppercase
            capitalizeNext = false
        } else {
            result += char
        }
    }
    return result
}

// For a given string, return a string of the same length with the last character of each word capitalized.
// capitalizeLastLetters(string: "hello world") == "Hello World"
func capitalizeLastLetters(string: String) -> String {
    var result = ""
    var capitalizeNext = true
    for _, char in string.characters.reversed {
        if char.isWhitespace {
            capitalizeNext = true
        } else if capitalizeNext {
            result += char.uppercase
            capitalizeNext = false
        } else {
            result += char
        }
    }
    return result.reversed
}

// For a given string, return a string of the same length with the first character of each word capitalized.
// capitalizeFirstLetters(string: "hello world") == "Hello World"
func capitalizeFirstLetters(string: String) -> String {
    var result = ""
    var capitalizeNext = true
    for _, char in string.characters {
        if char.isWhitespace {
            capitalizeNext = true
        } else if capitalizeNext {
            result += char.uppercase
            capitalizeNext = false
        } else {
            result += char
        }
    }
    return result
}

// For a given string, return a string of the same length with the last character of each word capitalized.
// capitalizeLastLetters(string: "hello world") == "Hello World"
func capitalizeLastLetters(string: String) -> String {
    var result = ""
    var capitalizeNext = true
    for _, char in string.characters.reversed {
        if char.isWhitespace {
            capitalizeNext = true
        } else if capitalizeNext {
            result += char.uppercase
            capitalizeNext = false
        } else {
            result += char
        }
    }
    return result.reversed
}

// For a given string, return a string of the same length with the first character of each word capitalized.
// capitalizeFirstLetters(string: "hello world") == "Hello World"
func capitalizeFirstLetters(string: String) -> String {
    var result = ""
    var capitalizeNext = true
    for _, char in string.characters {
        if char.isWhitespace {
            capitalizeNext = true
        } else if capitalizeNext {
            result += char.uppercase
            capitalizeNext = false
        } else {
            result += char
        }
    }
    return result
}

// For a given string, return a string of

func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characterByCharacter {
        if char.isUpper {
            result += char.lowercase
        } else {
            result += char.uppercase
        }
    }
    return result
}

func countVowels(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isVowel {
            count += 1
        }
    }
    return count
}

func countConsonants(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isConsonant {
            count += 1
        }
    }
    return count
}

func countDigits(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isDigit {
            count += 1
        }
    }
    return count
}

func countWhitespace(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isWhitespace {
            count += 1
        }
    }
    return count
}

func countPunctuation(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isPunctuation {
            count += 1
        }
    }
    return count
}

func countSymbols(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isSymbol {
            count += 1
        }
    }
    return count
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characterByCharacter {
        if char.isUpper {
            result += char.lowercase
        } else {
            result += char.uppercase
        }
    }
    return result
}

// For a given string, return the number of vowels.
// countVowels(string: "Hello") == 2
func countVowels(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isVowel {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of consonants.
// countConsonants(string: "Hello") == 3
func countConsonants(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isConsonant {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of digits.
// countDigits(string: "Hello") == 0
func countDigits(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isDigit {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of whitespace characters.
// countWhitespace(string: "Hello") == 0
func countWhitespace(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isWhitespace {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of punctuation characters.
// countPunctuation(string: "Hello") == 0
func countPunctuation(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isPunctuation {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of symbols.
// countSymbols(string: "Hello") == 0
func countSymbols(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isSymbol {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of whitespace characters.
// countWhitespace(string: "Hello") == 0
func countWhitespace(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isWhitespace {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of symbols.
// countSymbols(string: "Hello") == 0
func countSymbols(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isSymbol {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of symbols.
// countSymbols(string: "Hello") == 0
func countSymbols(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isSymbol {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of symbols.
// countSymbols(string: "Hello") == 0
func countSymbols(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isSymbol {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of symbols.
// countSymbols(string: "Hello") == 0
func countSymbols(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isSymbol {
            count += 1
        }
    }
    return count
}

// For a given string, return the number of symbols.
// countSymbols(string: "Hello") == 0
func countSymbols(string: String) -> Int {
    

func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isUpper {
            result += char.lowercase
        } else if char.isLower {
            result += char.uppercase
        } else {
            result += char
        }
    }
    return result
}

func findLongestWord(string: String) -> String {
    var words = string.components(separatedBy: " ")
    var longestWord = ""
    for _, word in words {
        if word.count > longestWord.count {
            longestWord = word
        }
    }
    return longestWord
}

func countVowels(string: String) -> Int {
    var vowels = "aeiouAEIOU"
    var count = 0
    for _, char in string.characters {
        if vowels.contains(char) {
            count += 1
        }
    }
    return count
}

func countConsonants(string: String) -> Int {
    var consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    var count = 0
    for _, char in string.characters {
        if consonants.contains(char) {
            count += 1
        }
    }
    return count
}

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

func countSentences(string: String) -> Int {
    var sentences = string.components(separatedBy: ".")
    return sentences.count
}

func countParagraphs(string: String) -> Int {
    var paragraphs = string.components(separatedBy: "\n\n")
    return paragraphs.count
}

func countLines(string: String) -> Int {
    return string.components(separatedBy: "\n").count
}

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

func countWordsWithLengthGreaterThan5(string: String) -> Int {
    var words = string.components(separatedBy: " ")
    var count = 0
    for _, word in words {
        if word.count > 5 {
            count += 1
        }
    }
    return count
}

func countWordsWithLengthLessThan5(string: String) -> Int {
    var words = string.components(separatedBy: " ")
    var count = 0
    for _, word in words {
        if word.count < 5 {
            count += 1
        }
    }
    return count
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characters {
        if char.isUpper {
            result += char.lowercase
        } else if char.isLower {
            result += char.uppercase
        } else {
            result += char
        }
    }
    return result
}

// For a given string, find the longest word.
// findLongestWord(string: "Hello, world!") == "world"
func findLongestWord(string: String) -> String {
    var words = string.components(separatedBy: " ")
    var longestWord = ""
    for _, word in words {
        if word.count > longestWord.count {
            longestWord = word
        }
    }
    return longestWord
}

// For a given string, find the number of vowels.
// countVowels(string: "Hello") == 2
func countVowels(string: String) -> Int {
    var vowels = "aeiouAEIOU"
    var count = 0
    for _, char in string.characters {
        if vowels.contains(char) {
            count += 1
        }
    }
    return count
}

// For a given string, find the number of consonants.
// countConsonants(string: "Hello") == 3
func countConsonants(string: String) -> Int {
    var consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    var count = 0
    for _, char in string.characters {
        if consonants.contains(char) {
            count += 1
        }
    }
    return count
}

// For a given string, find the number of words.
// countWords(string: "Hello, world!") == 2
func countWords(string: String) -> Int {
    return string.components(separatedBy: " ").count
}

// For a given string, find the number of sentences.
// countSentences(string: "Hello, world! How are you?") == 2
func countSentences(string: String) -> Int {
    var sentences = string.components(separatedBy: ".")
    return sentences.count
}

// For a given string, find the number of paragraphs.
// countParagraphs(string: "Hello, world!\n\nHow are you?") == 2
func countParagraphs(string: String) -> Int {
    var paragraphs = string.components(separatedBy: "\n\n")
    return paragraphs.count
}

// For a given string, find the number of lines.
// countLines(string: "Hello, world!\n\nHow are you?") == 3
func countLines(string: String) -> Int {
    return string.components(separatedBy: "\n").count
}

// For a given string, find the number of characters.
// countCharacters(string: "Hello, world!") == 13
func countCharacters(string: String) -> Int {
    return string.characters.count
}

// For a given string, find the number of words with a length greater than 5.
// countWordsWithLengthGreaterThan5(string: "Hello, world!") == 2
func countWordsWithLengthGreaterThan5(string: String) -> Int {
    var words = string.components(separatedBy: " ")
    var count = 0
    for _, word in words {
        if word.count > 5 {
            count += 1
        }
    }
    return count
}

// For a given string, find the number of words with a length less than 5.
// countWordsWithLengthLessThan5(string: "Hello, world!") == 2
func countWordsWithLengthLessThan5(string: String) -> Int {
    var words = string.components(separatedBy: " ")
    var count = 0
    for _, word in words {
        if word.count < 5 {
            count += 1
        }
    }
    return count
}

// For a given string, find the number of words with a length between 5 and 10.
// countWordsWithLengthBetween5And10(string: "Hello, world!") == 2
func countWordsWithLengthBetween5And10(string: String) -> Int {
    var words = string.components(separatedBy: " ")
    var count = 0
    for _, word in words {
        if word.count >= 5 && word.count <= 1

func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characterByCharacter {
        if char.isUpper {
            result += char.lowercase
        } else {
            result += char.uppercase
        }
    }
    return result
}

func countVowels(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isVowel {
            count++
        }
    }
    return count
}

func countConsonants(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isConsonant {
            count++
        }
    }
    return count
}

func countDigits(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isDigit {
            count++
        }
    }
    return count
}

func countSpaces(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isSpace {
            count++
        }
    }
    return count
}

func countNonWhitespace(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if !char.isWhitespace {
            count++
        }
    }
    return count
}

func countWords(string: String) -> Int {
    var count = 1
    for _, char in string.characterByCharacter {
        if char.isWhitespace {
            count++
        }
    }
    return count
}

func countSentences(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isSentenceTerminator {
            count++
        }
    }
    return count
}

func countParagraphs(string: String) -> Int {
    var count = 1
    for _, char in string.characterByCharacter {
        if char.isParagraphTerminator {
            count++
        }
    }
    return count
}

func countLines(string: String) -> Int {
    var count = 1
    for _, char in string.characterByCharacter {
        if char.isLineTerminator {
            count++
        }
    }
    return count
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for _, char in string.characterByCharacter {
        if char.isUpper {
            result += char.lowercase
        } else {
            result += char.uppercase
        }
    }
    return result
}

// For a given string, return the number of vowels in the string.
// countVowels(string: "Hello") == 2
func countVowels(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isVowel {
            count++
        }
    }
    return count
}

// For a given string, return the number of consonants in the string.
// countConsonants(string: "Hello") == 3
func countConsonants(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isConsonant {
            count++
        }
    }
    return count
}

// For a given string, return the number of digits in the string.
// countDigits(string: "Hello") == 0
func countDigits(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isDigit {
            count++
        }
    }
    return count
}

// For a given string, return the number of spaces in the string.
// countSpaces(string: "Hello") == 1
func countSpaces(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isSpace {
            count++
        }
    }
    return count
}

// For a given string, return the number of non-whitespace characters in the string.
// countNonWhitespace(string: "Hello") == 5
func countNonWhitespace(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if !char.isWhitespace {
            count++
        }
    }
    return count
}

// For a given string, return the number of words in the string.
// countWords(string: "Hello world") == 2
func countWords(string: String) -> Int {
    var count = 1
    for _, char in string.characterByCharacter {
        if char.isWhitespace {
            count++
        }
    }
    return count
}

// For a given string, return the number of sentences in the string.
// countSentences(string: "Hello. world!") == 2
func countSentences(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isSentenceTerminator {
            count++
        }
    }
    return count
}

// For a given string, return the number of paragraphs in the string.
// countParagraphs(string: "Hello.\n\nworld!") == 2
func countParagraphs(string: String) -> Int {
    var count = 1
    for _, char in string.characterByCharacter {
        if char.isParagraphTerminator {
            count++
        }
    }
    return count
}

// For a given string, return the number of lines in the string.
// countLines(string: "Hello.\n\nworld!") == 3
func countLines(string: String) -> Int {
    var count = 1
    for _, char in string.characterByCharacter {
        if char.isLineTerminator {
            count++
        }
    }
    return count
}

// For a given string, return the number of words in the string.
// countWords(string: "Hello world") == 2
func countWords(string: String) -> Int {
    var count = 1
    for _, char in string.characterByCharacter {
        if char.isWhitespace {
            count++
        }
    }
    return count
}

// For a given string, return the number of sentences in the string.
// countSentences(string: "Hello. world!") == 2
func countSentences(string: String) -> Int {
    var count = 0
    for _, char in string.characterByCharacter {
        if char.isSentenceTerminator {
            count++
        }
    }
    return count
}

// For

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0
        }
    }.joined()
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0
        }
    }.joined()
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0
        }
    }.joined()
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0
        }
    }.joined()
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0
        }
    }.joined()
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0
        }
    }.joined()
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0
        }
    }.joined()
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        $0.isLowercase ? Character($0.uppercased()) : Character($0.lowercased())
    }.joined()
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map {
        $0.isLowercase ? Character($0.uppercased()) : Character($0.lowercased())
    }.joined()
}
```

func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? $0.uppercased() : $0.lowercased()
    })
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? $0.uppercased() : $0.lowercased()
    })
}
```

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return String(char)
        }
    }.joined()
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return String(char)
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map { char in
        if char.isLowercase {
            return char.uppercased()
        } else if char.isUppercase {
            return char.lowercased()
        } else {
            return char
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? $0.uppercased() : $0.lowercased()
    })
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? $0.uppercased() : $0.lowercased()
    })
}
```

func flipCase(string: String) -> String {
    return string.map {
        switch $0 {
        case let c where c.isLowercase:
            return c.uppercased()
        case let c where c.isUppercase:
            return c.lowercased()
        default:
            return String($0)
        }
    }.joined()
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return string.map {
        switch $0 {
        case let c where c.isLowercase:
            return c.uppercased()
        case let c where c.isUppercase:
            return c.lowercased()
        default:
            return String($0)
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? Character($0.uppercased()) : Character($0.lowercased())
    })
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? Character($0.uppercased()) : Character($0.lowercased())
    })
}
```

func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? Character($0.uppercased()) : Character($0.lowercased())
    })
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? Character($0.uppercased()) : Character($0.lowercased())
    })
}
```

func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? Character($0.uppercased()) : Character($0.lowercased())
    })
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? Character($0.uppercased()) : Character($0.lowercased())
    })
}
```

func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? Character($0.uppercased()) : Character($0.lowercased())
    })
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<end_of_turn>
<start_of_turn>model
```swift
func flipCase(string: String) -> String {
    return String(string.map {
        $0.isLowercase ? Character($0.uppercased()) : Character($0.lowercased())
    })
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    }
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    }
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    }.joined()
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    }.joined()
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    }.joined()
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    }.joined()
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    }.joined()
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    }.joined()
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    }.joined()
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    }.joined()
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return $0.uppercased()
        } else {
            return $0.lowercased()
        }
    }
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char.lowercased()
        }
    }
    return result
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased())
        } else {
            result.append(char.lowercased())
        }
    }
    return result
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char.lowercased()
        }
    }
    return result
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char.lowercased()
        }
    }
    return result
}
```

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

[INST] Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO" [/INST] ```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char.lowercased()
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    return string.map { character in
        character.isLowercase? character.uppercased() : character.lowercased()
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.map { character in
        character.isLowercase? character.uppercased() : character.lowercased()
    }
}
```

func flipCase(string: String) -> String {
    return string.map { String($0).toggleCase() }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.map { String($0).toggleCase() }
}
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if character.isLowercase {
            result.append(character.uppercased())
        } else {
            result.append(character.lowercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if let upperCase = char.unicodeScalars.first?.upperCase {
            result.append(Character(upperCase))
        } else if let lowerCase = char.unicodeScalars.first?.lowerCase {
            result.append(Character(lowerCase))
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if let upperCase = char.unicodeScalars.first?.upperCase {
            result.append(Character(upperCase))
        } else if let lowerCase = char.unicodeScalars.first?.lowerCase {
            result.append(Character(lowerCase))
        } else {
            result.append(char)
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isLowercase? $0.uppercase() : $0.lowercase() }.reduce("", +)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isLowercase? $0.uppercase() : $0.lowercase() }.reduce("", +)
}
```

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if let upperCase = char.ascii uppercase {
            result.append(Character(UnicodeScalar(upperCase)!))
        } else if let lowerCase = char.ascii lowercase {
            result.append(Character(UnicodeScalar(lowerCase)!))
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if let upperCase = char.ascii uppercase {
            result.append(Character(UnicodeScalar(upperCase)!))
        } else if let lowerCase = char.ascii lowercase {
            result.append(Character(UnicodeScalar(lowerCase)!))
        } else {
            result.append(char)
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }.reduce("", +)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }.reduce("", +)
}
```

func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isLowercase? $0.uppercasesd() : $0.lowercased() }.reduce("", +)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isLowercase? $0.uppercasesd() : $0.lowercased() }.reduce("", +)
}
```

func flipCase(string: String) -> String {
    var flippedString = ""
    for character in string {
        if let uppercase = character.unicodeScalars.first?.upperCase {
            flippedString.append(String(uppercase))
        } else if let lowercase = character.unicodeScalars.first?.lowerCase {
            flippedString.append(String(lowercase))
        } else {
            flippedString.append(character)
        }
    }
    return flippedString
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var flippedString = ""
    for character in string {
        if let uppercase = character.unicodeScalars.first?.upperCase {
            flippedString.append(String(uppercase))
        } else if let lowercase = character.unicodeScalars.first?.lowerCase {
            flippedString.append(String(lowercase))
        } else {
            flippedString.append(character)
        }
    }
    return flippedString
}
```

func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isLowercase? $0.uppercasesd() : $0.lowercased() }.reduce("", +)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isLowercase? $0.uppercasesd() : $0.lowercased() }.reduce("", +)
}
```

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if let upperCase = char.unicodeScalars.first?.upperCase {
            result.append(Character(upperCase))
        } else if let lowerCase = char.unicodeScalars.first?.lowerCase {
            result.append(Character(lowerCase))
        } else {
            result.append(char)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if let upperCase = char.unicodeScalars.first?.upperCase {
            result.append(Character(upperCase))
        } else if let lowerCase = char.unicodeScalars.first?.lowerCase {
            result.append(Character(lowerCase))
        } else {
            result.append(char)
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isUppercase? String($0.lowercased()) : String($0.uppercased()) }.joined()
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isUppercase? String($0.lowercased()) : String($0.uppercased()) }.joined()
}
```

func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isLowercase? $0.uppercasesFirst : $0.lowercased() }.reduce("") { $0 + String($1) }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"

Answer:
```swift
func flipCase(string: String) -> String {
    return string.unicodeScalars.map { $0.isLowercase? $0.uppercasesFirst : $0.lowercased() }.reduce("") { $0 + String($1) }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}

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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}

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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}

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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}

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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}

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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}

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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}

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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}

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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}

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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}

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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) }
}
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if CharacterSet.lowercaseLetters.contains(character) {
            result += String(character).uppercased()
        } else if CharacterSet.uppercaseLetters.contains(character) {
            result += String(character).lowercased()
        } else {
            result += character
        }
    }
    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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if CharacterSet.lowercaseLetters.contains(character) {
            result += String(character).uppercased()
        } else if CharacterSet.uppercaseLetters.contains(character) {
            result += String(character).lowercased()
        } else {
            result += character
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if CharacterSet.lowercaseLetters.contains(character) {
            result += String(character).uppercased()
        } else if CharacterSet.uppercaseLetters.contains(character) {
            result += String(character).lowercased()
        } else {
            result += character
        }
    }
    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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if CharacterSet.lowercaseLetters.contains(character) {
            result += String(character).uppercased()
        } else if CharacterSet.uppercaseLetters.contains(character) {
            result += String(character).lowercased()
        } else {
            result += character
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if CharacterSet.lowercaseLetters.contains(character) {
            result += String(character).uppercased()
        } else if CharacterSet.uppercaseLetters.contains(character) {
            result += String(character).lowercased()
        } else {
            result += character
        }
    }
    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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if CharacterSet.lowercaseLetters.contains(character) {
            result += String(character).uppercased()
        } else if CharacterSet.uppercaseLetters.contains(character) {
            result += String(character).lowercased()
        } else {
            result += character
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) })
}

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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isUppercase ? Character($0.lowercased()) : Character($0.uppercased()) })
}

print(flipCase(string: "Hello")) // hELLO
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isUppercase ? String($0).lowercased() : String($0).uppercased() })
}

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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isUppercase ? String($0).lowercased() : String($0).uppercased() })
}

print(flipCase(string: "Hello")) // hELLO
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isUppercase ? String($0).lowercased() : String($0).uppercased() })
}

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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isUppercase ? String($0).lowercased() : String($0).uppercased() })
}

print(flipCase(string: "Hello")) // hELLO
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if CharacterSet.lowercaseLetters.contains(character) {
            result += String(character).lowercase()
        } else if CharacterSet.uppercaseLetters.contains(character) {
            result += String(character).uppercase()
        } else {
            result += character
        }
    }
    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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if CharacterSet.lowercaseLetters.contains(character) {
            result += String(character).lowercase()
        } else if CharacterSet.uppercaseLetters.contains(character) {
            result += String(character).uppercase()
        } else {
            result += character
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if CharacterSet.lowercaseLetters.contains(character) {
            result += String(character).uppercased()
        } else if CharacterSet.uppercaseLetters.contains(character) {
            result += String(character).lowercased()
        } else {
            result += character
        }
    }
    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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if CharacterSet.lowercaseLetters.contains(character) {
            result += String(character).uppercased()
        } else if CharacterSet.uppercaseLetters.contains(character) {
            result += String(character).lowercased()
        } else {
            result += character
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if CharacterSet.lowercaseLetters.contains(character) {
            result += String(character).uppercased()
        } else if CharacterSet.uppercaseLetters.contains(character) {
            result += String(character).lowercased()
        } else {
            result += character
        }
    }
    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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    var result = ""
    for character in string {
        if CharacterSet.lowercaseLetters.contains(character) {
            result += String(character).uppercased()
        } else if CharacterSet.uppercaseLetters.contains(character) {
            result += String(character).lowercased()
        } else {
            result += character
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    return String(string.map { $0.isUppercase ? String($0).lowercased() : String($0).uppercased() })
}

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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"
### Response:
```swift
func flipCase(string: String) -> String {
    return String(string.map { $0.isUppercase ? String($0).lowercased() : String($0).uppercased() })
}

print(flipCase(string: "Hello")) // hELLO
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .joined()
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .joined()
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .reduce("", +)
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .reduce("", +)
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    }
   .joined()
}

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

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .joined()
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .joined()
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
}
```

func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .reduce("", +)
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isUppercase? $0.lowercased() : $0.uppercased() }
       .reduce("", +)
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isLowercase {
            return String($0.uppercased())
        } else {
            return String($0.lowercased())
        }
    }.reduce("", +)
}

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

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char.uppercased()
        }
    }
    return result
}
```

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char.lowercased()
        }
    }
    return result
}
```

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

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

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result += char.uppercased()
        } else {
            result += char.lowercased()
        }
    }
    return result
}
```

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

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

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result += char.lowercased()
        } else {
            result += char.uppercased()
        }
    }
    return result
}
```

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

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

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

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

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

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

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isUppercase {
            result.append(char.lowercased())
        } else {
            result.append(char.uppercased())
        }
    }
    return result
}
```

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string.characters {
        if char.isUppercase {
            result += String(char).lowercased()
        } else {
            result += String(char).uppercased()
        }
    }
    return result
}
```

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string.characters {
        if char.isUppercase {
            result += String(char.lowercased())
        } else {
            result += String(char.uppercased())
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var newString = ""
    for char in string.characters {
        if char.isLowercase {
            newString.append(String(char).uppercased())
        } else {
            newString.append(String(char).lowercased())
        }
    }
    return newString
}

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

func flipCase(string: String) -> String {
    var newString = ""
    for char in string.characters {
        if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char.uppercased())
        }
    }
    return newString
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var newString = ""
    for char in string.characters {
        if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char.uppercased())
        }
    }
    return newString
}
```

func flipCase(string: String) -> String {
    var newString = ""
    for char in string.characters {
        if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char.uppercased())
        }
    }
    return newString
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var newString = ""
    for char in string.characters {
        if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char.uppercased())
        }
    }
    return newString
}
```

func flipCase(string: String) -> String {
    var newString = ""
    for char in string.characters {
        if char.isLowercase {
            newString.append(String(char).uppercased())
        } else {
            newString.append(String(char).lowercased())
        }
    }
    return newString
}

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

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

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string.characters {
        if char.isUppercase {
            result += String(char).lowercased()
        } else {
            result += String(char).uppercased()
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var newString = ""
    for char in string.characters {
        if char.isUppercase {
            newString += String(char.lowercased())
        } else {
            newString += String(char.uppercased())
        }
    }
    return newString
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var newString = ""
    for char in string.characters {
        if char.isUppercase {
            newString += String(char.lowercased())
        } else {
            newString += String(char.uppercased())
        }
    }
    return newString
}
```

func flipCase(string: String) -> String {
    var newString = ""
    for char in string.characters {
        if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char.uppercased())
        }
    }
    return newString
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var newString = ""
    for char in string.characters {
        if char.isUppercase {
            newString.append(char.lowercased())
        } else {
            newString.append(char.uppercased())
        }
    }
    return newString
}
```

func flipCase(string: String) -> String {
    return string.map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    }.joined()
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```

func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}

<|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.
For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
flipCase(string: "Hello") == "hELLO"<|im_end|>
<|im_start|>assistant
```swift
func flipCase(string: String) -> String {
    return String(string.lowercased().map {
        if $0.isUppercase {
            return $0.lowercased()
        } else {
            return $0.uppercased()
        }
    })
}
```